Merge remote-tracking branch 'origin/main' into perth-v2

# Conflicts:
#	CLAUDE.md
#	package.json

browse/test/config.test.ts

@@ -1,4 +1,5 @@
 import { describe, test, expect } from 'bun:test';
+import { canRevokeWrites } from '../../test/helpers/fs-caps';
 import { resolveConfig, ensureStateDir, readVersionHash, getGitRoot, getRemoteSlug, resolveGstackHome, resolveChromiumProfile, cleanSingletonLocks } from '../src/config';
 import * as fs from 'fs';
 import * as path from 'path';
@@ -129,6 +130,7 @@ describe('config', () => {
     });
 
     test('logs warning to browse-server.log on non-ENOENT gitignore error', () => {
+      if (!canRevokeWrites()) return; // chmod is advisory here (win32, root, DAC-override containers)
       const tmpDir = path.join(os.tmpdir(), `browse-gitignore-test-${Date.now()}`);
       fs.mkdirSync(tmpDir, { recursive: true });
       // Create a read-only .gitignore (no .gstack/ entry → would try to append)

browse/test/file-permissions.test.ts

@@ -77,6 +77,34 @@ describe('restrictDirectoryPermissions', () => {
     expect(fs.statSync(d).mode & 0o777).toBe(0o700);
   });
 
+  test('on POSIX, leaves a shared sticky world-writable dir untouched', () => {
+    if (process.platform === 'win32') return;
+    // Simulates /tmp: sticky + world-writable. Hardening a shared dir to
+    // 0o700 locks every other user on the machine out of it, so the helper
+    // must refuse — even when the caller owns the dir (root / CAP_FOWNER
+    // hosts are where the chmod would actually succeed).
+    const d = path.join(tmpDir, 'shared-tmp');
+    fs.mkdirSync(d);
+    // System chmod, not fs.chmodSync: Bun masks the sticky bit off chmod/
+    // mkdir modes, so 0o1777 through the fs API lands as 0o777.
+    Bun.spawnSync(['chmod', '1777', d]);
+    expect(fs.statSync(d).mode & 0o7777).toBe(0o1777); // fixture took
+    restrictDirectoryPermissions(d);
+    expect(fs.statSync(d).mode & 0o7777).toBe(0o1777);
+  });
+
+  test('on POSIX, leaves a directory owned by another user untouched', () => {
+    if (process.platform === 'win32') return;
+    const d = path.join(tmpDir, 'foreign');
+    fs.mkdirSync(d, { mode: 0o755 });
+    // Only constructible where chown to a foreign uid succeeds (root /
+    // CAP_CHOWN — containers, CI sandboxes). Elsewhere the chown throws
+    // and there's nothing to assert; bail.
+    try { fs.chownSync(d, process.getuid!() + 1, fs.statSync(d).gid); } catch { return; }
+    restrictDirectoryPermissions(d);
+    expect(fs.statSync(d).mode & 0o777).toBe(0o755);
+  });
+
   test('on Windows, does not throw on an existing directory', () => {
     if (process.platform !== 'win32') return;
     const d = path.join(tmpDir, 'subdir');
@@ -205,6 +233,23 @@ describe('mkdirSecure', () => {
     expect(() => mkdirSecure(d)).not.toThrow();
   });
 
+  test('does not chmod a pre-existing shared sticky dir (the /tmp state-dir case)', () => {
+    if (process.platform === 'win32') return;
+    // BROWSE_STATE_FILE=/tmp/foo.json derives stateDir=/tmp, and every
+    // daemon boot runs mkdirSecure(stateDir). The mkdir is a no-op on the
+    // existing dir; the permission re-apply must be one too — chmodding the
+    // real /tmp to 0o700 breaks fs.existsSync (access(2) → EACCES) for
+    // every process on the machine until something restores 1777.
+    const d = path.join(tmpDir, 'shared-tmp');
+    fs.mkdirSync(d);
+    // System chmod: Bun's fs API masks the sticky bit off modes (see the
+    // restrictDirectoryPermissions sticky-dir test).
+    Bun.spawnSync(['chmod', '1777', d]);
+    expect(fs.statSync(d).mode & 0o7777).toBe(0o1777); // fixture took
+    mkdirSecure(d);
+    expect(fs.statSync(d).mode & 0o7777).toBe(0o1777);
+  });
+
   test('on Windows, the created directory stays usable by the caller', () => {
     if (process.platform !== 'win32') return;
     // The state-dir path that broke: mkdirSecure() creates .gstack/, hardens
@@ -254,3 +299,27 @@ describe('repairBrokenDacl', () => {
     expect(() => repairBrokenDacl(path.join(tmpDir, 'nonexistent'))).not.toThrow();
   });
 });
+// Symlinked state dir (dotfiles-managed ~/.gstack via stow/chezmoi): the
+// fd-anchored path refuses to follow it (O_NOFOLLOW) — the refusal must warn,
+// never throw, and never chmod the symlink target. POSIX-branch behavior:
+// Windows takes the icacls branch and has no POSIX modes (stat reports 0o666),
+// so gate like the sibling tests above.
+test('restrictDirectoryPermissions warns and skips a symlinked dir without throwing', () => {
+  if (process.platform === 'win32') return;
+  const base = fs.mkdtempSync(path.join(os.tmpdir(), 'fp-symlink-'));
+  const target = path.join(base, 'real');
+  const link = path.join(base, 'link');
+  fs.mkdirSync(target, { mode: 0o755 });
+  fs.symlinkSync(target, link);
+  // Capture the actual post-umask mode rather than assuming 0o755 — a strict
+  // umask (077) would legitimately yield 0o700 at creation time.
+  const modeBefore = fs.statSync(target).mode & 0o777;
+  try {
+    expect(() => restrictDirectoryPermissions(link)).not.toThrow();
+    // Target permissions untouched — the link was never followed.
+    expect(fs.statSync(target).mode & 0o777).toBe(modeBefore);
+  } finally {
+    fs.rmSync(base, { recursive: true, force: true });
+  }
+});
+

browse/test/path-validation.test.ts

@@ -115,7 +115,7 @@ describe('validateOutputPath — symlink resolution', () => {
   it('blocks symlink inside /tmp pointing outside safe dirs', () => {
     const linkPath = join(tmpdir(), 'test-output-symlink-' + Date.now() + '.png');
     try {
-      symlinkSync('/etc/crontab', linkPath);
+      symlinkSync('/etc/passwd', linkPath); // /etc/passwd exists on every Unix — /etc/crontab is absent on Amazon Linux/Fedora minimal;
       expect(() => validateOutputPath(linkPath)).toThrow(/Path must be within/);
     } finally {
       try { unlinkSync(linkPath); } catch {}

browse/test/server-lock-errors.test.ts

@@ -14,6 +14,7 @@
  */
 
 import { describe, test, expect, afterAll } from 'bun:test';
+import { canRevokeWrites } from '../../test/helpers/fs-caps';
 import * as fs from 'fs';
 // Default (CJS) export — its properties are mutable in Bun, unlike the frozen
 // `* as fs` namespace, and mutations propagate to cli.ts's own fs import.
@@ -41,7 +42,7 @@ describe('acquireServerLock (#1084 error honesty)', () => {
   });
 
   test('EACCES throws ServerLockError with the real errno — NOT phantom contention', () => {
-    if (process.platform === 'win32' || process.getuid?.() === 0) return; // chmod semantics differ
+    if (!canRevokeWrites()) return; // chmod is advisory here (win32, root, DAC-override containers)
     const rodir = path.join(tmpRoot, 'rodir');
     fs.mkdirSync(rodir, { recursive: true });
     fs.chmodSync(rodir, 0o500); // r-x: open('wx') inside fails EACCES

browse/test/session-persist.test.ts

@@ -16,6 +16,7 @@
  */
 
 import { describe, test, expect, afterAll } from 'bun:test';
+import { canRevokeWrites } from '../../test/helpers/fs-caps';
 import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
@@ -128,7 +129,7 @@ describe('session-persist units', () => {
 
   test('a failed snapshot write preserves the previous good snapshot', async () => {
     // chmod-based read-only dirs don't bind on Windows or when running as root.
-    if (process.platform === 'win32' || process.getuid?.() === 0) return;
+    if (!canRevokeWrites()) return; // chmod is advisory here (win32, root, DAC-override containers)
     const dir = path.join(tmpRoot, 'ro');
     fs.mkdirSync(dir);
     const file = path.join(dir, 'session-state.json');