Files
opencode-power-pack/tests/sandbox-runtime.test.mjs
Wayner Barrios 4a1cdf22a4 Keep sandbox runtime resources private while preserving portable Git inspection
Create upstream proxy sockets, generated certificates, and temporary files inside each command's disposable root, and disable mutable host system Git configuration without broadening filesystem access.
2026-08-17 01:05:31 -05:00

1102 lines
40 KiB
JavaScript

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 {
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==",
);
});