Compare commits

..
3 Commits
6 changed files with 101 additions and 22 deletions

No files matched your search

@@ -468,10 +468,10 @@ test("W3 host watch: the default stat key reads the plugin root's plugins, and a
const dataRoot = scratch(t);
// The plugin root sits beside TMPDIR, not in it: TMPDIR is an env value the backstop already
// knows, so a root under it would be caught without the plugin root as a needle of its own.
// When TMPDIR's parent can't take it, the test skips: a root under TMPDIR would pass with the
// plugin root left out of the backstop.
// With TMPDIR unset, its value cannot mask the check, so a separate scratch directory works.
// Otherwise skip if the parent cannot take a sibling: a child would give a false pass.
let pluginRoot;
try { pluginRoot = mkdtempSync(join(dirname(tmpdir()), "mosaic-hw-plugins-")); }
try { pluginRoot = process.env.TMPDIR ? mkdtempSync(join(dirname(tmpdir()), "mosaic-hw-plugins-")) : scratch(t); }
catch { t.skip("the plugin root must sit beside TMPDIR, and TMPDIR's parent is not writable"); return; }
t.after(() => rmSync(pluginRoot, { recursive: true, force: true }));
const clock = fakeClock();
@@ -487,6 +487,7 @@ test("W3 host watch: the default stat key reads the plugin root's plugins, and a
// A plugin lock that can't be read changes the plugin root's key (the loader refuses it): a full pass.
writeFileSync(pluginPaths(pluginRoot).lock, "{", { mode: 0o600 });
line = `${pluginRoot}/plugins/pi`;
assert.equal(leakChecker({ env: {}, scratch: null, dataRoot })({ line }), false, "without the plugin root the backstop does not catch this path");
clock.fire(); await handle.settled();
assert.equal(stub.calls.length, 2, "the key read the plugin root, so its change ran a full pass");
assert.match(logs.join("\n"), /a state line held a host path or an env value/, "and the record that names the plugin root was not written");
+9 -2
View File
@@ -72,8 +72,15 @@ trust and `--no-approve` would then hide a seal flag the binary ignores.
Then one sealed rpc run per loader flag leaves out only that flag: its
kind must show, and no other kind (an MCP server may show beside an
extension when `--help` lists no `--no-mcp`, since pi then ties MCP to
`--no-extensions`). So each loader flag is shown to keep its own kind
out, and no other seal flag, nor their order, can stand in for it. Five
`--no-extensions`). If `--no-extensions` also disables the MCP loader,
the check leaves out both it and `--no-mcp` in one additional rpc run.
That run must show MCP and no kind beyond MCP and extensions. Together
with the run leaving out only `--no-extensions` (extensions load, MCP
does not), this proves `--no-mcp` with its loader enabled. The planted
MCP servers have distinct names so a trusted project entry cannot hide
the user entry. No version comparison selects these checks.
So each loader flag is shown to keep its own kind out, and no other
seal flag, nor their order, can stand in for it. Five
sealed `-p` runs have a bus session's shape: the arguments the adapter
passes for a session, in its order, from `sessionShape` in
`src/pi-fit.mjs`, with two `-e` and `--session-dir`. The adapter's four
+22 -5
View File
@@ -28,7 +28,9 @@
// kind it keeps out must show, and no other kind (pi without --no-mcp ties MCP to
// --no-extensions, so an MCP server may show beside an extension). So each loader flag
// is shown to keep its own kind out, and no other seal flag, nor the order they come
// in, can stand in for it.
// in, can stand in for it. If --no-extensions also disables the MCP loader, a run
// without both it and --no-mcp must show MCP and extensions only. Paired with the
// --no-extensions one-out run, this proves --no-mcp with its loader enabled.
// session five -p runs in a bus session's shape, with the arguments adapters/pi/adapter.sh
// passes for a session, in its order (sessionShape below): two -e, --session-dir in
// place of --no-session, a fixed --provider and --model, -p and a message. The
@@ -570,13 +572,26 @@ async function judge(found, { levels, who, digest, run }) {
// Each loader flag on its own: with every other seal flag on, its kind must show.
for (const [flag, kind, pending] of oneOut) {
const r = await pending;
const but = `with every seal flag but ${flag}`;
let r = await pending;
let but = `with every seal flag but ${flag}`;
if (r.stopped) return unsure(`the start ${but} ${r.stopped}`);
if (!r.answer.state || !r.answer.commands) return unsure(`it didn't answer get_state and get_commands ${but}`);
if (r.prompt === null) return unsure(`its -e extension didn't see the system prompt ${but}`);
// pi-152: MCP can itself be a built-in extension. Removing --no-mcp alone then leaves its
// loader disabled. The earlier --no-extensions one-out run proved that extensions load but
// MCP stays off with --no-mcp. Remove that flag too: MCP must now run, and no unrelated kind
// may load. This pair proves the flag, without demanding that the two seals be independent.
let pairedMcp = false;
if (flag === "--no-mcp" && r.seen.length === 0) {
pairedMcp = true;
but = "with every seal flag but --no-extensions and --no-mcp";
r = await rpcRun(without("--no-extensions", "--no-mcp"));
if (r.stopped) return unsure(`the start ${but} ${r.stopped}`);
if (!r.answer.state || !r.answer.commands) return unsure(`it didn't answer get_state and get_commands ${but}`);
if (r.prompt === null) return unsure(`its -e extension didn't see the system prompt ${but}`);
}
if (!r.seen.some((s) => s.kind === kind)) return unsure(`it didn't load a planted ${kind} ${but}`);
const others = r.seen.filter((s) => s.kind !== kind && !(flag === "--no-extensions" && !noMcp && s.kind === "MCP server"));
const others = r.seen.filter((s) => s.kind !== kind && !(pairedMcp && s.kind === "extension") && !(flag === "--no-extensions" && !noMcp && s.kind === "MCP server"));
if (others.length) return refuse(`loaded a planted ${others.map((s) => s.source).join(", ")} ${but}`);
}
@@ -896,7 +911,9 @@ function plant(scratch) {
const marks = join(scratch, "marks");
const put = (path, text) => { mkdirSync(dirname(path), { recursive: true }); writeFileSync(path, text); };
const ext = (source) => `import { writeFileSync } from "node:fs";\nexport default function (): void { writeFileSync(${JSON.stringify(join(marks, markerName(source)))}, ""); }\n`;
const mcp = (source) => JSON.stringify({ mcpServers: { fit: { command: "/bin/sh", args: ["-c", `: > ${join(marks, markerName(source))}`] } } });
// A trusted project's server replaces a user server with the same name (pi 1.5.2). The
// control must see a user source independently of project trust, so use a name per source.
const mcp = (source) => JSON.stringify({ mcpServers: { [markerName(source)]: { command: "/bin/sh", args: ["-c", `: > ${join(marks, markerName(source))}`] } } });
const skill = (name) => `---\nname: ${name}\ndescription: a planted skill\n---\nA planted skill.\n`;
const prompt = "A planted prompt template.\n";
const agent = join(scratch, "home", ".pi", "agent");
+50 -4
View File
@@ -124,6 +124,52 @@ test("pi-unpin S3: a stand-in that touches the planted MCP marker under the seal
for (const [kind, line] of Object.entries(lines)) assert.equal((await fit(standIn(t, { sealLeak: [kind] }).env)).message, `pi 2.0.0 (MOSAIC_PI_BIN) ${line}`, kind);
});
// pi-152: a trusted project MCP entry replaces a user entry of the same name. The positive
// control needs a user source, so the fixture must keep the two servers distinct.
test("pi-152: project MCP name precedence does not hide the user positive control", SKIP, async t => {
const s = standIn(t, { extraFlags: ["--no-mcp"], mcpProjectOverride: true });
const r = await fit(s.env);
assert.equal(r.ok, true, r.message);
assert.equal(r.noMcp, true);
});
test("pi-152: MCP name precedence still refuses a user server loaded under the seal flags", SKIP, async t => {
const s = standIn(t, { extraFlags: ["--no-mcp"], mcpProjectOverride: true, sealLeak: ["mcp"] });
const r = await fit(s.env);
assert.equal(r.ok, false);
assert.equal(r.undecided, false);
assert.equal(r.message, "pi 2.0.0 (MOSAIC_PI_BIN) loaded a planted user mcp.json with the seal flags on");
noPath(r.message, s.paths);
});
test("pi-152: --no-mcp is proved even when --no-extensions also disables the MCP loader", SKIP, async t => {
const s = standIn(t, { extraFlags: ["--no-mcp"], mcpProjectOverride: true, mcpAlso: "--no-extensions" });
const r = await fit(s.env);
assert.equal(r.ok, true, r.message);
assert.equal(r.noMcp, true);
});
test("pi-152: --no-extensions cannot mask an ignored --no-mcp", SKIP, async t => {
const s = standIn(t, { extraFlags: ["--no-mcp"], mcpProjectOverride: true, standIn: ["--no-mcp", "--no-extensions"] });
const r = await fit(s.env);
assert.equal(r.ok, false);
assert.equal(r.undecided, false);
assert.equal(r.message, "pi 2.0.0 (MOSAIC_PI_BIN) loaded a planted user mcp.json with every seal flag but --no-extensions");
noPath(r.message, s.paths);
});
test("pi-152: the paired MCP control still refuses unrelated ambient sources", SKIP, async t => {
const s = standIn(t, {
extraFlags: ["--no-mcp"], mcpProjectOverride: true, mcpAlso: "--no-extensions",
leakWith: ["--no-context-files"], leakWithoutAll: ["--no-extensions", "--no-mcp"],
});
const r = await fit(s.env);
assert.equal(r.ok, false);
assert.equal(r.undecided, false);
assert.match(r.message, /loaded a planted .*user skill.*user AGENTS.md.* with every seal flag but --no-extensions and --no-mcp$/);
noPath(r.message, s.paths);
});
// pi-skills: the worker's shape. pi 0.85.1 adds a --skill directory to discovery, so the adapter
// keeps --no-skills in front of each --skill; the fit check's last -p run passes the adapter's -p
// argv with MOSAIC_SKILLS (workerShape) and two --skill directories.
@@ -423,11 +469,11 @@ test("pi-unpin S3 re-check 7: a pi that loads every kind when TERM, TZ or LC_ALL
}
});
// Re-check 5 item 2: the --no-mcp run is the only one that shows --no-mcp alone keeps MCP out.
// This pi keeps MCP out with --no-mcp or with --no-context-files, so every other run hides that
// --no-mcp does nothing on its own.
// Re-check 5 item 2: another seal must not hide whether --no-mcp works. This pi keeps MCP out
// with --no-mcp or --no-context-files. Even the paired control that enables extensions cannot
// show MCP, so the check still cannot tell.
test("pi-unpin S3 re-check 5: a pi whose --no-mcp works only beside another seal flag is can't tell at the --no-mcp run", SKIP, async t => {
assert.equal((await fit(standIn(t, { extraFlags: ["--no-mcp"], mcpAlso: "--no-context-files" }).env)).message, "pi 2.0.0 (MOSAIC_PI_BIN) can't be checked: it didn't load a planted MCP server with every seal flag but --no-mcp");
assert.equal((await fit(standIn(t, { extraFlags: ["--no-mcp"], mcpAlso: "--no-context-files" }).env)).message, "pi 2.0.0 (MOSAIC_PI_BIN) can't be checked: it didn't load a planted MCP server with every seal flag but --no-extensions and --no-mcp");
assert.equal((await fit(standIn(t, { extraFlags: ["--no-mcp"] }).env)).ok, true);
});
+12 -6
View File
@@ -37,8 +37,11 @@
// none. `needs`: a flag the loader flags work only with; without it they do
// nothing. `leakWithout`: flags; when any of them is absent, every kind loads.
// `leakWith`: flags; when all of them are given, every kind loads (with
// `leakWithout` too, both must hold). `mcpAlso`: a flag that keeps MCP servers out
// as well as their own flag does. `leakNoAgentDir`: every kind loads when
// `leakWithout` too, both must hold). `leakWithoutAll`: every listed flag must be
// absent, combined with the other leak conditions. `mcpAlso`: a flag that keeps MCP servers out
// as well as their own flag does. `mcpProjectOverride`: like pi 1.5.2, merge the
// user and trusted project's .pi/mcp.json by name, with project entries winning;
// ignore .mcp.json. `leakNoAgentDir`: every kind loads when
// PI_CODING_AGENT_DIR is unset, as in a bus session. `leakNoVar`: names; every
// kind loads when any of them is unset (TERM, TZ, LC_ALL in a unit-started bus).
// `leakNoMatch`: with -c, every
@@ -233,7 +236,7 @@ if (modelRun) {
if (fs.existsSync(marker)) ignoreAll = true;
else { fs.writeFileSync(marker, ""); leak = new Set(ALL); }
}
if ((K.leakWith || K.leakWithout) && (K.leakWith || []).every(has) && (!K.leakWithout || K.leakWithout.some((f) => !has(f)))) leak = new Set(ALL);
if ((K.leakWith || K.leakWithout || K.leakWithoutAll) && (K.leakWith || []).every(has) && (!K.leakWithout || K.leakWithout.some((f) => !has(f))) && (!K.leakWithoutAll || K.leakWithoutAll.every((f) => !has(f)))) leak = new Set(ALL);
if (K.leakNoAgentDir && !process.env.PI_CODING_AGENT_DIR) leak = new Set(ALL);
if (K.leakNoVar && K.leakNoVar.some((n) => process.env[n] === undefined)) leak = new Set(ALL);
if (K.leakNoMatch && has("-c") && !storedFor(val("--session-dir"))) leak = new Set(ALL);
@@ -280,9 +283,12 @@ if (modelRun) {
}
const mcpFlag = (K.extraFlags || []).includes("--no-mcp") ? "--no-mcp" : "--no-extensions";
if (!ignoreAll && (!(sealed(mcpFlag) || (K.mcpAlso && has(K.mcpAlso))) || leak.has("mcp"))) {
for (const f of [path.join(agent, "mcp.json"), path.join(cwd, ".pi", "mcp.json"), path.join(cwd, ".mcp.json")]) {
for (const s of Object.values(json(f)?.mcpServers || {})) cp.spawnSync(s.command, s.args || [], { stdio: "ignore" });
}
const configs = K.mcpProjectOverride
? [path.join(agent, "mcp.json"), ...(trusted ? [path.join(cwd, ".pi", "mcp.json")] : [])]
: [path.join(agent, "mcp.json"), path.join(cwd, ".pi", "mcp.json"), path.join(cwd, ".mcp.json")];
const entries = configs.map((f) => json(f)?.mcpServers || {});
const servers = K.mcpProjectOverride ? Object.values(Object.assign({}, ...entries)) : entries.flatMap(Object.values);
for (const s of servers) cp.spawnSync(s.command, s.args || [], { stdio: "ignore" });
}
if (on("skills", "--no-skills") || (K.skillLeak && has("--skill") && !ignoreAll)) {
const home = process.env.HOME || "/";
@@ -255,15 +255,17 @@ test("W1 redaction covers real paths, trailing slashes, the user name, rule ids,
test("W1 no record holds a path under the scratch directory, the home directory or an env value", async (t) => {
const { pass, dir } = await watchTree(t, { h: {} });
const secret = "/srv/fixture-secret-place";
// A multi-segment loose path stays a path even when tmpdir() is just /tmp.
const looseTempPath = join(tmpdir(), "mosaic-redaction-probe");
const env = { WATCH_SECRET: secret, HOME: join(dir, "home"), MOSAIC_FIXTURE_BIN: "/opt/fixture/bin/tool", PATH: "/opt/fixture-tools/bin:/usr/bin:/bin" };
const answer = ok(DIGEST_A, {
source: dir, version: `9.9 at ${dir}/bin`,
line: `found at ${env.MOSAIC_FIXTURE_BIN} in ${secret}, home ${env.HOME}, ${realpathSync(dir)}`,
surfaces: { help: `usage: ${dir}/tool\nsee /opt/fixture-tools/bin/tool and ${tmpdir()}`, "Bad Name": dir },
surfaces: { help: `usage: ${dir}/tool\nsee /opt/fixture-tools/bin/tool and ${looseTempPath}`, "Bad Name": dir },
});
const out = await pass({ h: answer }, { env });
const text = JSON.stringify(out);
for (const p of [dir, realpathSync(dir), secret, env.MOSAIC_FIXTURE_BIN, "/opt/fixture-tools/bin", env.HOME, tmpdir()]) assert.ok(!text.includes(p), p);
for (const p of [dir, realpathSync(dir), secret, env.MOSAIC_FIXTURE_BIN, "/opt/fixture-tools/bin", env.HOME, looseTempPath]) assert.ok(!text.includes(p), p);
const rec = byName(out).h;
assert.equal(rec.source, null, "a source that is a path is dropped");
assert.deepEqual(Object.keys(rec.surfaces), ["help"]);