wishforge-ide/packages/runtime/test/git-contract.test.ts
eust-w d4ea7c7626 🔒 Reduce an agent workspace's Git config to a safe allowlist before trusted Git commands
The agent's file tools are confined to its workspace, and the
workspace holds .git. It could plant .git/config and .gitattributes
there, and the executor then ran trusted git add, diff, bundle and
merge in that workspace to export the checkpoint and start a repair
round. Git honours repo-local configuration for every command and no
environment variable disables it, so a planted clean or smudge filter,
diff or merge driver, core.fsmonitor or sshCommand, an include, or a
url.insteadOf transport rewrite would run as the worker: in the
development host mode, as the operator, outside any sandbox. The
driver names are the agent's to choose, so -c overrides cannot reach
them.

Before the checkpoint and before mergeTarget, .git/config is now
reduced to core basics, remote, branch and extensions, which is what a
clone needs to fetch, merge and bundle; everything else, the planted
drivers and includes among it, is dropped. It is redone each time,
since a paused run's agent could plant again before it resumes.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-26 12:08:02 +08:00

548 lines
26 KiB
TypeScript

import { afterEach, describe, expect, it, vi } from 'vitest';
import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
import { existsSync } from 'node:fs';
import path from 'node:path';
import os from 'node:os';
import {
GitWorkspace,
executeCommand,
requireBranchName,
validateRepositoryUrl,
type Command,
type LocalSshTransport,
} from '../src/index.js';
import { projectInput } from '../../contracts/src/index.js';
const dirs: string[] = [];
async function temporary() {
const dir = await mkdtemp(path.join(os.tmpdir(), 'wishforge-git-contract-'));
dirs.push(dir);
return dir;
}
afterEach(async () => {
await Promise.all(dirs.splice(0).map(dir => rm(dir, { recursive: true, force: true })));
vi.unstubAllEnvs();
});
describe('operator-pinned local SSH authentication', () => {
const transport: LocalSshTransport = {
repositoryUrl: 'https://gitea.example.org/team/project.git',
sshUrl: 'ssh://git@gitea.example.org/team/project.git',
home: '/home/operator',
};
const development = () => {
vi.stubEnv('WF_DEPLOYMENT_MODE', 'development');
vi.stubEnv('NODE_ENV', 'test');
};
it('leaves project SSH unsupported and requires explicit development mode', () => {
for (const mode of [undefined, 'production']) {
vi.stubEnv('WF_DEPLOYMENT_MODE', mode);
expect(() => new GitWorkspace(undefined, { localSshTransport: transport })).toThrow('explicit development');
}
development();
vi.stubEnv('NODE_ENV', 'production');
expect(() => new GitWorkspace(undefined, { localSshTransport: transport })).toThrow('explicit development');
development();
expect(() => validateRepositoryUrl(transport.sshUrl)).toThrow('SSH repository transport is not supported');
});
it('rejects host, repository, credentials, port and HOME changes in the operator mapping', () => {
development();
for (const change of [
{ sshUrl: 'ssh://git@other.example.org/team/project.git' },
{ sshUrl: 'ssh://git@gitea.example.org/team/other.git' },
{ sshUrl: 'ssh://root@gitea.example.org/team/project.git' },
{ sshUrl: 'ssh://git:secret@gitea.example.org/team/project.git' },
{ sshUrl: 'ssh://git@gitea.example.org:2222/team/project.git' },
{ sshUrl: 'ssh://git@gitea.example.org/team/project.git?upload-pack=evil' },
{ sshUrl: 'git@gitea.example.org:team/project.git' },
{ repositoryUrl: 'https://gitea.example.org:444/team/project.git' },
{ repositoryUrl: 'https://gitea.example.org/team/pro%6aect.git' },
{ home: 'relative' },
{ home: '/home/operator\nEVIL=1' },
])
expect(() => new GitWorkspace(undefined, { localSshTransport: { ...transport, ...change } })).toThrow();
});
it('keeps rewrites and SSH options inside Git processes, and binds clone/fetch/push to the pinned repository', async () => {
development();
const commands: Command[] = [];
const execute = vi.fn(async (command: Command) => {
commands.push(command);
return {
exitCode: 0,
stdout: command.args.includes('--is-bare-repository') ? 'true' : 'a'.repeat(40),
stderr: '',
};
});
const git = new GitWorkspace(execute, { localSshTransport: transport });
const root = await temporary();
await git.create({ repository: transport.repositoryUrl, targetBranch: 'poc', root, runId: 'clone' });
expect(commands[0]?.args).toContain(transport.repositoryUrl);
expect(commands[0]?.env).toMatchObject({
HOME: transport.home,
GIT_SSH_COMMAND: 'ssh -oBatchMode=yes -oStrictHostKeyChecking=yes',
GIT_CONFIG_COUNT: '2',
GIT_CONFIG_KEY_1: `url.${transport.sshUrl}.insteadOf`,
GIT_CONFIG_VALUE_1: transport.repositoryUrl,
GIT_CONFIG_GLOBAL: '/dev/null',
});
await git.initializeIntegration({
repository: path.join(root, 'integration.git'),
originalRepository: transport.repositoryUrl,
workspace: path.join(root, 'clone'),
sourceCommit: 'b'.repeat(40),
baseCommit: 'a'.repeat(40),
targetRef: 'refs/heads/poc',
});
const fetch = commands.find(
command => command.args.includes('fetch') && command.args.includes('+refs/heads/poc:refs/heads/poc'),
);
expect(fetch?.args).toContain(transport.repositoryUrl);
expect(fetch?.args).not.toContain('origin');
await git.pushVerifiedCandidate({
repository: root,
targetRef: 'refs/heads/poc',
expectedTargetCommit: 'a'.repeat(40),
candidateCommit: 'b'.repeat(40),
verifiedCommit: 'b'.repeat(40),
});
const push = commands.find(command => command.args.includes('push'));
expect(push?.args).toContain(transport.repositoryUrl);
expect(push?.args).not.toContain('origin');
await expect(
git.create({ repository: `${transport.repositoryUrl}-other`, root, runId: 'foreign' }),
).rejects.toMatchObject({ code: 'LOCAL_SSH_SCOPE' });
await expect(git.create({ repository: transport.sshUrl, root, runId: 'ssh-project' })).rejects.toMatchObject({
code: 'REPOSITORY_TRANSPORT_UNSUPPORTED',
});
vi.stubEnv('WF_DEPLOYMENT_MODE', 'production');
await expect(git.head(root)).rejects.toMatchObject({ code: 'LOCAL_SSH_POLICY' });
});
});
async function git(cwd: string, args: string[]) {
const result = await executeCommand({ executable: 'git', args: ['-c', 'core.hooksPath=/dev/null', ...args], cwd });
expect(result.exitCode).toBe(0);
return result.stdout.trim();
}
describe('exact target branch and immutable checkpoint contracts', () => {
it('starts from the configured remote branch rather than default HEAD or an ambiguous tag', async () => {
const root = await temporary(),
work = new GitWorkspace();
const source = await work.create({ root, runId: 'source' });
await git(source.workspace, ['checkout', '-b', 'feature/target']);
await writeFile(path.join(source.workspace, 'target.txt'), 'target branch contents');
const target = await work.checkpoint(source.workspace, source.baseCommit, 'source', 'test');
await git(source.workspace, ['tag', 'feature/target', source.baseCommit]);
await git(source.workspace, ['checkout', 'main']);
const prepared = await work.create({
repository: source.workspace,
allowLocalRepository: true,
targetBranch: 'feature/target',
root,
runId: 'target-run',
});
expect(prepared.baseCommit).toBe(target.sourceCommit);
expect(await work.head(prepared.workspace)).toBe(target.sourceCommit);
expect(prepared.baseCommit).not.toBe(source.baseCommit);
await expect(
work.create({
repository: source.workspace,
allowLocalRepository: true,
targetBranch: 'missing',
root,
runId: 'missing-run',
}),
).rejects.toMatchObject({ code: 'TARGET_BRANCH_UNAVAILABLE' });
});
it('preserves checkpoint source and original base when the repository target branch moves', async () => {
const root = await temporary(),
work = new GitWorkspace();
const source = await work.create({ root, runId: 'source', targetBranch: 'release/v1' });
await writeFile(path.join(source.workspace, 'app.txt'), 'first change');
const first = await work.checkpoint(source.workspace, source.baseCommit, 'source', 'test');
await writeFile(path.join(source.workspace, 'app.txt'), 'later branch change');
const later = await work.checkpoint(source.workspace, source.baseCommit, 'source', 'test');
expect(later.sourceCommit).not.toBe(first.sourceCommit);
const pinned = await work.create({
repository: source.workspace,
allowLocalRepository: true,
targetBranch: 'release/v1',
baseCommit: first.sourceCommit,
root,
runId: 'pinned',
});
expect(pinned.baseCommit).toBe(first.sourceCommit);
const restored = await work.restore({
checkpoint: first,
repository: source.workspace,
allowLocalRepository: true,
root,
runId: 'restored',
});
expect(await work.head(restored.workspace)).toBe(first.sourceCommit);
expect(restored.baseCommit).toBe(source.baseCommit);
});
it('pushes a verified candidate through the bare integration cache, including caches created as mirrors', async () => {
const root = await temporary(),
work = new GitWorkspace();
const seed = await work.create({ root, runId: 'seed' });
const remote = path.join(root, 'remote.git');
await git(root, ['clone', '--bare', seed.workspace, remote]);
const integration = path.join(root, 'integrations', 'project.git');
for (const [round, legacyMirror] of [
[1, false],
[2, true],
] as const) {
const run = await work.create({ root, runId: `run-${round}`, repository: remote, allowLocalRepository: true });
await writeFile(path.join(run.workspace, 'feature.txt'), `round ${round}`);
const checkpoint = await work.checkpoint(run.workspace, run.baseCommit, `run-${round}`, 'test');
if (legacyMirror) await git(integration, ['config', 'remote.origin.mirror', 'true']);
await work.initializeIntegration({
repository: integration,
originalRepository: remote,
allowLocalRepository: true,
workspace: run.workspace,
sourceCommit: checkpoint.sourceCommit,
baseCommit: checkpoint.baseCommit,
targetRef: 'refs/heads/main',
});
const expected = await work.head(integration, 'refs/heads/main');
expect(expected).toBe(run.baseCommit);
await work.pushVerifiedCandidate({
repository: integration,
targetRef: 'refs/heads/main',
expectedTargetCommit: expected,
candidateCommit: checkpoint.sourceCommit,
verifiedCommit: checkpoint.sourceCommit,
});
expect(await work.head(remote, 'refs/heads/main')).toBe(checkpoint.sourceCommit);
}
});
it('uses the verified commit itself when the target has not moved, and merges otherwise', async () => {
const root = await temporary(),
work = new GitWorkspace();
const seed = await work.create({ root, runId: 'seed' });
await writeFile(path.join(seed.workspace, 'a.txt'), 'a\n');
await writeFile(path.join(seed.workspace, 'b.txt'), 'b\n');
await work.checkpoint(seed.workspace, seed.baseCommit, 'seed', 'test');
const remote = path.join(root, 'remote.git');
await git(root, ['clone', '--bare', seed.workspace, remote]);
const integration = path.join(root, 'integrations', 'project.git');
const change = async (runId: string, file: string, text: string) => {
const run = await work.create({ root, runId, repository: remote, allowLocalRepository: true });
await writeFile(path.join(run.workspace, file), text);
return { run, checkpoint: await work.checkpoint(run.workspace, run.baseCommit, runId, 'test') };
};
const first = await change('first', 'a.txt', 'first\n');
const second = await change('second', 'b.txt', 'second\n');
const conflicting = await change('third', 'a.txt', 'third\n');
const integrate = async ({ run, checkpoint }: Awaited<ReturnType<typeof change>>, attempt: string) => {
await work.initializeIntegration({
repository: integration,
originalRepository: remote,
allowLocalRepository: true,
workspace: run.workspace,
sourceCommit: checkpoint.sourceCommit,
baseCommit: checkpoint.baseCommit,
targetRef: 'refs/heads/main',
});
const expected = await work.head(integration, 'refs/heads/main');
const candidate = await work.createCandidate({
repository: integration,
path: path.join(root, attempt),
targetRef: 'refs/heads/main',
expectedTargetCommit: expected,
sourceCommit: checkpoint.sourceCommit,
});
return { expected, candidate };
};
const fastForward = await integrate(first, 'candidate-1');
expect(fastForward.candidate).toMatchObject({ commit: first.checkpoint.sourceCommit, fastForward: true });
await work.pushVerifiedCandidate({
repository: integration,
targetRef: 'refs/heads/main',
expectedTargetCommit: fastForward.expected,
candidateCommit: first.checkpoint.sourceCommit,
verifiedCommit: first.checkpoint.sourceCommit,
});
const merged = await integrate(second, 'candidate-2');
expect(merged.candidate.fastForward).toBe(false);
expect(merged.candidate.commit).not.toBe(second.checkpoint.sourceCommit);
expect(merged.candidate.baseCommit).toBe(first.checkpoint.sourceCommit);
// Someone else pushes meanwhile: a push based on the old tip is reported as a moved target.
const other = await change('other', 'c.txt', 'other\n');
await git(other.run.workspace, ['push', 'origin', 'HEAD:refs/heads/main']);
await expect(
work.pushVerifiedCandidate({
repository: integration,
targetRef: 'refs/heads/main',
expectedTargetCommit: merged.expected,
candidateCommit: merged.candidate.commit,
verifiedCommit: merged.candidate.commit,
}),
).rejects.toMatchObject({ code: 'STALE_TARGET' });
const tip = other.checkpoint.sourceCommit;
// A conflict names the files and leaves no half-merged worktree behind.
const conflict = integrate(conflicting, 'candidate-3');
await expect(conflict).rejects.toMatchObject({ code: 'MERGE_CONFLICT', paths: ['a.txt'], targetCommit: tip });
await expect(
executeCommand({ executable: 'test', args: ['-e', path.join(root, 'candidate-3')] }),
).resolves.toMatchObject({
exitCode: 1,
});
// The repair round merges the current target and leaves the markers to the agent.
const repair = await work.restore({
checkpoint: conflicting.checkpoint,
repository: remote,
allowLocalRepository: true,
root,
runId: 'third-repair',
});
const started = await work.mergeTarget(repair.workspace, 'main');
expect(started).toEqual({ targetCommit: tip, conflicts: ['a.txt'] });
await writeFile(path.join(repair.workspace, 'a.txt'), 'first and third\n');
const resolved = await work.checkpoint(repair.workspace, started.targetCommit, 'third', 'test');
await git(repair.workspace, ['merge-base', '--is-ancestor', first.checkpoint.sourceCommit, resolved.sourceCommit]);
expect(resolved.baseCommit).toBe(tip);
// The checkpoint is relative to the new tip: only this run's resolution, not the other changes.
expect(resolved.patch).toContain('+first and third');
expect(resolved.patch).not.toContain('c.txt');
});
it('keeps installed dependencies out of checkpoints', async () => {
const root = await temporary(),
work = new GitWorkspace();
const run = await work.create({ root, runId: 'install' });
await writeFile(path.join(run.workspace, '.gitignore'), 'dist/\n');
await work.checkpoint(run.workspace, run.baseCommit, 'install', 'test');
await executeCommand({ executable: 'mkdir', args: ['-p', path.join(run.workspace, 'node_modules', 'left-pad')] });
await writeFile(path.join(run.workspace, 'node_modules', 'left-pad', 'index.js'), 'module.exports = 1;');
await writeFile(path.join(run.workspace, 'install[1].log'), 'installed');
expect((await work.excludeUntracked(run.workspace)).sort()).toEqual(['install[1].log', 'node_modules/']);
await writeFile(path.join(run.workspace, 'feature.txt'), 'agent change');
const checkpoint = await work.checkpoint(run.workspace, run.baseCommit, 'install', 'test');
expect(checkpoint.patch).toContain('feature.txt');
expect(checkpoint.patch).not.toContain('left-pad');
expect(checkpoint.patch).not.toContain('install[1].log');
});
it('restores an incremental checkpoint from the repository base and rejects a missing base', async () => {
const root = await temporary(),
work = new GitWorkspace();
const seed = await work.create({ root, runId: 'seed' });
const remote = path.join(root, 'remote.git');
await git(root, ['clone', '--bare', seed.workspace, remote]);
const run = await work.create({ root, runId: 'run', repository: remote, allowLocalRepository: true });
await writeFile(path.join(run.workspace, 'a.txt'), 'first');
await work.checkpoint(run.workspace, run.baseCommit, 'run', 'test');
await writeFile(path.join(run.workspace, 'b.txt'), 'second');
const checkpoint = await work.checkpoint(run.workspace, run.baseCommit, 'run', 'test');
const restored = await work.restore({
checkpoint,
repository: remote,
allowLocalRepository: true,
root: path.join(root, 'verifier'),
runId: 'restored',
});
expect(await work.head(restored.workspace)).toBe(checkpoint.sourceCommit);
const unchanged = await work.checkpoint(restored.workspace, checkpoint.sourceCommit, 'restored', 'test');
expect(unchanged.gitBundleBase64).toBeUndefined();
const elsewhere = path.join(root, 'unrelated.git');
await git(root, ['init', '--bare', elsewhere]);
await expect(
work.restore({
checkpoint,
repository: elsewhere,
allowLocalRepository: true,
root: path.join(root, 'verifier'),
runId: 'unrelated',
}),
).rejects.toThrow();
});
it('creates an immutable review branch and reconciles retries without advancing the target branch', async () => {
const root = await temporary(),
work = new GitWorkspace();
const source = await work.create({ root, runId: 'source' });
const clone = await work.create({
root,
runId: 'review',
repository: source.workspace,
allowLocalRepository: true,
targetBranch: 'main',
});
await writeFile(path.join(clone.workspace, 'review.txt'), 'review candidate');
const candidate = await work.checkpoint(clone.workspace, clone.baseCommit, 'review', 'test');
const request = {
repository: clone.workspace,
runId: 'review',
candidateCommit: candidate.sourceCommit,
verifiedCommit: candidate.sourceCommit,
};
const branch = await work.pushReviewBranch(request);
expect(branch).toBe(`wishforge/review/${candidate.sourceCommit}`);
expect(await work.pushReviewBranch(request)).toBe(branch);
expect(await work.head(source.workspace, 'refs/heads/main')).toBe(source.baseCommit);
expect(await work.head(source.workspace, `refs/heads/${branch}`)).toBe(candidate.sourceCommit);
await git(source.workspace, ['update-ref', `refs/heads/${branch}`, source.baseCommit]);
await expect(work.pushReviewBranch(request)).rejects.toMatchObject({ code: 'REVIEW_BRANCH_CONFLICT' });
expect(await work.head(source.workspace, 'refs/heads/main')).toBe(source.baseCommit);
});
it.each([
'-force',
'HEAD',
'main..other',
'main^{commit}',
'feature/.hidden',
'feature/end.',
'feature/a.lock/b',
'feature//name',
'refs/heads/main:evil',
'main\nother',
])('rejects unsafe branch %s consistently before Git execution', async branch => {
const execute = vi.fn();
const work = new GitWorkspace(execute);
expect(() => requireBranchName(branch)).toThrow();
expect(projectInput.safeParse({ name: 'Invalid branch', targetBranch: branch }).success).toBe(false);
await expect(
work.create({ repository: 'https://example.org/repo.git', targetBranch: branch, root: '/unused', runId: 'run' }),
).rejects.toMatchObject({ code: 'INVALID_REF' });
expect(execute).not.toHaveBeenCalled();
});
it('rejects unsupported SSH and credential/query-bearing URLs before cloning', async () => {
const execute = vi.fn(),
work = new GitWorkspace(execute);
for (const repository of ['ssh://git@github.com/org/repo.git', 'git@github.com:org/repo.git'])
await expect(work.create({ repository, root: '/unused', runId: 'run' })).rejects.toMatchObject({
code: 'REPOSITORY_TRANSPORT_UNSUPPORTED',
});
for (const repository of [
'https://user:password@example.org/repo.git',
'https://example.org/repo.git?access_token=secret',
'https://example.org/repo.git#main',
'file:///tmp/repo',
' https://example.org/repo',
])
await expect(work.create({ repository, root: '/unused', runId: 'run' })).rejects.toThrow();
expect(execute).not.toHaveBeenCalled();
expect(
validateRepositoryUrl('http://127.0.0.1:4504/repo.git', { allowLocalHttp: true, production: false }).protocol,
).toBe('http:');
expect(() =>
validateRepositoryUrl('http://127.0.0.1:4504/repo.git', { allowLocalHttp: true, production: true }),
).toThrow();
expect(() =>
validateRepositoryUrl('http://remote.example/repo.git', { allowLocalHttp: true, production: false }),
).toThrow();
});
});
describe('planted Git configuration cannot run commands during trusted export', () => {
// The agent has file tools in its workspace, so it can write .git/config and .gitattributes.
// None of its drivers may run as the worker during checkpoint or merge.
async function workspaceWith(config: string, attributes = '* filter=x diff=d merge=m\n') {
const root = await temporary();
const work = new GitWorkspace();
const prepared = await work.create({ root, runId: 'run' });
const ran = path.join(root, 'driver-ran');
await writeFile(
path.join(prepared.workspace, '.git', 'config'),
`${(
await executeCommand({ executable: 'git', args: ['config', '--list', '--local'], cwd: prepared.workspace })
).stdout
.split('\n')
.filter(Boolean)
.map(line => {
const [key, ...rest] = line.split('=');
const dot = key!.lastIndexOf('.');
return `[${key!.slice(0, dot)}]\n\t${key!.slice(dot + 1)} = ${rest.join('=')}`;
})
.join('\n')}\n${config.replaceAll('RAN', ran)}\n`,
);
await writeFile(path.join(prepared.workspace, '.gitattributes'), attributes);
await writeFile(path.join(prepared.workspace, 'app.txt'), 'the agent edited this\n');
return { root, work, prepared, ran };
}
// Git runs a driver via `sh -c <value>` and strips the config value's own quotes, so a bare
// `touch <abspath>` reliably creates the marker when the vector fires (extra %O/%A args are
// harmless), making each test fail if the hardening is removed.
for (const [name, config] of [
['a clean filter', '[filter "x"]\n\tclean = touch RAN'],
['a diff driver', '[diff "d"]\n\tcommand = touch RAN'],
['a merge driver', '[merge "m"]\n\tdriver = touch RAN %O %A %B'],
['core.fsmonitor', '[core]\n\tfsmonitor = touch RAN'],
['an include', '[include]\n\tpath = evil-config'],
] as const) {
it(`neutralizes ${name} before the checkpoint`, async () => {
const f = await workspaceWith(config);
if (name === 'an include')
// A relative include path resolves from .git/, so plant the included file there.
await writeFile(
path.join(f.prepared.workspace, '.git', 'evil-config'),
`[filter "x"]\n\tclean = touch ${f.ran}\n`,
);
const checkpoint = await f.work.checkpoint(f.prepared.workspace, f.prepared.baseCommit, 'run', 'codex');
expect(existsSync(f.ran)).toBe(false);
// The agent's actual edit still travels in the checkpoint.
expect(checkpoint.patch).toContain('the agent edited this');
// The config was reduced to the safe allowlist: the driver and any include are gone.
const left = await readFile(path.join(f.prepared.workspace, '.git', 'config'), 'utf8');
expect(left).not.toMatch(/\btouch\b/);
expect(left).not.toMatch(/\[include\]/);
expect(left).toMatch(/\[core\]/);
});
}
it('drops a planted url.insteadOf transport redirect but keeps the clone origin', async () => {
const root = await temporary();
const work = new GitWorkspace();
const origin = await work.create({ root, runId: 'origin' });
await writeFile(path.join(origin.workspace, 'seed.txt'), 'seed\n');
await work.checkpoint(origin.workspace, origin.baseCommit, 'origin', 'codex');
const run = await work.create({ repository: origin.workspace, allowLocalRepository: true, root, runId: 'run' });
await writeFile(
path.join(run.workspace, '.git', 'config'),
(await readFile(path.join(run.workspace, '.git', 'config'), 'utf8')) +
'[url "https://attacker.example/"]\n\tinsteadOf = ' +
origin.workspace +
'\n',
);
await writeFile(path.join(run.workspace, 'app.txt'), 'edited\n');
await work.checkpoint(run.workspace, run.baseCommit, 'run', 'codex');
const left = await readFile(path.join(run.workspace, '.git', 'config'), 'utf8');
expect(left).not.toContain('attacker.example');
expect(left).toMatch(/\[remote "origin"\]/);
expect(left).toContain(origin.workspace); // the real remote.origin.url is untouched
});
it('neutralizes a merge driver before a repair-round mergeTarget, and still merges and conflicts', async () => {
const root = await temporary();
const work = new GitWorkspace();
const base = await work.create({ root, runId: 'base', targetBranch: 'main' });
await writeFile(path.join(base.workspace, 'shared.txt'), 'target side\n');
const moved = await work.checkpoint(base.workspace, base.baseCommit, 'base', 'codex');
// A run that branched from the original base, with a planted merge driver.
const run = await work.create({
repository: base.workspace,
allowLocalRepository: true,
targetBranch: 'main',
baseCommit: base.baseCommit,
root,
runId: 'run',
});
// Commit the run side directly (not via checkpoint, which would harden first), then plant the
// driver, so mergeTarget's own hardening is what must neutralize it.
await writeFile(path.join(run.workspace, '.gitattributes'), 'shared.txt merge=m\n');
await writeFile(path.join(run.workspace, 'shared.txt'), 'run side\n');
await git(run.workspace, ['add', '--all']);
await git(run.workspace, ['-c', 'user.name=x', '-c', 'user.email=x@x', 'commit', '-m', 'run side']);
const ran = path.join(root, 'merge-ran');
await writeFile(
path.join(run.workspace, '.git', 'config'),
(await readFile(path.join(run.workspace, '.git', 'config'), 'utf8')) +
`[merge "m"]\n\tdriver = touch ${ran} %O %A %B\n`,
);
const merged = await work.mergeTarget(run.workspace, 'main');
expect(existsSync(ran)).toBe(false);
expect(merged.targetCommit).toBe(moved.sourceCommit);
// A real conflict is still reported (Git's own resolver ran, not the planted driver).
expect(merged.conflicts).toContain('shared.txt');
});
});