@aiworker/web 1.22.2 → 1.23.0

package/server/lib/git/service.test.js

@@ -4,6 +4,8 @@ import os from 'node:os';
 import path from 'node:path';
 import { afterAll, afterEach, describe, expect, it, vi } from 'vitest';
 import simpleGit from 'simple-git';
+import { loadSourceSections, parseSource, sourceKey } from '../walkthrough/sources.js';
+import { registerGitRoutes } from './routes.js';
 
 import {
   checkoutBranch,
@@ -14,6 +16,10 @@ import {
   getBranches,
   getUnpushedBranchCounts,
   getRangeDiff,
+  getBranchBase,
+  getCommitDiff,
+  getCommitFiles,
+  getLog,
   getStatus,
   getWorktrees,
   isGitRepository,
@@ -29,6 +35,7 @@ import {
   unstageFiles,
   applyHunk,
   getDiff,
+  getUntrackedDiffs,
   getFileDiff,
   validateWorktreeCreate,
   parseBranchCreationSource,
@@ -183,28 +190,49 @@ describe.runIf(canRunGit())('setLocalIdentity', () => {
       "ssh -i '/tmp/test key' -o IdentitiesOnly=yes"
     );
   });
+
+  it('configures the stored credential helper for token auth with the targeted simple-git opt-in', async () => {
+    const { tmpDir } = await createTempRepo();
+
+    await setLocalIdentity(tmpDir, {
+      userName: 'Token User',
+      userEmail: 'token@example.com',
+      authType: 'token',
+      host: 'github.com',
+    });
+
+    expect(runGit(tmpDir, ['config', '--local', '--get', 'credential.helper']).trim()).toBe('store');
+  });
+
+  it('clears the stored credential helper when switching to SSH auth', async () => {
+    const { tmpDir } = await createTempRepo();
+
+    await setLocalIdentity(tmpDir, {
+      userName: 'Token User',
+      userEmail: 'token@example.com',
+      authType: 'token',
+      host: 'github.com',
+    });
+    await setLocalIdentity(tmpDir, {
+      userName: 'SSH User',
+      userEmail: 'ssh@example.com',
+      authType: 'ssh',
+      sshKey: '/tmp/test key',
+    });
+
+    expect(runGit(tmpDir, ['config', '--local', '--get', 'core.sshCommand']).trim()).toBe(
+      "ssh -i '/tmp/test key' -o IdentitiesOnly=yes"
+    );
+    expect(() => runGit(tmpDir, ['config', '--local', '--get', 'credential.helper'])).toThrow();
+  });
 });
 
 // ---------------------------------------------------------------------------
 // applyHunk (per-hunk stage / unstage / discard)
 // ---------------------------------------------------------------------------
 
-/** Minimal unified-diff splitter: returns standalone per-hunk patches. */
-const splitHunks = (patch) => {
-  const lines = patch.split(/\r?\n/);
-  const headerEnd = lines.findIndex((line) => /^@@\s/.test(line));
-  if (headerEnd === -1) return [];
-  const header = lines.slice(0, headerEnd);
-  const hunks = [];
-  for (let i = headerEnd; i < lines.length; i += 1) {
-    const line = lines[i];
-    if (/^@@\s/.test(line)) hunks.push([...header, line]);
-    else if (hunks.length > 0) hunks[hunks.length - 1].push(line);
-  }
-  return hunks.map((hunk) => hunk.join('\n'))
-    .filter((hunk) => hunk.trim().length > 0)
-    .map((hunk) => (hunk.endsWith('\n') ? hunk : `${hunk}\n`));
-};
+// Exercise the actual client splitter against the server apply boundary.
+import { splitPatchIntoHunks as splitHunks } from '../../../../ui/src/lib/diff/patchFileDiff.ts';
 
 const writeFile = (repo, name, contents) =>
   fs.promises.writeFile(path.join(repo, name), contents, 'utf8');
