fix(pi): pi-unpin S3 review: the control must show each planted kind and answer get_commands, the -e extension reads the system prompt so context and trusted project files are checked, settings and package sources are planted, help flags come from the option column, missing -e and the seal run in -p too, and the digest covers npm's lock files (#1873)
This commit is contained in:
1 parent
7c1b87d154
commit
df26085303
6 files changed
+310
-102
No files matched your search
@@ -30,16 +30,27 @@ Pi is not pinned (#1873 pi-unpin). Before a session starts, `preflight`
|
||||
and `env` run the fit check in `src/pi-fit.mjs` on the binary the module
|
||||
found. It runs that binary in a sandbox with the network unshared, an
|
||||
empty environment and a scratch home, and calls no model. It needs
|
||||
`--help` to list every flag the adapter passes (with rpc mode and each
|
||||
thinking level), a missing `-e` file to stop the start, and the planted
|
||||
ambient sources (extensions, settings lists, `mcp.json` files, skills,
|
||||
prompt templates, context files) to stay unloaded with the seal flags on.
|
||||
A control run without the seal flags must load at least one of them, or
|
||||
the check can't tell and refuses. Any failure refuses the launch with
|
||||
`--help` to list, in its option column, every flag the adapter passes
|
||||
(with rpc mode and each thinking level), and a missing `-e` file to stop
|
||||
the start in rpc and in `-p`. The planted ambient sources must stay
|
||||
unloaded with the seal flags on, in rpc and in `-p`: extensions, MCP
|
||||
servers, skills and prompt templates (found in their directories, listed
|
||||
in a `settings.json`, or in a local package a `settings.json` lists),
|
||||
context files (`AGENTS.md`, `CLAUDE.md`, `SYSTEM.md`) and a trusted
|
||||
project's `.pi/SYSTEM.md` and `.pi/APPEND_SYSTEM.md`. The project has a
|
||||
saved trust, so only `--no-approve` keeps those two out. An `-e`
|
||||
extension writes the system prompt it sees at `session_start`; the
|
||||
sealed runs must show the `--system-prompt` file and none of the planted
|
||||
files. A control run without the seal flags must show each kind of
|
||||
source (an MCP server only when `--help` lists `--no-mcp`) and answer
|
||||
`get_state` and `get_commands`, or the check can't tell and refuses. Pi
|
||||
0.85.1 appends the agent directory's `APPEND_SYSTEM.md` whatever the
|
||||
flags, so the check doesn't plant one. Any failure refuses the launch with
|
||||
`harness-feature-missing` and one line that names the binary by its label,
|
||||
for example `pi 2.0.0 (MOSAIC_PI_BIN) lacks --no-context-files`. When
|
||||
`--help` lists `--no-mcp`, the adapter passes it too. A pass is cached in
|
||||
memory by a digest of the package's files. Lines 1, 2, 4 and 5 are not
|
||||
memory by a digest of the package's files (and npm's lock files, for
|
||||
the repository's copy). Lines 1, 2, 4 and 5 are not
|
||||
checked at start; a pi other than the repository's copy relies on them
|
||||
unproved until a scripted-model fit run exists (design section 5, S6).
|
||||
|
||||
|
||||
+160
-65
@@ -1,23 +1,35 @@
|
||||
// #1873 pi-unpin S3: the start-time fit check for a pi binary the harness module found. Nothing
|
||||
// here compares a version. The check runs the binary only inside a sandbox with the network
|
||||
// unshared, an empty environment, a scratch HOME and agent directory, and the found package
|
||||
// mounted as a session mounts it. No model is called. It asks:
|
||||
// mounted as a session mounts it. No model is called and no provider key is passed. It asks:
|
||||
//
|
||||
// --version a label for the refusal line and the record; not a gate
|
||||
// --help lists every flag Mosaic passes, with rpc mode and each thinking level
|
||||
// -e /missing a missing extension stops the start (exit non-zero) before any answer
|
||||
// control with planted ambient sources and no seal flags, the binary answers get_state and
|
||||
// loads at least one planted source, so the sealed run can tell
|
||||
// sealed with the adapter's seal flags (and --no-mcp when --help lists it) and one -e
|
||||
// extension, the binary answers get_state, loads that extension (a session's gate
|
||||
// comes in that way) and loads none of the planted sources
|
||||
// --help lists, in its option column, every flag Mosaic passes, with rpc mode and each
|
||||
// thinking level
|
||||
// control rpc, planted ambient sources, a saved trust for the project, no seal flags and
|
||||
// one -e extension that writes the system prompt it sees at session_start. The
|
||||
// binary answers get_state and get_commands, and shows each kind of planted source:
|
||||
// an extension, a skill, a prompt template, a context file, a trusted project file
|
||||
// (the trust --no-approve must undo), and an MCP server when --help lists --no-mcp.
|
||||
// A kind it doesn't show could not be told apart from a sealed one.
|
||||
// sealed rpc the adapter's seal flags (and --no-mcp when --help lists it), the -e extension and
|
||||
// --system-prompt. The binary answers both, loads that extension (a session's gate
|
||||
// comes in that way), uses the --system-prompt file, and shows no planted source.
|
||||
// sealed -p the same in -p, the mode the adapter runs. Its -e extension must reach
|
||||
// session_start, and no planted source may show.
|
||||
// missing -e a missing -e file, in rpc and in -p, stops the start: exit non-zero, no answer,
|
||||
// and no session_start for the -e extension given after it
|
||||
//
|
||||
// A check that cannot tell refuses: a sandbox that fails, a run that times out, an answer that
|
||||
// doesn't parse. A pass is cached in memory by a digest of the files that run (the package's
|
||||
// package.json, every file under dist/bundle/, and every file in the directory tree that holds
|
||||
// the binary's real file) and the mount layout.
|
||||
// A check that cannot tell refuses: a sandbox that fails, a run that times out, an answer that is
|
||||
// missing or doesn't parse, a kind of source the control doesn't show. A pass is cached in memory
|
||||
// by a digest of the files that run (the package's package.json, every file under dist/bundle/,
|
||||
// every file in the directory tree that holds the binary's real file, and, for a copy mounted
|
||||
// with the node_modules it sits in, npm's lock files there) and the mount layout.
|
||||
// A refusal line names the found binary by its label (MOSAIC_PI_BIN, the pi on PATH, the
|
||||
// repository's pi), never a host path.
|
||||
//
|
||||
// Known limit: pi 0.85.1 appends the agent directory's APPEND_SYSTEM.md whatever the flags. The
|
||||
// check doesn't plant one; a session's agent directory is the run's own.
|
||||
import { spawnSync } from "node:child_process";
|
||||
import { createHash } from "node:crypto";
|
||||
import { lstatSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
|
||||
@@ -62,40 +74,66 @@ export function piFit(found, { levels = [], bwrap = BWRAP, node = process.execPa
|
||||
|
||||
function check(found, { levels, bwrap, node, scratch, who, digest }) {
|
||||
const run = (args, input = "") => runIn(found, { bwrap, node, scratch, args, input });
|
||||
const refuse = (why) => ({ ok: false, message: `${who(version)} ${why}` });
|
||||
plant(scratch);
|
||||
const v = run(["--version"]);
|
||||
const version = v.status === 0 ? versionLabel(v.stdout) : null;
|
||||
const help = run(["--help"]);
|
||||
if (help.status !== 0) return { ok: false, message: `${who(version)} can't be checked: --help failed` };
|
||||
if (help.status !== 0) return refuse("can't be checked: --help failed");
|
||||
const lines = help.stdout.split("\n");
|
||||
const has = (flag) => lines.some((l) => flagIn(l, flag));
|
||||
const line = (flag) => lines.find((l) => flagIn(l, flag)) ?? "";
|
||||
const has = (flag) => lines.some((l) => optionsIn(l).includes(flag));
|
||||
const line = (flag) => lines.find((l) => optionsIn(l).includes(flag)) ?? "";
|
||||
const missing = FIT_FLAGS.filter((f) => !has(f));
|
||||
if (has("--mode") && !word(line("--mode"), "rpc")) missing.push("--mode rpc");
|
||||
if (has("--thinking")) for (const l of levels) if (!word(line("--thinking"), l)) missing.push(`--thinking ${l}`);
|
||||
if (missing.length) return { ok: false, message: `${who(version)} lacks ${missing.join(", ")}` };
|
||||
if (missing.length) return refuse(`lacks ${missing.join(", ")}`);
|
||||
const noMcp = has("--no-mcp");
|
||||
const approve = has("--approve");
|
||||
|
||||
const ask = '{"id":"fit-state","type":"get_state"}\n{"id":"fit-commands","type":"get_commands"}\n';
|
||||
plant(scratch);
|
||||
const missingExt = run(["-e", join(scratch, "missing", "extension.ts"), "--mode", "rpc", ...SEAL], ask);
|
||||
if (missingExt.timedOut) return { ok: false, message: `${who(version)} can't be checked: a start with a missing -e extension timed out` };
|
||||
if (missingExt.status === 0 || answered(missingExt.stdout).state) return { ok: false, message: `${who(version)} starts with a missing -e extension` };
|
||||
const explicit = ["-e", join(scratch, "explicit", "fit.ts")];
|
||||
const sealed = [...SEAL, ...(noMcp ? ["--no-mcp"] : []), ...explicit, "--system-prompt", join(scratch, "prompt.md")];
|
||||
// -p takes a message; offline with no key, pi stops before any model call.
|
||||
const print = ["-p", ...sealed, "fit check"];
|
||||
|
||||
plant(scratch);
|
||||
const control = run(["--mode", "rpc", "--no-session", "--offline", ...(approve ? ["--approve"] : [])], ask);
|
||||
const control = run(["--mode", "rpc", "--no-session", "--offline", ...explicit], ask);
|
||||
if (control.timedOut) return refuse("can't be checked: the start without the seal flags timed out");
|
||||
const controlAnswer = answered(control.stdout);
|
||||
if (!controlAnswer.state) return { ok: false, message: `${who(version)} can't be checked: it didn't answer get_state` };
|
||||
if (seen(scratch, controlAnswer).length === 0) return { ok: false, message: `${who(version)} can't be checked: it loaded none of the planted sources without the seal flags` };
|
||||
if (!controlAnswer.state) return refuse("can't be checked: it didn't answer get_state");
|
||||
if (!controlAnswer.commands) return refuse("can't be checked: it didn't answer get_commands");
|
||||
if (!marked(scratch, EXPLICIT) || prompted(scratch) === null) return refuse("can't be checked: its -e extension didn't see the system prompt without the seal flags");
|
||||
const shown = new Set(seen(scratch, controlAnswer).map((s) => s.kind));
|
||||
const unshown = KINDS.filter((k) => (k !== "MCP server" || noMcp) && !shown.has(k));
|
||||
if (unshown.length) return refuse(`can't be checked: it didn't load a planted ${unshown.join(", ")} without the seal flags`);
|
||||
|
||||
plant(scratch);
|
||||
const sealed = run(["--mode", "rpc", ...SEAL, ...(noMcp ? ["--no-mcp"] : []), "-e", join(scratch, "explicit", "fit.ts"), "--system-prompt", join(scratch, "prompt.md")], ask);
|
||||
const sealedAnswer = answered(sealed.stdout);
|
||||
if (!sealedAnswer.state) return { ok: false, message: `${who(version)} can't be checked: it didn't answer get_state with the seal flags on` };
|
||||
if (!marked(scratch, EXPLICIT)) return { ok: false, message: `${who(version)} didn't load an -e extension with the seal flags on` };
|
||||
const leaked = seen(scratch, sealedAnswer);
|
||||
if (leaked.length) return { ok: false, message: `${who(version)} loaded a planted ${leaked.join(", ")} with the seal flags on` };
|
||||
const rpc = run(["--mode", "rpc", ...sealed], ask);
|
||||
if (rpc.timedOut) return refuse("can't be checked: the start with the seal flags timed out");
|
||||
const rpcAnswer = answered(rpc.stdout);
|
||||
if (!rpcAnswer.state) return refuse("can't be checked: it didn't answer get_state with the seal flags on");
|
||||
if (!rpcAnswer.commands) return refuse("can't be checked: it didn't answer get_commands with the seal flags on");
|
||||
if (!marked(scratch, EXPLICIT)) return refuse("didn't load an -e extension with the seal flags on");
|
||||
const rpcPrompt = prompted(scratch);
|
||||
if (rpcPrompt === null) return refuse("can't be checked: its -e extension didn't see the system prompt with the seal flags on");
|
||||
if (!rpcPrompt.includes(GIVEN)) return refuse("didn't use the --system-prompt file with the seal flags on");
|
||||
let leaked = seen(scratch, rpcAnswer);
|
||||
if (leaked.length) return refuse(`loaded a planted ${leaked.map((s) => s.source).join(", ")} with the seal flags on`);
|
||||
|
||||
plant(scratch);
|
||||
const p = run(print);
|
||||
if (p.timedOut) return refuse("can't be checked: a -p start with the seal flags timed out");
|
||||
if (prompted(scratch) === null) return refuse("can't be checked: a -p start with the seal flags didn't run its -e extension");
|
||||
leaked = seen(scratch, { commands: [] });
|
||||
if (leaked.length) return refuse(`loaded a planted ${leaked.map((s) => s.source).join(", ")} with the seal flags on in -p`);
|
||||
|
||||
// A missing -e file stops the start. pi 0.85.1 loads the -e files in order and still loads the
|
||||
// one after the missing one, then exits 1 before session_start, so only session_start tells.
|
||||
for (const [mode, args, input] of [["rpc", ["--mode", "rpc"], ask], ["-p", ["-p"], ""]]) {
|
||||
plant(scratch);
|
||||
const r = run([...args, ...SEAL, "-e", join(scratch, "missing", "extension.ts"), ...explicit, "--system-prompt", join(scratch, "prompt.md"), ...(mode === "-p" ? ["fit check"] : [])], input);
|
||||
if (r.timedOut) return refuse(`can't be checked: a ${mode} start with a missing -e extension timed out`);
|
||||
if (r.status === 0 || answered(r.stdout).state || prompted(scratch) !== null) return refuse("starts with a missing -e extension");
|
||||
}
|
||||
return { ok: true, version, noMcp, digest };
|
||||
}
|
||||
|
||||
@@ -113,13 +151,14 @@ function runIn(found, { bwrap, node, scratch, args, input }) {
|
||||
return { status: r.status, stdout: typeof r.stdout === "string" ? r.stdout : "", timedOut: r.error?.code === "ETIMEDOUT" || r.signal === "SIGKILL" };
|
||||
}
|
||||
|
||||
// One flag in one help line: the flag as its own token, at the line's start or after a space or
|
||||
// a comma, and followed by the end, a space, a comma, "=" or "<".
|
||||
function flagIn(line, flag) {
|
||||
const at = (i) => i === 0 || line[i - 1] === " " || line[i - 1] === "," || line[i - 1] === "\t";
|
||||
const after = (i) => i === line.length || " ,=<\t".includes(line[i]);
|
||||
for (let i = line.indexOf(flag); i !== -1; i = line.indexOf(flag, i + 1)) if (at(i) && after(i + flag.length)) return true;
|
||||
return false;
|
||||
// The options one help line lists in its option column: a line that starts with "-" (after its
|
||||
// indent), up to the first run of two spaces or a tab, split at commas; the first word of each
|
||||
// part. " --extension, -e <path> Load an extension" lists --extension and -e. A flag named in a
|
||||
// sentence is not listed.
|
||||
function optionsIn(line) {
|
||||
const t = line.trim();
|
||||
if (!t.startsWith("-")) return [];
|
||||
return t.split(/ {2,}|\t/)[0].split(",").map((part) => part.trim().split(/[ =<[]/)[0]).filter((o) => /^--?[A-Za-z0-9]/.test(o));
|
||||
}
|
||||
const word = (line, w) => line.split(/[^A-Za-z0-9-]+/).includes(w);
|
||||
|
||||
@@ -131,83 +170,133 @@ function versionLabel(stdout) {
|
||||
}
|
||||
|
||||
// The rpc answers in the output: whether get_state succeeded, and the command names get_commands
|
||||
// listed (an empty list when it failed).
|
||||
// listed, or null when it didn't answer with a { commands: [...] } list.
|
||||
function answered(stdout) {
|
||||
let state = false;
|
||||
const commands = [];
|
||||
let commands = null;
|
||||
for (const l of String(stdout).split("\n")) {
|
||||
let m;
|
||||
try { m = JSON.parse(l); } catch { continue; }
|
||||
if (!m || m.type !== "response" || m.success !== true) continue;
|
||||
if (m.id === "fit-state" && m.command === "get_state" && m.data && typeof m.data === "object") state = true;
|
||||
if (m.id === "fit-commands" && m.command === "get_commands" && Array.isArray(m.data?.commands)) {
|
||||
for (const c of m.data.commands) if (typeof c?.name === "string") commands.push(c.name);
|
||||
commands = m.data.commands.filter((c) => typeof c?.name === "string").map((c) => c.name);
|
||||
}
|
||||
}
|
||||
return { state, commands };
|
||||
}
|
||||
|
||||
// The planted sources. Each extension and each MCP server touches its own marker; each skill and
|
||||
// prompt template has a name get_commands would list. Context and system prompt files are planted
|
||||
// too, so nothing ambient that a session could meet is missing from the tree.
|
||||
// "default agent ..." sits in $HOME/.pi/agent, where pi looks when PI_CODING_AGENT_DIR is unset.
|
||||
const MARKED = ["user extension", "user settings extension", "default agent extension", "project extension", "project settings extension", "user mcp.json", "default agent mcp.json", "project mcp.json", "project .mcp.json"];
|
||||
const NAMED = { "fit-user-skill": "user skill", "fit-default-skill": "default agent skill", "fit-project-skill": "project skill", "fit-agents-skill": "project .agents skill", "fit-home-skill": "home .agents skill", "fit-user-prompt": "user prompt template", "fit-default-prompt": "default agent prompt template", "fit-project-prompt": "project prompt template" };
|
||||
// The -e extension the sealed run passes, which must load.
|
||||
// The planted sources, each with the kind the control must show. Each extension and each MCP
|
||||
// server touches its own marker; each skill and prompt template has a name get_commands lists;
|
||||
// each context and system prompt file holds a word the -e extension's view of the system prompt
|
||||
// shows. "default agent ..." sits in $HOME/.pi/agent, where pi looks when PI_CODING_AGENT_DIR is
|
||||
// unset. "settings" sources are listed by a settings.json; "package" sources come from a local
|
||||
// package a settings.json lists. "parent" is a directory above the project.
|
||||
const KINDS = ["extension", "MCP server", "skill", "prompt template", "context file", "trusted project file"];
|
||||
const MARKED = {
|
||||
"user extension": "extension", "user settings extension": "extension", "user package extension": "extension", "default agent extension": "extension",
|
||||
"project extension": "extension", "project settings extension": "extension", "project package extension": "extension",
|
||||
"user mcp.json": "MCP server", "default agent mcp.json": "MCP server", "project mcp.json": "MCP server", "project .mcp.json": "MCP server",
|
||||
};
|
||||
const NAMED = {
|
||||
"fit-user-skill": ["user skill", "skill"], "fit-user-set-skill": ["user settings skill", "skill"], "fit-user-pkg-skill": ["user package skill", "skill"],
|
||||
"fit-default-skill": ["default agent skill", "skill"], "fit-project-skill": ["project skill", "skill"], "fit-project-set-skill": ["project settings skill", "skill"],
|
||||
"fit-project-pkg-skill": ["project package skill", "skill"], "fit-agents-skill": ["project .agents skill", "skill"], "fit-home-skill": ["home .agents skill", "skill"],
|
||||
"fit-user-prompt": ["user prompt template", "prompt template"], "fit-user-set-prompt": ["user settings prompt template", "prompt template"],
|
||||
"fit-user-pkg-prompt": ["user package prompt template", "prompt template"], "fit-default-prompt": ["default agent prompt template", "prompt template"],
|
||||
"fit-project-prompt": ["project prompt template", "prompt template"], "fit-project-set-prompt": ["project settings prompt template", "prompt template"],
|
||||
"fit-project-pkg-prompt": ["project package prompt template", "prompt template"],
|
||||
};
|
||||
// Planted file (under the scratch directory), the word it holds, the source, the kind. A project
|
||||
// SYSTEM.md or APPEND_SYSTEM.md loads only in a trusted project: the saved trust makes it trusted,
|
||||
// and only --no-approve undoes that with the seal flags on.
|
||||
const TEXTS = [
|
||||
["agent/SYSTEM.md", "FITUSERSYSTEM", "user SYSTEM.md", "context file"],
|
||||
["agent/AGENTS.md", "FITUSERAGENTS", "user AGENTS.md", "context file"],
|
||||
["home/.pi/agent/AGENTS.md", "FITDEFAULTAGENTS", "default agent AGENTS.md", "context file"],
|
||||
["project/.pi/SYSTEM.md", "FITPROJECTSYSTEM", "project SYSTEM.md", "trusted project file"],
|
||||
["project/.pi/APPEND_SYSTEM.md", "FITPROJECTAPPEND", "project APPEND_SYSTEM.md", "trusted project file"],
|
||||
["project/AGENTS.md", "FITPROJECTAGENTS", "project AGENTS.md", "context file"],
|
||||
["project/CLAUDE.md", "FITPROJECTCLAUDE", "project CLAUDE.md", "context file"],
|
||||
["CLAUDE.md", "FITPARENTCLAUDE", "parent CLAUDE.md", "context file"],
|
||||
];
|
||||
// The --system-prompt file's word, which the sealed runs must show.
|
||||
const GIVEN = "FITGIVENPROMPT";
|
||||
// The -e extension the control and sealed runs pass, which must load.
|
||||
const EXPLICIT = "explicit extension";
|
||||
const markerName = (source) => source.replace(/[^a-z]/g, "-");
|
||||
const marked = (scratch, source) => { try { return readdirSync(join(scratch, "marks")).includes(markerName(source)); } catch { return false; } };
|
||||
// The system prompt the -e extension saw at session_start, or null when it wrote none.
|
||||
const prompted = (scratch) => { try { return readFileSync(join(scratch, "marks", "system-prompt"), "utf8"); } catch { return null; } };
|
||||
|
||||
function plant(scratch) {
|
||||
for (const d of ["home", "agent", "project", "marks", "tmp", "missing", "explicit"]) rmSync(join(scratch, d), { recursive: true, force: true });
|
||||
for (const d of ["home", "agent", "project", "marks", "tmp", "missing", "explicit", "listed"]) rmSync(join(scratch, d), { recursive: true, force: true });
|
||||
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))}`] } } });
|
||||
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, "agent");
|
||||
const project = join(scratch, "project");
|
||||
mkdirSync(marks, { recursive: true });
|
||||
mkdirSync(join(scratch, "tmp"), { recursive: true });
|
||||
mkdirSync(project, { recursive: true });
|
||||
// Each settings.json lists an extension, a skill directory, a prompt template and a local
|
||||
// package holding one of each.
|
||||
const listed = (who) => {
|
||||
const dir = join(scratch, "listed", who);
|
||||
put(join(dir, "fit.ts"), ext(`${who} settings extension`));
|
||||
put(join(dir, `fit-${who}-set-skill`, "SKILL.md"), skill(`fit-${who}-set-skill`));
|
||||
put(join(dir, `fit-${who}-set-prompt.md`), prompt);
|
||||
const pkg = join(dir, "package");
|
||||
put(join(pkg, "package.json"), JSON.stringify({ name: `fit-${who}-package`, version: "1.0.0" }));
|
||||
put(join(pkg, "extensions", "fit.ts"), ext(`${who} package extension`));
|
||||
put(join(pkg, "skills", `fit-${who}-pkg-skill`, "SKILL.md"), skill(`fit-${who}-pkg-skill`));
|
||||
put(join(pkg, "prompts", `fit-${who}-pkg-prompt.md`), prompt);
|
||||
return { extensions: [join(dir, "fit.ts")], skills: [join(dir, `fit-${who}-set-skill`)], prompts: [join(dir, `fit-${who}-set-prompt.md`)], packages: [pkg] };
|
||||
};
|
||||
// A saved trust for the project, so the control loads its trust-gated files without --approve.
|
||||
put(join(agent, "settings.json"), JSON.stringify({ ...listed("user"), defaultProjectTrust: "always" }));
|
||||
put(join(agent, "trust.json"), JSON.stringify({ [realpathSync(project)]: true }));
|
||||
put(join(agent, "extensions", "fit.ts"), ext("user extension"));
|
||||
put(join(agent, "listed", "fit.ts"), ext("user settings extension"));
|
||||
put(join(agent, "settings.json"), JSON.stringify({ extensions: [join(agent, "listed", "fit.ts")] }));
|
||||
put(join(agent, "mcp.json"), mcp("user mcp.json"));
|
||||
put(join(agent, "skills", "fit-user-skill", "SKILL.md"), skill("fit-user-skill"));
|
||||
put(join(agent, "prompts", "fit-user-prompt.md"), "A planted prompt template.\n");
|
||||
for (const f of ["SYSTEM.md", "APPEND_SYSTEM.md", "AGENTS.md"]) put(join(agent, f), "A planted file.\n");
|
||||
put(join(agent, "prompts", "fit-user-prompt.md"), prompt);
|
||||
put(join(project, ".pi", "settings.json"), JSON.stringify(listed("project")));
|
||||
put(join(project, ".pi", "extensions", "fit.ts"), ext("project extension"));
|
||||
put(join(project, ".pi", "listed", "fit.ts"), ext("project settings extension"));
|
||||
put(join(project, ".pi", "settings.json"), JSON.stringify({ extensions: [join(project, ".pi", "listed", "fit.ts")] }));
|
||||
put(join(project, ".pi", "mcp.json"), mcp("project mcp.json"));
|
||||
put(join(project, ".mcp.json"), mcp("project .mcp.json"));
|
||||
put(join(project, ".pi", "skills", "fit-project-skill", "SKILL.md"), skill("fit-project-skill"));
|
||||
put(join(project, ".agents", "skills", "fit-agents-skill", "SKILL.md"), skill("fit-agents-skill"));
|
||||
put(join(project, ".pi", "prompts", "fit-project-prompt.md"), "A planted prompt template.\n");
|
||||
for (const f of [".pi/SYSTEM.md", ".pi/APPEND_SYSTEM.md", "AGENTS.md", "CLAUDE.md"]) put(join(project, f), "A planted file.\n");
|
||||
put(join(project, ".pi", "prompts", "fit-project-prompt.md"), prompt);
|
||||
put(join(scratch, "home", ".agents", "skills", "fit-home-skill", "SKILL.md"), skill("fit-home-skill"));
|
||||
const fallback = join(scratch, "home", ".pi", "agent");
|
||||
put(join(fallback, "extensions", "fit.ts"), ext("default agent extension"));
|
||||
put(join(fallback, "mcp.json"), mcp("default agent mcp.json"));
|
||||
put(join(fallback, "skills", "fit-default-skill", "SKILL.md"), skill("fit-default-skill"));
|
||||
put(join(fallback, "prompts", "fit-default-prompt.md"), "A planted prompt template.\n");
|
||||
put(join(scratch, "explicit", "fit.ts"), ext(EXPLICIT));
|
||||
put(join(scratch, "prompt.md"), "A fit check.\n");
|
||||
put(join(fallback, "prompts", "fit-default-prompt.md"), prompt);
|
||||
for (const [file, text] of TEXTS) put(join(scratch, file), `${text}\n`);
|
||||
put(join(scratch, "explicit", "fit.ts"), `import { writeFileSync } from "node:fs";\nexport default function (pi: any): void {\n writeFileSync(${JSON.stringify(join(marks, markerName(EXPLICIT)))}, "");\n pi.on("session_start", (_event: any, ctx: any) => { writeFileSync(${JSON.stringify(join(marks, "system-prompt"))}, ctx.getSystemPrompt()); });\n}\n`);
|
||||
put(join(scratch, "prompt.md"), `${GIVEN}\n`);
|
||||
}
|
||||
|
||||
// The planted sources a run loaded: markers present, and planted names get_commands listed.
|
||||
// The planted sources a run loaded, as { source, kind }: markers present, planted names
|
||||
// get_commands listed, and planted words in the system prompt the -e extension saw.
|
||||
function seen(scratch, answer) {
|
||||
let marks = [];
|
||||
try { marks = readdirSync(join(scratch, "marks")); } catch { marks = []; }
|
||||
const out = MARKED.filter((s) => marks.includes(markerName(s)));
|
||||
for (const [name, source] of Object.entries(NAMED)) if (answer.commands.some((c) => c === name || c.endsWith(`:${name}`))) out.push(source);
|
||||
const out = Object.entries(MARKED).filter(([s]) => marks.includes(markerName(s))).map(([source, kind]) => ({ source, kind }));
|
||||
for (const [name, [source, kind]] of Object.entries(NAMED)) if ((answer.commands ?? []).some((c) => c === name || c.endsWith(`:${name}`))) out.push({ source, kind });
|
||||
const text = prompted(scratch) ?? "";
|
||||
for (const [, word, source, kind] of TEXTS) if (text.includes(word)) out.push({ source, kind });
|
||||
return out;
|
||||
}
|
||||
|
||||
// sha256 over the sorted (path, sha256) list of the package's package.json, every regular file
|
||||
// under dist/bundle/ (design section 4), and every regular file in the directory tree that holds
|
||||
// the binary's real file, so a bin outside dist/bundle/ can't import a file the digest skips. A
|
||||
// symlink there is read through.
|
||||
// under dist/bundle/ (design section 4), every regular file in the directory tree that holds the
|
||||
// binary's real file, so a bin outside dist/bundle/ can't import a file the digest skips, and npm's
|
||||
// lock files for a copy mounted with its node_modules. A symlink there is read through.
|
||||
function filesDigest(found) {
|
||||
const pkg = found.pkg;
|
||||
const bin = realpathSync(found.bin);
|
||||
@@ -225,6 +314,12 @@ function filesDigest(found) {
|
||||
walk(join(pkg, "dist", "bundle"));
|
||||
const binDir = dirname(bin);
|
||||
if (binDir !== pkg && binDir.startsWith(`${pkg}/`)) walk(binDir);
|
||||
// A copy mounted with the node_modules it sits in imports packages beside it: npm's lock files
|
||||
// there stand for them.
|
||||
if (found.root !== pkg) for (const f of [join(found.root, ".package-lock.json"), join(dirname(found.root), "package-lock.json")]) {
|
||||
try { lstatSync(f); } catch (e) { if (e.code === "ENOENT") continue; throw e; }
|
||||
files.add(f);
|
||||
}
|
||||
const h = createHash("sha256");
|
||||
for (const f of [...files].sort()) {
|
||||
h.update(relative(pkg, f)).update("\0").update(createHash("sha256").update(readFileSync(f)).digest("hex")).update("\n");
|
||||
|
||||
@@ -73,6 +73,8 @@ test("pi-unpin S3: a stand-in that exits 0 on a missing -e is refused", SKIP, t
|
||||
const problem = pi.preflight({ env: { ...CREDENTIAL, ...s.env } });
|
||||
assert.deepEqual(problem, { code: "harness-feature-missing", message: "pi 2.0.0 (MOSAIC_PI_BIN) starts with a missing -e extension" });
|
||||
noPath(problem.message, s.paths);
|
||||
// Review finding 5: the adapter runs -p, so a pi that starts anyway in either mode is refused.
|
||||
for (const mode of ["print", "rpc"]) assert.equal(fit(standIn(t, { missingExtOk: mode }).env).message, "pi 2.0.0 (MOSAIC_PI_BIN) starts with a missing -e extension", mode);
|
||||
});
|
||||
|
||||
test("pi-unpin S3: a stand-in that touches the planted MCP marker under the seal flags is refused", SKIP, t => {
|
||||
@@ -82,9 +84,13 @@ test("pi-unpin S3: a stand-in that touches the planted MCP marker under the seal
|
||||
noPath(problem.message, s.paths);
|
||||
// Each other kind of planted source is caught the same way.
|
||||
const lines = {
|
||||
extensions: "loaded a planted user extension, user settings extension, project extension, project settings extension with the seal flags on",
|
||||
skills: "loaded a planted user skill, project skill, project .agents skill, home .agents skill with the seal flags on",
|
||||
prompts: "loaded a planted user prompt template, project prompt template with the seal flags on",
|
||||
extensions: "loaded a planted user extension, user settings extension, user package extension, project extension, project settings extension, project package extension with the seal flags on",
|
||||
skills: "loaded a planted user skill, user settings skill, user package skill, project skill, project settings skill, project package skill, project .agents skill, home .agents skill with the seal flags on",
|
||||
prompts: "loaded a planted user prompt template, user settings prompt template, user package prompt template, project prompt template, project settings prompt template, project package prompt template with the seal flags on",
|
||||
// Review finding 2: the context files reach the system prompt an -e extension sees.
|
||||
context: "loaded a planted user AGENTS.md, project AGENTS.md, parent CLAUDE.md with the seal flags on",
|
||||
// A saved trust makes the project trusted, so only --no-approve keeps its APPEND_SYSTEM.md out.
|
||||
approve: "loaded a planted project APPEND_SYSTEM.md with the seal flags on",
|
||||
};
|
||||
for (const [kind, line] of Object.entries(lines)) assert.equal(fit(standIn(t, { sealLeak: [kind] }).env).message, `pi 2.0.0 (MOSAIC_PI_BIN) ${line}`, kind);
|
||||
});
|
||||
@@ -92,10 +98,36 @@ test("pi-unpin S3: a stand-in that touches the planted MCP marker under the seal
|
||||
test("pi-unpin S3: a stand-in that ignores the planted sources even without the seal flags fails the positive control and is refused as can't tell", SKIP, t => {
|
||||
const s = standIn(t, { ignoreAll: true });
|
||||
const problem = pi.preflight({ env: { ...CREDENTIAL, ...s.env } });
|
||||
assert.deepEqual(problem, { code: "harness-feature-missing", message: "pi 2.0.0 (MOSAIC_PI_BIN) can't be checked: it loaded none of the planted sources without the seal flags" });
|
||||
assert.deepEqual(problem, { code: "harness-feature-missing", message: "pi 2.0.0 (MOSAIC_PI_BIN) can't be checked: it didn't load a planted extension, skill, prompt template, context file, trusted project file without the seal flags" });
|
||||
noPath(problem.message, s.paths);
|
||||
});
|
||||
|
||||
// Review finding 1: one planted source seen in the control does not prove the others can be seen.
|
||||
test("pi-unpin S3 review: a get_commands answer that fails or changes shape is refused as can't tell, even when skills and prompts leak", SKIP, t => {
|
||||
for (const commands of ["fail", "list"]) {
|
||||
const s = standIn(t, { commands, sealLeak: ["skills", "prompts"] });
|
||||
assert.equal(fit(s.env).message, "pi 2.0.0 (MOSAIC_PI_BIN) can't be checked: it didn't answer get_commands", commands);
|
||||
}
|
||||
// MCP is a kind the control must show only when --help lists --no-mcp.
|
||||
assert.equal(fit(standIn(t, { extraFlags: ["--no-mcp"], ignoreAll: true }).env).message, "pi 2.0.0 (MOSAIC_PI_BIN) can't be checked: it didn't load a planted extension, MCP server, skill, prompt template, context file, trusted project file without the seal flags");
|
||||
});
|
||||
|
||||
// Review finding 2: the sealed runs read the system prompt through the -e extension, so a pi that
|
||||
// drops the --system-prompt file, or never runs session_start in -p, can't pass.
|
||||
test("pi-unpin S3 review: a stand-in that drops the --system-prompt file, or runs no session_start in -p, is refused", SKIP, t => {
|
||||
assert.equal(fit(standIn(t, { ignoreSystemPrompt: true }).env).message, "pi 2.0.0 (MOSAIC_PI_BIN) didn't use the --system-prompt file with the seal flags on");
|
||||
assert.equal(fit(standIn(t, { printNoStart: true }).env).message, "pi 2.0.0 (MOSAIC_PI_BIN) can't be checked: a -p start with the seal flags didn't run its -e extension");
|
||||
});
|
||||
|
||||
// Review finding 3: only the option column counts, not a flag named in a sentence.
|
||||
test("pi-unpin S3 review: a flag named only in help prose is missing", SKIP, t => {
|
||||
const s = standIn(t, { dropFlags: ["--no-context-files", "--no-approve"], helpProse: ["Removed: --no-context-files is gone in this release", "Note: --no-approve was removed", " -x, --no-context-files-old a different flag"] });
|
||||
assert.equal(fit(s.env).message, "pi 2.0.0 (MOSAIC_PI_BIN) lacks --no-context-files, --no-approve");
|
||||
// An alias column counts: "-e" listed as "--extension, -e <path>".
|
||||
const aliased = standIn(t, { dropFlags: ["-e"], helpProse: [" --extension, -e <path> Load an extension file"] });
|
||||
assert.equal(fit(aliased.env).ok, true, fit(aliased.env).message);
|
||||
});
|
||||
|
||||
test("pi-unpin S3: a stand-in that ignores an -e extension with the seal flags on is refused, since a session's gate comes in that way", SKIP, t => {
|
||||
const s = standIn(t, { dropExplicit: true });
|
||||
const problem = pi.preflight({ env: { ...CREDENTIAL, ...s.env } });
|
||||
@@ -123,6 +155,25 @@ test("pi-unpin S3: a pass is cached by the files that run; a changed file is che
|
||||
assert.equal(fit(s.env).ok, true, "the refusal was not kept");
|
||||
});
|
||||
|
||||
// Review finding 7: a copy mounted with the node_modules it sits in (the repository's copy) is
|
||||
// checked again when npm's lock files there change, since it imports packages beside it.
|
||||
test("pi-unpin S3 review: for a copy mounted with its node_modules, a changed lock file is checked again", SKIP, t => {
|
||||
const s = standIn(t, {});
|
||||
const nodeModules = join(s.root, "prefix", "lib", "node_modules");
|
||||
const found = { ...locate(s.env), root: nodeModules, dest: null };
|
||||
const lock = join(nodeModules, ".package-lock.json");
|
||||
writeFileSync(lock, "{}");
|
||||
const first = piFit(found, { levels: LEVELS });
|
||||
assert.equal(first.ok, true, first.message);
|
||||
assert.equal(piFit(found, { levels: LEVELS }), first);
|
||||
writeFileSync(lock, '{"packages":{}}');
|
||||
const again = piFit(found, { levels: LEVELS });
|
||||
assert.equal(again.ok, true, again.message);
|
||||
assert.notEqual(again, first, "a changed .package-lock.json is checked again");
|
||||
writeFileSync(join(s.root, "prefix", "lib", "package-lock.json"), "{}");
|
||||
assert.notEqual(piFit(found, { levels: LEVELS }), again, "a changed package-lock.json beside node_modules is checked again");
|
||||
});
|
||||
|
||||
test("pi-unpin S3: when --help lists --no-mcp the session env asks the adapter to pass it", SKIP, t => {
|
||||
const s = standIn(t, { extraFlags: ["--no-mcp"] });
|
||||
assert.equal(fit(s.env).noMcp, true);
|
||||
|
||||
@@ -7,14 +7,26 @@
|
||||
// $ARGV_OUT set: a session. Writes its argv there, prints `sessionOut`, exits 0. This part is
|
||||
// sh, so it runs in a sandbox that holds no node.
|
||||
// otherwise runs node (the absolute path, since the fit check gives it no PATH) on the rest:
|
||||
// --help lists every flag the fit check wants, less `dropFlags`, plus `extraFlags`
|
||||
// -e <file> a file that doesn't exist stops it with exit 1, unless `missingExtOk`; one that
|
||||
// exists is loaded even with --no-extensions, unless `dropExplicit`
|
||||
// --mode rpc loads the planted sources the way pi finds them, honouring the seal flags,
|
||||
// then answers get_state and get_commands. `ignoreAll` loads nothing.
|
||||
// `sealLeak` lists kinds (extensions, mcp, skills, prompts) loaded even when
|
||||
// their seal flag is on.
|
||||
// --help lists every flag the fit check wants, less `dropFlags`, plus `extraFlags`, then
|
||||
// the `helpProse` lines as they are
|
||||
// -e <file> a file that doesn't exist stops it with exit 1, unless `missingExtOk` is true or
|
||||
// names the mode ("rpc" or "print") it starts in anyway
|
||||
// --mode rpc loads the planted sources the way pi 0.85.1 finds them, honouring the seal flags,
|
||||
// or -p runs each -e extension's session_start (one that writes ctx.getSystemPrompt()
|
||||
// gets the prompt this stand-in builds), then answers get_state and get_commands
|
||||
// (rpc), or prints `sessionOut` and exits 0 (-p).
|
||||
// An -e file that exists loads even with --no-extensions, unless `dropExplicit`
|
||||
// (then it loads only without --no-extensions). `printNoStart`: -p runs no
|
||||
// session_start.
|
||||
// `ignoreAll` loads no planted source. `sealLeak` lists kinds (extensions, mcp,
|
||||
// skills, prompts, context, approve) loaded even when their seal flag is on.
|
||||
// `ignoreSystemPrompt` drops the --system-prompt file. `commands` "fail" answers
|
||||
// get_commands with success false; "list" answers with a bare list.
|
||||
// otherwise a session with no $ARGV_OUT: prints `sessionOut` and exits 0.
|
||||
//
|
||||
// Trust, as pi 0.85.1 has it: the project is trusted with --approve, or with a saved trust and
|
||||
// no --no-approve. Only the project SYSTEM.md and APPEND_SYSTEM.md wait on it here. The user
|
||||
// APPEND_SYSTEM.md is appended whatever the flags, as 0.85.1 does when the project has none.
|
||||
import { FIT_FLAGS } from "../src/pi-fit.mjs";
|
||||
|
||||
const BODY = String.raw`
|
||||
@@ -34,34 +46,49 @@ if (argv[0] === "--help") {
|
||||
else lines.push(" " + f);
|
||||
}
|
||||
for (const f of K.extraFlags || []) lines.push(" " + f);
|
||||
for (const l of K.helpProse || []) lines.push(l);
|
||||
process.stdout.write(lines.join("\n") + "\n");
|
||||
process.exit(0);
|
||||
}
|
||||
const rpc = val("--mode") === "rpc";
|
||||
const print = !rpc && has("-p");
|
||||
const startsAnyway = K.missingExtOk === true || (rpc && K.missingExtOk === "rpc") || (print && K.missingExtOk === "print");
|
||||
for (let i = 0; i < argv.length; i++) {
|
||||
if (argv[i] === "-e" && !fs.existsSync(argv[i + 1]) && !K.missingExtOk) {
|
||||
if (argv[i] === "-e" && !fs.existsSync(argv[i + 1]) && !startsAnyway) {
|
||||
process.stderr.write("Failed to load extension: it does not exist\n");
|
||||
process.exit(1);
|
||||
}
|
||||
}
|
||||
if (val("--mode") === "rpc") {
|
||||
if (rpc || print) {
|
||||
const leak = new Set(K.sealLeak || []);
|
||||
const on = (kind, flag) => !K.ignoreAll && (!has(flag) || leak.has(kind));
|
||||
const agent = process.env.PI_CODING_AGENT_DIR || path.join(process.env.HOME || "/", ".pi", "agent");
|
||||
const cwd = process.cwd();
|
||||
const list = (dir, test) => { try { return fs.readdirSync(dir).filter(test).map((n) => path.join(dir, n)); } catch { return []; } };
|
||||
const json = (file) => { try { return JSON.parse(fs.readFileSync(file, "utf8")); } catch { return null; } };
|
||||
const read = (file) => { try { return fs.readFileSync(file, "utf8"); } catch { return null; } };
|
||||
const settings = [json(path.join(agent, "settings.json")), json(path.join(cwd, ".pi", "settings.json"))].filter(Boolean);
|
||||
const trust = json(path.join(agent, "trust.json")) || {};
|
||||
const saved = settings.some((s) => s.defaultProjectTrust === "always") || trust[cwd] === true;
|
||||
const trusted = !K.ignoreAll && (has("--approve") || (saved && (!has("--no-approve") || leak.has("approve"))));
|
||||
const commands = [];
|
||||
// Each planted extension writes one marker; do what it would do on load.
|
||||
// A planted extension writes one marker on load; an -e extension may also write the system
|
||||
// prompt at session_start. Do what each would do.
|
||||
const starts = [];
|
||||
const load = (f) => {
|
||||
let text = "";
|
||||
try { text = fs.readFileSync(f, "utf8"); } catch { return; }
|
||||
const m = text.match(/writeFileSync\(("(?:[^"\\]|\\.)*")/);
|
||||
if (m) fs.writeFileSync(JSON.parse(m[1]), "");
|
||||
const text = read(f);
|
||||
if (text === null) return;
|
||||
for (const m of text.matchAll(/writeFileSync\(("(?:[^"\\]|\\.)*")(, ctx\.getSystemPrompt\(\))?/g)) {
|
||||
if (m[2]) starts.push(JSON.parse(m[1]));
|
||||
else fs.writeFileSync(JSON.parse(m[1]), "");
|
||||
}
|
||||
};
|
||||
if (!K.dropExplicit) for (let i = 0; i < argv.length; i++) if (argv[i] === "-e") load(argv[i + 1]);
|
||||
if (!(K.dropExplicit && has("--no-extensions"))) for (let i = 0; i < argv.length; i++) if (argv[i] === "-e") load(argv[i + 1]);
|
||||
const packages = settings.flatMap((s) => (s.packages || []).map((p) => typeof p === "string" ? p : p.source));
|
||||
if (on("extensions", "--no-extensions")) {
|
||||
const files = [...list(path.join(agent, "extensions"), (n) => n.endsWith(".ts")), ...list(path.join(cwd, ".pi", "extensions"), (n) => n.endsWith(".ts"))];
|
||||
for (const s of [path.join(agent, "settings.json"), path.join(cwd, ".pi", "settings.json")]) files.push(...(json(s)?.extensions || []));
|
||||
for (const s of settings) files.push(...(s.extensions || []));
|
||||
for (const p of packages) files.push(...list(path.join(p, "extensions"), (n) => n.endsWith(".ts")));
|
||||
for (const f of files) load(f);
|
||||
}
|
||||
if (on("mcp", "--no-extensions") && (!has("--no-mcp") || leak.has("mcp"))) {
|
||||
@@ -71,14 +98,30 @@ if (val("--mode") === "rpc") {
|
||||
}
|
||||
if (on("skills", "--no-skills")) {
|
||||
const home = process.env.HOME || "/";
|
||||
for (const d of [path.join(agent, "skills"), path.join(cwd, ".pi", "skills"), path.join(cwd, ".agents", "skills"), path.join(home, ".agents", "skills")]) {
|
||||
for (const p of list(d, () => true)) commands.push({ name: "skill:" + path.basename(p), source: "skill" });
|
||||
}
|
||||
const dirs = [path.join(agent, "skills"), path.join(cwd, ".pi", "skills"), path.join(cwd, ".agents", "skills"), path.join(home, ".agents", "skills"), ...packages.map((p) => path.join(p, "skills"))];
|
||||
for (const d of dirs) for (const p of list(d, () => true)) commands.push({ name: "skill:" + path.basename(p), source: "skill" });
|
||||
for (const s of settings) for (const p of s.skills || []) commands.push({ name: "skill:" + path.basename(p), source: "skill" });
|
||||
}
|
||||
if (on("prompts", "--no-prompt-templates")) {
|
||||
for (const d of [path.join(agent, "prompts"), path.join(cwd, ".pi", "prompts")]) {
|
||||
for (const p of list(d, (n) => n.endsWith(".md"))) commands.push({ name: path.basename(p, ".md"), source: "prompt" });
|
||||
}
|
||||
const dirs = [path.join(agent, "prompts"), path.join(cwd, ".pi", "prompts"), ...packages.map((p) => path.join(p, "prompts"))];
|
||||
for (const d of dirs) for (const p of list(d, (n) => n.endsWith(".md"))) commands.push({ name: path.basename(p, ".md"), source: "prompt" });
|
||||
for (const s of settings) for (const p of s.prompts || []) commands.push({ name: path.basename(p, ".md"), source: "prompt" });
|
||||
}
|
||||
// The system prompt: the --system-prompt file, else SYSTEM.md; then APPEND_SYSTEM.md; then the
|
||||
// context files, from the agent directory and from / down to the working directory.
|
||||
const given = K.ignoreSystemPrompt ? null : val("--system-prompt");
|
||||
const own = (name) => (trusted && read(path.join(cwd, ".pi", name))) || (!K.ignoreAll && read(path.join(agent, name))) || "";
|
||||
const parts = [given ? (read(given) || "") : own("SYSTEM.md"), own("APPEND_SYSTEM.md")];
|
||||
if (!K.ignoreAll && (!has("--no-context-files") || leak.has("context"))) {
|
||||
const dirs = [];
|
||||
for (let d = cwd; ; d = path.dirname(d)) { dirs.unshift(d); if (path.dirname(d) === d) break; }
|
||||
parts.push(read(path.join(agent, "AGENTS.md")) || "");
|
||||
for (const d of dirs) parts.push(read(path.join(d, "AGENTS.md")) || read(path.join(d, "CLAUDE.md")) || "");
|
||||
}
|
||||
if (!(print && K.printNoStart)) for (const f of starts) fs.writeFileSync(f, parts.join("\n"));
|
||||
if (print) {
|
||||
if (K.sessionOut) process.stdout.write(K.sessionOut);
|
||||
process.exit(0);
|
||||
}
|
||||
let input = "";
|
||||
try { input = fs.readFileSync(0, "utf8"); } catch { input = ""; }
|
||||
@@ -86,7 +129,10 @@ if (val("--mode") === "rpc") {
|
||||
let m;
|
||||
try { m = JSON.parse(line); } catch { continue; }
|
||||
if (m.type === "get_state") process.stdout.write(JSON.stringify({ id: m.id, type: "response", command: "get_state", success: true, data: { isStreaming: false } }) + "\n");
|
||||
if (m.type === "get_commands") process.stdout.write(JSON.stringify({ id: m.id, type: "response", command: "get_commands", success: true, data: { commands } }) + "\n");
|
||||
if (m.type === "get_commands") {
|
||||
const answer = K.commands === "fail" ? { success: false, error: "no" } : { success: true, data: K.commands === "list" ? commands : { commands } };
|
||||
process.stdout.write(JSON.stringify({ id: m.id, type: "response", command: "get_commands", ...answer }) + "\n");
|
||||
}
|
||||
}
|
||||
process.exit(0);
|
||||
}
|
||||
|
||||
@@ -253,7 +253,8 @@ export returns:
|
||||
which must be an absolute path to an executable file; else the first
|
||||
`pi` on PATH, skipping the repository's own `node_modules/.bin`; else
|
||||
the repository's copy. The binary must belong to the
|
||||
`@earendil-works/pi-coding-agent` package. With none, the message is
|
||||
`@earendil-works/pi-coding-agent` package: it is the bin that package's
|
||||
`package.json` names. With none, the message is
|
||||
"no pi found: set MOSAIC_PI_BIN, put pi on PATH, or run npm ci". No
|
||||
version is pinned. Pi's `mounts` and `installRoots` hold the found
|
||||
package's directory (the repository's whole `node_modules` for the
|
||||
@@ -264,7 +265,7 @@ export returns:
|
||||
the fit check (#1873 S3, `packages/harness/src/pi-fit.mjs`), which
|
||||
refuses `harness-feature-missing` when the binary lacks a flag the
|
||||
adapter passes, starts with a missing `-e` file, loads a planted ambient
|
||||
source with the seal flags on, or can't be checked. When its `--help`
|
||||
source or context file with the seal flags on, or can't be checked. When its `--help`
|
||||
lists `--no-mcp`, `env` sets `MOSAIC_PI_NO_MCP=1` and the adapter
|
||||
passes `--no-mcp`; otherwise it sets `MOSAIC_PI_NO_MCP=0`.
|
||||
- `version({env})` is what the manifest records as `harnessVersion`. Pi's
|
||||
|
||||
@@ -118,7 +118,11 @@ export function bundle({ dir, models, proxy = null, transports = {} } = {}) {
|
||||
|
||||
// The tool limit is the built-ins plus the typed tools, which the extension serves. #1873 S2:
|
||||
// MOSAIC_PI_BIN is the found binary's path inside the session; the bus's own environment names it
|
||||
// (env defaults to it, since the launcher and the Triage host call env() without one).
|
||||
// (env defaults to it, since buildBundle and the Triage host call env() without one). preflight,
|
||||
// version and mounts get the launcher's env instead. Both find the same binary: the session env
|
||||
// copies PATH and MOSAIC_PI_BIN from the bus's, and locate() skips the repository's .bin on PATH.
|
||||
// Should they ever differ, env() still runs the fit check on what it found and throws, so the
|
||||
// launch fails closed (as harness-failed, not harness-feature-missing).
|
||||
export function env({ policy, tools, session, proxy = null, env: hostEnv = process.env }) {
|
||||
const at = found(hostEnv);
|
||||
// #1873 S3: a session runs only a binary that passed the fit check (cached from preflight).
|
||||
|
||||
Reference in new issue
Block a user