With WF_CLAUDE_COMMAND_SANDBOX=true, Claude Code also gets Bash, run in its built-in sandbox through --settings: - The sandbox must start (failIfUnavailable), and no command may run outside it (allowUnsandboxedCommands: false). - No network: an empty allowedDomains with strictAllowlist, since an absent allowlist leaves the network open. Local binding stays off, because it would also open every local port, Temporal's included. - Commands cannot read the home directories, the CLI's home or the worker's own directory, except the workspace, a per-run scratch directory and WF_CLAUDE_COMMAND_READ_PATHS; they write only to the workspace and the scratch directory; credential variables are unset. - WF_CLAUDE_COMMAND_ENV gives commands toolchain variables, such as the POC's read-only Go module cache. The executor probes the sandbox first (Seatbelt on macOS; bubblewrap and socat on Linux) and keeps file tools only where it cannot start, saying so on the timeline. The adapter now writes the execution contract into the prompt, for the tools the agent actually has. scripts/check-claude-command-sandbox.ts checks a machine with one short real session and judges each probe by its effect, not the agent's account. On the local Mac every probe was blocked; the login keychain remains reachable, because Claude Code's Seatbelt profile always allows the security server. That limit is documented. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
629 lines
27 KiB
TypeScript
629 lines
27 KiB
TypeScript
import { describe, expect, it, afterEach } from 'vitest';
|
||
import { createHash, generateKeyPairSync } from 'node:crypto';
|
||
import { mkdtemp, writeFile, rm, chmod, mkdir, readFile, realpath } from 'node:fs/promises';
|
||
import os from 'node:os';
|
||
import path from 'node:path';
|
||
import {
|
||
ClaudeCodeAdapter,
|
||
CodeBuddyAdapter,
|
||
CodexAdapter,
|
||
ComposeDeploymentAdapter,
|
||
executeCommand,
|
||
FileNonceStore,
|
||
GitWorkspace,
|
||
KubernetesDeploymentAdapter,
|
||
signRunnerTask,
|
||
validateRelease,
|
||
probeClaudeSandbox,
|
||
probeCodexSandbox,
|
||
verifyRunnerTask,
|
||
verifyWorkspace,
|
||
type CodexFactory,
|
||
type Command,
|
||
type CommandResult,
|
||
type ReleaseManifest,
|
||
type RunnerTask,
|
||
} from '../src/index.js';
|
||
|
||
const dirs: string[] = [];
|
||
async function temp() {
|
||
const directory = await mkdtemp(path.join(os.tmpdir(), 'wishforge-runtime-'));
|
||
dirs.push(directory);
|
||
return directory;
|
||
}
|
||
afterEach(async () => {
|
||
await Promise.all(dirs.splice(0).map(directory => rm(directory, { recursive: true, force: true })));
|
||
});
|
||
const release: ReleaseManifest = {
|
||
schemaVersion: 1,
|
||
id: 'release-1',
|
||
tenantId: 'tenant-1',
|
||
environmentId: 'env-1',
|
||
sourceCommit: 'a'.repeat(40),
|
||
image: `registry.example/web@sha256:${'b'.repeat(64)}`,
|
||
containerPort: 3000,
|
||
healthPath: '/health',
|
||
expectedPreviousReleaseId: null,
|
||
smokeChecks: [{ path: '/', expectedStatus: 200, bodyIncludes: 'ready' }],
|
||
};
|
||
|
||
describe('signed outbound runner tasks', () => {
|
||
const keys = generateKeyPairSync('ed25519');
|
||
const publicKeys = { current: keys.publicKey.export({ type: 'spki', format: 'pem' }).toString() };
|
||
const task: RunnerTask = {
|
||
schemaVersion: 1,
|
||
id: 'task-1',
|
||
tenantId: 'tenant-1',
|
||
environmentId: 'env-1',
|
||
nonce: 'nonce-1',
|
||
issuedAt: new Date(1_000_000).toISOString(),
|
||
expiresAt: new Date(1_300_000).toISOString(),
|
||
action: 'deploy',
|
||
target: 'compose',
|
||
release,
|
||
};
|
||
const policy = { tenantId: task.tenantId, environmentId: task.environmentId, publicKeys, now: 1_100_000 };
|
||
it('accepts a scoped Ed25519 task and rejects tampering, expiry and wrong tenants', () => {
|
||
const envelope = signRunnerTask(task, 'current', keys.privateKey);
|
||
expect(verifyRunnerTask(envelope, policy)).toEqual(task);
|
||
expect(() => verifyRunnerTask({ ...envelope, payload: { ...task, action: 'reconcile' } }, policy)).toThrow(
|
||
'signature',
|
||
);
|
||
expect(() => verifyRunnerTask(envelope, { ...policy, now: 1_400_000 })).toThrow('expired');
|
||
expect(() => verifyRunnerTask(envelope, { ...policy, tenantId: 'tenant-2' })).toThrow('tenant/environment');
|
||
});
|
||
it('claims a nonce once, including concurrent calls and process-local store reconstruction', async () => {
|
||
const directory = await temp();
|
||
const claims = await Promise.all(
|
||
Array.from({ length: 8 }, () => new FileNonceStore(directory).consume('tenant/env', 'nonce')),
|
||
);
|
||
expect(claims.filter(Boolean)).toHaveLength(1);
|
||
expect(await new FileNonceStore(directory).consume('tenant/env', 'nonce')).toBe(false);
|
||
});
|
||
});
|
||
|
||
describe('deployments fail closed', () => {
|
||
it('renders both targets without executing commands and never labels dry-run as verified', async () => {
|
||
let calls = 0;
|
||
const execute = async () => {
|
||
calls++;
|
||
throw new Error('must not execute');
|
||
};
|
||
expect((await new ComposeDeploymentAdapter({}, execute).deploy(release)).status).toBe('dry-run');
|
||
expect((await new KubernetesDeploymentAdapter({}, execute).deploy(release)).status).toBe('dry-run');
|
||
expect((await new KubernetesDeploymentAdapter({}, execute).deploy(release, { execute: true })).status).toBe(
|
||
'unconfigured',
|
||
);
|
||
expect(calls).toBe(0);
|
||
});
|
||
it('rejects mutable images and health URLs that can escape the target origin', () => {
|
||
expect(() => validateRelease({ ...release, image: 'registry.example/web:latest' })).toThrow('digest');
|
||
expect(() => validateRelease({ ...release, healthPath: '//metadata.example/' })).toThrow('same-origin');
|
||
});
|
||
it('renders bound architecture and refuses to silently omit secret references', async () => {
|
||
const configured = {
|
||
...release,
|
||
architecture: 'linux/arm64' as const,
|
||
configVersion: 'version-7',
|
||
secretVersionRefs: [],
|
||
};
|
||
expect(JSON.parse(new ComposeDeploymentAdapter().render(configured)).services.web.platform).toBe('linux/arm64');
|
||
const workload = JSON.parse(new KubernetesDeploymentAdapter().render(configured)).items[0];
|
||
expect(workload.spec.template.spec.nodeSelector['kubernetes.io/arch']).toBe('arm64');
|
||
expect(workload.metadata.annotations['wishforge.io/config-version']).toBe('version-7');
|
||
for (const adapter of [new ComposeDeploymentAdapter(), new KubernetesDeploymentAdapter()])
|
||
expect(
|
||
(await adapter.deploy({ ...configured, secretVersionRefs: ['vault/database@version-1'] }, { execute: true }))
|
||
.status,
|
||
).toBe('unconfigured');
|
||
});
|
||
it('requires observed Kubernetes generation, exact image and all replicas before verification', async () => {
|
||
const state = {
|
||
metadata: {
|
||
generation: 3,
|
||
annotations: JSON.parse(new KubernetesDeploymentAdapter().render(release)).items[0].metadata.annotations,
|
||
},
|
||
spec: { template: { spec: { containers: [{ image: release.image }] } } },
|
||
status: { observedGeneration: 2, updatedReplicas: 1, availableReplicas: 1, replicas: 1 },
|
||
};
|
||
const stable = {
|
||
metadata: {
|
||
annotations: JSON.parse(new KubernetesDeploymentAdapter().render(release)).items[0].metadata.annotations,
|
||
},
|
||
spec: {
|
||
selector: {
|
||
'app.kubernetes.io/name': JSON.parse(new KubernetesDeploymentAdapter().render(release)).items[1].spec
|
||
.selector['app.kubernetes.io/name'],
|
||
'wishforge.io/revision': createHash('sha256').update(release.id).digest('hex').slice(0, 12),
|
||
},
|
||
},
|
||
};
|
||
const adapter = new KubernetesDeploymentAdapter(
|
||
{
|
||
context: 'test',
|
||
namespace: 'test',
|
||
healthUrl: 'https://app.example',
|
||
candidateHealthUrlTemplate: 'http://{service}.test.svc',
|
||
},
|
||
async command => ({
|
||
exitCode: 0,
|
||
stdout: JSON.stringify(command.args.includes('service') ? stable : state),
|
||
stderr: '',
|
||
}),
|
||
async () => new Response('ready'),
|
||
);
|
||
expect((await adapter.reconcile(release)).status).toBe('applied');
|
||
state.status.observedGeneration = 3;
|
||
expect((await adapter.reconcile(release)).status).toBe('verified');
|
||
state.spec.template.spec.containers[0]!.image = 'other';
|
||
expect((await adapter.reconcile(release)).status).toBe('conflict');
|
||
});
|
||
});
|
||
|
||
describe('portable provider execution', () => {
|
||
it('never starts from ambient credentials', () => {
|
||
expect(new CodexAdapter().capabilities().availability).toBe('unconfigured');
|
||
expect(new CodeBuddyAdapter().capabilities().availability).toBe('unconfigured');
|
||
});
|
||
it('requires Codex turn.completed and does not forward worker secrets or raw reasoning', async () => {
|
||
const home = await temp();
|
||
let options: Record<string, unknown> = {};
|
||
const adapter = new CodexAdapter({
|
||
apiKey: 'tenant-key',
|
||
isolatedHome: home,
|
||
factory: async config => {
|
||
options = config;
|
||
return {
|
||
startThread: () => ({
|
||
runStreamed: async () => ({
|
||
events: (async function* () {
|
||
yield { type: 'thread.started', thread_id: 'session' };
|
||
yield { type: 'item.completed', item: { type: 'reasoning', text: 'private' } };
|
||
yield { type: 'item.completed', item: { type: 'agent_message', text: 'tenant-key output' } };
|
||
})(),
|
||
}),
|
||
}),
|
||
resumeThread: () => {
|
||
throw new Error('not used');
|
||
},
|
||
};
|
||
},
|
||
});
|
||
await adapter.start({ runId: 'r', tenantId: 't', workspace: home, baseCommit: 'a'.repeat(40), prompt: 'test' });
|
||
const events = [];
|
||
for await (const event of adapter.events('r')) events.push(event);
|
||
expect((await adapter.inspect('r')).status).toBe('failed');
|
||
expect(JSON.stringify(events)).not.toContain('private');
|
||
expect(JSON.stringify(events)).not.toContain('tenant-key');
|
||
expect(Object.keys(options.env as object).sort()).toEqual([
|
||
'CODEX_HOME',
|
||
'GIT_AUTHOR_EMAIL',
|
||
'GIT_AUTHOR_NAME',
|
||
'GIT_COMMITTER_EMAIL',
|
||
'GIT_COMMITTER_NAME',
|
||
'HOME',
|
||
'NO_PROXY',
|
||
'PATH',
|
||
'no_proxy',
|
||
]);
|
||
});
|
||
it('reports commands, file changes and plan updates from Codex without command output', async () => {
|
||
const home = await temp();
|
||
const adapter = new CodexAdapter({
|
||
apiKey: 'tenant-key',
|
||
isolatedHome: home,
|
||
factory: async () => ({
|
||
startThread: () => ({
|
||
runStreamed: async () => ({
|
||
events: (async function* () {
|
||
yield {
|
||
type: 'item.updated',
|
||
item: { type: 'todo_list', items: [{ text: 'Write tests', completed: false }] },
|
||
};
|
||
yield {
|
||
type: 'item.completed',
|
||
item: {
|
||
type: 'command_execution',
|
||
command: 'npm test',
|
||
aggregated_output: 'tenant-key leaked',
|
||
exit_code: 1,
|
||
status: 'failed',
|
||
},
|
||
};
|
||
yield {
|
||
type: 'item.completed',
|
||
item: { type: 'file_change', changes: [{ path: 'src/app.ts', kind: 'update' }], status: 'completed' },
|
||
};
|
||
yield { type: 'turn.completed', usage: { input_tokens: 3, output_tokens: 2 } };
|
||
})(),
|
||
}),
|
||
}),
|
||
resumeThread: () => {
|
||
throw new Error('not used');
|
||
},
|
||
}),
|
||
});
|
||
await adapter.start({ runId: 'r', tenantId: 't', workspace: home, baseCommit: 'a'.repeat(40), prompt: 'test' });
|
||
const events = [];
|
||
for await (const event of adapter.events('r')) events.push(event);
|
||
expect((await adapter.inspect('r')).status).toBe('completed');
|
||
expect(events.map(event => event.type)).toEqual([
|
||
'started',
|
||
'plan',
|
||
'command',
|
||
'file_change',
|
||
'usage',
|
||
'completed',
|
||
]);
|
||
expect(events[1]?.data).toEqual({ items: [{ text: 'Write tests', completed: false }] });
|
||
expect(events[2]?.data).toEqual({ command: 'npm test', exitCode: 1, status: 'failed' });
|
||
expect(events[3]?.data).toEqual({ status: 'completed', changes: [{ path: 'src/app.ts', kind: 'update' }] });
|
||
expect(JSON.stringify(events)).not.toContain('leaked');
|
||
});
|
||
it('runs Codex commands in its sandbox, and without it only where a development sandbox allows', async () => {
|
||
const home = await temp();
|
||
const threads: Array<Record<string, unknown>> = [];
|
||
const factory: CodexFactory = async () => ({
|
||
startThread: options => {
|
||
threads.push(options);
|
||
return {
|
||
runStreamed: async () => ({
|
||
events: (async function* () {
|
||
yield { type: 'turn.completed', usage: {} };
|
||
})(),
|
||
}),
|
||
};
|
||
},
|
||
resumeThread: () => {
|
||
throw new Error('not used');
|
||
},
|
||
});
|
||
const start = (adapter: CodexAdapter, runId: string) =>
|
||
adapter.start({ runId, tenantId: 't', workspace: home, baseCommit: 'a'.repeat(40), prompt: 'test' });
|
||
const denied = async () => 'bwrap: No permissions to create new namespace';
|
||
await start(
|
||
new CodexAdapter({ apiKey: 'k', isolatedHome: home, factory, sandboxProbe: async () => undefined }),
|
||
'available',
|
||
);
|
||
expect(threads[0]?.sandboxMode).toBe('workspace-write');
|
||
// Otherwise every command the agent ran would fail; the run stops before the agent starts.
|
||
await expect(
|
||
start(new CodexAdapter({ apiKey: 'k', isolatedHome: home, factory, sandboxProbe: denied }), 'strict'),
|
||
).rejects.toMatchObject({ code: 'PROVIDER_SANDBOX_UNAVAILABLE' });
|
||
expect(threads).toHaveLength(1);
|
||
const development = new CodexAdapter({
|
||
apiKey: 'k',
|
||
isolatedHome: home,
|
||
factory,
|
||
sandboxProbe: denied,
|
||
allowUnsandboxed: true,
|
||
});
|
||
await start(development, 'development');
|
||
expect(threads[1]?.sandboxMode).toBe('danger-full-access');
|
||
const events = [];
|
||
for await (const event of development.events('development')) events.push(event);
|
||
expect(events[0]).toMatchObject({
|
||
type: 'started',
|
||
data: { unsandboxed: true, reason: 'bwrap: No permissions to create new namespace' },
|
||
});
|
||
});
|
||
it('probes Codex’s sandbox with the workspace-write policy in the isolated home', async () => {
|
||
const home = await temp();
|
||
const commands: Command[] = [];
|
||
const answering =
|
||
(result: CommandResult) =>
|
||
async (command: Command): Promise<CommandResult> => {
|
||
commands.push(command);
|
||
return result;
|
||
};
|
||
expect(await probeCodexSandbox(home, answering({ exitCode: 0, stdout: '', stderr: '' }))).toBeUndefined();
|
||
expect(commands[0]?.executable).toBe(process.execPath);
|
||
expect(commands[0]?.args[0]).toMatch(/@openai[/\\]codex[/\\]bin[/\\]codex\.js$/);
|
||
expect(commands[0]?.args.slice(1)).toEqual(['sandbox', '-c', 'sandbox_mode="workspace-write"', '--', 'true']);
|
||
expect(commands[0]?.env).toMatchObject({ HOME: home, CODEX_HOME: home });
|
||
const stderr = 'WARNING: proceeding without PATH aliases\nbwrap: No permissions to create new namespace\n';
|
||
expect(await probeCodexSandbox(home, answering({ exitCode: 1, stdout: '', stderr }))).toBe(
|
||
'bwrap: No permissions to create new namespace',
|
||
);
|
||
});
|
||
it('reports CodeBuddy messages and tool calls as progress', async () => {
|
||
const home = await temp();
|
||
const binary = path.join(home, 'codebuddy-progress');
|
||
const lines = [
|
||
{
|
||
type: 'assistant',
|
||
message: {
|
||
content: [
|
||
{ type: 'text', text: 'Running the tests' },
|
||
{ type: 'tool_use', name: 'Bash', input: { command: 'npm test' } },
|
||
{ type: 'tool_use', name: 'Edit', input: { file_path: 'src/app.ts' } },
|
||
],
|
||
},
|
||
},
|
||
{ type: 'result', subtype: 'success', is_error: false, result: 'done' },
|
||
];
|
||
await writeFile(
|
||
binary,
|
||
`#!/usr/bin/env node\n${lines.map(line => `console.log(${JSON.stringify(JSON.stringify(line))});`).join('\n')}\n`,
|
||
);
|
||
await chmod(binary, 0o700);
|
||
const adapter = new CodeBuddyAdapter({
|
||
binary,
|
||
isolatedHome: home,
|
||
credentialEnv: { CODEBUDDY_API_KEY: 'test-key' },
|
||
isolationConfirmed: true,
|
||
allowUnsandboxed: true,
|
||
});
|
||
await adapter.start({ runId: 'r', tenantId: 't', workspace: home, baseCommit: 'a'.repeat(40), prompt: 'test' });
|
||
const events = [];
|
||
for await (const event of adapter.events('r')) events.push(event);
|
||
expect(events.map(event => event.type)).toEqual([
|
||
'started',
|
||
'output',
|
||
'command',
|
||
'file_change',
|
||
'output',
|
||
'completed',
|
||
]);
|
||
expect(events[2]?.data).toEqual({ command: 'npm test' });
|
||
expect(events[3]?.data).toEqual({ changes: [{ path: 'src/app.ts' }] });
|
||
});
|
||
it('runs Claude Code headless with only workspace file tools and its own credential variable', async () => {
|
||
const home = await temp();
|
||
const binary = path.join(home, 'claude-fixture');
|
||
// The fixture insists on print mode streaming JSON in restricted mode: no tools that run
|
||
// commands, file tools confined to the workspace and no repository settings, hooks or MCP.
|
||
await writeFile(
|
||
binary,
|
||
`#!/usr/bin/env node
|
||
const args = process.argv.slice(2);
|
||
const flags = ['--output-format', 'stream-json', '--verbose', '--permission-mode', 'dontAsk', '--safe-mode', '--restricted', '--strict-mcp-config'];
|
||
const tools = 'Read,Edit,Write,Glob,Grep';
|
||
if (
|
||
args[0] !== '-p' ||
|
||
!flags.every(flag => args.includes(flag)) ||
|
||
args.includes('bypassPermissions') ||
|
||
args.includes('--settings') ||
|
||
!args[1].includes('only Read/Edit/Write/Glob/Grep file tools are available') ||
|
||
args[args.indexOf('--tools') + 1] !== tools ||
|
||
args[args.indexOf('--allowedTools') + 1] !== tools ||
|
||
!process.env.ANTHROPIC_API_KEY
|
||
)
|
||
process.exit(2);
|
||
console.log(JSON.stringify({type:'system',subtype:'init',session_id:'claude-session'}));
|
||
console.log(JSON.stringify({type:'assistant',message:{content:[{type:'tool_use',name:'Write',input:{file_path:'notes.md'}}]}}));
|
||
console.log(JSON.stringify({type:'result',subtype:'success',is_error:false,result:'done',usage:{input_tokens:3,output_tokens:4}}));
|
||
`,
|
||
);
|
||
await chmod(binary, 0o700);
|
||
const adapter = new ClaudeCodeAdapter({
|
||
binary,
|
||
isolatedHome: home,
|
||
credentialEnv: { ANTHROPIC_API_KEY: 'test-key' },
|
||
isolationConfirmed: true,
|
||
});
|
||
expect(adapter.capabilities()).toMatchObject({ provider: 'claude-code', availability: 'available' });
|
||
await adapter.start({ runId: 'r', tenantId: 't', workspace: home, baseCommit: 'a'.repeat(40), prompt: 'test' });
|
||
const events = [];
|
||
for await (const event of adapter.events('r')) events.push(event);
|
||
expect(events.map(event => event.type)).toEqual(['started', 'file_change', 'output', 'usage', 'completed']);
|
||
expect((await adapter.inspect('r')).sessionId).toBe('claude-session');
|
||
// CodeBuddy's variables are not Claude Code's; nothing else crosses into the CLI.
|
||
const mismatched = new ClaudeCodeAdapter({
|
||
binary,
|
||
isolatedHome: home,
|
||
credentialEnv: { CODEBUDDY_API_KEY: 'test-key' },
|
||
isolationConfirmed: true,
|
||
});
|
||
await expect(
|
||
mismatched.start({ runId: 'x', tenantId: 't', workspace: home, baseCommit: 'a'.repeat(40), prompt: 'test' }),
|
||
).rejects.toMatchObject({ code: 'CREDENTIAL_ENV_POLICY' });
|
||
});
|
||
it('lets Claude Code run commands only inside its own sandbox, and keeps file tools where it cannot start', async () => {
|
||
const home = await temp();
|
||
const workspace = path.join(home, 'workspace');
|
||
await mkdir(workspace);
|
||
const binary = path.join(home, 'claude-sandbox-fixture');
|
||
// The fixture records how it was started for the test to inspect.
|
||
await writeFile(
|
||
binary,
|
||
`#!/usr/bin/env node
|
||
require('node:fs').writeFileSync(${JSON.stringify(path.join(home, 'invocation.json'))}, JSON.stringify({ args: process.argv.slice(2), env: process.env }));
|
||
console.log(JSON.stringify({type:'result',subtype:'success',is_error:false,result:'done'}));
|
||
`,
|
||
);
|
||
await chmod(binary, 0o700);
|
||
const start = async (probe: () => Promise<string | undefined>) => {
|
||
const adapter = new ClaudeCodeAdapter({
|
||
binary,
|
||
isolatedHome: path.join(home, 'provider-home'),
|
||
credentialEnv: { ANTHROPIC_API_KEY: 'test-key' },
|
||
isolationConfirmed: true,
|
||
commandSandbox: {
|
||
readable: ['/opt/module-cache'],
|
||
unreadable: ['/srv/worker'],
|
||
env: { GOFLAGS: '-mod=readonly' },
|
||
probe,
|
||
},
|
||
});
|
||
await adapter.start({ runId: 'r', tenantId: 't', workspace, baseCommit: 'a'.repeat(40), prompt: 'Change it' });
|
||
const events = [];
|
||
for await (const event of adapter.events('r')) events.push(event);
|
||
const invocation = JSON.parse(await readFile(path.join(home, 'invocation.json'), 'utf8'));
|
||
return { events, args: invocation.args as string[], env: invocation.env as Record<string, string> };
|
||
};
|
||
const flag = (args: string[], name: string) => args[args.indexOf(name) + 1];
|
||
|
||
const sandboxed = await start(async () => undefined);
|
||
expect(flag(sandboxed.args, '--tools')).toBe('Read,Edit,Write,Glob,Grep,Bash');
|
||
// Only sandboxed commands are allowed, by the sandbox's own setting; no rule allows Bash.
|
||
expect(flag(sandboxed.args, '--allowedTools')).toBe('Read,Edit,Write,Glob,Grep');
|
||
expect(sandboxed.args).toEqual(expect.arrayContaining(['--restricted', 'dontAsk']));
|
||
const { sandbox } = JSON.parse(flag(sandboxed.args, '--settings') ?? '{}');
|
||
expect(sandbox).toMatchObject({
|
||
enabled: true,
|
||
failIfUnavailable: true,
|
||
autoAllowBashIfSandboxed: true,
|
||
allowUnsandboxedCommands: false,
|
||
network: { allowedDomains: [], strictAllowlist: true },
|
||
credentials: { envVars: [{ name: 'ANTHROPIC_API_KEY', mode: 'deny' }] },
|
||
});
|
||
expect(sandbox.network.allowLocalBinding).toBeUndefined();
|
||
const scratch = await realpath(path.join(home, 'provider-home', 'command-scratch'));
|
||
expect(sandbox.filesystem.denyRead).toEqual(
|
||
expect.arrayContaining([os.homedir(), await realpath(path.join(home, 'provider-home')), '/srv/worker']),
|
||
);
|
||
expect(sandbox.filesystem.allowRead).toEqual([await realpath(workspace), scratch, '/opt/module-cache']);
|
||
expect(sandbox.filesystem.allowWrite).toEqual([scratch]);
|
||
expect(sandboxed.env).toMatchObject({
|
||
ANTHROPIC_API_KEY: 'test-key',
|
||
GOCACHE: path.join(scratch, 'go-build'),
|
||
GOFLAGS: '-mod=readonly',
|
||
GIT_CONFIG_GLOBAL: '/dev/null',
|
||
});
|
||
expect(sandboxed.args[1]).toMatch(/^Change it\n\nExecution contract: .*Bash runs in a sandbox/);
|
||
expect(sandboxed.events[0]).toMatchObject({ type: 'started', data: { commands: 'sandboxed' } });
|
||
|
||
const unavailable = await start(async () => 'bwrap: No permissions to create new namespace');
|
||
expect(unavailable.args).not.toContain('--settings');
|
||
expect(flag(unavailable.args, '--tools')).toBe('Read,Edit,Write,Glob,Grep');
|
||
expect(unavailable.args[1]).toContain('only Read/Edit/Write/Glob/Grep file tools are available');
|
||
expect(unavailable.env.GOCACHE).toBeUndefined();
|
||
expect(unavailable.events[0]).toMatchObject({
|
||
type: 'started',
|
||
data: { commands: 'none', reason: 'bwrap: No permissions to create new namespace' },
|
||
});
|
||
});
|
||
it('probes whether Claude Code can start its command sandbox here', async () => {
|
||
const calls: string[][] = [];
|
||
const ready = await probeClaudeSandbox(async command => {
|
||
calls.push([command.executable, ...command.args]);
|
||
return { exitCode: 0, stdout: '', stderr: '' };
|
||
});
|
||
const denied = await probeClaudeSandbox(async () => ({ exitCode: 1, stdout: '', stderr: 'denied here' }));
|
||
if (process.platform === 'darwin') {
|
||
expect(ready).toBeUndefined();
|
||
expect(calls[0]?.[0]).toBe('/usr/bin/sandbox-exec');
|
||
expect(denied).toBe('denied here');
|
||
} else if (process.platform === 'linux') {
|
||
expect(ready).toBeUndefined();
|
||
expect(calls.map(call => call[1])).toEqual(['socat', 'bwrap']);
|
||
expect(calls[1]).toEqual(expect.arrayContaining(['--unshare-all', '--proc']));
|
||
expect(denied).toBe('socat is not available: denied here');
|
||
} else expect(ready).toMatch(/no command sandbox/);
|
||
});
|
||
it('starts CodeBuddy, which has no command sandbox, only in a development sandbox and says so', async () => {
|
||
const home = await temp();
|
||
const binary = path.join(home, 'codebuddy-unsandboxed');
|
||
await writeFile(
|
||
binary,
|
||
`#!/usr/bin/env node\nconsole.log(JSON.stringify({type:'result',subtype:'success',is_error:false,result:'done'}));\n`,
|
||
);
|
||
await chmod(binary, 0o700);
|
||
const config = { binary, isolatedHome: home, credentialEnv: { CODEBUDDY_API_KEY: 'test-key' } };
|
||
const start = { runId: 'r', tenantId: 't', workspace: home, baseCommit: 'a'.repeat(40), prompt: 'test' };
|
||
await expect(new CodeBuddyAdapter({ ...config, isolationConfirmed: true }).start(start)).rejects.toMatchObject({
|
||
code: 'PROVIDER_SANDBOX_UNAVAILABLE',
|
||
});
|
||
const adapter = new CodeBuddyAdapter({ ...config, isolationConfirmed: true, allowUnsandboxed: true });
|
||
await adapter.start(start);
|
||
const events = [];
|
||
for await (const event of adapter.events('r')) events.push(event);
|
||
expect(events[0]).toMatchObject({ type: 'started', data: { unsandboxed: true, reason: 'CodeBuddy has none' } });
|
||
expect((await adapter.inspect('r')).status).toBe('completed');
|
||
});
|
||
it('runs the configured headless executable and requires its structured final result', async () => {
|
||
const home = await temp();
|
||
const binary = path.join(home, 'codebuddy-fixture');
|
||
await writeFile(
|
||
binary,
|
||
`#!/usr/bin/env node\nconsole.log(JSON.stringify({type:'result',subtype:'success',is_error:false,result:'implemented'}));\n`,
|
||
);
|
||
await chmod(binary, 0o700);
|
||
const adapter = new CodeBuddyAdapter({
|
||
binary,
|
||
isolatedHome: home,
|
||
credentialEnv: { CODEBUDDY_API_KEY: 'test-key' },
|
||
isolationConfirmed: true,
|
||
allowUnsandboxed: true,
|
||
});
|
||
await adapter.start({ runId: 'r', tenantId: 't', workspace: home, baseCommit: 'a'.repeat(40), prompt: 'test' });
|
||
for await (const _event of adapter.events('r')) {
|
||
/* consume */
|
||
}
|
||
expect((await adapter.inspect('r')).status).toBe('completed');
|
||
});
|
||
});
|
||
|
||
describe('isolated Git checkpoints and independent verification', () => {
|
||
it('includes new files in a committed portable patch and verifies that exact SHA', async () => {
|
||
const root = await temp();
|
||
const git = new GitWorkspace();
|
||
const prepared = await git.create({ root, runId: 'run-1' });
|
||
await writeFile(path.join(prepared.workspace, 'hello.txt'), 'hello\n');
|
||
const checkpoint = await git.checkpoint(prepared.workspace, prepared.baseCommit, 'run-1', 'test');
|
||
expect(checkpoint.patch).toContain('hello.txt');
|
||
expect(checkpoint.sourceCommit).not.toBe(prepared.baseCommit);
|
||
const report = await verifyWorkspace({
|
||
workspace: prepared.workspace,
|
||
sourceCommit: checkpoint.sourceCommit,
|
||
commands: [[process.execPath, '-e', 'process.exit(0)']],
|
||
isolation: 'host',
|
||
});
|
||
expect(report).toMatchObject({ passed: true, isolation: 'host' });
|
||
await expect(
|
||
verifyWorkspace({
|
||
workspace: prepared.workspace,
|
||
sourceCommit: checkpoint.sourceCommit,
|
||
commands: [],
|
||
isolation: 'host',
|
||
}),
|
||
).rejects.toThrow('Protected');
|
||
});
|
||
it('concludes a resolved merge even when the result equals the branch it merged into', async () => {
|
||
const root = await temp();
|
||
const git = new GitWorkspace();
|
||
const { workspace } = await git.create({ root, runId: 'run-merge' });
|
||
const run = async (...args: string[]) =>
|
||
(
|
||
await executeCommand({
|
||
executable: 'git',
|
||
args: ['-c', 'user.name=Fixture', '-c', 'user.email=fixture@example.invalid', ...args],
|
||
cwd: workspace,
|
||
})
|
||
).stdout.trim();
|
||
const commit = async (content: string) => {
|
||
await writeFile(path.join(workspace, 'greeting.txt'), `${content}\n`);
|
||
await run('commit', '--quiet', '--all', '--allow-empty', '-m', content);
|
||
};
|
||
await writeFile(path.join(workspace, 'greeting.txt'), 'base\n');
|
||
await run('add', 'greeting.txt');
|
||
await commit('base');
|
||
await run('checkout', '--quiet', '-b', 'target');
|
||
await commit('target');
|
||
const targetCommit = await run('rev-parse', 'HEAD');
|
||
await run('checkout', '--quiet', '-');
|
||
await commit('ours');
|
||
await run('merge', '--no-ff', '--no-edit', 'target');
|
||
// The agent keeps its own side: the tree equals HEAD, but the merge must still be recorded.
|
||
await writeFile(path.join(workspace, 'greeting.txt'), 'ours\n');
|
||
const checkpoint = await git.checkpoint(workspace, targetCommit, 'run-merge', 'test');
|
||
expect((await run('rev-list', '--parents', '-n', '1', checkpoint.sourceCommit)).split(' ')).toContain(targetCommit);
|
||
});
|
||
it('rejects unverified promotion and credential-bearing URLs before touching a repository', async () => {
|
||
const git = new GitWorkspace();
|
||
await expect(
|
||
git.promoteVerifiedCandidate({
|
||
repository: '/unused',
|
||
targetRef: 'refs/heads/main',
|
||
expectedTargetCommit: 'a'.repeat(40),
|
||
candidateCommit: 'b'.repeat(40),
|
||
verifiedCommit: 'c'.repeat(40),
|
||
}),
|
||
).rejects.toThrow('exact candidate');
|
||
await expect(
|
||
git.create({ repository: 'https://user:secret@example.test/repo', root: await temp(), runId: 'run' }),
|
||
).rejects.toThrow('inline credentials');
|
||
});
|
||
});
|