@@ -220,6 +248,77 @@ const readWorking = (repo) => fs.promises.readFile(path.join(repo, 'file.txt'),
 const readStaged = async (git) => (await git.raw(['show', ':file.txt'])).replace(/\r\n/g, '\n');
 
 describe('applyHunk', () => {
+  it('stages successive hunks and never discards a stale staged or committed patch', async () => {
+    if (!canRunGit()) return;
+    const { tmpDir, git } = await createTempRepo();
+    const original = Array.from({ length: 60 }, (_, index) => `line${index}`);
+    const changed = [...original];
+    changed[1] = 'FIRST'; changed[25] = 'SECOND'; changed[50] = 'THIRD';
+    await writeFile(tmpDir, 'file.txt', original.join('\n') + '\n');
+    await git.add('file.txt'); await git.commit('Initial');
+    await writeFile(tmpDir, 'file.txt', changed.join('\n') + '\n');
+    const historical = splitHunks(await getDiff(tmpDir, { path: 'file.txt' }));
+    expect(historical).toHaveLength(3);
+    await applyHunk(tmpDir, 'file.txt', { patch: historical[0], action: 'stage' });
+    const remaining = splitHunks(await getDiff(tmpDir, { path: 'file.txt' }));
+    expect(remaining).toHaveLength(2);
+    await applyHunk(tmpDir, 'file.txt', { patch: remaining[0], action: 'stage' });
+    const stalePath = path.join(tmpDir, 'stale.patch');
+    await fs.promises.writeFile(stalePath, historical[0]);
+    // Git's reverse applicability check accepts it, but it is no longer an
+    // unstaged hunk. The server must reject it before touching the working file.
+    await git.raw(['apply', '--reverse', '--check', stalePath]);
+    await expect(applyHunk(tmpDir, 'file.txt', { patch: historical[0], action: 'discard' })).rejects.toThrow('refresh and try again');
+    expect(await readWorking(tmpDir)).toBe(changed.join('\n') + '\n');
+    const last = splitHunks(await getDiff(tmpDir, { path: 'file.txt' }));
+    expect(last).toHaveLength(1);
+    await applyHunk(tmpDir, 'file.txt', { patch: last[0], action: 'discard' });
+    changed[50] = original[50];
+    expect(await readWorking(tmpDir)).toBe(changed.join('\n') + '\n');
+    expect(await readStaged(git)).toBe(changed.join('\n') + '\n');
+    const staged = splitHunks(await getDiff(tmpDir, { path: 'file.txt', staged: true }));
+    await applyHunk(tmpDir, 'file.txt', { patch: staged[0], action: 'unstage' });
+    expect(await readWorking(tmpDir)).toBe(changed.join('\n') + '\n');
+    await git.add('file.txt'); await git.commit('Committed changes');
+    await expect(applyHunk(tmpDir, 'file.txt', { patch: historical[0], action: 'discard' })).rejects.toThrow('refresh and try again');
+  });
+
+  it.each(['crlf', 'mixed'])('preserves %s file bytes through stage, unstage and discard', async (endings) => {
+    if (!canRunGit()) return;
+    const { tmpDir, git } = await createTempRepo();
+    await git.addConfig('core.autocrlf', 'false');
+    const serialize = (first, last) => Array.from({ length: 30 }, (_, index) => {
+      const text = index === 0 ? first : index === 29 ? last : `line${index}`;
+      return text + (endings === 'crlf' || index % 2 === 0 ? '\r\n' : '\n');
+    }).join('');
+    const original = serialize('first', 'last');
+    const edited = serialize('FIRST', 'LAST');
+    await writeFile(tmpDir, 'file.txt', original);
+    await git.add('file.txt'); await git.commit('Initial');
+    await writeFile(tmpDir, 'file.txt', edited);
+    const hunks = splitHunks(await getDiff(tmpDir, { path: 'file.txt' }));
+    await applyHunk(tmpDir, 'file.txt', { patch: hunks[0], action: 'stage' });
+    expect(await git.raw(['show', ':file.txt'])).toBe(serialize('FIRST', 'last'));
+    const staged = splitHunks(await getDiff(tmpDir, { path: 'file.txt', staged: true }));
+    await applyHunk(tmpDir, 'file.txt', { patch: staged[0], action: 'unstage' });
+    expect(await git.raw(['show', ':file.txt'])).toBe(original);
+    const working = splitHunks(await getDiff(tmpDir, { path: 'file.txt' }));
+    await applyHunk(tmpDir, 'file.txt', { patch: working[0], action: 'discard' });
+    expect(await fs.promises.readFile(path.join(tmpDir, 'file.txt'), 'utf8')).toBe(serialize('first', 'LAST'));
+  });
+
+  it('rejects extra files hidden before the requested patch', async () => {
+    if (!canRunGit()) return;
+    const { tmpDir, git } = await createTempRepo();
+    for (const name of ['file.txt', 'other.txt']) await writeFile(tmpDir, name, ORIGINAL_FILE);
+    await git.add('.'); await git.commit('Initial');
+    for (const name of ['file.txt', 'other.txt']) await writeFile(tmpDir, name, EDITED_FILE);
+    const other = splitHunks(await getDiff(tmpDir, { path: 'other.txt' }))[0];
+    const requested = splitHunks(await getDiff(tmpDir, { path: 'file.txt' }))[0];
+    await expect(applyHunk(tmpDir, 'file.txt', { patch: requested + other, action: 'stage' })).rejects.toThrow('refresh and try again');
+    expect(await git.raw(['diff', '--cached'])).toBe('');
+  });
+
   it('rejects an invalid action or a patch without a hunk header', async () => {
     const { tmpDir } = await createTempRepo();
     await expect(applyHunk(tmpDir, 'file.txt', { patch: '@@ -1 +1 @@\n a\n', action: 'bogus' })).rejects.toThrow(
@@ -302,10 +401,9 @@ describe('applyHunk', () => {
     );
   });
 
-  it('accepts hunk patches for files with spaces in their path', async () => {
+  it.each(['file name.txt', 'зміни.txt'])('accepts hunk patches for %s', async (filePath) => {
     if (!canRunGit()) return;
     const { tmpDir, git } = await createTempRepo();
-    const filePath = 'file name.txt';
     await writeFile(tmpDir, filePath, ORIGINAL_FILE);
     await git.add(filePath);
     await git.commit('Initial');
@@ -322,6 +420,71 @@ describe('applyHunk', () => {
   });
 });
 
+describe.runIf(canRunGit())('untracked diffs', () => {
+  it.each(['false', 'warn'])('returns only the patch with core.safecrlf=%s', async (safecrlf) => {
+    const { tmpDir, git } = await createTempRepo();
+    await git.addConfig('core.autocrlf', 'true');
+    await git.addConfig('core.safecrlf', safecrlf);
+    fs.writeFileSync(path.join(tmpDir, 'new file.txt'), 'first\nsecond\n');
+
+    // Confirm this fixture produces a real diff exit, including stderr in the warning case.
+    let expectedPatch;
+    try {
+      runGit(tmpDir, ['diff', '--no-color', '--full-index', '--no-index', '--', '/dev/null', 'new file.txt']);
+      throw new Error('Expected git diff to exit with differences');
+    } catch (error) {
+      expect(error.status).toBe(1);
+      expectedPatch = error.stdout;
+      if (safecrlf === 'warn') {
+        expect(error.stderr).toContain('LF will be replaced by CRLF');
+      }
+    }
+
+    const diff = await getDiff(tmpDir, { path: 'new file.txt' });
+    expect(diff).toBe(expectedPatch);
+    expect(diff).toContain('+first\n+second\n');
+    expect(diff).not.toContain('warning:');
+    expect(await getUntrackedDiffs(tmpDir, ['new file.txt'])).toEqual([diff]);
+  });
+
+  it('accepts an empty untracked file without a process error', async () => {
+    const { tmpDir } = await createTempRepo();
+    fs.writeFileSync(path.join(tmpDir, 'empty.txt'), '');
+    const diff = await getDiff(tmpDir, { path: 'empty.txt' });
+    expect(diff).toContain('new file mode 100644');
+    expect(diff).not.toContain('@@');
+    expect(await getUntrackedDiffs(tmpDir, ['empty.txt'])).toEqual([diff]);
+  });
+
+  it('rejects fatal conversion errors while preserving other batch entries', async () => {
+    const { tmpDir } = await createTempRepo();
+    runGit(tmpDir, ['config', 'diff.broken.textconv', 'false']);
+    fs.writeFileSync(path.join(tmpDir, '.gitattributes'), 'bad.txt diff=broken\n');
+    fs.writeFileSync(path.join(tmpDir, 'first.safe'), 'first\n');
+    fs.writeFileSync(path.join(tmpDir, 'bad.txt'), 'bad\n');
+    fs.writeFileSync(path.join(tmpDir, 'last.safe'), 'last\n');
+
+    await expect(getDiff(tmpDir, { path: 'bad.txt' })).rejects.toThrow('unable to read files to diff');
+    const diffs = await getUntrackedDiffs(tmpDir, ['first.safe', 'bad.txt', 'last.safe'], { concurrency: 1 });
+    expect(diffs).toHaveLength(3);
+    expect(diffs[0]).toContain('+first\n');
+    expect(diffs[1]).toBe('');
+    expect(diffs[2]).toContain('+last\n');
+  });
+
+  it('rejects truncated patches when the process output exceeds the buffer limit', async () => {
+    const { tmpDir } = await createTempRepo();
+    fs.writeFileSync(path.join(tmpDir, 'large.txt'), 'x'.repeat(21 * 1024 * 1024) + '\n');
+    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    try {
+      await expect(getDiff(tmpDir, { path: 'large.txt' })).rejects.toThrow('maxBuffer');
+      expect(await getUntrackedDiffs(tmpDir, ['large.txt'])).toEqual(['']);
+    } finally {
+      errorSpy.mockRestore();
+    }
+  });
+});
+
 describe('symlink diffs', () => {
   it('treats an untracked directory symlink as a link in patch and split diffs', async () => {
     if (!canRunGit() || process.platform === 'win32') return;
@@ -1669,18 +1832,249 @@ describe.runIf(canRunGit())('getUnpushedBranchCounts', () => {
   });
 });
 
+describe.runIf(canRunGit())('commit comparisons', () => {
+  it('shows only the selected commit and gives walkthrough the identical patch', async () => {
+    const { repository } = createRepositoryWithRemote();
+    fs.writeFileSync(path.join(repository, 'README.md'), 'selected version\n');
+    runGit(repository, ['add', '.']);
+    runGit(repository, ['commit', '-m', 'selected']);
+    const hash = runGit(repository, ['rev-parse', 'HEAD']).trim();
+    fs.writeFileSync(path.join(repository, 'README.md'), 'later version\n');
+    runGit(repository, ['add', '.']);
+    runGit(repository, ['commit', '-m', 'later']);
+    fs.writeFileSync(path.join(repository, 'README.md'), 'uncommitted version\n');
+    const patch = await getCommitDiff(repository, { hash, path: 'README.md' });
+    expect(patch).toContain('+selected version');
+    expect(patch).not.toContain('later version');
+    expect(patch).not.toContain('uncommitted version');
+    expect((await getCommitFiles(repository, hash)).files).toEqual([
+      { path: 'README.md', insertions: 1, deletions: 1, isBinary: false, changeType: 'M' },
+    ]);
+    const source = parseSource({ kind: 'commit', hash });
+    expect(sourceKey(source)).toBe(`commit:${hash}`);
+    expect((await loadSourceSections(repository, source)).sections).toEqual([{ scope: 'commit', patch }]);
+    const routes = new Map();
+    registerGitRoutes({
+      get: (url, handler) => routes.set(url, handler), post() {}, put() {}, delete() {},
+    });
+    let response;
+    await routes.get('/api/git/commit-diff')(
+      { query: { directory: repository, hash, path: 'README.md' } },
+      { json: (body) => { response = body; }, status: (code) => { throw new Error(`Unexpected status ${code}`); } },
+    );
+    expect(response).toEqual({ diff: patch });
+  });
+
+  it('handles root and empty commits and rejects invalid hashes', async () => {
+    const { repository } = createRepositoryWithRemote();
+    const root = runGit(repository, ['rev-parse', 'HEAD']).trim();
+    expect(await getCommitDiff(repository, { hash: root })).toContain('+# Test');
+    expect((await getCommitFiles(repository, root)).files[0].changeType).toBe('A');
+    runGit(repository, ['commit', '--allow-empty', '-m', 'empty']);
+    const empty = runGit(repository, ['rev-parse', 'HEAD']).trim();
+    expect(await getCommitDiff(repository, { hash: empty })).toBe('');
+    expect(await getCommitFiles(repository, empty)).toEqual({ files: [] });
+    expect(() => parseSource({ kind: 'commit', hash: 'HEAD' })).toThrow();
+    expect(() => parseSource({ kind: 'commit', hash: [root] })).toThrow();
+    await expect(getCommitDiff(repository, { hash: 'HEAD' })).rejects.toThrow();
+    await expect(getCommitFiles(repository, '0'.repeat(40))).rejects.toThrow();
+  });
+
+  it('keeps rename paths and original contents together, including whitespace in names', async () => {
+    const { repository } = createRepositoryWithRemote();
+    const destination = ' new\nname.md';
+    runGit(repository, ['mv', 'README.md', destination]);
+    runGit(repository, ['commit', '-m', 'rename']);
+    const hash = runGit(repository, ['rev-parse', 'HEAD']).trim();
+    const { files } = await getCommitFiles(repository, hash);
+    expect(files).toEqual([{ path: destination, previousPath: 'README.md', changeType: 'R', insertions: 0, deletions: 0, isBinary: false }]);
+    const patch = await getCommitDiff(repository, { hash, path: destination, previousPath: files[0].previousPath });
+    expect(patch).toContain('rename from README.md');
+    expect(patch).toContain('similarity index 100%');
+  });
+
+  it('compares a merge commit against its first parent', async () => {
+    const { repository } = createRepositoryWithRemote();
+    runGit(repository, ['checkout', '-b', 'side']);
+    fs.writeFileSync(path.join(repository, 'side.txt'), 'side\n');
+    runGit(repository, ['add', '.']);
+    runGit(repository, ['commit', '-m', 'side']);
+    runGit(repository, ['checkout', 'next']);
+    fs.writeFileSync(path.join(repository, 'main.txt'), 'main\n');
+    runGit(repository, ['add', '.']);
+    runGit(repository, ['commit', '-m', 'main']);
+    runGit(repository, ['merge', '--no-ff', 'side', '-m', 'merge']);
+    const hash = runGit(repository, ['rev-parse', 'HEAD']).trim();
+    expect((await getCommitFiles(repository, hash)).files.map((file) => file.path)).toEqual(['side.txt']);
+    const patch = await getCommitDiff(repository, { hash });
+    expect(patch).toContain('+side');
+    expect(patch).not.toContain('main.txt');
+  });
+
+  it('limits current-branch history to 50 commits without including another branch', async () => {
+    const { repository } = createRepositoryWithRemote();
+    runGit(repository, ['checkout', '-b', 'other']);
+    runGit(repository, ['commit', '--allow-empty', '-m', 'other branch only']);
+    runGit(repository, ['checkout', 'next']);
+    for (let index = 0; index < 51; index += 1) runGit(repository, ['commit', '--allow-empty', '-m', `current ${index}`]);
+    const history = await getLog(repository, { maxCount: 50, to: 'refs/heads/next' });
+    expect(history.all).toHaveLength(50);
+    expect(history.all[0].message).toBe('current 50');
+    expect(history.all.some((commit) => commit.message === 'other branch only')).toBe(false);
+  });
+});
+
 describe.runIf(canRunGit())('getRangeDiff', () => {
-  it('resolves a base that exists only on a remote other than origin', async () => {
+  it('loads a committed deletion that no longer exists in HEAD or the working tree', async () => {
+    const { repository } = createRepositoryWithRemote();
+    runGit(repository, ['rm', 'README.md']);
+    runGit(repository, ['commit', '-m', 'delete file']);
+    const diff = await getRangeDiff(repository, { base: 'origin/react', head: 'next', path: 'README.md', includeWorkingTree: true });
+    expect(diff).toContain('deleted file mode');
+    expect(diff).toContain('-# Test');
+  });
+
+  it('carries the working-tree option through the actual HTTP route handlers', async () => {
+    const { repository } = createRepositoryWithRemote();
+    fs.writeFileSync(path.join(repository, 'local.txt'), 'current local work\n');
+    const routes = new Map();
+    registerGitRoutes({
+      get: (url, handler) => routes.set(url, handler),
+      post() {},
+      put() {},
+      delete() {},
+    });
+    const query = { directory: repository, base: 'origin/react', head: 'next', includeWorkingTree: 'true' };
+    for (const endpoint of ['range-diff', 'range-files']) {
+      let status = 200;
+      let body;
+      const response = {
+        status(value) { status = value; return this; },
+        json(value) { body = value; },
+      };
+      await routes.get(`/api/git/${endpoint}`)({ query }, response);
+      expect(status).toBe(200);
+      if (endpoint === 'range-diff') expect(body.diff).toContain('+current local work');
+      else expect(body.files).toEqual([{ path: 'local.txt', status: 'A' }]);
+    }
+  });
+
+  it('asks for a new base after restacking and compares against the selected parent', async () => {
+    const { repository } = createRepositoryWithRemote();
+    runGit(repository, ['checkout', '-b', 'child', 'origin/react']);
+    fs.writeFileSync(path.join(repository, 'child.txt'), 'child\n');
+    runGit(repository, ['add', '.']);
+    runGit(repository, ['commit', '-m', 'child']);
+    expect(await getBranchBase(repository, 'child')).toEqual({ base: 'origin/react' });
+    runGit(repository, ['checkout', '-b', 'parent', 'origin/react']);
+    fs.writeFileSync(path.join(repository, 'parent.txt'), 'parent\n');
+    runGit(repository, ['add', '.']);
+    runGit(repository, ['commit', '-m', 'parent']);
+    runGit(repository, ['checkout', 'child']);
+    runGit(repository, ['rebase', 'parent']);
+    expect(await getBranchBase(repository, 'child')).toEqual({ base: null });
+    fs.writeFileSync(path.join(repository, 'child.txt'), 'current child\n');
+    const options = { base: 'refs/heads/parent', head: 'child', includeWorkingTree: true };
+    expect(await getRangeFiles(repository, options)).toEqual([{ path: 'child.txt', status: 'A' }]);
+    const diff = await getRangeDiff(repository, options);
+    expect(diff).toContain('+current child');
+    expect(diff).not.toContain('parent.txt');
+  });
+
+  it('combines committed, staged, unstaged and untracked work without changing the real index', async () => {
+    const { repository } = createRepositoryWithRemote();
+    fs.writeFileSync(path.join(repository, 'README.md'), '# Committed\n');
+    runGit(repository, ['add', 'README.md']);
+    runGit(repository, ['commit', '-m', 'branch change']);
+    fs.writeFileSync(path.join(repository, 'README.md'), '# Staged\n');
+    fs.writeFileSync(path.join(repository, 'staged.txt'), 'staged only\n');
+    runGit(repository, ['add', '.']);
+    fs.writeFileSync(path.join(repository, 'README.md'), '# Current\n');
+    fs.writeFileSync(path.join(repository, 'untracked.txt'), 'new local file\n');
+    fs.writeFileSync(path.join(repository, ' leading space.txt'), 'space path\n');
+    const indexBefore = fs.readFileSync(path.join(repository, '.git/index'));
+    const options = { base: 'origin/react', head: 'next', includeWorkingTree: true };
+
+    const diff = await getRangeDiff(repository, options);
+    expect(diff).toContain('-# Test');
+    expect(diff).toContain('+# Current');
+    expect(diff).not.toContain('+# Staged');
+    expect(diff).not.toContain('+# Committed');
+    expect(diff).toContain('+new local file');
+    expect(diff).toContain('+staged only');
+    expect(await getRangeFiles(repository, options)).toEqual(expect.arrayContaining([
+      { path: 'README.md', status: 'M' },
+      { path: 'staged.txt', status: 'A' },
+      { path: 'untracked.txt', status: 'A' },
+      { path: ' leading space.txt', status: 'A' },
+    ]));
+    const { sections } = await loadSourceSections(repository, { kind: 'branch', baseRef: options.base, headRef: options.head });
+    expect(sections).toEqual([{ scope: 'branch', patch: diff }]);
+    expect(fs.readFileSync(path.join(repository, '.git/index'))).toEqual(indexBefore);
+
+    const committed = await getRangeDiff(repository, { base: options.base, head: options.head });
+    expect(committed).toContain('+# Committed');
+    expect(committed).not.toContain('+new local file');
+    fs.writeFileSync(path.join(repository, 'README.md'), '# Latest\n');
+    expect(await getRangeDiff(repository, { ...options, path: 'README.md' })).toContain('+# Latest');
+  });
+
+  it('reports the final file after a staged deletion is recreated, and omits undone branch changes', async () => {
+    const { repository } = createRepositoryWithRemote();
+    runGit(repository, ['rm', 'README.md']);
+    fs.writeFileSync(path.join(repository, 'README.md'), '# Recreated\n');
+    const options = { base: 'origin/react', head: 'next', includeWorkingTree: true };
+    expect(await getRangeFiles(repository, options)).toEqual([{ path: 'README.md', status: 'M' }]);
+    const diff = await getRangeDiff(repository, options);
+    expect(diff).toContain('-# Test');
+    expect(diff).toContain('+# Recreated');
+    expect(diff.match(/diff --git/g)).toHaveLength(1);
+    fs.writeFileSync(path.join(repository, 'README.md'), '# Test\n');
+    expect(await getRangeFiles(repository, options)).toEqual([]);
+    expect(await getRangeDiff(repository, options)).toBe('');
+  });
+
+  it('keeps local and remote bases distinct and rejects a different checked-out branch', async () => {
+    const { repository } = createRepositoryWithRemote();
+    runGit(repository, ['branch', 'react']);
+    fs.writeFileSync(path.join(repository, 'parent.txt'), 'parent work\n');
+    runGit(repository, ['add', '.']);
+    runGit(repository, ['commit', '-m', 'parent work']);
+    runGit(repository, ['branch', '-f', 'react', 'HEAD']);
+    fs.writeFileSync(path.join(repository, 'child.txt'), 'child work\n');
+    const options = { head: 'next', includeWorkingTree: true };
+    const local = await getRangeDiff(repository, { ...options, base: 'react' });
+    const remote = await getRangeDiff(repository, { ...options, base: 'origin/react' });
+    expect(local).not.toContain('parent.txt');
+    expect(remote).toContain('parent.txt');
+    expect(local).toContain('child.txt');
+    expect(await getRangeFiles(repository, { ...options, base: 'react' })).toEqual([{ path: 'child.txt', status: 'A' }]);
+    runGit(repository, ['checkout', 'react']);
+    await expect(getRangeDiff(repository, { ...options, base: 'origin/react' })).rejects.toThrow(/checked-out branch/);
+  });
+
+  it('includes untracked symlinks as links without reading their targets', async () => {
+    const { repository } = createRepositoryWithRemote();
+    const outside = path.join(createTempDir(), 'outside.txt');
+    fs.writeFileSync(outside, 'must not be in a diff\n');
+    fs.symlinkSync(outside, path.join(repository, 'link.txt'));
+    const diff = await getRangeDiff(repository, { base: 'origin/react', head: 'next', includeWorkingTree: true });
+    expect(diff).toContain('new file mode 120000');
+    expect(diff).toContain(outside);
+    expect(diff).not.toContain('must not be in a diff');
+  });
+
+  it('uses an explicitly selected base on a remote other than origin', async () => {
     const { repository } = createRepositoryWithRemote({ remoteName: 'upstream', defaultBranch: 'react' });
-    // Only refs/remotes/upstream/react carries the base — git cannot resolve the
-    // bare name, so an unqualified `react...next` fails with "ambiguous argument".
+    // The selected remote ref must work without a local branch of that name.
     fs.writeFileSync(path.join(repository, 'feature.txt'), 'work\n');
     runGit(repository, ['add', 'feature.txt']);
     runGit(repository, ['commit', '-m', 'feature']);
 
-    const diff = await getRangeDiff(repository, { base: 'react', head: 'next' });
+    const diff = await getRangeDiff(repository, { base: 'upstream/react', head: 'next' });
 
     expect(diff).toContain('feature.txt');
+    await expect(getRangeDiff(repository, { base: 'react', head: 'next' })).rejects.toThrow(/is not available locally/);
   });
 
   it('names an unfetched remote-only ref instead of failing with git\'s ambiguous argument (#2735)', async () => {
@@ -1693,6 +2087,9 @@ describe.runIf(canRunGit())('getRangeDiff', () => {
 });
 
 describe('parseBranchCreationSource', () => {
+  it('does not reuse the creation base after a rebase', () => {
+    expect(parseBranchCreationSource('rebase (finish): refs/heads/feature onto abc123\nbranch: Created from main')).toBeNull();
+  });
   it('returns the source ref from the oldest creation entry', () => {
     // Reflog lists newest entries first; creation is the last line.
     const reflog = [
@@ -1739,7 +2136,7 @@ describe.runIf(canRunGit())('getRangeFiles', () => {
     runGit(repository, ['add', 'added.txt', 'README.md']);
     runGit(repository, ['commit', '-m', 'changes']);
 
-    const files = await getRangeFiles(repository, { base: 'react', head: 'next' });
+    const files = await getRangeFiles(repository, { base: 'origin/react', head: 'next' });
 
     expect(files).toEqual(expect.arrayContaining([
       { path: 'added.txt', status: 'A' },
@@ -1761,7 +2158,7 @@ describe.runIf(canRunGit())('getRangeFiles', () => {
     runGit(repository, ['add', '-A']);
     runGit(repository, ['commit', '-m', 'rename']);
 
-    const files = await getRangeFiles(repository, { base: 'react', head: 'next' });
+    const files = await getRangeFiles(repository, { base: 'origin/react', head: 'next' });
 
     const renameEntry = files.find((file) => file.status === 'R');
     expect(renameEntry).toBeDefined();
@@ -1783,7 +2180,7 @@ describe.runIf(canRunGit())('getRangeFiles', () => {
     runGit(repository, ['add', '-A']);
     runGit(repository, ['commit', '-m', 'copy']);
 
-    const files = await getRangeFiles(repository, { base: 'react', head: 'next' });
+    const files = await getRangeFiles(repository, { base: 'origin/react', head: 'next' });
 
     const copyEntry = files.find((file) => file.status === 'C');
     expect(copyEntry).toBeDefined();

package/server/lib/inherited-env.js

@@ -12,7 +12,9 @@
 import { createRequire } from 'node:module';
 import { existsSync } from 'node:fs';
 
-const LINUX_ENV_BINARIES = ['/usr/bin/env', '/bin/env'];
+const POSIX_ENV_BINARIES = ['/usr/bin/env', '/bin/env'];
+/** Variables a PTY shell must never inherit from the AiWorker host process. */
+const PTY_HOST_PRIVATE_VARIABLES = Object.freeze(['ARGV0', 'NODE_CHANNEL_FD']);
 
 /**
  * Remove AppImage `ARGV0` from a mutable env object (or `process.env`).
@@ -49,26 +51,31 @@ export function clearAppImageArgv0FromProcessEnv() {
 }
 
 /**
- * Resolve a Linux PTY launch that drops native `ARGV0` before the shell starts.
+ * Resolve a POSIX PTY launch that unsets host-private variables before the
+ * shell starts.
  *
- * `bun-pty` merges the OS environ into the child, so deleting `ARGV0` from the
- * JS env object alone is not enough. Wrapping with `env -u ARGV0` unsets it
- * before execing the real shell. No-op on non-Linux platforms.
+ * `bun-pty` merges the OS environ into the child, so deleting a variable from
+ * the JS env object alone is not enough: AppImage `ARGV0` came back on Linux,
+ * and the daemon's `NODE_CHANNEL_FD` came back everywhere (Node then warns
+ * "Failed to parse IPC channel number" when a CLI such as opencode exits).
+ * Wrapping with `env -u NAME ...` unsets them before execing the real shell.
+ * No-op on Windows and when no `env` binary is found.
  *
  * @param {string} executable
  * @param {string[]} args
+ * @param {readonly string[]} variables
  * @returns {{ executable: string, args: string[] }}
  */
-export function resolveLinuxPtyLaunch(executable, args = []) {
-  if (process.platform !== 'linux') {
+export function resolvePosixPtyLaunch(executable, args = [], variables = PTY_HOST_PRIVATE_VARIABLES) {
+  if (process.platform === 'win32' || variables.length === 0) {
     return { executable, args };
   }
-  const envBinary = LINUX_ENV_BINARIES.find((candidate) => existsSync(candidate));
+  const envBinary = POSIX_ENV_BINARIES.find((candidate) => existsSync(candidate));
   if (!envBinary) {
     return { executable, args };
   }
   return {
     executable: envBinary,
-    args: ['-u', 'ARGV0', executable, ...args],
+    args: [...variables.flatMap((name) => ['-u', name]), executable, ...args],
   };
 }

package/server/lib/inherited-env.test.js

@@ -1,7 +1,7 @@
 import { describe, expect, it } from 'vitest';
 import {
   clearAppImageArgv0FromProcessEnv,
-  resolveLinuxPtyLaunch,
+  resolvePosixPtyLaunch,
   stripAppImageArgv0Leak,
 } from './inherited-env.js';
 
@@ -46,18 +46,17 @@ describe('clearAppImageArgv0FromProcessEnv', () => {
   });
 });
 
-describe('resolveLinuxPtyLaunch', () => {
-  it('wraps the shell with env -u ARGV0 on Linux', () => {
-    if (process.platform !== 'linux') return;
-    expect(resolveLinuxPtyLaunch('/bin/zsh', ['-l'])).toEqual({
+describe('resolvePosixPtyLaunch', () => {
+  it('wraps the shell with env -u for every host-private variable on POSIX', () => {
+    if (process.platform === 'win32') return;
+    expect(resolvePosixPtyLaunch('/bin/zsh', ['-l'])).toEqual({
       executable: expect.stringMatching(/\/env$/),
-      args: ['-u', 'ARGV0', '/bin/zsh', '-l'],
+      args: ['-u', 'ARGV0', '-u', 'NODE_CHANNEL_FD', '/bin/zsh', '-l'],
     });
   });
 
-  it('leaves non-Linux launches unchanged', () => {
-    if (process.platform === 'linux') return;
-    expect(resolveLinuxPtyLaunch('/bin/zsh', ['-l'])).toEqual({
+  it('leaves the launch unchanged with nothing to unset', () => {
+    expect(resolvePosixPtyLaunch('/bin/zsh', ['-l'], [])).toEqual({
       executable: '/bin/zsh',
       args: ['-l'],
     });

package/server/lib/message-queue/DOCUMENTATION.md

@@ -140,7 +140,10 @@ allowlists.
 
 Every mutation broadcasts `aiworker:message-queue.updated` with
 `{ revision, session }` to all connected clients (SSE and WS), so several
-devices on one server see one queue. The session in that payload always names
+devices on one server see one queue. SSE uses the shared control stream at
+`/api/openchamber/events`; `/api/global/event` carries no AiWorker events.
+The UI subscribes independently of its OpenCode transport and re-reads the
+snapshot whenever either stream reconnects. The session in that payload always names
 its `directory`, including the broadcast that removes the last item: the UI
 keys its projection by directory, and a broadcast without one left the
 delivered message on screen (a session's directory is remembered until the