Files

154 lines
7.5 KiB
JavaScript

// #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 `<bin> --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);
});
});
}