// #1873 pi-unpin: the pi binary a session runs, and the package it comes from. Nothing here is // pinned. The version label is read from the binary (or its package.json), never compared to a // fixed one. The launcher, the bundle and the usage reader call these on the host. import { accessSync, constants, readFileSync, realpathSync, statSync } from "node:fs"; import { dirname, isAbsolute, join, relative } from "node:path"; import { homedir } from "node:os"; import { fileURLToPath } from "node:url"; import { spawn } from "node:child_process"; const REPO = fileURLToPath(new URL("../../../../", import.meta.url)); export const PACKAGE = "@earendil-works/pi-coding-agent"; export const REPO_BIN = join(REPO, "node_modules", ".bin", "pi"); const VERSION_MAX = 128; export const executable = (path) => { try { accessSync(path, constants.X_OK); return statSync(path).isFile(); } catch { return false; } }; const REPO_NODE_MODULES = join(REPO, "node_modules"); const realOrNull = (path) => { try { return realpathSync(path); } catch { return null; } }; const inside = (path, root) => root === "/" || path === root || path.startsWith(root + "/"); // #1873 S2: the binary a session runs, with the name a refusal line uses for it (never a path): // MOSAIC_PI_BIN, which must be an absolute path to an executable file; else the first executable // pi on PATH, skipping the repository's own node_modules/.bin (a session PATH starts with it, so // the bus's own PATH and a session's give the same answer); else the repository's copy. The binary // must belong to the pi package: its package directory (or, for the repository's copy, the // repository's node_modules) is what the sandbox mounts. The answer: { bin, label, root, view, // dest, pkg } or { bin: null, problem }. root is the real directory mounted, dest where it is // mounted (null: at root itself), view the binary's path inside the session, pkg the package's // real directory. export function locate(env = {}) { if (env.MOSAIC_PI_BIN !== undefined && env.MOSAIC_PI_BIN !== "") { const bin = env.MOSAIC_PI_BIN; if (typeof bin !== "string" || !isAbsolute(bin) || !executable(bin)) return { bin: null, problem: "MOSAIC_PI_BIN isn't an executable file at an absolute path" }; return placed(bin, "MOSAIC_PI_BIN", env); } const repoBin = realOrNull(join(REPO_NODE_MODULES, ".bin")); for (const dir of String(env.PATH ?? "").split(":")) { if (!isAbsolute(dir)) continue; const real = realOrNull(dir); if (real === null || (repoBin !== null && real === repoBin)) continue; if (executable(join(dir, "pi"))) return placed(join(dir, "pi"), "the pi on PATH", env); } if (executable(REPO_BIN)) return placed(REPO_BIN, "the repository's pi", env); return { bin: null, problem: "no pi found: set MOSAIC_PI_BIN, put pi on PATH, or run npm ci" }; } function placed(bin, label, env) { const pkg = packageDir(bin); const realBin = realOrNull(bin); if (!pkg || !realBin) return { bin: null, problem: `${label} isn't part of the ${PACKAGE} package` }; // The package directory is mounted whole, so the binary must be the pi bin its package.json // names (a string bin, or bin.pi), inside that directory. A stray executable under some wider // directory whose package.json carries the name doesn't count. if (namedBin(pkg) !== realBin) return { bin: null, problem: `${label} isn't the pi bin the ${PACKAGE} package names` }; // The repository's copy keeps the mount every session has had: all of node_modules, at its own // path, since its packages are hoisted beside pi. const repoReal = realOrNull(REPO_NODE_MODULES); if (repoReal !== null && inside(pkg, repoReal)) { return { bin, label, root: repoReal, dest: REPO_NODE_MODULES, view: join(REPO_NODE_MODULES, relative(repoReal, realBin)), pkg }; } // Any other copy: its package directory alone, at its real path. npm nests a global install's // dependencies inside it; a copy that needs packages beside it fails the fit check (S3). // A package directory that holds the home directory or the repository would mount them. const held = [homedir(), env.HOME, REPO].filter((p) => typeof p === "string" && isAbsolute(p)).map((p) => realOrNull(p) ?? p); if (held.some((p) => inside(p, pkg))) return { bin: null, problem: `${label}'s package directory holds the home directory or the repository` }; return { bin, label, root: pkg, dest: null, view: realBin, pkg }; } // The real path of the pi bin the package.json in `pkg` names, inside `pkg`, or null. function namedBin(pkg) { let bin; try { bin = JSON.parse(readFileSync(join(pkg, "package.json"), "utf8")).bin; } catch { return null; } const rel = typeof bin === "string" ? bin : bin && typeof bin === "object" ? bin.pi : null; if (typeof rel !== "string" || !rel) return null; const real = realOrNull(join(pkg, rel)); return real !== null && real !== pkg && inside(real, pkg) ? real : null; } // The package directory that holds the binary's real file: the nearest directory above it whose // package.json has a name. That name must be PACKAGE, or there is none (null). export function packageDir(bin) { let dir; try { dir = dirname(realpathSync(bin)); } catch { return null; } for (let depth = 0; depth < 32; depth++) { let pkg = null; try { pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf8")); } catch { pkg = null; } if (pkg && typeof pkg === "object" && pkg.name !== undefined) return pkg.name === PACKAGE ? dir : null; const up = dirname(dir); if (up === dir) return null; dir = up; } return null; } // The found package's own version, a file read with no spawn, or null. export function packageVersion(bin) { const dir = bin ? packageDir(bin) : null; if (!dir) return null; try { const v = JSON.parse(readFileSync(join(dir, "package.json"), "utf8")).version; return typeof v === "string" && cleanLabel(v) ? v : null; } catch { return null; } } // The most a --version may print (spawnSync's default buffer, which the check used before). const VERSION_OUTPUT_MAX = 1024 * 1024; // One printable line, short enough to record. const cleanLabel = (s) => s.length > 0 && s.length <= VERSION_MAX && !/[\u0000-\u001f\u007f-\u009f\u2028\u2029]/.test(s); // The first line ` --version` prints, or null when it fails, times out or prints something // that is not one short printable line. The environment holds only a PATH that finds node. A // promise: the binary runs as a child process, so the caller's event loop keeps running. export function printedVersion(bin) { if (!bin) return Promise.resolve(null); return new Promise((resolve) => { const out = []; let size = 0; let done = false; let child; let timer = null; const finish = (line) => { if (done) return; done = true; clearTimeout(timer); resolve(line); }; try { child = spawn(bin, ["--version"], { env: { PATH: `${dirname(process.execPath)}:/usr/bin:/bin`, PI_OFFLINE: "1" }, stdio: ["ignore", "pipe", "ignore"] }); } catch { finish(null); return; } timer = setTimeout(() => { try { child.kill("SIGKILL"); } catch {} finish(null); }, 5000); child.stdout.on("data", (chunk) => { size += chunk.length; if (size > VERSION_OUTPUT_MAX) { try { child.kill("SIGKILL"); } catch {} finish(null); } else out.push(chunk); }); child.on("error", () => finish(null)); child.on("close", (status) => { const line = Buffer.concat(out).toString("utf8").split("\n")[0].trim(); finish(status === 0 && cleanLabel(line) ? line : null); }); }); }