feat(conversation, discord): the conversation engine takes pi from the harness lookup and the fit check, with no pin (#1873) #2015

Merged
jason.woltje merged 8 commits from pi-unpin-s4 into refactor 2026-11-20 13:16:03 +00:00
16 changed files with 932 additions and 150 deletions

No files matched your search

+2 -1
View File
@@ -146,7 +146,8 @@ test('real pinned install loads bus and Console; the Console starts only with --
const s=setup(t,true);
const copied=(await s.run('stack-copy.sh',['copy',s.id,'--copies',s.copies]));assert.equal(copied.status,0,copied.stderr);
const root=join(s.copies,s.id),url=f=>pathToFileURL(join(root,f)).href;
const {checkEnginePin}=await import(url('packages/conversation/src/pi-pin.mjs'));assert.equal(checkEnginePin(root).version,'0.85.1');
await import(url('packages/conversation/src/pi-seal.mjs'));const {locate}=await import(url('packages/plugins/harness/pi/binary.mjs')),{levels}=await import(url('packages/plugins/harness/pi/index.mjs')),{piFit}=await import(url('packages/harness/src/pi-fit.mjs'));
const copyPi=locate({});assert.equal(copyPi.label,"the repository's pi");assert.equal(copyPi.bin,join(root,'node_modules','.bin','pi'));const fit=await piFit(copyPi,{levels:levels()});assert.equal(fit.ok,true,fit.message);assert.equal(fit.version,'0.85.1');
const home=join(s.root,'home'),f=fixture(home),configDir=join(home,'.config','mosaic-pin');
mkdirSync(join(home,'.config'),{recursive:true});renameSync(join(home,'config'),configDir);chmodSync(configDir,0o700);
writeFileSync(join(f.dataRoot,'instance.json'),JSON.stringify({instanceVersion:1,name:'pin'}));
+71 -15
View File
@@ -234,7 +234,7 @@ live session, and the controller never writes a session file (W11).
| `src/cohort.mjs` | `ScopeLauncher` (systemd user scope plus `shim.mjs`), `PgroupLauncher`, force stop, cohort and boot proofs |
| `src/shim.mjs` | the scope's first process, outside the `engine` cgroup; ops `hello`, `events`, `members`, `term`, `freeze`, `kill`, `release`; ignores SIGTERM and exits on `release` once `engine` is empty |
| `src/guard.mjs` | `LiveSessionGuard`: refuses live sessions and paths under live roots |
| `src/pi-pin.mjs` | the Pi pin (0.85.1 and its integrity) and the seal |
| `src/pi-seal.mjs` | the seal (with `--no-mcp` when the pi's help lists it) and the engine refusal codes |
| `src/engine.mjs`, `src/framing.mjs` | the engine link and LF framing |
| `src/turns.mjs` | `Tracker`: runs, the dispatch slot, overlap signals O1–O6 |
| `src/events.mjs` | native event to CHAT-01 event mapping |
@@ -289,16 +289,71 @@ can disagree with it.
(`--no-session`, `--fork`, `--export`, `--print`, `--continue`, ...) or a
bare word, which Pi reads as a prompt (lead decision 31; N24, including the missing flag
through `checkSeal`).
- **Engine command and environment (slice 1 S5, #1522).** The controller
always launches `node <pinRoot>/node_modules/@earendil-works/pi-coding-agent/dist/bundle/cli.js`
and checks that at construction and again at bind. `engine` takes only
- **Engine command and environment (slice 1 S5, #1522; #1873 S4).** The
controller launches `node <the real file of the pi the lookup finds>`.
The lookup is the pi harness module's (`packages/plugins/harness/pi/binary.mjs`):
`MOSAIC_PI_BIN`, else the first `pi` on `PATH`, else the repository's
copy. The `pi` option takes a lookup answer and defaults to
`locate(process.env)`. The controller checks the command at construction
and again at bind, resolving the bin's real path each time, so a bin link
moved after construction refuses `unsealed-engine`. `engine` takes only
`extraArgs`, `cwd` and `envKeys`; any other key (`command`, `preArgs`,
`env`), or an `engine` that isn't an object, refuses `unsealed-engine`.
The fake engine comes in through `opts[TEST_ENGINE]`, a symbol key that
JSON config can't carry, so no config file reaches an unsealed command.
`preArgs` carrying `--extension` still refuses there too. The binding's
`argvDigest` records the full command line.
- **Engine environment.** The engine gets `ENGINE_ENV` (`pi-pin.mjs`):
- **Engine fit and pins (#1873 S4).** No pi is refused for its version.
Before a claim, a resume or a launch, the controller runs the fit check
(`packages/harness/src/pi-fit.mjs`) on the pi the lookup finds. A pi that
lacks a feature the seal needs, or that the check can't read, refuses
`engine-feature-missing` with the fit check's line (for example
`pi 9.9.9 (MOSAIC_PI_BIN) lacks --mode rpc`). The claim's pins are
`engineVersion` (what `--version` printed, or null), `enginePin` (the fit
check's digest of the pi's files) and `argvDigest`. A resume or recovery
whose pins differ refuses `engine-pin-mismatch`, so changed bytes under a
stopped claim can't resume it. A claim made before #1873 holds npm's
integrity in `enginePin`; it refuses `engine-pin-mismatch` with "the claim
was made under the old pin record; start a new claim". Like any pin
mismatch, that refusal holds at every start of the session, since a resume
is checked against the session's last proven stop. A new session starts a
new claim.
- **Same file, same interpreter.** The fit check runs the bin as a program,
so its first line picks what runs it, while the launch runs the bin's real
file with this Node. A pi whose first line isn't `#!/usr/bin/env node` or
`#!` and an absolute path that resolves to this Node refuses
`engine-feature-missing`. So does a first line that doesn't end within the
256 bytes the kernel reads, or one with a CR before its newline. Under
`#!/usr/bin/env node`, env takes node from the fit check's PATH (the
repository's `.bin`, then this process's PATH, as `sessionEnv` builds it),
and it looks inside the fit check's sandbox, which shows only `/usr`,
`/etc`, the host's `/bin`, `/lib`, `/lib64` and `/sbin`, and this Node's
own file at its path unless that path is under `/tmp` (the sandbox's fresh
`/tmp` covers it). Up to the first `node`, every entry must read the
same in the sandbox as on the host: absolute (env reads an empty or
relative one against the fit check's directory), already in plain form (a
`..` after a link goes where the link points), and not in `/proc` or
`/dev`, which the sandbox makes its own, by its spelling or by the real
path of the nearest part of it that resolves. The sandbox's `/tmp` is its
own too, but starts empty, so a `/tmp` entry is judged like any other
directory the sandbox doesn't show. An entry or a `node` link there that
can't be checked refuses too. No `node` the sandbox can't show
(or reaches through a link it can't show) may come before the first one it
can, and that first one must be this Node. No `node` anywhere on the PATH
may lie inside the package the fit check mounts. Otherwise the start
refuses `engine-feature-missing`. A refusal line, the fit check's
included, names the pi by the lookup's label, which is words such as
`MOSAIC_PI_BIN`, or "the pi" for any other label. A lookup that found no
pi refuses with its own line, or "the pi lookup gave no binary" when that
line holds a path or a control character.
The controller keeps a frozen plain copy of the lookup's answer, its own
string data fields only, so an answer that changes later changes nothing.
That copy must still be the lookup's at each check: the lookup run again on
its bin gives the same `root`, `dest`, `view` and `pkg`, so the fit check
mounts, runs and digests the package the launch runs. A package link moved
since the lookup, an answer changed by hand, or a bin the lookup no longer
takes refuses `unsealed-engine`.
- **Engine environment.** The engine gets `ENGINE_ENV` (`pi-seal.mjs`):
`PATH`, `HOME`, `USER`, `LOGNAME`, `SHELL`, `LANG`, `LC_ALL`,
`LC_CTYPE`, `TZ`, `TERM`, `TMPDIR`, `PI_CODING_AGENT_DIR`, `PI_OFFLINE`,
`PI_SKIP_VERSION_CHECK` and `PI_TELEMETRY`, plus the names in
@@ -472,7 +527,7 @@ different IDs, so overlap at the seam can't be deduplicated (CHAT-01 lines
## Slash text
`textPolicy` refuses any prompt whose text, after leading whitespace, starts
with `/`: pinned Pi runs extension commands, skills (`/skill:`) and prompt
with `/`: Pi runs extension commands, skills (`/skill:`) and prompt
templates from index 0 (S1, S2). `!`, `!!` and `@` are interpreted only by
Pi's interactive mode and CLI, not on the RPC prompt path, so they are
admitted and sent as text. A `/` on a later line is not interpreted
@@ -547,13 +602,14 @@ runs in CHAT-01 `check.mjs` order, then the CHAT-03 narrowings.
| `eligibility` | launch with a used or unknown eligibility record, one from another incarnation, or a changed reservation (K17) |
| `already-active`, `unsafe-replacement`, `foreign-host` | the writer claim (W2, W3, W17) |
| `live-session-refused` | the live-session guard, at construction, bind and launch (G1–G3) |
| `unsealed-engine`, `engine-pin-mismatch` | the seal or the Pi pin (N24) |
| `unsealed-engine`, `engine-pin-mismatch` | the seal, or the engine's version, digest or argv changed under a claim (N24, W9, S4c) |
| `engine-feature-missing` | the fit check found the pi lacks a feature, or couldn't tell (S4b) |
| `configuration` | a required constructor path is missing or misplaced, the session file is unreadable, or the session header ID isn't a CHAT-01 ID |
`malformed`, `eligibility` and `preflight` are names this build adds; the
brief describes those refusals without naming them.
The controller, claim store, live-session guard and engine pin throw
The controller, claim store, live-session guard and engine checks throw
`ControlRefusal` (`safe-fs.mjs`), a subclass of the reader's `Refusal`. These
codes reach a socket client, never the reader's HTTP routes, so the control
board's status map (`REFUSAL_STATUS`, which its tests check against every
@@ -563,15 +619,15 @@ board ever serves the controller, these codes need statuses there first.
Receipt reason codes, not refusals: `transport-unknown`,
`handled-without-run`, `ack-without-start`, `interrupted`, `run-overlap`.
## Findings against pinned Pi
## Findings against Pi 0.85.1
From `tests/smoke.test.mjs`, which starts the pinned binary sealed, in a
From `tests/smoke.test.mjs`, which starts the repository's pi (0.85.1) sealed, in a
scratch home with an empty agent dir and no inherited environment, and sends
no prompt:
- It starts with no credentials and answers `get_state`, `get_commands`,
`clear_queue`, `abort` and `get_tree`. Every field the fake engine sends
for those commands, pinned Pi sends with the same type. `clear_queue` emits
for those commands, Pi 0.85.1 sends with the same type. `clear_queue` emits
`queue_update` with empty queues before its response, as the fake does.
Pi writes `auth.json` (`{}`) and `models-store.json` into the agent dir.
- **Startup append.** Pi appends to the session at startup in two cases
@@ -593,13 +649,13 @@ no prompt:
| Suite | Covers |
|---|---|
| `claim.test.mjs` | W1–W17, W20, G1–G3: the writer claim, crash barriers, the guard |
| `claim.test.mjs` | W1–W17, W20, G1–G3, S4a–S4h: the writer claim, crash barriers, the guard, the engine fit, pins and seal, the node-script check and the lookup answer check |
| `races.test.mjs` | H1–H4, H9–H23: takeover, Interrupt and force stop, retries, incarnations |
| `turns.test.mjs` | N1–N25, N24b: the turn tracker against the fake engine's Pi behaviors; the engine seal and environment |
| `turns.test.mjs` | N1–N25, N24b, N24c: the turn tracker against the fake engine's Pi behaviors; the engine seal, `--no-mcp` and environment |
| `cohort.test.mjs` | K1–K19, R1–R3, R5–R13, E1–E6: scopes, force stop, proofs, recovery, eligibility, the scope's environment, scope release and its retry after a crash, the engine-exit stop (needs a systemd user manager) |
| `flows.test.mjs` | S1–S7, P3, E1–E7, the terminal, and a CHAT-01 schema check of every record produced |
| `smoke.test.mjs` | the pinned Pi binary, as above |
| `smoke.test.mjs` | the repository's Pi binary, as above, and its fit check |
`fake-pi.mjs` models pinned Pi's RPC mode, including the startup append, and
`fake-pi.mjs` models Pi 0.85.1's RPC mode, including the startup append, and
`ctrl-child.mjs` runs a controller in a child process for the crash tests.
Fixtures live in temporary directories and are removed after each file.
+234 -20
View File
@@ -16,7 +16,7 @@
// as in CHAT-01. With no verifier nothing verifies, and every stop ends
// `uncertain`.
import { lstatSync, mkdirSync, readFileSync, unlinkSync } from "node:fs";
import { closeSync, lstatSync, mkdirSync, openSync, readFileSync, readSync, readlinkSync, realpathSync, statSync, unlinkSync } from "node:fs";
import { createServer } from "node:net";
import { basename, dirname, join, resolve } from "node:path";
import { fileURLToPath } from "node:url";
@@ -30,7 +30,11 @@ import { LineSplitter, encodeLine, parseLine } from "./framing.mjs";
import { LiveSessionGuard, realPath } from "./guard.mjs";
import { ID, fragments, safeId } from "./parts.mjs";
import { parseSnapshot } from "./pi.mjs";
import { ENGINE_PIN_MISMATCH, PI_BIN, UNSEALED_ENGINE, argvDigest, buildPiArgs, checkEnginePin, checkSeal, engineEnv } from "./pi-pin.mjs";
import { ENGINE_FEATURE_MISSING, ENGINE_PIN_MISMATCH, OLD_PIN_LINE, UNSEALED_ENGINE, argvDigest, buildPiArgs, checkSeal, engineEnv, oldPinRecord } from "./pi-seal.mjs";
import { PACKAGE, executable, locate } from "../../plugins/harness/pi/binary.mjs";
import { sessionEnv } from "../../seat/src/session.mjs";
import { levels } from "../../plugins/harness/pi/index.mjs";
import { piFit } from "../../harness/src/pi-fit.mjs";
import { ACTOR, conversationId, createReader, rootsFromSpecs } from "./reader.mjs";
import { clone, equal, hash, newId, receiptAllows, record, scopeMatch, sealProof, sha256, targetOf } from "./records.mjs";
import { ControlRefusal, Refusal } from "./safe-fs.mjs";
@@ -79,7 +83,7 @@ const STOP_IN_PROGRESS = new Set(["fenced", "cancelling", "stopping"]);
const STOP_NEXT = { fenced: ["cancelling", "stopping", "uncertain"], cancelling: ["stopping", "uncertain"], stopping: ["uncertain"], uncertain: [] };
// check.mjs `ending`: the binding follows only stops that end the engine.
const ending = (mode) => mode === "force-stop" || mode === "engine-exit";
const SEAL_BASIS = "seal: --no-extensions and no --extension argument (pi-pin.mjs SEAL_FLAGS)";
const SEAL_BASIS = "seal: --no-extensions and no --extension argument (pi-seal.mjs SEAL_FLAGS)";
const DIALOG_REASON = "Pi dialogs are not answered in CHAT-03 (lead decision 30); shown disabled";
const refused = (code, extra = {}) => ({ outcome: `refused:${code}`, refusal: code, ...extra });
@@ -152,13 +156,72 @@ export function sessionTools(parsed) {
return tools;
}
// A first line that runs node: #!/usr/bin/env node, or #! and an absolute path
// whose last part is node, with nothing after it.
const NODE_SHEBANG = /^#![ \t]*(?:\/usr\/bin\/env[ \t]+node|(\/[^\s]*\/node))[ \t]*$/;
const ANSWER_KEYS = ["root", "dest", "view", "pkg"];
const ANSWER_FIELDS = ["bin", "label", "problem", ...ANSWER_KEYS];
// #1873 S4: what the fit check's sandbox (systemBinds in seat/src/sandbox.mjs)
// shows as the host has it: /usr, /etc and the host's /bin, /lib, /lib64 and
// /sbin, and this node's own file at process.execPath. shownInFit follows p
// one part at a time as the sandbox would and gives the file it reaches, or
// null when a link or the file lies anywhere else. Null may be too strict (the
// package's own mount is left out on purpose: no node may come from it), never
// too loose.
const SHOWN_DIRS = ["/usr", "/etc", "/bin", "/lib", "/lib64", "/sbin"];
const shownDir = (p) => SHOWN_DIRS.some((d) => p === d || p.startsWith(d + "/"));
// The sandbox makes its own /proc and /dev, so a path there names something
// else inside it than on the host. Its /tmp is another directory too, but one
// that starts empty (pi-fit.mjs makes it fresh for each run), so an entry
// there holds no node in the sandbox, and a node the host finds there is one
// the sandbox can't show. That holds for this Node's own file too: pi-fit.mjs
// puts the fresh /tmp in place after it mounts that file, so an engine whose
// node sits under /tmp is hidden in the sandbox.
const OWN_COPY_DIRS = ["/proc", "/dev"];
const underTmp = (p) => p === "/tmp" || p.startsWith("/tmp/");
function shownInFit(p, hops = 0) {
if (hops > 40) return null;
const parts = p.split("/").filter(Boolean);
let at = "/";
for (let i = 0; i < parts.length; i++) {
const next = join(at, parts[i]);
let st;
try { st = lstatSync(next); } catch { return null; }
if (st.isSymbolicLink()) {
if (!shownDir(next)) return null;
let target;
try { target = readlinkSync(next); } catch { return null; }
return shownInFit(resolve(at, target, ...parts.slice(i + 1)), hops + 1);
}
at = next;
}
return (at === process.execPath && !underTmp(at)) || shownDir(at) ? at : null;
}
// #1873 S4: the lookup's answer, copied once into a frozen plain object of
// its own data fields, so what the seal checks and what the fit check reads
// are the same values for the controller's life. A getter, a Proxy that
// answers differently later, or an inherited field changes nothing after
// this copy.
function answerCopy(pi) {
if (!pi || typeof pi !== "object") return pi;
const out = {};
for (const k of ANSWER_FIELDS) {
let d;
try { d = Object.getOwnPropertyDescriptor(pi, k); } catch { d = undefined; }
if (d && "value" in d && (typeof d.value === "string" || d.value === null)) out[k] = d.value;
}
return Object.freeze(out);
}
export class Controller {
constructor(opts = {}) {
const {
fixtureRoot, claimRoot, socketDir, sessionFile, seat, workspace = "default",
engine = {}, launcher = new PgroupLauncher(), verifier = null, host, identity, barrier = null, units = systemdUnits,
grants = null, guardOptions = {}, timeouts = {}, now = () => new Date(),
policyRevision = "policy-fixture-1", sourceRootRef = "source-fixture-1", approvedMappings = null, pinRoot = REPO_ROOT, auditWritable = true,
policyRevision = "policy-fixture-1", sourceRootRef = "source-fixture-1", approvedMappings = null, pi = locate(process.env), auditWritable = true,
hostId = null,
} = opts;
for (const [k, v] of Object.entries({ claimRoot, socketDir, sessionFile, seat })) {
@@ -180,12 +243,15 @@ export class Controller {
this.conversation = conversationId(this.root, basename(this.paths.sessionFile));
if (!engine || typeof engine !== "object" || Array.isArray(engine)) throw new ControlRefusal(UNSEALED_ENGINE, "engine is not an object");
const extra = Object.keys(engine).find((k) => !ENGINE_KEYS.has(k));
if (extra !== undefined) throw new ControlRefusal(UNSEALED_ENGINE, `engine.${extra.slice(0, 40)} can't be configured; the controller launches the pinned Pi with its own environment`);
if (extra !== undefined) throw new ControlRefusal(UNSEALED_ENGINE, `engine.${extra.slice(0, 40)} can't be configured; the controller launches the pi the lookup finds, with its own environment`);
const test = opts[TEST_ENGINE] ?? null;
// #1873 S4: the pi is binary.mjs's answer ({ bin, label, ... } or
// { bin: null, problem }). A sealed launch runs its bin's real file.
this.pi = answerCopy(pi);
this.engine = {
sealed: test === null,
command: test ? test.command : process.execPath,
preArgs: test ? test.preArgs : [join(pinRoot, PI_BIN)],
preArgs: test ? test.preArgs : [this.#piFile()],
extraArgs: engine.extraArgs ?? [],
cwd: engine.cwd ?? projectRoot,
env: test ? test.env : engineEnv(engine.envKeys),
@@ -194,8 +260,8 @@ export class Controller {
if (!Array.isArray(this.engine[k])) throw new ControlRefusal(UNSEALED_ENGINE, `engine.${k} is not a list`);
}
if (typeof this.engine.command !== "string" || !this.engine.command) throw new ControlRefusal(UNSEALED_ENGINE, "the engine command is not a path");
this.noMcp = false;
this.piArgs = buildPiArgs({ sessionFile: this.paths.sessionFile, extraArgs: this.engine.extraArgs });
this.pinRoot = pinRoot;
this.#checkSeal();
this.launcher = launcher;
this.verifier = verifier;
@@ -257,20 +323,168 @@ export class Controller {
if (this.barrier) await this.barrier(name, detail);
}
// The real file of the pi's bin, read now. No answer from the lookup, or a
// bin that no longer resolves, refuses: the lookup's own line names the
// step, never a path. The answer must still be the lookup's: the lookup run
// again on its bin gives the same root, dest, view and pkg. A stale
// answer (a link moved since the lookup) or one changed by hand refuses
// unsealed-engine.
#piFile() {
const pi = this.pi;
if (!pi || typeof pi !== "object" || typeof pi.bin !== "string" || !pi.bin) {
// The lookup's problem lines are words and its package's name; a
// hand-built one with a path or a control character in it isn't shown.
const problem = pi?.problem;
const plain = typeof problem === "string" && problem && !/[\x00-\x1f\x7f-\x9f\u2028\u2029]/.test(problem) && !problem.replaceAll(PACKAGE, "").includes("/");
const why = plain ? problem : "the pi lookup gave no binary";
throw new ControlRefusal(ENGINE_FEATURE_MISSING, why);
}
const label = this.#label();
let real;
try {
real = realpathSync(pi.bin);
} catch {
throw new ControlRefusal(ENGINE_FEATURE_MISSING, `${label} no longer resolves to a file`);
}
// The lookup run again on the same bin must give the same answer: what the
// fit check mounts (root at dest), runs (view) and digests (pkg) is then
// the package the launch runs.
const again = locate({ MOSAIC_PI_BIN: pi.bin, ...(typeof process.env.HOME === "string" ? { HOME: process.env.HOME } : {}) });
if (again.bin === null || ANSWER_KEYS.some((k) => (again[k] ?? null) !== (pi[k] ?? null))) {
throw new ControlRefusal(UNSEALED_ENGINE, `${label} no longer matches the lookup's answer; look the pi up again`);
}
return real;
}
// #1873 S4: the launch is this Node running the bin's real file, while the
// fit check runs the bin as a program, so its first line picks what runs it.
// Only a file whose first line runs node (#!/usr/bin/env node, or an
// absolute path to this same node) runs the same way in both.
#nodeScript(file) {
let head = "";
let fd = null;
try {
fd = openSync(file, "r");
const buf = Buffer.alloc(256);
head = buf.subarray(0, readSync(fd, buf, 0, buf.length, 0)).toString("latin1");
} catch {
head = "";
} finally {
if (fd !== null) try { closeSync(fd); } catch {}
}
const label = this.#label();
// The kernel reads at most 256 bytes for the first line; one that doesn't
// end inside them isn't run as a #! line at all.
const nl = head.indexOf("\n");
const m = nl < 0 ? null : NODE_SHEBANG.exec(head.slice(0, nl));
if (!m) throw new ControlRefusal(ENGINE_FEATURE_MISSING, `${label} isn't a node script, and the engine runs pi with node`);
// An absolute node must be this one: a file named node that is something
// else would let the fit check run another program than the launch does.
if (m[1] !== undefined) {
let interp = null;
try { interp = realpathSync(m[1]); } catch {}
if (interp === null || interp !== realpathSync(process.execPath)) {
throw new ControlRefusal(ENGINE_FEATURE_MISSING, `${label}'s first line runs another node than the engine's`);
}
return;
}
// env takes node from the fit check's PATH, the one a bus session gets
// (sessionEnv: the repository's .bin, then this process's PATH), and it
// looks inside the sandbox, which shows only some of the host. Up to the
// first node, every entry must read the same in both: absolute, already
// in plain form (a ".." after a link goes where the link points, not
// where the text does), and nowhere the sandbox gives its own copy of
// (/proc, /dev), in its spelling or its real path. An entry or a
// node there that can't be checked refuses. No node the sandbox can't show
// may come first, and the first one must be this node. No node on the
// PATH may come from the package the fit check mounts.
const engineNode = realpathSync(process.execPath);
const realOrNull = (p) => { try { return realpathSync(p); } catch { return null; } };
const root = realOrNull(this.pi.root) ?? this.pi.root;
const refuse = (why) => { throw new ControlRefusal(ENGINE_FEATURE_MISSING, `${label}'s first line runs node from the fit check's PATH, ${why}`); };
const missing = (e) => e?.code === "ENOENT" || e?.code === "ENOTDIR";
const ownCopy = (p) => OWN_COPY_DIRS.some((d) => p === d || p.startsWith(d + "/"));
let first = null;
for (const dir of String(sessionEnv(process.env, "fit").PATH ?? "").split(":")) {
if (first === null) {
if (!dir.startsWith("/")) refuse("which has an empty or relative entry");
const plain = dir.length > 1 ? dir.replace(/\/+$/, "") : dir;
if (resolve(plain) !== plain) refuse("which has an entry that isn't in plain form");
const own = "which has an entry the fit check's sandbox has its own copy of";
if (ownCopy(plain)) refuse(own);
// An entry that doesn't exist is judged by the real path of the
// nearest part of it that does.
let realDir = null;
for (let at = plain; realDir === null; at = dirname(at)) {
try { realDir = realpathSync(at); } catch (e) { if (!missing(e) || at === "/") refuse("where an entry can't be checked"); }
}
if (ownCopy(realDir)) refuse(own);
const candidate = join(plain, "node");
try { lstatSync(candidate); } catch (e) { if (missing(e)) continue; refuse("where an entry can't be checked"); }
let held = null;
try { held = statSync(candidate); } catch { refuse("where a node can't be checked"); }
if (!held.isFile() || !executable(candidate)) continue;
} else if (!dir.startsWith("/") || !executable(resolve(dir, "node"))) {
continue;
}
const candidate = resolve(dir, "node");
const real = realOrNull(candidate);
if (real === null) {
if (first === null) refuse("where a node can't be checked");
continue;
}
if (real === root || real.startsWith(root + "/")) {
throw new ControlRefusal(ENGINE_FEATURE_MISSING, `${label}'s package puts a node on the fit check's PATH`);
}
if (first !== null) continue;
first = shownInFit(candidate);
if (first === null) refuse("where a node the fit check can't see comes first");
}
if (first === null || realOrNull(first) !== engineNode) {
throw new ControlRefusal(ENGINE_FEATURE_MISSING, `${label}'s first line runs the first node on the fit check's PATH, which isn't the engine's`);
}
}
// The name a refusal line uses for the pi: the lookup's label, which names
// a step in words ("MOSAIC_PI_BIN", "the pi on PATH", "the repository's
// pi"), never a path. Anything else, such as a hand-built answer's label
// with a / or a newline in it, is "the pi".
#label() {
const label = this.pi?.label;
return typeof label === "string" && /^[A-Za-z_' ]{1,64}$/.test(label) ? label : "the pi";
}
// The seal covers the command: unless a test engine was given, the launch
// is this Node running the pinned Pi's bin, and nothing else.
// is this Node running the real file of the bin the lookup found, read
// again at each check, and nothing else.
#checkSeal() {
if (this.engine.sealed && (this.engine.command !== process.execPath || this.engine.preArgs.length !== 1 || this.engine.preArgs[0] !== join(this.pinRoot, PI_BIN))) {
throw new ControlRefusal(UNSEALED_ENGINE, "the engine command is not the pinned Pi");
if (this.engine.sealed && (this.engine.command !== process.execPath || this.engine.preArgs.length !== 1 || this.engine.preArgs[0] !== this.#piFile())) {
throw new ControlRefusal(UNSEALED_ENGINE, `the engine command is not ${this.#label()} the lookup found`);
}
const bad = this.engine.preArgs.find((a) => typeof a !== "string" || a === "-e" || a === "--extension" || a.startsWith("--extension="));
if (bad !== undefined) throw new ControlRefusal(UNSEALED_ENGINE, `engine pre-arguments carry ${bad}`);
checkSeal(this.piArgs);
checkSeal(this.piArgs, { noMcp: this.noMcp });
}
#pins() {
const pin = checkEnginePin(this.pinRoot);
return { engineVersion: pin.version, enginePin: pin.pin, argvDigest: argvDigest(this.engine.command, [...this.engine.preArgs, ...this.piArgs]) };
// #1873 S4: the fit check (pi-fit.mjs, cached by the digest of the files
// that run) stands where the version pin stood. A pi that fails it, or
// can't be checked, refuses engine-feature-missing with the check's line.
// engineVersion is the --version text (null when pi printed none) and
// enginePin the digest. --no-mcp joins the seal when the help lists it.
async #pins() {
this.#nodeScript(this.#piFile());
const fit = await piFit({ ...this.pi, label: this.#label() }, { levels: levels() });
if (!fit?.ok) throw new ControlRefusal(ENGINE_FEATURE_MISSING, typeof fit?.message === "string" ? fit.message : "the pi could not be checked");
if (typeof fit.digest !== "string" || !/^[0-9a-f]{64}$/.test(fit.digest)) throw new ControlRefusal(ENGINE_FEATURE_MISSING, "the fit check gave no digest");
this.noMcp = fit.noMcp === true;
this.piArgs = buildPiArgs({ sessionFile: this.paths.sessionFile, extraArgs: this.engine.extraArgs, noMcp: this.noMcp });
this.#checkSeal();
return { engineVersion: typeof fit.version === "string" ? fit.version : null, enginePin: fit.digest, argvDigest: argvDigest(this.engine.command, [...this.engine.preArgs, ...this.piArgs]) };
}
// The line for a pins mismatch against a claim's recorded pins.
static pinLine(recorded, since) {
return oldPinRecord(recorded) ? OLD_PIN_LINE : `the engine pin or launch argv changed since ${since}`;
}
// Every read after construction refuses a header ID other than the one the
@@ -341,7 +555,7 @@ export class Controller {
async start() {
this.#guardCheck("bind");
this.#checkSeal();
const pins = this.#pins();
const pins = await this.#pins();
const session = this.#readSession();
const classified = await this.store.classify(this.seatK, this.sessionK, {
units: this.units,
@@ -373,7 +587,7 @@ export class Controller {
let priorRef = null;
if (prior.n > 0 && !prior.damaged && prior.record.state === "stopped") {
const p = prior.record;
if (!equal(p.pins, pins)) throw new ControlRefusal(ENGINE_PIN_MISMATCH, "the engine pin or launch argv changed since the proven stop");
if (!equal(p.pins, pins)) throw new ControlRefusal(ENGINE_PIN_MISMATCH, Controller.pinLine(p.pins, "the proven stop"));
const leaf = p.leafAtProof !== undefined ? p.leafAtProof : p.leaf;
const branch = p.branchAtProof ?? p.branch;
if (leaf !== session.leaf || branch !== session.branch) throw new ControlRefusal("target", "the session branch or leaf changed since the proven stop");
@@ -1679,11 +1893,11 @@ export class Controller {
if (b.state !== "stopped" || b.admission !== "closed" || !this.#stopped(s)) return refused("stop-proof");
let pins;
try {
pins = this.#pins();
pins = await this.#pins();
} catch (err) {
return refused(err.code ?? ENGINE_PIN_MISMATCH);
return refused(err.code ?? ENGINE_PIN_MISMATCH, typeof err?.message === "string" ? { detail: err.message } : {});
}
if (!equal(pins, this.claim.record.pins)) return refused(ENGINE_PIN_MISMATCH);
if (!equal(pins, this.claim.record.pins)) return refused(ENGINE_PIN_MISMATCH, { detail: Controller.pinLine(this.claim.record.pins, "the proven stop") });
const session = this.#readSession();
if (session.leaf !== this.claim.record.leafAtProof || session.branch !== this.claim.record.branchAtProof) return refused("target");
if (!this.#checkConfirmation(r, c, "recover")) return refused("confirmation");
@@ -1715,7 +1929,7 @@ export class Controller {
throw new ControlRefusal(ELIGIBILITY, "the reserved claim changed since eligibility");
}
}
const pins = this.#pins();
const pins = await this.#pins();
if (!equal(pins, e.pins)) throw new ControlRefusal(ENGINE_PIN_MISMATCH, "the engine pin or launch argv changed since eligibility");
const session = this.#readSession();
if (session.leaf !== e.leaf || session.branch !== e.branch) throw new ControlRefusal("target", "the session branch or leaf changed since eligibility (K18)");
@@ -1,14 +1,21 @@
// The Pi pin and the engine seal (#1507, CHAT-03 §3, lead decisions 31–32).
// The engine seal and the engine's pins (#1507, CHAT-03 §3, lead decisions
// 31–32; #1873 pi-unpin S4).
//
// Pin: package-lock.json and npm's installed record
// (node_modules/.package-lock.json) must both name the pinned version with the
// pinned integrity. That ties the install to the package through npm's record;
// it is not a hash of the files on disk. `pi` runs dist/bundle/cli.js, the
// package's bin, and the built-in llama.cpp extension ships inside it.
// Pins: no pi version is pinned (Jason, 2026-11-19). The controller runs the
// pi binary.mjs's lookup finds (MOSAIC_PI_BIN, else the first pi on PATH, else
// the repository's) once the fit check (packages/harness/src/pi-fit.mjs)
// passes it. The claim's pins are what that check reports: `engineVersion`,
// the `--version` text (null when pi printed none), and `enginePin`, the
// sha256 digest of the files that run. A pi that fails the check, or can't be
// checked, is refused `engine-feature-missing`; a digest or argv that differs
// from a claim's is refused `engine-pin-mismatch`. A claim made before #1873
// holds npm's sha512 integrity in `enginePin`, which no digest equals, so it
// refuses once with OLD_PIN_LINE.
//
// Seal: the controller builds the launch argv. It always carries
// --no-extensions, --no-prompt-templates, --no-themes and --no-approve, and
// never an --extension argument (cli/args.js; usage.md 224 and 233–236).
// --no-extensions, --no-prompt-templates, --no-themes and --no-approve, plus
// --no-mcp when the pi's --help lists it, and never an --extension argument
// (cli/args.js; usage.md 224 and 233–236).
// --no-approve sets the project trust override to false, so a project's
// .pi/settings.json, SYSTEM.md, APPEND_SYSTEM.md and skills don't load even
// when trust.json under the agent dir trusts it (main.js 574–581;
@@ -23,60 +30,45 @@
// file, so the argv must be exactly the controller's prefix followed by
// ENGINE_OPTIONS pairs, each at most once with one plain value.
import { readFileSync } from "node:fs";
import { isAbsolute, join } from "node:path";
import { isAbsolute } from "node:path";
import { createHash } from "node:crypto";
import { ControlRefusal } from "./safe-fs.mjs";
export const PI_PACKAGE = "@earendil-works/pi-coding-agent";
export const PI_VERSION = "0.85.1";
export const PI_INTEGRITY = "sha512-FGRN+OHbWaefBPGaTggAdLjrIHW+s2PzLyglz/5dfLzb9of7uuXMXYC0fJIeZTw+shS32o2cuQ9jF7YSDuL/oQ==";
export const PI_BIN = join("node_modules", PI_PACKAGE, "dist", "bundle", "cli.js");
export const SEAL_FLAGS = Object.freeze(["--no-extensions", "--no-prompt-templates", "--no-themes", "--no-approve"]);
export const ENGINE_OPTIONS = Object.freeze(["--model", "--provider", "--thinking"]);
export const ENGINE_PIN_MISMATCH = "engine-pin-mismatch";
export const UNSEALED_ENGINE = "unsealed-engine";
export const ENGINE_FEATURE_MISSING = "engine-feature-missing";
function lockEntry(path) {
let lock;
try {
lock = JSON.parse(readFileSync(path, "utf8"));
} catch {
return null;
}
const entry = lock?.packages?.[`node_modules/${PI_PACKAGE}`];
return entry && typeof entry === "object" ? entry : null;
// The seal flags for a pi whose --help does (noMcp) or doesn't list --no-mcp.
export const sealFlags = (noMcp = false) => (noMcp ? [...SEAL_FLAGS, "--no-mcp"] : [...SEAL_FLAGS]);
// An `enginePin` the fit check gives is a sha256 hex digest.
export const PIN_DIGEST = /^[0-9a-f]{64}$/;
export const OLD_PIN_LINE = "the claim was made under the old pin record; start a new claim";
// True when a claim's pins came from the old npm pin record: an `enginePin`
// string that isn't a digest (npm's integrity is `sha512-...`).
export const oldPinRecord = (pins) => typeof pins?.enginePin === "string" && !PIN_DIGEST.test(pins.enginePin);
export function buildPiArgs({ sessionFile, extraArgs = [], noMcp = false }) {
return ["--mode", "rpc", ...sealFlags(noMcp), "--session", sessionFile, ...extraArgs];
}
// `root` holds package-lock.json and node_modules/.package-lock.json.
export function checkEnginePin(root) {
for (const path of [join(root, "package-lock.json"), join(root, "node_modules", ".package-lock.json")]) {
const entry = lockEntry(path);
if (!entry || entry.version !== PI_VERSION || entry.integrity !== PI_INTEGRITY) {
throw new ControlRefusal(ENGINE_PIN_MISMATCH, `${path} does not pin ${PI_PACKAGE} ${PI_VERSION} with the pinned integrity`);
}
}
return { version: PI_VERSION, pin: PI_INTEGRITY };
}
export function buildPiArgs({ sessionFile, extraArgs = [] }) {
return ["--mode", "rpc", ...SEAL_FLAGS, "--session", sessionFile, ...extraArgs];
}
// Refuses any argv that is not `--mode rpc`, the four --no-* flags and
// `--session <absolute path>`, in that order, followed by ENGINE_OPTIONS
// pairs. That covers --extension in either spelling, a second --mode or
// Refuses any argv that is not `--mode rpc`, the four --no-* flags (and
// --no-mcp when noMcp), and `--session <absolute path>`, in that order,
// followed by ENGINE_OPTIONS pairs. That covers --extension in either spelling, a second --mode or
// --session, session and output flags (--no-session, --fork, --export, ...)
// and stray prompt words.
export function checkSeal(args) {
export function checkSeal(args, { noMcp = false } = {}) {
if (!Array.isArray(args) || args.some((a) => typeof a !== "string")) throw new ControlRefusal(UNSEALED_ENGINE, "launch argv is not a list of strings");
const extension = args.find((a) => a === "-e" || a === "--extension" || a.startsWith("--extension="));
if (extension !== undefined) throw new ControlRefusal(UNSEALED_ENGINE, `launch argv carries ${extension}`);
for (const flag of SEAL_FLAGS) {
const flags = sealFlags(noMcp);
for (const flag of flags) {
if (!args.includes(flag)) throw new ControlRefusal(UNSEALED_ENGINE, `launch argv lacks ${flag}`);
}
const prefix = ["--mode", "rpc", ...SEAL_FLAGS, "--session"];
const prefix = ["--mode", "rpc", ...flags, "--session"];
if (prefix.some((a, i) => args[i] !== a)) throw new ControlRefusal(UNSEALED_ENGINE, `launch argv does not start with ${prefix.join(" ")}`);
const file = args[prefix.length];
if (typeof file !== "string" || !isAbsolute(file)) throw new ControlRefusal(UNSEALED_ENGINE, "the --session value is not an absolute path");
+1 -1
View File
@@ -1,6 +1,6 @@
// Run tracking, overlap signals and receipt settlement (#1507, CHAT-03 §3).
//
// Pinned Pi ties no event to a prompt. Under the seal (pi-pin.mjs) the Mosaic
// Pi ties no event to a prompt. Under the seal (pi-seal.mjs) the Mosaic
// prompt in the slot is the only thing that can start a run, so a run that
// follows the slot's ack is attributed to it by order. The tracker watches
// for signs that the seal failed (O1–O6) and for lead decision 34's
+414 -12
View File
@@ -5,23 +5,27 @@
import { test, after } from "node:test";
import assert from "node:assert/strict";
import { appendFileSync, copyFileSync, linkSync, mkdirSync, statSync, mkdtempSync, readFileSync, readdirSync, rmSync, symlinkSync, unlinkSync, writeFileSync, lstatSync } from "node:fs";
import { appendFileSync, chmodSync, copyFileSync, linkSync, mkdirSync, statSync, mkdtempSync, readFileSync, readdirSync, realpathSync, rmSync, symlinkSync, unlinkSync, writeFileSync, lstatSync } from "node:fs";
import { homedir, tmpdir } from "node:os";
import { join } from "node:path";
import { dirname, join } from "node:path";
import { spawnSync } from "node:child_process";
import { createHash } from "node:crypto";
import { types as utilTypes } from "node:util";
import { ALREADY_ACTIVE, ClaimStore, FOREIGN_HOST, UNSAFE_REPLACEMENT, held, machineId } from "../src/claim.mjs";
import { Controller } from "../src/controller.mjs";
import { Controller, REPO_ROOT } from "../src/controller.mjs";
import { ConversationClient } from "../src/client.mjs";
import { AUTHORITY, scopeAvailable } from "../src/cohort.mjs";
import { FixtureVerifier } from "../src/records.mjs";
import { LIVE_SESSION_REFUSED } from "../src/guard.mjs";
import { ENGINE_PIN_MISMATCH, PI_PACKAGE } from "../src/pi-pin.mjs";
import { ENGINE_FEATURE_MISSING, ENGINE_PIN_MISMATCH, OLD_PIN_LINE, UNSEALED_ENGINE } from "../src/pi-seal.mjs";
import { piFit } from "../../harness/src/pi-fit.mjs";
import { levels } from "../../plugins/harness/pi/index.mjs";
import { bootId } from "../../discord/src/journal.mjs";
import { FakeLauncher } from "./fake-pi.mjs";
import {
REPO, FAST, fixture, controllerFor, started, spawnController, killChildren, cleanupAll, reap, claimRecords,
userEntry, assistantEntry, thinkingEntry, receiptState, noUnits, tick, killShims, shimsGone,
PI_PACKAGE, standInPi, piAt,
} from "./harness.mjs";
const reaped = [];
@@ -579,14 +583,8 @@ test("W8: resume after a proven stop with the same pins: new claim ID, generatio
test("W9: resume with a changed binary, argv digest, branch or leaf is refused and the claim is unchanged", async () => {
const cases = {
binary: (fx) => {
const root = mkdtempSync(join(fx.base, "pin-"));
const lock = { packages: { [`node_modules/${PI_PACKAGE}`]: { version: "0.85.2", integrity: "sha512-other" } } };
mkdirSync(join(root, "node_modules"));
writeFileSync(join(root, "package-lock.json"), JSON.stringify(lock));
writeFileSync(join(root, "node_modules", ".package-lock.json"), JSON.stringify(lock));
return [{ pinRoot: root }, ENGINE_PIN_MISMATCH];
},
// Another pi, which the fit check passes, with other files.
binary: (fx) => [{ pi: standInPi(join(fx.base, "other-pi"), { version: "0.85.2" }).found }, ENGINE_PIN_MISMATCH],
argv: () => [{ engine: { extraArgs: ["--model", "other"] } }, ENGINE_PIN_MISMATCH],
leaf: (fx) => {
appendFileSync(fx.sessionFile, JSON.stringify(userEntry("d4e5f6a7", "b2c3d4e5", "outside", 9)) + "\n");
@@ -610,6 +608,410 @@ test("W9: resume with a changed binary, argv digest, branch or leaf is refused a
}
});
// ---- #1873 pi-unpin S4: the engine is the pi the lookup finds --------------
test("S4a: a stand-in pi with another version and every feature launches, and the claim records its version and digest", async () => {
const fx = fixture();
const pi = standInPi(join(fx.base, "pi"), { version: "7.4.2" });
const h = await started({ fx, pi: pi.found });
try {
assert.equal(h.launcher.launches.length, 1);
const fit = await piFit(pi.found, { levels: levels() });
assert.equal(fit.ok, true, fit.message);
const recorded = h.ctrl.claim.record.pins;
assert.equal(recorded.engineVersion, "7.4.2");
assert.equal(recorded.enginePin, fit.digest);
assert.match(recorded.enginePin, /^[0-9a-f]{64}$/);
} finally {
await h.close();
}
});
test("S4b: a stand-in pi whose --help lacks --mode rpc is refused engine-feature-missing with a plain line; nothing launches or is claimed", async () => {
const fx = fixture();
const pi = standInPi(join(fx.base, "pi"), { modes: ["text", "json"] });
const k = keysFor(fx, { pi: pi.found });
const { ctrl, launcher } = controllerFor(fx, { pi: pi.found });
try {
await assert.rejects(ctrl.start(), (e) => {
assert.equal(e.code, ENGINE_FEATURE_MISSING);
assert.equal(e.message, "pi 9.9.9 (MOSAIC_PI_BIN) lacks --mode rpc");
return true;
});
assert.equal(launcher.launches.length, 0);
assert.deepEqual([revisionTexts(k.store, k.seatK), revisionTexts(k.store, k.sessionK)], [[], []]);
} finally {
await ctrl.close().catch(() => {});
}
});
test("S4c: changed bytes in the pi between launch and resume refuse engine-pin-mismatch; the claim is unchanged", async () => {
const fx = fixture();
const pi = standInPi(join(fx.base, "pi"));
const first = await provenStop(fx, { pi: pi.found });
appendFileSync(pi.cli, "// one more line\n");
const k = keysFor(fx, { pi: pi.found });
const before = [revisionTexts(k.store, k.seatK), revisionTexts(k.store, k.sessionK)];
const { ctrl, launcher } = controllerFor(fx, { pi: piAt(pi.bin) });
try {
await assert.rejects(ctrl.start(), (e) => {
assert.equal(e.code, ENGINE_PIN_MISMATCH);
assert.equal(e.message, "the engine pin or launch argv changed since the proven stop");
return true;
});
assert.equal(launcher.launches.length, 0);
assert.deepEqual([revisionTexts(k.store, k.seatK), revisionTexts(k.store, k.sessionK)], before);
assert.equal(first.pins.engineVersion, "9.9.9");
} finally {
await ctrl.close().catch(() => {});
}
});
test("S4d: a pre-argument that is not the resolved bin's real file refuses unsealed-engine at bind, as does a bin link moved after construction", async () => {
const fx = fixture();
const pi = standInPi(join(fx.base, "pi"));
const make = () => new Controller({ fixtureRoot: fx.base, claimRoot: fx.claimRoot, socketDir: fx.socketDir, sessionFile: fx.sessionFile, seat: fx.seat, launcher: new FakeLauncher(), units: noUnits, timeouts: FAST, pi: pi.found });
{
const ctrl = make();
try {
assert.deepEqual(ctrl.engine.preArgs, [realpathSync(pi.cli)]);
// The repository's own pi, which the old pin accepted.
ctrl.engine.preArgs = [join(REPO_ROOT, "node_modules", PI_PACKAGE, "dist", "bundle", "cli.js")];
await assert.rejects(ctrl.start(), (e) => e.code === UNSEALED_ENGINE);
assert.equal(ctrl.launcher.launches.length, 0);
// The bin link itself, not its real file.
ctrl.engine.preArgs = [pi.bin];
await assert.rejects(ctrl.start(), (e) => e.code === UNSEALED_ENGINE);
assert.equal(ctrl.launcher.launches.length, 0);
} finally {
await ctrl.close().catch(() => {});
}
}
{
const ctrl = make();
const other = standInPi(join(fx.base, "pi-other"), { version: "1.0.0" });
try {
unlinkSync(pi.bin);
symlinkSync(other.cli, pi.bin);
await assert.rejects(ctrl.start(), (e) => e.code === UNSEALED_ENGINE);
assert.equal(ctrl.launcher.launches.length, 0);
} finally {
await ctrl.close().catch(() => {});
}
}
});
test("S4e: a claim made under the old pin record (npm's integrity in enginePin) refuses engine-pin-mismatch with the old-record line at every start of that session", async () => {
const fx = fixture();
const first = await provenStop(fx);
// Rewrite the stopped heads as a claim made before #1873 would hold them.
for (const { path, record } of claimRecords(fx)) {
if (record?.claimId !== first.claimId || record.state !== "stopped") continue;
const old = { ...record, pins: { ...record.pins, engineVersion: "0.85.1", enginePin: "sha512-FGRN+OHbWaefBPGaTggAdLjrIHW+s2PzLyglz/5dfLzb9of7uuXMXYC0fJIeZTw+shS32o2cuQ9jF7YSDuL/oQ==" } };
unlinkSync(path);
writeFileSync(path, JSON.stringify(old), { mode: 0o400 });
}
// Like any pin mismatch, the refusal holds at each start: the session's last
// proven stop is what a resume is checked against.
for (let i = 0; i < 2; i++) {
const { ctrl, launcher } = controllerFor(fx);
try {
await assert.rejects(ctrl.start(), (e) => {
assert.equal(e.code, ENGINE_PIN_MISMATCH);
assert.equal(e.message, OLD_PIN_LINE);
assert.match(e.message, /old pin record; start a new claim/);
return true;
});
assert.equal(launcher.launches.length, 0);
} finally {
await ctrl.close().catch(() => {});
}
}
});
test("S4f: a pi whose first line doesn't run node is refused engine-feature-missing, though the fit check passes it; #!/usr/bin/env node launches", async () => {
const fx = fixture();
// The sh form of the stand-in passes the fit check, which runs the bin as a
// program, but the engine runs the bin's real file with node.
const sh = standInPi(join(fx.base, "pi-sh"), { form: "sh" });
const fit = await piFit(sh.found, { levels: levels() });
assert.equal(fit.ok, true, fit.message);
const k = keysFor(fx, { pi: sh.found });
{
const { ctrl, launcher } = controllerFor(fx, { pi: sh.found });
try {
await assert.rejects(ctrl.start(), (e) => {
assert.equal(e.code, ENGINE_FEATURE_MISSING);
assert.equal(e.message, "MOSAIC_PI_BIN isn't a node script, and the engine runs pi with node");
return true;
});
assert.equal(launcher.launches.length, 0);
assert.deepEqual([revisionTexts(k.store, k.seatK), revisionTexts(k.store, k.sessionK)], [[], []]);
} finally {
await ctrl.close().catch(() => {});
}
}
// The node form with the shebang npm writes for pi.
const env = standInPi(join(fx.base, "pi-env"));
const text = readFileSync(env.cli, "utf8");
writeFileSync(env.cli, "#!/usr/bin/env node" + text.slice(text.indexOf("\n")));
const h = await started({ fx, pi: env.found });
try {
assert.equal(h.launcher.launches.length, 1);
assert.equal(h.launcher.launches[0].args[0], realpathSync(env.cli));
} finally {
await h.close();
}
});
test("S4g: a lookup answer that is no longer the lookup's refuses unsealed-engine: a package link moved since the lookup, a hand-built answer with another bin, one field changed by hand, a bin no package holds, or a getter; an answer that changes after construction changes nothing", async () => {
const fx = fixture();
const good = standInPi(join(fx.base, "pi-good"));
const lacking = standInPi(join(fx.base, "pi-lacking"), { modes: ["text", "json"] });
// A global prefix whose package directory is a link, as a version manager
// keeps it.
const prefix = join(fx.base, "prefix");
mkdirSync(join(prefix, "lib", "node_modules", "@earendil-works"), { recursive: true });
mkdirSync(join(prefix, "bin"));
const link = join(prefix, "lib", "node_modules", PI_PACKAGE);
symlinkSync(good.pkg, link);
const bin = join(prefix, "bin", "pi");
symlinkSync(`../lib/node_modules/${PI_PACKAGE}/dist/bundle/cli.js`, bin);
const found = piAt(bin);
assert.equal(found.bin, bin);
const make = (pi) => new Controller({ fixtureRoot: fx.base, claimRoot: fx.claimRoot, socketDir: fx.socketDir, sessionFile: fx.sessionFile, seat: fx.seat, launcher: new FakeLauncher(), units: noUnits, timeouts: FAST, pi });
const ctrl = make(found);
try {
unlinkSync(link);
symlinkSync(lacking.pkg, link);
// Built before the move: the start refuses.
await assert.rejects(ctrl.start(), (e) => {
assert.equal(e.code, UNSEALED_ENGINE);
assert.equal(e.message, "MOSAIC_PI_BIN no longer matches the lookup's answer; look the pi up again");
return true;
});
assert.equal(ctrl.launcher.launches.length, 0);
} finally {
await ctrl.close().catch(() => {});
}
// Built after the move, with the stale answer.
assert.throws(() => make(found), (e) => e.code === UNSEALED_ENGINE);
// An answer with a bin swapped in by hand.
assert.throws(() => make({ ...good.found, bin: lacking.bin }), (e) => e.code === UNSEALED_ENGINE);
assert.throws(() => make({ bin: good.bin, label: "MOSAIC_PI_BIN" }), (e) => e.code === UNSEALED_ENGINE);
// One field changed by hand at a time: the fit check would mount, run or
// digest another package than the launch runs.
for (const k of ["root", "dest", "view", "pkg"]) {
const value = k === "dest" ? lacking.found.root : lacking.found[k];
assert.throws(() => make({ ...good.found, [k]: value }), (e) => e.code === UNSEALED_ENGINE, k);
}
// The lacking pi's answer with the good package mounted over its path.
assert.throws(() => make({ ...lacking.found, root: good.found.root, dest: lacking.found.root }), (e) => e.code === UNSEALED_ENGINE);
// A bin the lookup no longer takes (no package holds it) refuses when the
// controller is built.
const loose = join(fx.base, "loose-pi");
writeFileSync(loose, "#!/usr/bin/env node\n", { mode: 0o755 });
assert.throws(() => make({ bin: loose, label: "MOSAIC_PI_BIN" }), (e) => e.code === UNSEALED_ENGINE);
// A getter is not a data field: the copy the controller keeps lacks it.
assert.throws(() => make({ ...good.found, get view() { return good.found.view; } }), (e) => e.code === UNSEALED_ENGINE);
// An answer that changes after the controller is built changes nothing: it
// keeps a frozen plain copy, and the start checks and launches the good pi.
let flipped = false;
const live = new Proxy({ ...good.found }, {
get: (t, k) => (flipped && k in lacking.found ? lacking.found[k] : t[k]),
getOwnPropertyDescriptor: (t, k) => {
const d = Reflect.getOwnPropertyDescriptor(t, k);
return d && flipped && k in lacking.found ? { ...d, value: lacking.found[k] } : d;
},
});
const { ctrl: kept, launcher: keptLauncher } = controllerFor(fx, { pi: live });
try {
flipped = true;
assert.ok(Object.isFrozen(kept.pi));
assert.equal(utilTypes.isProxy(kept.pi), false);
assert.deepEqual(kept.pi, good.found);
await kept.start();
assert.equal(keptLauncher.launches.length, 1);
assert.equal(keptLauncher.launches[0].args[0], realpathSync(good.cli));
} finally {
await kept.close({ killEngine: true }).catch(() => {});
}
// The answer as the lookup gives it still builds.
await make(piAt(good.bin)).close();
});
test("S4h: a first line the kernel and node read differently refuses engine-feature-missing: an absolute node that isn't the engine's, a first line past 256 bytes, a CR before the newline, under env a node from the package, a node the fit check's sandbox can't see ahead of the first it can (even a link to the engine's node), an empty, relative or unplain entry before the first node, one in /proc or /dev, one that can't be checked, or a first shown node that isn't the engine's; the engine's own directory first launches, and a label that isn't the lookup's kind reads \"the pi\", in the fit check's line too; a lookup's problem line shows, a hand-built one with a path or a newline doesn't", async () => {
const fx = fixture();
const refused = async (pi, message, f = fx) => {
const { ctrl, launcher } = controllerFor(f, { pi });
try {
await assert.rejects(ctrl.start(), (e) => {
assert.equal(e.code, ENGINE_FEATURE_MISSING);
assert.equal(e.message, message);
return true;
});
assert.equal(launcher.launches.length, 0);
} finally {
await ctrl.close().catch(() => {});
}
};
const withFirstLine = (name, line) => {
const pi = standInPi(join(fx.base, name));
const text = readFileSync(pi.cli, "utf8");
writeFileSync(pi.cli, line + text.slice(text.indexOf("\n")));
return pi;
};
// A program named node in the package that runs another program: here the
// real node, so the fit check passes it.
const shim = standInPi(join(fx.base, "pi-shim"));
const fakeNode = join(dirname(shim.cli), "node");
writeFileSync(fakeNode, `#!/bin/sh\nexec ${process.execPath} "$@"\n`, { mode: 0o755 });
const shimText = readFileSync(shim.cli, "utf8");
writeFileSync(shim.cli, `#!${fakeNode}` + shimText.slice(shimText.indexOf("\n")));
const fit = await piFit(shim.found, { levels: levels() });
assert.equal(fit.ok, true, fit.message);
await refused(shim.found, "MOSAIC_PI_BIN's first line runs another node than the engine's");
// The kernel reads 256 bytes for the first line; this one ends past them.
const long = withFirstLine("pi-long", "#!/usr/bin/env node" + " ".repeat(260));
await refused(long.found, "MOSAIC_PI_BIN isn't a node script, and the engine runs pi with node");
// The kernel looks for a program named with the CR.
const cr = withFirstLine("pi-cr", "#!/usr/bin/env node\r");
await refused(cr.found, "MOSAIC_PI_BIN isn't a node script, and the engine runs pi with node");
// A link to the engine's own node is the same file.
const linked = standInPi(join(fx.base, "pi-linked"));
const nodeLink = join(dirname(linked.cli), "node");
symlinkSync(process.execPath, nodeLink);
const linkedText = readFileSync(linked.cli, "utf8");
writeFileSync(linked.cli, `#!${nodeLink}` + linkedText.slice(linkedText.indexOf("\n")));
const h = await started({ fx, pi: linked.found });
try {
assert.equal(h.launcher.launches.length, 1);
assert.equal(h.launcher.launches[0].args[0], realpathSync(linked.cli));
} finally {
await h.close();
}
// #!/usr/bin/env node takes node from the fit check's PATH, which is this
// process's PATH behind the repository's .bin.
const envPi = withFirstLine("pi-env-path", "#!/usr/bin/env node");
const fx2 = fixture();
const onPath = async (dir, fn) => {
const saved = process.env.PATH;
process.env.PATH = `${dir}:${saved}`;
try {
await fn();
} finally {
process.env.PATH = saved;
}
};
// A node in the package itself, put on PATH.
const pkgBin = join(envPi.pkg, "bin");
mkdirSync(pkgBin);
writeFileSync(join(pkgBin, "node"), `#!/bin/sh\nexec ${process.execPath} "$@"\n`, { mode: 0o755 });
await onPath(pkgBin, () => refused(envPi.found, "MOSAIC_PI_BIN's package puts a node on the fit check's PATH", fx2));
// The fit check's sandbox shows only /usr, /etc, the host's /bin, /lib,
// /lib64 and /sbin, and the engine's own node file. A node in any other
// directory ahead of the engine's: env in the sandbox would pass it by,
// while the host finds it first. Even a link to the engine's node.
const otherBin = join(fx.base, "other-bin");
mkdirSync(otherBin);
writeFileSync(join(otherBin, "node"), `#!/bin/sh\nexec ${process.execPath} "$@"\n`, { mode: 0o755 });
const hidden = "MOSAIC_PI_BIN's first line runs node from the fit check's PATH, where a node the fit check can't see comes first";
await onPath(otherBin, () => refused(envPi.found, hidden, fx2));
const linkBin = join(fx.base, "link-bin");
mkdirSync(linkBin);
symlinkSync(process.execPath, join(linkBin, "node"));
await onPath(linkBin, () => refused(envPi.found, hidden, fx2));
// env reads an empty or relative entry against the fit check's directory.
const relative = "MOSAIC_PI_BIN's first line runs node from the fit check's PATH, which has an empty or relative entry";
await onPath("", () => refused(envPi.found, relative, fx2));
await onPath("some/bin", () => refused(envPi.found, relative, fx2));
// Up to the first node, an entry must read the same in the sandbox as on
// the host. A ".." after a link goes where the link points, not where the
// text does.
symlinkSync("/usr/lib", join(fx.base, "sys"));
await onPath(`${fx.base}/sys/../bin`, () => refused(envPi.found, "MOSAIC_PI_BIN's first line runs node from the fit check's PATH, which has an entry that isn't in plain form", fx2));
// The sandbox makes its own /proc and /dev: pid 1 there is its own, and a
// link into /proc counts too, even past a pid the host lacks.
const ownCopy = "MOSAIC_PI_BIN's first line runs node from the fit check's PATH, which has an entry the fit check's sandbox has its own copy of";
await onPath("/proc/1/root/usr/bin", () => refused(envPi.found, ownCopy, fx2));
await onPath("/dev/mosaic-no-such-dir", () => refused(envPi.found, ownCopy, fx2));
symlinkSync("/proc", join(fx.base, "p"));
await onPath(`${fx.base}/p/999999999/root/usr/bin`, () => refused(envPi.found, ownCopy, fx2));
// A node link that leads nowhere on the host can't be checked: what the
// sandbox finds at its target need not be what the host lacks there.
const dangling = join(fx.base, "dangling-bin");
mkdirSync(dangling);
symlinkSync("/tmp/mosaic-no-such-dir/node", join(dangling, "node"));
await onPath(dangling, () => refused(envPi.found, "MOSAIC_PI_BIN's first line runs node from the fit check's PATH, where a node can't be checked", fx2));
// An entry the host can't read can't be checked.
const locked = join(fx.base, "locked");
mkdirSync(join(locked, "bin"), { recursive: true });
chmodSync(locked, 0o000);
try {
await onPath(join(locked, "bin"), () => refused(envPi.found, "MOSAIC_PI_BIN's first line runs node from the fit check's PATH, where an entry can't be checked", fx2));
} finally {
chmodSync(locked, 0o755);
}
// The first node the sandbox shows must be the engine's: no node at all
// isn't, and neither is a system node that is another file.
const notEngine = "MOSAIC_PI_BIN's first line runs the first node on the fit check's PATH, which isn't the engine's";
const withPath = async (path, fn) => {
const saved = process.env.PATH;
process.env.PATH = path;
try {
await fn();
} finally {
process.env.PATH = saved;
}
};
await withPath("/usr/share", () => refused(envPi.found, notEngine, fx2));
const systemNode = ["/usr/bin/node", "/usr/local/bin/node"].find((n) => {
try {
return realpathSync(n) !== realpathSync(process.execPath);
} catch {
return false;
}
});
if (systemNode) await withPath(`${dirname(systemNode)}:${dirname(process.execPath)}`, () => refused(envPi.found, notEngine, fx2));
// The engine's own directory first: the sandbox shows that file at the same
// path, so env runs the engine's node in both.
// Entries after it are never read, so a trailing slash on it and an empty
// entry at the end change nothing. The sandbox's /tmp starts empty, so a
// /tmp entry with no node on the host holds none there either.
await withPath(`/tmp/mosaic-no-such-dir:${dirname(process.execPath)}/:/usr/bin:/bin:`, async () => {
const h2 = await started({ fx: fx2, pi: envPi.found });
try {
assert.equal(h2.launcher.launches.length, 1);
assert.equal(h2.launcher.launches[0].args[0], realpathSync(envPi.cli));
} finally {
await h2.close();
}
});
// A hand-built label that is a path never reaches a refusal line.
await refused({ ...shim.found, label: join(fx.base, "named") }, "the pi's first line runs another node than the engine's");
await refused({ ...shim.found, label: "MOSAIC_PI_BIN\nrefused: forged" }, "the pi's first line runs another node than the engine's");
// Nor the fit check's own line.
const lacking = standInPi(join(fx.base, "pi-lacking"), { modes: ["text", "json"] });
await refused({ ...lacking.found, label: join(fx.base, "named") }, "pi 9.9.9 (the pi) lacks --mode rpc");
// A lookup that found no pi refuses when the controller is built: its own
// line, which names the step and the package, never a path; a hand-built
// line with a path or a newline isn't shown.
const unbuilt = (pi, message) =>
assert.throws(() => controllerFor(fx, { pi }), (e) => {
assert.equal(e.code, ENGINE_FEATURE_MISSING);
assert.equal(e.message, message);
return true;
});
unbuilt(piAt("relative/pi"), "MOSAIC_PI_BIN isn't an executable file at an absolute path");
const loose = join(fx.base, "loose-pi");
writeFileSync(loose, "#!/usr/bin/env node\n", { mode: 0o755 });
unbuilt(piAt(loose), `MOSAIC_PI_BIN isn't part of the ${PI_PACKAGE} package`);
unbuilt({ bin: null, problem: `${fx.base} has no pi` }, "the pi lookup gave no binary");
unbuilt({ bin: null, problem: "no pi\nrefused: forged" }, "the pi lookup gave no binary");
unbuilt({ bin: null, problem: "no pi\u2028refused: forged" }, "the pi lookup gave no binary");
unbuilt({ bin: null, problem: "no pi\u0085refused: forged" }, "the pi lookup gave no binary");
});
// ---- W11, W16, W17 ----------------------------------------------------------
test("W11: the controller writes no session file; only the fake engine's own appends appear", async () => {
+14 -22
View File
@@ -9,17 +9,17 @@
import { test, after } from "node:test";
import assert from "node:assert/strict";
import { appendFileSync, chmodSync, copyFileSync, mkdirSync, readFileSync, renameSync, rmdirSync, writeFileSync } from "node:fs";
import { appendFileSync, chmodSync, mkdirSync, readFileSync, renameSync, rmdirSync, writeFileSync } from "node:fs";
import { spawn, spawnSync } from "node:child_process";
import { dirname, join } from "node:path";
import { ClaimStore, FOREIGN_HOST, defaultHost, newClaimId, unitNameFor } from "../src/claim.mjs";
import { ConversationClient } from "../src/client.mjs";
import { AUTHORITY, PgroupLauncher, ScopeLauncher, engineExitCohort, forceStopCohort, releaseCohort, scopeAvailable, shimRequest, systemctlShow, systemdUnits } from "../src/cohort.mjs";
import { Controller, ELIGIBILITY, TEST_ENGINE } from "../src/controller.mjs";
import { ENGINE_ENV, ENGINE_PIN_MISMATCH, engineEnv } from "../src/pi-pin.mjs";
import { ENGINE_ENV, ENGINE_PIN_MISMATCH, engineEnv } from "../src/pi-seal.mjs";
import { FixtureVerifier, newId } from "../src/records.mjs";
import { ControlClient, FakeLauncher } from "./fake-pi.mjs";
import { FAST, REPO, assistantEntry, claimRecords, cleanupAll, controllerFor, fixture, killChildren, killShims, liveShims, noUnits, reap, receiptState, shimsGone, spawnController, started, tick } from "./harness.mjs";
import { FAST, PI, assistantEntry, claimRecords, cleanupAll, controllerFor, fixture, killChildren, killShims, liveShims, noUnits, reap, receiptState, shimsGone, spawnController, standInPi, started, tick } from "./harness.mjs";
const reaped = [];
const strays = new Set();
@@ -111,7 +111,7 @@ async function live({ kind = "scope", barrier = null, verifier = new FixtureVeri
fixtureRoot: fx.base, claimRoot: fx.claimRoot, socketDir: fx.socketDir, sessionFile: fx.sessionFile, seat: fx.seat,
launcher: launcher ?? (kind === "scope" ? new ScopeLauncher() : new PgroupLauncher()),
engine: { cwd: fx.proj }, [TEST_ENGINE]: { command: process.execPath, preArgs: [FAKE_PI], env: { ...process.env, FAKE_PI_CONTROL: control, FAKE_PI_LOG: join(fx.base, "fake.log") } },
verifier, units: kind === "scope" ? systemdUnits : noUnits, timeouts, barrier,
verifier, units: kind === "scope" ? systemdUnits : noUnits, timeouts, barrier, pi: PI.found,
});
await ctrl.start();
assert.equal(ctrl.binding.state, "active", JSON.stringify(ctrl.evidence.uncertain));
@@ -532,14 +532,6 @@ async function provenStop(h, c = h.client) {
return fs.stop.id;
}
function pinRootCopy(fx) {
const root = join(fx.base, "pins");
mkdirSync(join(root, "node_modules"), { recursive: true });
copyFileSync(join(REPO, "package-lock.json"), join(root, "package-lock.json"));
copyFileSync(join(REPO, "node_modules", ".package-lock.json"), join(root, "node_modules", ".package-lock.json"));
return root;
}
test("K6: recover without proof, without confirmation, or with changed pins is refused", async () => {
{
const h = await started();
@@ -562,8 +554,8 @@ test("K6: recover without proof, without confirmation, or with changed pins is r
}
{
const fx = track(fixture());
const pinRoot = pinRootCopy(fx);
const h = await started({ fx, pinRoot });
const pi = standInPi(join(fx.base, "pi"));
const h = await started({ fx, pi: pi.found });
try {
const stop = await provenStop(h);
const missing = await h.client.request("recover", { stop });
@@ -574,13 +566,13 @@ test("K6: recover without proof, without confirmation, or with changed pins is r
const id = issued.data.confirmation.id;
await h.client.request("answer-confirmation", { confirmation: id, answer: "confirm" });
assert.equal((await h.client.request("recover", { stop, confirmation: id })).refusal, "confirmation", "a confirmation for another operation");
const lock = join(pinRoot, "package-lock.json");
const original = readFileSync(lock, "utf8");
const changed = JSON.parse(original);
changed.packages["node_modules/@earendil-works/pi-coding-agent"].version = "0.0.0";
writeFileSync(lock, JSON.stringify(changed));
assert.equal((await h.client.confirmed("recover", { stop })).refusal, ENGINE_PIN_MISMATCH);
writeFileSync(lock, original);
// Other bytes in the pi the lookup finds, then the same bytes again.
const original = readFileSync(pi.cli, "utf8");
writeFileSync(pi.cli, `${original}// other bytes\n`);
const changed = await h.client.confirmed("recover", { stop });
assert.equal(changed.refusal, ENGINE_PIN_MISMATCH);
assert.equal(changed.detail, "the engine pin or launch argv changed since the proven stop");
writeFileSync(pi.cli, original);
const again = await h.client.request("issue-confirmation", { operationToConfirm: "recover" });
const once = again.data.confirmation.id;
await h.client.request("answer-confirmation", { confirmation: once, answer: "confirm" });
@@ -1177,7 +1169,7 @@ function scopeController(fx, { host, verifier = new FixtureVerifier({ authoritie
fixtureRoot: fx.base, claimRoot: fx.claimRoot, socketDir: fx.socketDir, sessionFile: fx.sessionFile, seat: fx.seat,
launcher, engine: { cwd: fx.proj },
[TEST_ENGINE]: { command: process.execPath, preArgs: [FAKE_PI], env: { ...process.env, FAKE_PI_CONTROL: join(fx.base, "fake-b.sock"), FAKE_PI_LOG: join(fx.base, "fake-b.log") } },
verifier, units: systemdUnits, timeouts: FAST, barrier, host,
verifier, units: systemdUnits, timeouts: FAST, barrier, host, pi: PI.found,
});
}
+2 -1
View File
@@ -20,6 +20,7 @@ import { Controller, TEST_ENGINE } from "../src/controller.mjs";
import { AUTHORITY, PgroupLauncher, ScopeLauncher, systemdUnits } from "../src/cohort.mjs";
import { FixtureVerifier } from "../src/records.mjs";
import { defaultHost } from "../src/claim.mjs";
import { locate } from "../../plugins/harness/pi/binary.mjs";
const cfg = JSON.parse(process.argv[2]);
const out = (v) => process.stdout.write(JSON.stringify(v) + "\n");
@@ -79,7 +80,7 @@ try {
engine: { cwd: fx.proj }, [TEST_ENGINE]: { command: process.execPath, preArgs: [fakePi], env: { ...process.env, ...(cfg.fakeEnv ?? {}) } },
verifier: cfg.verifier === false ? null : new FixtureVerifier({ authorities: [AUTHORITY] }),
units: cfg.units === "absent" ? { lookup: async () => ({ state: "absent" }) } : systemdUnits,
host, barrier, timeouts: cfg.timeouts,
host, barrier, timeouts: cfg.timeouts, pi: locate({ MOSAIC_PI_BIN: cfg.piBin, PATH: "/usr/bin:/bin" }),
});
const started = await ctrl.start();
out({ ready: true, started, socketPath: ctrl.socketPath, incarnation: ctrl.incarnation, pid: process.pid, binding: ctrl.binding, claim: ctrl.claim ? { claimId: ctrl.claim.claimId, record: ctrl.claim.record } : null });
+26 -3
View File
@@ -2,7 +2,7 @@
// directory: fixture root, project, session file, claim root and socket
// directory. Nothing here touches a live session.
import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, rmSync } from "node:fs";
import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, rmSync, symlinkSync } from "node:fs";
import { tmpdir } from "node:os";
import { join, resolve } from "node:path";
import { spawnSync } from "node:child_process";
@@ -11,6 +11,8 @@ import { ConversationClient } from "../src/client.mjs";
import { AUTHORITY } from "../src/cohort.mjs";
import { FixtureVerifier } from "../src/records.mjs";
import { FakeLauncher } from "./fake-pi.mjs";
import { piStandIn } from "../../harness/tests/pi-stand-in.mjs";
import { locate } from "../../plugins/harness/pi/binary.mjs";
export const REPO = resolve(import.meta.dirname, "..", "..", "..");
export const SESSION_ID = "0f5e1c2a-1111-4222-8333-944455556666";
@@ -20,6 +22,27 @@ export const time = (i) => new Date(Date.UTC(2026, 9, 4, 12, 0, 0) + i * 1000).t
const tmp = mkdtempSync(join(tmpdir(), "chat03-"));
let serial = 0;
// #1873 S4: a stand-in pi package (packages/harness/tests/pi-stand-in.mjs,
// which the fit check passes unless its knobs say otherwise) under `dir`,
// with an npm-style bin link. `found` is the lookup's answer for it, through
// MOSAIC_PI_BIN. The test engine still launches fake-pi.mjs; the stand-in is
// what the controller's fit check and pins read.
export const PI_PACKAGE = "@earendil-works/pi-coding-agent";
export function standInPi(dir, knobs = {}) {
const pkg = join(dir, "prefix", "lib", "node_modules", PI_PACKAGE);
mkdirSync(join(pkg, "dist", "bundle"), { recursive: true });
writeFileSync(join(pkg, "package.json"), JSON.stringify({ name: PI_PACKAGE, version: knobs.version ?? "9.9.9", bin: { pi: "dist/bundle/cli.js" } }));
const cli = join(pkg, "dist", "bundle", "cli.js");
writeFileSync(cli, piStandIn(knobs, { form: knobs.form ?? "node" }), { mode: 0o755 });
mkdirSync(join(dir, "prefix", "bin"));
const bin = join(dir, "prefix", "bin", "pi");
symlinkSync(`../lib/node_modules/${PI_PACKAGE}/dist/bundle/cli.js`, bin);
return { bin, cli, pkg, found: piAt(bin) };
}
export const piAt = (bin) => locate({ MOSAIC_PI_BIN: bin, PATH: "/usr/bin:/bin" });
// The pi every fixture controller checks unless a test passes its own.
export const PI = standInPi(join(tmp, "pi"));
export function cleanupAll() {
spawnSync("chmod", ["-R", "u+rwx", tmp]);
rmSync(tmp, { recursive: true, force: true });
@@ -51,7 +74,7 @@ export const noUnits = Object.freeze({ lookup: async () => ({ state: "absent" })
export function controllerFor(fx, { launcher = new FakeLauncher(), verifier = new FixtureVerifier({ authorities: [AUTHORITY] }), timeouts = FAST, ...opts } = {}) {
const ctrl = new Controller({
fixtureRoot: fx.base, claimRoot: fx.claimRoot, socketDir: fx.socketDir, sessionFile: fx.sessionFile, seat: fx.seat,
launcher, verifier, units: noUnits, timeouts, ...opts,
launcher, verifier, units: noUnits, timeouts, pi: PI.found, ...opts,
});
return { ctrl, launcher, verifier };
}
@@ -118,7 +141,7 @@ export function killChildren() {
// Spawns ctrl-child.mjs. `msgs` collects its JSON lines; `next(pred)` waits
// for one.
export function spawnController(cfg) {
const proc = spawn(process.execPath, [CHILD, JSON.stringify({ timeouts: FAST, ...cfg })], { stdio: ["pipe", "pipe", "pipe"] });
const proc = spawn(process.execPath, [CHILD, JSON.stringify({ timeouts: FAST, piBin: PI.bin, ...cfg })], { stdio: ["pipe", "pipe", "pipe"] });
childPids.add(proc.pid);
const msgs = [];
const waiters = new Set();
+26 -14
View File
@@ -1,8 +1,8 @@
// CHAT-03 (#1507): the pinned Pi binary, started sealed in a scratch home with
// CHAT-03 (#1507): the repository's Pi binary, started sealed in a scratch home with
// no credentials, answers the RPC commands the controller sends with the
// shapes the fake engine models. No prompt is sent, so no model is called.
//
// It also records pinned Pi's startup append (sdk.js 240–252): a session
// It also records Pi 0.85.1's startup append (sdk.js 240–252): a session
// whose branch has no thinking_level_change entry gains one at every start,
// so the leaf moves after launch and the K8 load check fails closed on it.
//
@@ -16,9 +16,15 @@ import { tmpdir } from "node:os";
import { join } from "node:path";
import { PassThrough } from "node:stream";
import { LineSplitter, encodeLine } from "../src/framing.mjs";
import { PI_BIN, PI_VERSION, buildPiArgs, checkEnginePin, checkSeal } from "../src/pi-pin.mjs";
import { buildPiArgs, checkSeal } from "../src/pi-seal.mjs";
import { piFit } from "../../harness/src/pi-fit.mjs";
import { locate } from "../../plugins/harness/pi/binary.mjs";
import { levels } from "../../plugins/harness/pi/index.mjs";
import { FakePi } from "./fake-pi.mjs";
import { REPO, assistantEntry, header, thinkingEntry, userEntry } from "./harness.mjs";
import { assistantEntry, header, thinkingEntry, userEntry } from "./harness.mjs";
// The repository's pi: with no MOSAIC_PI_BIN and no PATH the lookup ends there.
const REPO_PI = locate({});
const scratch = mkdtempSync(join(tmpdir(), "chat03-smoke-"));
after(() => rmSync(scratch, { recursive: true, force: true }));
@@ -90,9 +96,11 @@ async function realPi(tag, sessionFile, { project = "proj", trusted = null, afte
assert.equal(existsSync(join(home, ".pi", "agent", "auth.json")), false);
assert.deepEqual(readdirSync(agent), [], "the agent dir starts empty");
if (trusted) writeFileSync(join(agent, "trust.json"), JSON.stringify({ [realpathSync(join(scratch, trusted))]: true }));
const args = buildPiArgs({ sessionFile });
checkSeal(args);
const pi = spawn(process.execPath, [join(REPO, PI_BIN), ...args, ...after], { cwd: join(scratch, project), env, stdio: ["pipe", "pipe", "pipe"] });
const fit = await piFit(REPO_PI, { levels: levels() });
assert.equal(fit.ok, true, fit.message);
const args = buildPiArgs({ sessionFile, noMcp: fit.noMcp });
checkSeal(args, { noMcp: fit.noMcp });
const pi = spawn(process.execPath, [realpathSync(REPO_PI.bin), ...args, ...after], { cwd: join(scratch, project), env, stdio: ["pipe", "pipe", "pipe"] });
let stderr = "";
pi.stderr.on("data", (c) => (stderr += c));
const exited = new Promise((r) => pi.on("exit", (code, signal) => r({ code, signal })));
@@ -118,11 +126,15 @@ function fakePi(sessionFile) {
const lastId = (file) => JSON.parse(readFileSync(file, "utf8").trim().split("\n").at(-1)).id;
const typesOf = (data) => Object.fromEntries(Object.entries(data ?? {}).map(([k, v]) => [k, v === null ? "null" : Array.isArray(v) ? "array" : typeof v]));
test("the engine pin holds for the installed package", () => {
assert.deepEqual(checkEnginePin(REPO).version, PI_VERSION);
test("the repository's pi passes the fit check and gives a version and a digest", async () => {
assert.equal(REPO_PI.label, "the repository's pi");
const fit = await piFit(REPO_PI, { levels: levels() });
assert.equal(fit.ok, true, fit.message);
assert.equal(fit.version, "0.85.1");
assert.match(fit.digest, /^[0-9a-f]{64}$/);
});
test("pinned Pi, sealed and without credentials, answers the controller's commands with the shapes the fake models", async () => {
test("the repository's Pi, sealed and without credentials, answers the controller's commands with the shapes the fake models", async () => {
const entries = [thinkingEntry(), userEntry("a1b2c3d4", "f0e1d2c3", "hello"), assistantEntry("b2c3d4e5", "a1b2c3d4", "hi")];
const realFile = session("real.jsonl", entries);
const fakeFile = session("fake.jsonl", entries);
@@ -155,7 +167,7 @@ test("pinned Pi, sealed and without credentials, answers the controller's comman
assert.equal(r.command, f.command, type);
assert.equal(r.success, f.success, type);
const rt = typesOf(r.data), ft = typesOf(f.data);
for (const [k, t] of Object.entries(ft)) assert.equal(rt[k], t, `${type}.${k}: the fake models a field pinned Pi doesn't send that way`);
for (const [k, t] of Object.entries(ft)) assert.equal(rt[k], t, `${type}.${k}: the fake models a field the repository's Pi doesn't send that way`);
}
// clear_queue: one queue_update with both queues empty precedes the response, in both.
for (const side of [real, fake]) {
@@ -165,7 +177,7 @@ test("pinned Pi, sealed and without credentials, answers the controller's comman
}
});
test("sealed, pinned Pi ignores a trusted project's .pi resources; --approve past the seal would load them, and checkSeal refuses it (Filbert F2 on #1522)", async () => {
test("sealed Pi ignores a trusted project's .pi resources; --approve past the seal would load them, and checkSeal refuses it (Filbert F2 on #1522)", async () => {
const skill = join(scratch, "trusted", ".pi", "skills", "probe");
mkdirSync(skill, { recursive: true });
writeFileSync(join(skill, "SKILL.md"), "---\nname: probe\ndescription: A project skill that only a trusted load offers.\n---\nprobe\n");
@@ -183,7 +195,7 @@ test("sealed, pinned Pi ignores a trusted project's .pi resources; --approve pas
}
});
test("pinned Pi appends thinking_level_change at start when the branch lacks one, so the leaf moves (K8 then fails closed)", async () => {
test("the repository's Pi appends thinking_level_change at start when the branch lacks one, so the leaf moves (K8 then fails closed)", async () => {
const entries = [userEntry("a1b2c3d4", null, "hello"), assistantEntry("b2c3d4e5", "a1b2c3d4", "hi")];
const realFile = session("bare-real.jsonl", entries);
const fakeFile = session("bare-fake.jsonl", entries);
@@ -197,5 +209,5 @@ test("pinned Pi appends thinking_level_change at start when the branch lacks one
assert.notEqual(side.responses.get_tree.data.leafId, "b2c3d4e5", "the leaf moved off the loaded leaf");
assert.equal(side.responses.get_tree.data.leafId, added[0].id);
}
if (process.env.CHAT03_SMOKE_OUT) writeFileSync(process.env.CHAT03_SMOKE_OUT, JSON.stringify({ pi: PI_VERSION, commands: COMMANDS, exchanges }, null, 2) + "\n");
if (process.env.CHAT03_SMOKE_OUT) writeFileSync(process.env.CHAT03_SMOKE_OUT, JSON.stringify({ pi: (await piFit(REPO_PI, { levels: levels() })).version, commands: COMMANDS, exchanges }, null, 2) + "\n");
});
+49 -6
View File
@@ -5,14 +5,16 @@
import { test, after } from "node:test";
import assert from "node:assert/strict";
import { PassThrough } from "node:stream";
import { realpathSync } from "node:fs";
import { join } from "node:path";
import { Controller, TEST_ENGINE, REPO_ROOT, HANDLED_WITHOUT_RUN, ACK_WITHOUT_START, NO_TURN, RUN_OVERLAP, TRANSPORT_UNKNOWN } from "../src/controller.mjs";
import { AUTHORITY } from "../src/cohort.mjs";
import { FixtureVerifier, sha256 } from "../src/records.mjs";
import { ENGINE_ENV, PI_BIN, SEAL_FLAGS, UNSEALED_ENGINE, checkSeal } from "../src/pi-pin.mjs";
import { ENGINE_ENV, SEAL_FLAGS, UNSEALED_ENGINE, checkSeal } from "../src/pi-seal.mjs";
import { locate } from "../../plugins/harness/pi/binary.mjs";
import { LineSplitter, encodeLine, parseLine } from "../src/framing.mjs";
import { BUSY_ERROR, FakeLauncher, FakePi } from "./fake-pi.mjs";
import { fixture, started, receiptState, outcomeUnknownPush, sessionText, cleanupAll, tick, noUnits, FAST } from "./harness.mjs";
import { fixture, started, receiptState, outcomeUnknownPush, sessionText, cleanupAll, tick, noUnits, FAST, PI, PI_PACKAGE, standInPi } from "./harness.mjs";
after(() => cleanupAll());
@@ -982,12 +984,38 @@ test("N24: the seal is an allow-list: --extension, a missing --no-* flag, a seco
}
});
test("N24c: when --help lists --no-mcp the launch passes it after the seal flags, and the seal then requires it (#1873 S4)", async () => {
const fx = fixture();
const pi = standInPi(join(fx.base, "pi"), { extraFlags: ["--no-mcp"] });
const h = await started({ fx, pi: pi.found });
try {
const args = h.launcher.launches[0].args.slice(1);
assert.deepEqual(args.slice(0, SEAL_FLAGS.length + 5), ["--mode", "rpc", ...SEAL_FLAGS, "--no-mcp", "--session", fx.sessionFile]);
assert.equal(h.ctrl.noMcp, true);
assert.equal(checkSeal(args, { noMcp: true }), true);
const without = args.filter((a) => a !== "--no-mcp");
assert.throws(() => checkSeal(without, { noMcp: true }), (e) => e.code === UNSEALED_ENGINE);
assert.throws(() => checkSeal(args), (e) => e.code === UNSEALED_ENGINE, "--no-mcp where help lacks it");
} finally {
await h.close();
}
// The shared stand-in's help lacks --no-mcp, so its launch has none.
const plain = await started({ fx: fixture() });
try {
assert.equal(plain.launcher.launches[0].args.includes("--no-mcp"), false);
assert.equal(plain.ctrl.noMcp, false);
} finally {
await plain.close();
}
});
test("N24b: the seal covers the engine command and environment: config can't name either, the env is built from names, and a mutated command is refused at bind", async () => {
const fx = fixture();
const make = (extra) => new Controller({ fixtureRoot: fx.base, claimRoot: fx.claimRoot, socketDir: fx.socketDir, sessionFile: fx.sessionFile, seat: fx.seat, launcher: new FakeLauncher(), units: noUnits, timeouts: FAST, ...extra });
// The plain engine option takes extraArgs, cwd and envKeys; the command,
// pre-arguments and environment are the controller's (I3, #1507).
for (const engine of [{ command: "/bin/sh" }, { preArgs: [join(REPO_ROOT, PI_BIN)] }, { command: process.execPath, preArgs: [join(REPO_ROOT, PI_BIN), "--extension", "x"] }, { env: {} }, { env: process.env }, null, [], "pi"]) {
const repoCli = join(REPO_ROOT, "node_modules", PI_PACKAGE, "dist", "bundle", "cli.js");
for (const engine of [{ command: "/bin/sh" }, { preArgs: [repoCli] }, { command: process.execPath, preArgs: [repoCli, "--extension", "x"] }, { env: {} }, { env: process.env }, null, [], "pi"]) {
assert.throws(() => make({ engine }), (e) => e.code === UNSEALED_ENGINE, JSON.stringify(engine));
}
// A configuration is JSON, which can't carry the symbol-keyed test engine.
@@ -1001,7 +1029,7 @@ test("N24b: the seal covers the engine command and environment: config can't nam
assert.throws(() => make({ [TEST_ENGINE]: { command: process.execPath, preArgs: ["fake.mjs", "-e", "x"], env: {} } }), (e) => e.code === UNSEALED_ENGINE);
assert.throws(() => make({ [TEST_ENGINE]: { command: "", preArgs: [], env: {} } }), (e) => e.code === UNSEALED_ENGINE);
// The launch: this Node, the pinned bin, and an environment of named keys
// The launch: this Node, the real file of the pi the lookup found, and an environment of named keys
// only, whatever the controller's own environment holds.
const planted = { NODE_OPTIONS: "--require /tmp/x.cjs", LD_PRELOAD: "/tmp/x.so", PI_PACKAGE_DIR: "/tmp/pkg", ZAI_API_KEY: "zai-test-value", OTHER_API_KEY: "other-test-value" };
const saved = Object.fromEntries(Object.keys(planted).map((k) => [k, process.env[k]]));
@@ -1015,7 +1043,8 @@ test("N24b: the seal covers the engine command and environment: config can't nam
try {
const l = h.launcher.launches[0];
assert.equal(l.command, process.execPath);
assert.equal(l.args[0], join(REPO_ROOT, PI_BIN));
assert.equal(l.args[0], realpathSync(PI.bin));
assert.equal(l.args[0], h.ctrl.engine.preArgs[0]);
assert.equal(l.env.ZAI_API_KEY, "zai-test-value");
for (const k of Object.keys(l.env)) assert.ok(ENGINE_ENV.includes(k) || k === "ZAI_API_KEY", k);
for (const k of ["NODE_OPTIONS", "LD_PRELOAD", "PI_PACKAGE_DIR", "OTHER_API_KEY"]) assert.equal(k in l.env, false, k);
@@ -1027,7 +1056,21 @@ test("N24b: the seal covers the engine command and environment: config can't nam
// A command changed after construction is refused at bind; nothing launches.
const fx2 = fixture();
const launcher = new FakeLauncher();
const ctrl = new Controller({ fixtureRoot: fx2.base, claimRoot: fx2.claimRoot, socketDir: fx2.socketDir, sessionFile: fx2.sessionFile, seat: fx2.seat, launcher, units: noUnits, timeouts: FAST });
// With no pi option the controller takes the one the lookup finds in its own
// environment, read when it is built (#1873 S4): here MOSAIC_PI_BIN names a
// stand-in, which no other step of the lookup would find.
const own = standInPi(join(fx2.base, "env-pi"));
const savedBin = process.env.MOSAIC_PI_BIN;
process.env.MOSAIC_PI_BIN = own.bin;
let ctrl;
try {
ctrl = new Controller({ fixtureRoot: fx2.base, claimRoot: fx2.claimRoot, socketDir: fx2.socketDir, sessionFile: fx2.sessionFile, seat: fx2.seat, launcher, units: noUnits, timeouts: FAST });
assert.deepEqual(ctrl.pi, locate(process.env));
} finally {
if (savedBin === undefined) delete process.env.MOSAIC_PI_BIN; else process.env.MOSAIC_PI_BIN = savedBin;
}
assert.equal(ctrl.pi.label, "MOSAIC_PI_BIN");
assert.deepEqual(ctrl.engine.preArgs, [realpathSync(own.cli)]);
// Closed in finally: a start that wrongly succeeds holds the socket open.
try {
ctrl.engine.command = "/bin/sh";
+6 -1
View File
@@ -30,7 +30,12 @@ scripts/discord-service.sh render | install | uninstall | status <binding>
`--repo` for you; the CLI also takes `--config PATH`.
- `check` validates the binding, the token file (0600, regular, not a
symlink), the context files and the pi install; reads the bot, the guild and
symlink), the context files and the pi the harness lookup finds
(`MOSAIC_PI_BIN`, else the first `pi` on `PATH`, else the repository's;
#1873 S4). `--repo` no longer picks the pi, and the CLI runs no fit check
on it yet, so a pi on `PATH` is used as it is. The service wrapper still
checks that the copy has its own `node_modules/.bin/pi`, but the CLI may run
another pi that the lookup finds first. It then reads the bot, the guild and
every listed channel over REST; opens one gateway connection, waits for
READY, closes it. Nothing is sent to a channel. Close code 4014 is reported
as the message-content intent not being granted in the developer portal.
+7 -3
View File
@@ -46,7 +46,7 @@
// 3 refused by a brake (STOP present or the binding held; a supervisor must
// not retry); 4 usage.
import { existsSync, mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
import { dirname, join, resolve } from "node:path";
import { createHash } from "node:crypto";
import { DiscordError, printable } from "./errors.mjs";
@@ -57,6 +57,7 @@ import { defaultConfigPath, loadDataRoot, bindingPath, bindingDataDir, loadBindi
import { createRest } from "./rest.mjs";
import { createGateway, CONNECTOR_INTENTS } from "./gateway.mjs";
import { createEngine, buildPiArgs, sessionContinues } from "./engine-pi.mjs";
import { locate } from "../../plugins/harness/pi/binary.mjs";
import { TOOLS_ENV, enabledToolNames } from "./tools.mjs";
import { createSetsparkApi } from "./setspark.mjs";
import { assembleContext } from "./context.mjs";
@@ -134,8 +135,11 @@ function prepare(opts) {
checkLibraryEngine(dirname(opts.config), binding);
const contextFiles = resolveContextFiles(binding, opts.repo);
const toolRoots = resolveToolRoots(binding, { dataRoot });
const pi = join(opts.repo, "node_modules", ".bin", "pi");
if (!existsSync(pi)) throw new DiscordError("pi not found at node_modules/.bin/pi in the repository; run npm ci in the repository");
// #1873 S4: the pi the harness lookup finds (MOSAIC_PI_BIN, the first pi on PATH, the
// repository's), not only the repository's copy.
const found = locate(process.env);
if (!found.bin) throw new DiscordError(found.problem);
const pi = found.bin;
const journalDir = bindingDataDir(dataRoot, binding.name);
const sessionDir = join(dataRoot, "sessions", `discord-${binding.name}`);
return { dataRoot, bindingFile, binding, contextFiles, toolRoots, pi, journalDir, sessionDir };
+10 -3
View File
@@ -1,5 +1,5 @@
// Shared fakes for the offline suite. No network, no token, no model.
import { mkdtempSync, mkdirSync, writeFileSync, rmSync, chmodSync } from "node:fs";
import { mkdtempSync, mkdirSync, writeFileSync, rmSync, chmodSync, symlinkSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { after } from "node:test";
@@ -53,12 +53,19 @@ export function binding(overrides = {}) {
return validateBinding(rawBinding(overrides));
}
// A fake repository with the files prepare() looks for.
// A fake repository with the files prepare() looks for. Its pi is a package the
// harness lookup accepts, and MOSAIC_PI_BIN names it for every CLI this test
// process starts (#1873 S4), so no test reads the host's own pi.
export function makeRepo(root) {
const repo = join(root, "repo");
const pkg = join(repo, "node_modules", "@earendil-works", "pi-coding-agent");
mkdirSync(join(repo, "node_modules", ".bin"), { recursive: true });
mkdirSync(join(pkg, "dist"), { recursive: true });
mkdirSync(join(repo, "contracts"), { recursive: true });
writeFileSync(join(repo, "node_modules", ".bin", "pi"), "#!/bin/sh\nexit 0\n", { mode: 0o755 });
writeFileSync(join(pkg, "package.json"), JSON.stringify({ name: "@earendil-works/pi-coding-agent", version: "0.0.0-test", bin: { pi: "dist/cli.js" } }));
writeFileSync(join(pkg, "dist", "cli.js"), "#!/bin/sh\nexit 0\n", { mode: 0o755 });
symlinkSync("../@earendil-works/pi-coding-agent/dist/cli.js", join(repo, "node_modules", ".bin", "pi"));
process.env.MOSAIC_PI_BIN = join(repo, "node_modules", ".bin", "pi");
writeFileSync(join(repo, "contracts", "CONSTITUTION.md"), "# constitution\nbe good\n");
return repo;
}
+14 -3
View File
@@ -1,19 +1,21 @@
import test from 'node:test';
import assert from 'node:assert/strict';
import {spawnSync} from 'node:child_process';
import {writeFileSync,chmodSync,unlinkSync,existsSync} from 'node:fs';
import {join} from 'node:path';
import {writeFileSync,chmodSync,unlinkSync,existsSync,mkdirSync,symlinkSync} from 'node:fs';
import {dirname,join} from 'node:path';
import {fileURLToPath} from 'node:url';
import {makeRoot,makeRepo,makeDeployment} from './helpers.mjs';
const CLI=fileURLToPath(new URL('../src/cli.mjs',import.meta.url));
function setup(){
const root=makeRoot(),repo=makeRepo(root),d=makeDeployment(root,{}, {tokenContent:'MTAw.abcdefghijklmnopqrstuvwxyz0123456789'}),calls=join(root,'network-called'),preload=join(root,'no-network.mjs');
writeFileSync(preload,`import {writeFileSync} from 'node:fs';const refuse=()=>{writeFileSync(${JSON.stringify(calls)},'called');throw Error('fixture refuses network')};globalThis.fetch=refuse;globalThis.WebSocket=class{constructor(){refuse()}};`);
const run=(command='check',args=[])=>spawnSync(process.execPath,['--import',preload,CLI,command,d.raw.name,'--config',d.config,'--repo',repo,...args],{encoding:'utf8',timeout:5000});
const run=(command='check',args=[],env=process.env)=>spawnSync(process.execPath,['--import',preload,CLI,command,d.raw.name,'--config',d.config,'--repo',repo,...args],{encoding:'utf8',timeout:5000,env});
return {root,repo,d,calls,run};
}
test('check --offline validates local fixture without REST or gateway calls',()=>{
const s=setup(),r=s.run('check',['--offline']);assert.equal(r.status,0,r.stderr);assert.match(r.stdout,/token file mode 0600 ok; STOP absent/);assert.match(r.stdout,/offline check passed; no REST or gateway calls were made\n$/);assert.ok(!existsSync(s.calls));
// #1873 S4: the fixture's own pi, which the helpers name in MOSAIC_PI_BIN, never the host's.
assert.ok(r.stdout.includes(`pi ${join(s.repo,'node_modules','.bin','pi')};`),r.stdout);
// Online check still reaches REST: the trap fails it immediately.
const online=s.run();assert.equal(online.status,1);assert.ok(existsSync(s.calls));assert.match(online.stderr,/fixture refuses network/);
});
@@ -24,3 +26,12 @@ test('check --offline refuses token mode and missing context under the selected
test('run --offline is a usage refusal before reading config or networking',()=>{
const s=setup();unlinkSync(s.d.config);const r=s.run('run',['--offline']);assert.equal(r.status,4,r.stderr);assert.match(r.stderr,/--offline/);assert.ok(!existsSync(s.calls));
});
test('#1873 S4: check takes the pi the harness lookup finds; MOSAIC_PI_BIN names it, and a bad one refuses with the lookup line, no path',()=>{
// A pi package the way npm installs one under a prefix: its bin is linked from prefix/bin.
const s=setup(),pkg=join(s.root,'prefix','lib','node_modules','@earendil-works','pi-coding-agent'),bin=join(s.root,'prefix','bin','pi');
mkdirSync(join(pkg,'dist'),{recursive:true});mkdirSync(dirname(bin),{recursive:true});
writeFileSync(join(pkg,'package.json'),JSON.stringify({name:'@earendil-works/pi-coding-agent',version:'9.9.9',bin:{pi:'dist/cli.js'}}));
writeFileSync(join(pkg,'dist','cli.js'),'#!/bin/sh\nexit 0\n',{mode:0o755});symlinkSync(join(pkg,'dist','cli.js'),bin);
const named=s.run('check',['--offline'],{...process.env,MOSAIC_PI_BIN:bin});assert.equal(named.status,0,named.stderr);assert.ok(named.stdout.includes(`pi ${bin};`),named.stdout);
const bad=s.run('check',['--offline'],{...process.env,MOSAIC_PI_BIN:'relative/pi'});assert.equal(bad.status,2,bad.stderr);assert.match(bad.stderr,/MOSAIC_PI_BIN isn't an executable file at an absolute path/);assert.ok(!bad.stderr.includes(s.root));assert.ok(!existsSync(s.calls));
});
+20 -1
View File
@@ -233,7 +233,26 @@ process.exit(0);
const quote = (text) => `'${String(text).replace(/'/g, "'\\''")}'`;
// The script text. node: the interpreter the fit part runs on (absolute, so it runs with no PATH).
export function piStandIn(knobs = {}, { node = process.execPath } = {}) {
// form "node" (#1873 S4): the same stand-in as one node script with node in its shebang, the kind
// of file the conversation controller launches with node; its --version and $ARGV_OUT parts are
// JavaScript too, so it needs node wherever it runs.
export function piStandIn(knobs = {}, { node = process.execPath, form = "sh" } = {}) {
if (form === "node") {
const head = knobs.versionHang ? "setTimeout(() => process.exit(0), 60000); return;" : knobs.versionExit != null ? `process.exit(${Number(knobs.versionExit)});` : `process.stdout.write(${JSON.stringify(String(knobs.version ?? "9.9.9"))} + "\\n"); process.exit(0);`;
return [
`#!${node}`,
`"use strict";`,
`process.argv.splice(1, 1);`,
`(() => {`,
`if (process.argv[1] === "--version") { ${head} }`,
`if (process.env.ARGV_OUT) { require("node:fs").writeFileSync(process.env.ARGV_OUT, process.argv.slice(1).map((a) => a + "\\n").join("")); process.stdout.write(${JSON.stringify(String(knobs.sessionOut ?? ""))}); process.exit(0); }`,
`const K = ${JSON.stringify(knobs)};`,
`const FLAGS = ${JSON.stringify(FIT_FLAGS)};`,
BODY,
`})();`,
"",
].join("\n");
}
const version = knobs.versionHang ? "sleep 60; exit 0" : knobs.versionExit != null ? `exit ${Number(knobs.versionExit)}` : `printf '%s\\n' ${quote(knobs.version ?? "9.9.9")}; exit 0`;
const program = `"use strict";\nconst K = ${JSON.stringify(knobs)};\nconst FLAGS = ${JSON.stringify(FIT_FLAGS)};\n${BODY}`;
return [