import { execFile } from "node:child_process"; import { EventEmitter } from "node:events"; import { chmod, link, mkdir, mkdtemp, readFile, realpath, rm, symlink, writeFile, } from "node:fs/promises"; import os from "node:os"; import path from "node:path"; import { promisify } from "node:util"; import { test } from "node:test"; import assert from "node:assert/strict"; import { buildChildEnvironment, commandToShellString, compileSandboxExecution, applyMacOSCompatibilityProfile, assertNoExternalHardlinks, existingSystemReadRoots, probeSandboxRuntime, quotePosixArgument, runSandboxedCommand, } from "../bin/sandbox/runtime.mjs"; const execFileAsync = promisify(execFile); const REPO = process.env.REPO || process.cwd(); function profile(name, overrides = {}) { const capabilities = { workspace: "read", temporaryFiles: "write", network: "deny", credentials: "deny", externalSideEffects: "deny", ...overrides, }; return { name, description: name, riskLevel: 0, capabilities, enforcementLevel: "advisory" }; } function compile(overrides = {}) { return compileSandboxExecution({ profile: profile("observe"), workspace: REPO, runRoot: "/tmp/opp-sandbox-unit", sourceEnvironment: { PATH: "/usr/bin:/bin", LANG: "C.UTF-8", GH_TOKEN: "secret-gh-token", SSH_AUTH_SOCK: "/tmp/agent.sock", }, originalHome: os.homedir(), helperPaths: { bwrap: "/usr/bin/bwrap", rg: "/usr/bin/rg", socat: "/usr/bin/socat", }, ...overrides, }); } test("observe compiles to read-only workspace, private temporary writes, and a scrubbed environment", () => { const result = compile(); assert.deepEqual(result.runtimeConfig.filesystem.allowRead, [REPO, "/tmp/opp-sandbox-unit"]); assert.deepEqual(result.runtimeConfig.filesystem.allowWrite, ["/tmp/opp-sandbox-unit"]); assert.deepEqual(result.runtimeConfig.filesystem.denyRead, [path.parse(REPO).root]); assert.equal(result.runtimeConfig.network.strictAllowlist, true); assert.deepEqual(result.runtimeConfig.network.allowedDomains, []); assert.equal(result.runtimeConfig.enableWeakerNestedSandbox, false); assert.equal(result.runtimeConfig.enableWeakerNetworkIsolation, false); assert.equal(result.runtimeConfig.allowAppleEvents, false); assert.equal(result.childEnvironment.GH_TOKEN, undefined); assert.equal(result.childEnvironment.SSH_AUTH_SOCK, undefined); assert.equal(result.childEnvironment.GIT_CONFIG_NOSYSTEM, "1"); assert.equal(result.childEnvironment.HOME, "/tmp/opp-sandbox-unit/home"); assert.equal(result.childEnvironment.TMPDIR, "/tmp/opp-sandbox-unit/tmp"); assert.ok( result.runtimeConfig.credentials.files.some((entry) => entry.path === path.join(REPO, ".env")), ); }); test("system runtime reads do not expose all of usr or usr-local configuration", async () => { const roots = await existingSystemReadRoots(process.platform); assert.equal(roots.includes("/usr"), false); assert.equal(roots.includes("/usr/local"), false); assert.ok(roots.includes(await realpath("/usr/bin"))); if (process.platform === "darwin") { assert.ok(roots.includes("/private/var/select/sh")); assert.ok(roots.includes(await realpath("/private/var/select/sh"))); } }); function isParent(candidate, target) { const relative = path.relative(candidate, target); return relative !== "" && !relative.startsWith("..") && !path.isAbsolute(relative); } test("develop permits workspace writes without granting network or credentials", () => { const result = compile({ profile: profile("develop", { workspace: "write" }), }); assert.deepEqual(result.runtimeConfig.filesystem.allowWrite, [REPO, "/tmp/opp-sandbox-unit"]); assert.deepEqual(result.runtimeConfig.network.allowedDomains, []); assert.equal(result.childEnvironment.GH_TOKEN, undefined); assert.ok(result.runtimeConfig.filesystem.denyWrite.includes(path.join(REPO, ".git", "hooks"))); assert.ok(result.runtimeConfig.filesystem.denyWrite.includes(path.join(REPO, ".agents"))); }); test("compilation denies upstream shared Claude temporary paths on every platform", () => { const result = compile({ temporaryRoot: "/private/var/folders/example/T", }); assert.ok(result.runtimeConfig.filesystem.denyWrite.includes("/tmp/claude")); assert.ok(result.runtimeConfig.filesystem.denyWrite.includes("/private/tmp/claude")); assert.ok( result.runtimeConfig.filesystem.denyWrite.includes("/private/var/folders/example/T/claude"), ); }); test("workspace hardlink scan allows internal links and rejects links to external inodes", async () => { const fixture = await mkdtemp(path.join(os.tmpdir(), "opp-hardlink-unit-")); const workspace = path.join(fixture, "workspace"); const outside = path.join(fixture, "outside.txt"); await mkdir(workspace); await writeFile(outside, "outside", "utf8"); await link(outside, path.join(workspace, "external-link")); try { await assert.rejects(assertNoExternalHardlinks(workspace), /external hardlink/); await rm(path.join(workspace, "external-link")); await writeFile(path.join(workspace, "internal-a"), "inside", "utf8"); await link(path.join(workspace, "internal-a"), path.join(workspace, "internal-b")); await assert.doesNotReject(assertNoExternalHardlinks(workspace)); } finally { await rm(fixture, { recursive: true, force: true }); } }); test("network-read blocks raw protocols and mutation-oriented HTTP methods", async () => { const result = compile({ profile: profile("network-read", { workspace: "write", network: "explicit", credentials: "explicit", }), allowedDomains: ["api.github.com:443"], readOnlySocksProxyPort: 43123, }); assert.deepEqual(result.runtimeConfig.network.allowedDomains, ["api.github.com:443"]); assert.equal(result.runtimeConfig.network.socksProxyPort, 43123); assert.deepEqual(result.runtimeConfig.network.tlsTerminate, {}); assert.deepEqual( await result.runtimeConfig.network.filterRequest(new Request("https://api.github.com", { method: "GET", })), { action: "allow" }, ); assert.equal( (await result.runtimeConfig.network.filterRequest(new Request("https://api.github.com", { method: "POST", }))).action, "deny", ); }); test("capability grants and publish confirmation fail closed", () => { assert.throws(() => compile({ allowedDomains: ["example.com"] }), /does not permit network/); assert.throws(() => compile({ allowedEnvironment: ["GH_TOKEN"] }), /does not permit credential/); assert.throws(() => compile({ profile: profile("network-read", { network: "explicit", credentials: "explicit" }), allowedEnvironment: ["GIT_CONFIG_SYSTEM"], }), /Sandbox control variable cannot be granted/); assert.throws( () => compile({ confirmExternalSideEffects: true }), /does not permit external side-effect confirmation/, ); assert.throws( () => compile({ profile: profile("publish", { workspace: "write", network: "explicit", credentials: "explicit", externalSideEffects: "confirm", }), }), /requires --confirm-external-side-effects/, ); assert.throws( () => compile({ profile: profile("publish", { workspace: "write", network: "explicit", credentials: "explicit", externalSideEffects: "confirm", }), allowedEnvironment: ["NODE_OPTIONS"], confirmExternalSideEffects: true, }), /cannot be granted/, ); }); test("an explicit credential exposes only the named variable", () => { const result = compile({ profile: profile("publish", { workspace: "write", network: "explicit", credentials: "explicit", externalSideEffects: "confirm", }), allowedEnvironment: ["GH_TOKEN"], confirmExternalSideEffects: true, }); assert.equal(result.childEnvironment.GH_TOKEN, "secret-gh-token"); assert.equal(result.childEnvironment.SSH_AUTH_SOCK, undefined); assert.ok(result.runtimeConfig.credentials.envVars.some((entry) => entry.name === "SSH_AUTH_SOCK")); assert.ok(!result.runtimeConfig.credentials.envVars.some((entry) => entry.name === "GH_TOKEN")); }); test("child environment removes workspace-controlled PATH entries", () => { const environment = buildChildEnvironment({ sourceEnvironment: { PATH: `${REPO}/bin${path.delimiter}/usr/bin${path.delimiter}relative/bin`, LANG: "C", }, allowedEnvironment: [], workspace: REPO, runRoot: "/tmp/opp-sandbox-unit", }); assert.equal(environment.PATH, "/usr/bin"); assert.equal(environment.LANG, "C"); }); test("POSIX quoting preserves shell metacharacters as literal argv", async () => { const values = [ "plain", "space value", "", "single'quote", "$(printf injected)", "`printf injected`", "semi;colon", "line\nbreak", "*.mjs", "--skill", "unicode-雪", ]; const command = commandToShellString([ process.execPath, "-e", "process.stdout.write(JSON.stringify(process.argv.slice(1)))", ...values, ]); const { stdout } = await execFileAsync("/bin/sh", ["-c", command], { cwd: REPO }); assert.deepEqual(JSON.parse(stdout), values); assert.equal(quotePosixArgument("a'b"), `'a'"'"'b'`); assert.throws(() => quotePosixArgument("bad\0value"), /NUL/); }); test("runtime probing reports readiness and fails closed on unsupported or missing backends", async () => { const ready = await probeSandboxRuntime({ platform: "linux", loadRuntime: async () => ({ SandboxManager: { isSupportedPlatform: () => true, checkDependenciesAsync: async () => ({ errors: [], warnings: ["preview"] }), }, }), hostProbe: async () => ({ errors: [], warnings: [] }), }); assert.equal(ready.runnerReady, true); assert.equal(ready.executionLevel, "shell-contained"); assert.deepEqual(ready.warnings, ["preview"]); const unsupportedArchitecture = await probeSandboxRuntime({ platform: "linux", architecture: "s390x", loadRuntime: async () => ({ SandboxManager: { isSupportedPlatform: () => true, checkDependenciesAsync: async () => ({ errors: [], warnings: [] }), }, }), hostProbe: async () => ({ errors: [], warnings: [] }), }); assert.equal(unsupportedArchitecture.runnerReady, false); assert.match(unsupportedArchitecture.errors[0], /unsupported on architecture/); const unsupported = await probeSandboxRuntime({ platform: "win32" }); assert.equal(unsupported.runnerReady, false); assert.match(unsupported.errors[0], /Unsupported platform/); const missing = await probeSandboxRuntime({ platform: "linux", loadRuntime: async () => { throw new Error("module missing"); }, }); assert.equal(missing.runnerReady, false); assert.deepEqual(missing.errors, ["module missing"]); }); function fakeSpawn(exitCode, onSpawn) { return (file, args, options) => { onSpawn?.(file, args, options); const child = new EventEmitter(); queueMicrotask(() => child.emit("close", exitCode, null)); return child; }; } function fakeMacSandboxDescriptor() { return { argv: [ "/bin/sh", "-c", "sandbox-exec -p '(allow file-read-metadata\n (vnode-type DIRECTORY))\n(allow process-exec)\n(allow process-fork)' /bin/sh -c true", ], env: {}, }; } test("macOS descriptor shim enables scripts and raw temp paths, then fails closed on drift", () => { const original = fakeMacSandboxDescriptor(); const patched = applyMacOSCompatibilityProfile(original, "darwin"); assert.notEqual(patched, original); assert.match(patched.argv[2], /\(allow process-exec-interpreter\)/); assert.match( patched.argv[2], /\(vnode-type DIRECTORY\)\)\n\(allow file-read-metadata\n \(literal "\/var"\)\)/, ); assert.doesNotMatch(patched.argv[2], /\(subpath "\/var"\)/); assert.doesNotMatch(original.argv[2], /process-exec-interpreter/); assert.equal(applyMacOSCompatibilityProfile(original, "linux"), original); assert.throws( () => applyMacOSCompatibilityProfile({ argv: [ "/bin/sh", "-c", "(allow file-read-metadata\n (vnode-type DIRECTORY))\nchanged", ], }, "darwin"), /rules no longer match/, ); assert.throws( () => applyMacOSCompatibilityProfile({ argv: [ "/bin/sh", "-c", "(allow process-exec)\n(allow process-fork)", ], }, "darwin"), /rules no longer match/, ); assert.throws( () => applyMacOSCompatibilityProfile({ argv: ["unexpected"] }, "darwin"), /unexpected command descriptor/, ); }); test("runner initializes before spawn, uses shell false, propagates exit codes, and resets once", async () => { let initialized; let initializationTemporaryEnvironment; let resetCount = 0; let spawnOptions; let wrappingTemporaryEnvironment; let wrappedCommand; const temporaryNames = ["CLAUDE_CODE_TMPDIR", "TEMP", "TMP", "TMPDIR"]; const originalTemporaryEnvironment = Object.fromEntries( temporaryNames.map((name) => [name, process.env[name]]), ); const captureTemporaryEnvironment = () => Object.fromEntries( temporaryNames.map((name) => [name, process.env[name]]), ); const manager = { isSupportedPlatform: () => true, initialize: async (config) => { initialized = config; initializationTemporaryEnvironment = captureTemporaryEnvironment(); }, wrapWithSandboxArgv: async (command) => { wrappedCommand = command; wrappingTemporaryEnvironment = captureTemporaryEnvironment(); return { argv: ["/fake/sandbox", "wrapped"], env: { SHOULD_NOT_LEAK: "yes" } }; }, reset: async () => { resetCount += 1; }, }; let diagnostics = ""; const exitCode = await runSandboxedCommand({ profile: profile("observe"), allowedDomains: [], allowedEnvironment: [], confirmExternalSideEffects: false, command: ["printf", "%s", "literal;$(not-run)"], }, { cwd: REPO, home: os.homedir(), env: { PATH: "/usr/bin:/bin", GH_TOKEN: "secret", "JAVA_HOME_17.0.16_x64": "/invalid-host-key", }, helperPaths: { bwrap: "/usr/bin/bwrap", rg: "/usr/bin/rg", socat: "/usr/bin/socat" }, platform: "linux", loadRuntime: async () => ({ SandboxManager: manager, SandboxRuntimeConfigSchema: { parse: (config) => config }, }), spawn: fakeSpawn(7, (_file, _args, options) => { spawnOptions = options; }), writeError: (text) => { diagnostics += text; }, }); assert.equal(exitCode, 7); assert.equal(resetCount, 1); assert.equal(spawnOptions.shell, false); assert.equal(spawnOptions.env.GH_TOKEN, undefined); assert.equal(spawnOptions.env["JAVA_HOME_17.0.16_x64"], undefined); assert.equal(spawnOptions.env.SHOULD_NOT_LEAK, undefined); assert.equal(spawnOptions.env.GIT_CONFIG_NOSYSTEM, "1"); assert.deepEqual(initializationTemporaryEnvironment, wrappingTemporaryEnvironment); assert.ok(Object.values(initializationTemporaryEnvironment).every( (value) => value.endsWith(`${path.sep}tmp`) && value.includes("opp-sandbox-"), )); assert.deepEqual(captureTemporaryEnvironment(), originalTemporaryEnvironment); assert.equal(initialized.enableWeakerNestedSandbox, false); assert.ok(initialized.seccomp.applyPath.endsWith(path.join( "vendor", "seccomp", process.arch === "arm64" ? "arm64" : "x64", "apply-seccomp", ))); assert.ok(initialized.filesystem.allowRead.includes(initialized.seccomp.applyPath)); assert.equal(initialized.credentials.envVars.some( (entry) => entry.name === "JAVA_HOME_17.0.16_x64", ), false); assert.equal(wrappedCommand, `'printf' '%s' 'literal;$(not-run)'`); assert.match(diagnostics, /Sandbox: observe, shell-contained/); assert.doesNotMatch(diagnostics, /GH_TOKEN|secret|literal/); }); test("macOS runner enables correlated violation diagnostics for failed commands", async () => { const fixture = await mkdtemp(path.join(os.tmpdir(), "opp-macos-diagnostic-")); const workspace = path.join(fixture, "workspace"); await mkdir(workspace); let monitorEnabled; let commandId; let diagnostics = ""; const manager = { isSupportedPlatform: () => true, initialize: async (_config, _callback, enabled) => { monitorEnabled = enabled; }, wrapWithSandboxArgv: async (_command, _shell, _a, _b, _cwd, options) => { commandId = options.commandId; return fakeMacSandboxDescriptor(); }, getSandboxViolationStore: () => ({ getViolationsForCommand: (id) => id === commandId ? [{ line: "deny process-exec-interpreter /bin/sh" }] : [], }), reset: async () => {}, }; try { assert.equal(await runSandboxedCommand({ profile: profile("observe"), allowedDomains: [], allowedEnvironment: [], confirmExternalSideEffects: false, command: ["true"], }, { cwd: workspace, home: os.homedir(), temporaryRoot: fixture, env: { PATH: "/usr/bin:/bin" }, platform: "darwin", loadRuntime: async () => ({ SandboxManager: manager, SandboxRuntimeConfigSchema: { parse: (config) => config }, }), spawn: fakeSpawn(126), writeError: (message) => { diagnostics += message; }, }), 126); assert.equal(monitorEnabled, true); assert.match(commandId, /^[0-9a-f-]{36}$/); assert.match(diagnostics, /Sandbox violation: deny process-exec-interpreter \/bin\/sh/); } finally { await rm(fixture, { recursive: true, force: true }); } }); test("runner canonicalizes a symlinked temporary root before compiling private paths", async () => { const fixture = await mkdtemp(path.join(os.tmpdir(), "opp-canonical-temp-")); const actualTemporaryRoot = path.join(fixture, "actual-temp"); const linkedTemporaryRoot = path.join(fixture, "linked-temp"); const workspace = path.join(fixture, "workspace"); await mkdir(actualTemporaryRoot); await mkdir(workspace); await symlink(actualTemporaryRoot, linkedTemporaryRoot); let spawnEnvironment; const manager = { isSupportedPlatform: () => true, initialize: async () => {}, wrapWithSandboxArgv: async () => fakeMacSandboxDescriptor(), reset: async () => {}, }; try { assert.equal(await runSandboxedCommand({ profile: profile("observe"), allowedDomains: [], allowedEnvironment: [], confirmExternalSideEffects: false, command: ["true"], }, { cwd: workspace, home: os.homedir(), temporaryRoot: linkedTemporaryRoot, env: { PATH: "/usr/bin:/bin" }, platform: "darwin", loadRuntime: async () => ({ SandboxManager: manager, SandboxRuntimeConfigSchema: { parse: (config) => config }, }), spawn: fakeSpawn(0, (_file, _args, options) => { spawnEnvironment = options.env; }), }), 0); assert.ok(spawnEnvironment.HOME.startsWith(`${await realpath(actualTemporaryRoot)}${path.sep}`)); assert.ok(spawnEnvironment.TMPDIR.startsWith(`${await realpath(actualTemporaryRoot)}${path.sep}`)); } finally { await rm(fixture, { recursive: true, force: true }); } }); test("runner rejects a workspace inside an upstream shared-write compatibility path", async () => { const fixture = await mkdtemp(path.join(os.tmpdir(), "opp-shared-write-root-")); const workspace = path.join(fixture, "claude", "project"); await mkdir(workspace, { recursive: true }); try { // A repository-local TMPDIR must not resolve to the enclosing checkout. await execFileAsync("git", ["init", "--quiet", workspace]); await assert.rejects(runSandboxedCommand({ profile: profile("develop", { workspace: "write" }), allowedDomains: [], allowedEnvironment: [], confirmExternalSideEffects: false, command: ["true"], }, { cwd: workspace, home: os.homedir(), temporaryRoot: fixture, env: { PATH: "/usr/bin:/bin" }, platform: "darwin", }), /protected shared-write path/); } finally { await rm(fixture, { recursive: true, force: true }); } }); test("runner rejects Linux helpers from an attacker-writable PATH directory", async () => { const fixture = await mkdtemp(path.join(os.tmpdir(), "opp-helper-trust-")); const workspace = path.join(fixture, "workspace"); const hostileBin = path.join(fixture, "hostile-bin"); await mkdir(workspace); await mkdir(hostileBin); for (const helper of ["bwrap", "rg", "socat"]) { const executable = path.join(hostileBin, helper); await writeFile(executable, "#!/bin/sh\nexit 0\n", "utf8"); await chmod(executable, 0o755); } try { await assert.rejects(runSandboxedCommand({ profile: profile("observe"), allowedDomains: [], allowedEnvironment: [], confirmExternalSideEffects: false, command: ["true"], }, { cwd: workspace, home: os.homedir(), temporaryRoot: fixture, env: { PATH: hostileBin }, platform: "linux", }), /trusted host paths/); } finally { await rm(fixture, { recursive: true, force: true }); } }); test("runner exposes an explicitly selected executable outside static system roots", async () => { const fixture = await mkdtemp(path.join(os.tmpdir(), "opp-command-root-")); const workspace = path.join(fixture, "workspace"); const tools = path.join(fixture, "toolcache", "bin"); const executable = path.join(tools, "custom-node"); const runtimeResource = path.join(fixture, "toolcache", "lib", "resource.txt"); await mkdir(workspace); await mkdir(tools, { recursive: true }); await mkdir(path.dirname(runtimeResource), { recursive: true }); await writeFile(path.join(fixture, "toolcache", "package.json"), "{}\n", "utf8"); await writeFile(runtimeResource, "runtime-resource", "utf8"); await writeFile(executable, "#!/bin/sh\nexit 0\n", "utf8"); await chmod(executable, 0o755); let runtimeConfig; const manager = { isSupportedPlatform: () => true, initialize: async (config) => { runtimeConfig = config; }, wrapWithSandboxArgv: async () => ({ argv: ["/fake/sandbox"], env: {} }), reset: async () => {}, }; try { assert.equal(await runSandboxedCommand({ profile: profile("observe"), allowedDomains: [], allowedEnvironment: [], confirmExternalSideEffects: false, command: [executable], }, { cwd: workspace, home: os.homedir(), temporaryRoot: fixture, env: { PATH: "/usr/bin:/bin" }, helperPaths: { bwrap: "/usr/bin/bwrap", rg: "/usr/bin/rg", socat: "/usr/bin/socat" }, platform: "linux", loadRuntime: async () => ({ SandboxManager: manager, SandboxRuntimeConfigSchema: { parse: (config) => config }, }), spawn: fakeSpawn(0), }), 0); assert.ok(runtimeConfig.filesystem.allowRead.some( (allowed) => allowed === executable || isParent(allowed, executable), )); const canonicalRuntimeResource = await realpath(runtimeResource); assert.ok(runtimeConfig.filesystem.allowRead.some( (allowed) => allowed === canonicalRuntimeResource || isParent(allowed, canonicalRuntimeResource), )); } finally { await rm(fixture, { recursive: true, force: true }); } }); test("runner exposes an env shebang interpreter and its bounded runtime", async () => { const fixture = await mkdtemp(path.join(os.tmpdir(), "opp-shebang-root-")); const workspace = path.join(fixture, "workspace"); const toolRoot = path.join(fixture, "tool"); const executable = path.join(toolRoot, "bin", "env-tool"); const fakeHome = path.join(fixture, "home"); const interpreterBin = path.join(fakeHome, "bin"); const interpreter = path.join(interpreterBin, "custom-node"); await mkdir(workspace); await mkdir(path.dirname(executable), { recursive: true }); await mkdir(interpreterBin, { recursive: true }); await mkdir(path.join(fakeHome, "lib", "node_modules"), { recursive: true }); await writeFile(path.join(toolRoot, "package.json"), "{}\n", "utf8"); await writeFile(executable, "#!/usr/bin/env -S custom-node --no-warnings\n", "utf8"); await chmod(executable, 0o755); await symlink(process.execPath, interpreter); let runtimeConfig; const manager = { isSupportedPlatform: () => true, initialize: async (config) => { runtimeConfig = config; }, wrapWithSandboxArgv: async () => fakeMacSandboxDescriptor(), reset: async () => {}, }; try { assert.equal(await runSandboxedCommand({ profile: profile("observe"), allowedDomains: [], allowedEnvironment: [], confirmExternalSideEffects: false, command: [executable], }, { cwd: workspace, home: fakeHome, temporaryRoot: fixture, env: { PATH: `${interpreterBin}${path.delimiter}/usr/bin:/bin` }, platform: "darwin", loadRuntime: async () => ({ SandboxManager: manager, SandboxRuntimeConfigSchema: { parse: (config) => config }, }), spawn: fakeSpawn(0), }), 0); assert.ok(runtimeConfig.filesystem.allowRead.includes(interpreterBin)); assert.equal(runtimeConfig.filesystem.allowRead.includes(interpreter), false); assert.ok(runtimeConfig.filesystem.allowRead.includes(await realpath(process.execPath))); for (const broadRoot of ["/usr", "/usr/local", fakeHome, fixture]) { assert.equal(runtimeConfig.filesystem.allowRead.includes(broadRoot), false); } } finally { await rm(fixture, { recursive: true, force: true }); } }); test("runner rejects executable symlinks whose directory overlaps protected credentials", async () => { const fixture = await mkdtemp(path.join(os.tmpdir(), "opp-credential-command-")); const workspace = path.join(fixture, "workspace"); const credentialDirectory = path.join(workspace, ".ssh"); const executable = path.join(credentialDirectory, "run"); const credentialAlias = path.join(workspace, "tools"); await mkdir(credentialDirectory, { recursive: true }); await writeFile(path.join(credentialDirectory, "id_test"), "private-key", "utf8"); await symlink(process.execPath, executable); await symlink(credentialDirectory, credentialAlias); let spawned = false; try { await assert.rejects(runSandboxedCommand({ profile: profile("observe"), allowedDomains: [], allowedEnvironment: [], confirmExternalSideEffects: false, command: [path.join(credentialAlias, "run"), "-e", "process.exit(0)"], }, { cwd: workspace, home: os.homedir(), temporaryRoot: fixture, env: { PATH: "/usr/bin:/bin" }, helperPaths: { bwrap: "/usr/bin/bwrap", rg: "/usr/bin/rg", socat: "/usr/bin/socat" }, platform: "linux", spawn: () => { spawned = true; return fakeSpawn(0)(); }, }), /unsafe executable symlink directory/); assert.equal(spawned, false); assert.equal(await readFile(path.join(credentialDirectory, "id_test"), "utf8"), "private-key"); } finally { await rm(fixture, { recursive: true, force: true }); } }); test("runner discovers Git roots from nested directories and validates linked worktrees", async () => { const fixture = await mkdtemp(path.join(os.tmpdir(), "opp-git-root-")); const repository = path.join(fixture, "repository"); const nested = path.join(repository, "src", "nested"); const linkedWorktree = path.join(fixture, "linked-worktree"); const submodule = path.join(repository, "submodule"); const submoduleGitDirectory = path.join(repository, ".git", "modules", "submodule"); const siblingSubmodule = path.join(repository, "sibling-submodule"); const siblingSubmoduleGitDirectory = path.join(repository, ".git", "modules", "sibling-submodule"); const credentialSibling = path.join(repository, "src", "sibling"); const deepCredential = path.join( repository, ...Array.from({ length: 12 }, (_value, index) => `level-${index}`), ".npmrc", ); await mkdir(nested, { recursive: true }); await mkdir(path.join(credentialSibling, ".ssh"), { recursive: true }); await writeFile(path.join(credentialSibling, ".npmrc"), "credential", "utf8"); await mkdir(path.dirname(deepCredential), { recursive: true }); await writeFile(deepCredential, "deep-credential", "utf8"); await execFileAsync("git", ["init", "--quiet", repository]); await mkdir(path.dirname(submoduleGitDirectory), { recursive: true }); await execFileAsync("git", [ "init", "--quiet", "--separate-git-dir", submoduleGitDirectory, submodule, ]); await execFileAsync("git", [ "init", "--quiet", "--separate-git-dir", siblingSubmoduleGitDirectory, siblingSubmodule, ]); await execFileAsync("git", [ "config", "--file", path.join(submoduleGitDirectory, "config"), "core.worktree", "../../../submodule", ]); await execFileAsync("git", [ "config", "--file", path.join(siblingSubmoduleGitDirectory, "config"), "core.worktree", "../../../sibling-submodule", ]); await writeFile(path.join(repository, ".gitmodules"), [ '[submodule "submodule"]', "\tpath = submodule", '[submodule "sibling-submodule"]', "\tpath = sibling-submodule", "", ].join("\n"), "utf8"); const submoduleNested = path.join(submodule, "nested"); await mkdir(submoduleNested); await execFileAsync("git", [ "-C", repository, "worktree", "add", "--quiet", "--orphan", linkedWorktree, ]); const linkedNested = path.join(linkedWorktree, "src"); await mkdir(linkedNested); const canonicalRepository = await realpath(repository); const canonicalNested = await realpath(nested); const canonicalCredentialSibling = await realpath(credentialSibling); const canonicalDeepCredential = await realpath(deepCredential); const canonicalLinkedWorktree = await realpath(linkedWorktree); const canonicalLinkedNested = await realpath(linkedNested); const canonicalSubmodule = await realpath(submodule); const canonicalSubmoduleNested = await realpath(submoduleNested); const canonicalSubmoduleGitDirectory = await realpath(submoduleGitDirectory); const canonicalRepositoryGitDirectory = await realpath(path.join(repository, ".git")); let runtimeConfig; let wrappedCwd; const manager = { isSupportedPlatform: () => true, initialize: async (config) => { runtimeConfig = config; }, wrapWithSandboxArgv: async (_command, _shell, _a, _b, cwd) => { wrappedCwd = cwd; return fakeMacSandboxDescriptor(); }, reset: async () => {}, }; const execute = (cwd) => runSandboxedCommand({ profile: profile("observe"), allowedDomains: [], allowedEnvironment: [], confirmExternalSideEffects: false, command: ["git", "status", "--short"], }, { cwd, home: os.homedir(), temporaryRoot: fixture, env: { PATH: "/usr/bin:/bin" }, platform: "darwin", loadRuntime: async () => ({ SandboxManager: manager, SandboxRuntimeConfigSchema: { parse: (config) => config }, }), spawn: fakeSpawn(0), }); try { assert.equal(await execute(nested), 0); assert.equal(wrappedCwd, canonicalNested); assert.ok(runtimeConfig.filesystem.allowRead.includes(canonicalRepository)); assert.ok(runtimeConfig.credentials.files.some( (entry) => entry.path === path.join(canonicalNested, ".env") && entry.mode === "deny", )); assert.ok(runtimeConfig.credentials.files.some( (entry) => entry.path === path.join(canonicalRepository, "**", ".env") && entry.mode === "deny", )); assert.ok(runtimeConfig.filesystem.denyWrite.includes(path.join(canonicalNested, ".npmrc"))); assert.ok(runtimeConfig.filesystem.denyWrite.includes(path.join(canonicalCredentialSibling, ".npmrc"))); assert.ok(runtimeConfig.filesystem.denyWrite.includes(path.join(canonicalCredentialSibling, ".ssh"))); assert.ok(runtimeConfig.filesystem.denyWrite.includes(canonicalDeepCredential)); assert.ok(runtimeConfig.filesystem.denyWrite.includes(path.join(canonicalSubmodule, ".git"))); assert.ok(runtimeConfig.filesystem.denyWrite.includes( path.join(canonicalSubmoduleGitDirectory, "config"), )); assert.equal(await execute(linkedNested), 0); assert.equal(wrappedCwd, canonicalLinkedNested); assert.ok(runtimeConfig.filesystem.allowRead.includes(canonicalLinkedWorktree)); assert.ok(runtimeConfig.filesystem.allowRead.includes(canonicalRepositoryGitDirectory)); assert.ok(runtimeConfig.filesystem.denyWrite.includes( path.join(canonicalRepositoryGitDirectory, "config"), )); assert.equal(await execute(submoduleNested), 0); assert.equal(wrappedCwd, canonicalSubmoduleNested); assert.ok(runtimeConfig.filesystem.allowRead.includes(canonicalSubmodule)); assert.ok(runtimeConfig.filesystem.allowRead.includes(canonicalSubmoduleGitDirectory)); assert.equal(runtimeConfig.filesystem.allowRead.includes(canonicalRepository), false); assert.ok(runtimeConfig.filesystem.denyWrite.includes(path.join(canonicalSubmodule, ".git"))); await writeFile( path.join(submodule, ".git"), `gitdir: ${siblingSubmoduleGitDirectory}\n`, "utf8", ); await writeFile(path.join(repository, ".gitmodules"), [ '[submodule "sibling-submodule"]', "\tpath = submodule", "", ].join("\n"), "utf8"); await assert.rejects(execute(submoduleNested), /Untrusted submodule Git metadata/); } finally { await rm(fixture, { recursive: true, force: true }); } }); test("runner rejects concurrent in-process execution instead of sharing global sandbox state", async () => { let releaseSpawn; const spawnStarted = new Promise((resolve) => { releaseSpawn = resolve; }); let finishChild; const childFinished = new Promise((resolve) => { finishChild = resolve; }); const manager = { isSupportedPlatform: () => true, initialize: async () => {}, wrapWithSandboxArgv: async () => ({ argv: ["/fake/sandbox"], env: {} }), reset: async () => {}, }; const context = { cwd: REPO, home: os.homedir(), env: { PATH: "/usr/bin:/bin" }, helperPaths: { bwrap: "/usr/bin/bwrap", rg: "/usr/bin/rg", socat: "/usr/bin/socat" }, platform: "linux", loadRuntime: async () => ({ SandboxManager: manager, SandboxRuntimeConfigSchema: { parse: (config) => config }, }), spawn: () => { const child = new EventEmitter(); releaseSpawn(); childFinished.then(() => child.emit("close", 0, null)); return child; }, }; const options = { profile: profile("observe"), allowedDomains: [], allowedEnvironment: [], confirmExternalSideEffects: false, command: ["true"], }; const first = runSandboxedCommand(options, context); await spawnStarted; await assert.rejects(runSandboxedCommand(options, context), /already active/); finishChild(); assert.equal(await first, 0); assert.equal(await runSandboxedCommand(options, { ...context, spawn: fakeSpawn(0), }), 0); }); test("runner forwards termination to the isolated child group and restores signal handlers", async () => { const signalSource = new EventEmitter(); let existingSignalHandlerRuns = 0; const existingSignalHandler = () => { existingSignalHandlerRuns += 1; }; signalSource.on("SIGTERM", existingSignalHandler); const child = new EventEmitter(); child.pid = 4321; let spawnOptions; let notifySpawn; const spawned = new Promise((resolve) => { notifySpawn = resolve; }); const kills = []; let backendSignalCleanupRan = false; function cleanupHandler() { backendSignalCleanupRan = true; } const manager = { isSupportedPlatform: () => true, initialize: async () => { signalSource.once("SIGINT", cleanupHandler); signalSource.once("SIGTERM", cleanupHandler); signalSource.once("exit", cleanupHandler); }, wrapWithSandboxArgv: async () => ({ argv: ["/fake/sandbox"], env: {} }), reset: async () => {}, }; const execution = runSandboxedCommand({ profile: profile("observe"), allowedDomains: [], allowedEnvironment: [], confirmExternalSideEffects: false, command: ["true"], }, { cwd: REPO, home: os.homedir(), env: { PATH: "/usr/bin:/bin" }, helperPaths: { bwrap: "/usr/bin/bwrap", rg: "/usr/bin/rg", socat: "/usr/bin/socat" }, platform: "linux", loadRuntime: async () => ({ SandboxManager: manager, SandboxRuntimeConfigSchema: { parse: (config) => config }, }), spawn: (_file, _args, options) => { spawnOptions = options; notifySpawn(); return child; }, signalSource, runtimeSignalSource: signalSource, killProcess: (pid, signal) => { kills.push([pid, signal]); queueMicrotask(() => child.emit("close", 0, null)); }, }); await spawned; signalSource.emit("SIGTERM"); assert.equal(await execution, 143); assert.equal(spawnOptions.detached, true); assert.deepEqual(kills, [[-4321, "SIGTERM"]]); assert.equal(backendSignalCleanupRan, false); assert.equal(existingSignalHandlerRuns, 1); assert.equal(signalSource.listenerCount("exit"), 0); assert.equal(signalSource.listenerCount("SIGINT"), 0); assert.deepEqual(signalSource.listeners("SIGTERM"), [existingSignalHandler]); signalSource.removeListener("SIGTERM", existingSignalHandler); }); test("runner treats SIGHUP as fail-closed child-group termination", async () => { const signalSource = new EventEmitter(); const child = new EventEmitter(); child.pid = 9876; let notifySpawn; const spawned = new Promise((resolve) => { notifySpawn = resolve; }); const kills = []; const manager = { isSupportedPlatform: () => true, initialize: async () => {}, wrapWithSandboxArgv: async () => ({ argv: ["/fake/sandbox"], env: {} }), reset: async () => {}, }; const execution = runSandboxedCommand({ profile: profile("observe"), allowedDomains: [], allowedEnvironment: [], confirmExternalSideEffects: false, command: ["true"], }, { cwd: REPO, home: os.homedir(), env: { PATH: "/usr/bin:/bin" }, helperPaths: { bwrap: "/usr/bin/bwrap", rg: "/usr/bin/rg", socat: "/usr/bin/socat" }, platform: "linux", loadRuntime: async () => ({ SandboxManager: manager, SandboxRuntimeConfigSchema: { parse: (config) => config }, }), spawn: () => { notifySpawn(); return child; }, signalSource, runtimeSignalSource: signalSource, killProcess: (pid, signal) => { kills.push([pid, signal]); queueMicrotask(() => child.emit("close", 0, null)); }, }); await spawned; signalSource.emit("SIGHUP"); assert.equal(await execution, 129); assert.deepEqual(kills, [[-9876, "SIGHUP"]]); assert.equal(signalSource.listenerCount("SIGHUP"), 0); }); test("initialization failures never spawn and still reset the backend", async () => { let spawned = false; let resetCount = 0; const manager = { isSupportedPlatform: () => true, initialize: async () => { throw new Error("backend init failed"); }, reset: async () => { resetCount += 1; }, }; await assert.rejects( runSandboxedCommand({ profile: profile("observe"), allowedDomains: [], allowedEnvironment: [], confirmExternalSideEffects: false, command: ["true"], }, { cwd: REPO, home: os.homedir(), env: { PATH: "/usr/bin:/bin" }, helperPaths: { bwrap: "/usr/bin/bwrap", rg: "/usr/bin/rg", socat: "/usr/bin/socat" }, platform: "linux", loadRuntime: async () => ({ SandboxManager: manager, SandboxRuntimeConfigSchema: { parse: (config) => config }, }), spawn: () => { spawned = true; }, }), /backend init failed/, ); assert.equal(spawned, false); assert.equal(resetCount, 1); }); test("the runtime dependency is exactly pinned in package metadata and lock data", async () => { const packageJson = JSON.parse(await readFile(path.join(REPO, "package.json"), "utf8")); const lock = JSON.parse(await readFile(path.join(REPO, "package-lock.json"), "utf8")); assert.equal(packageJson.dependencies["@anthropic-ai/sandbox-runtime"], "0.0.73"); assert.equal(packageJson.engines.node, ">=20.11.0"); assert.equal(lock.packages[""].dependencies["@anthropic-ai/sandbox-runtime"], "0.0.73"); assert.equal( lock.packages["node_modules/@anthropic-ai/sandbox-runtime"].integrity, "sha512-F608iUirrCqwvInZYGRRgJWDQj0tt6fNVE9aPagpotLJ5LhC4JbrMFIIZww5MFjb+HRCkpE0+xdI79c30tdVYg==", ); });