154 lines
7.5 KiB
JavaScript
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);
|
|
});
|
|
});
|
|
}
|