@zhuxixi/pi-agent-board 0.3.0

package/runner/pty-runner.mjs

@@ -0,0 +1,310 @@
+#!/usr/bin/env node
+/**
+ * Detached PTY host runner.
+ *
+ * Owns one long-lived interactive Pi child, captures raw terminal output, and exposes
+ * a small JSONL-over-Unix-socket protocol for live attach from the dashboard.
+ * Uses node-pty when available; falls back to stdio pipes so tests and installs without
+ * native deps still exercise the control protocol.
+ */
+import { spawn } from "node:child_process";
+import { createRequire } from "node:module";
+import { createServer } from "node:net";
+import { existsSync, unlinkSync } from "node:fs";
+import { appendLine, readJson } from "../src/core/atomic.mjs";
+import * as P from "../src/core/paths.mjs";
+import { appendBoundedScreenLog, reconcileScreenLog } from "../src/core/screen-log.mjs";
+import { encodePromptForCliArg } from "../src/core/prompt-transport.mjs";
+import { readState, writeHost, writeState } from "../src/core/store.mjs";
+import { ensureNodePtySpawnHelperExecutable } from "../src/core/pty-support.mjs";
+
+const requireForPty = createRequire(import.meta.url);
+
+/** @type {any|null} */
+let pty = null;
+try {
+	pty = await import("node-pty");
+} catch {
+	pty = null;
+}
+
+const HEARTBEAT_MS = 1000;
+
+function main() {
+	const configPath = process.argv[2];
+	if (!configPath) failEarly("pty-runner: missing config path");
+	/** @type {import("../src/core/types.mjs").HostConfig|null} */
+	const config = readJson(configPath, null);
+	if (!config) failEarly(`pty-runner: cannot read config ${configPath}`);
+
+	const socketPath = P.controlSocketPath(config.root, config.viewId);
+	const screenLog = P.screenLogPath(config.root, config.viewId);
+	// Optional per-install cap override from launch prefs (screenLogMaxSize).
+	// undefined → screen-log.mjs falls back to its built-in default.
+	const screenLogMaxBytes =
+		Number.isFinite(config.screenLogMaxBytes) && config.screenLogMaxBytes > 0
+			? Math.floor(config.screenLogMaxBytes)
+			: undefined;
+	const screenLogLimits = { maxBytes: screenLogMaxBytes };
+	let screenLogBytes = reconcileScreenLog(screenLog, screenLogLimits);
+	try {
+		if (existsSync(socketPath)) unlinkSync(socketPath);
+	} catch {}
+
+	/** @type {Set<import("node:net").Socket>} */
+	const clients = new Set();
+	let childPid = null;
+	let exitCode = null;
+	let stopping = false;
+	/** @type {import("../src/core/types.mjs").HostStatus} */
+	let host = {
+		version: 1,
+		viewId: config.viewId,
+		mode: "pty",
+		runnerPid: process.pid,
+		childPid: null,
+		socketPath,
+		state: "starting",
+		startedAt: Date.now(),
+		lastSeenAt: Date.now(),
+		endedAt: null,
+		exitCode: null,
+		error: null,
+		cols: config.cols || 120,
+		rows: config.rows || 36,
+		attachedClients: 0,
+		attachedEver: false,
+	};
+	const persist = () => writeHost(config.root, host);
+	const broadcast = (msg) => {
+		const line = JSON.stringify(msg) + "\n";
+		for (const c of clients) c.write(line);
+	};
+	const update = (patch = {}) => {
+		host = { ...host, ...patch, lastSeenAt: Date.now(), attachedClients: clients.size };
+		persist();
+		broadcast({ type: "status", status: host });
+	};
+	persist();
+
+	const args = [...config.piArgsPrefix, "--session", config.sessionFile];
+	if (config.model) args.push("--model", config.model);
+	if (config.thinkingLevel) args.push("--thinking", config.thinkingLevel);
+	if (config.tools) args.push("--tools", config.tools);
+	if (config.initialPrompt) args.push(encodePromptForCliArg(config.initialPrompt));
+
+	const env = {
+		...process.env,
+		...(config.env || {}),
+		AGENT_BOARD_ROOT: config.root,
+		AGENT_BOARD_VIEW_ID: config.viewId,
+		AGENT_BOARD_CHILD: "1",
+		AGENT_BOARD_HOSTED: "pty",
+		// Legacy names are exported too so older child extension builds still behave.
+		AGENT_VIEW_ROOT: config.root,
+		AGENT_VIEW_VIEW_ID: config.viewId,
+		AGENT_VIEW_CHILD: "1",
+		AGENT_VIEW_HOSTED: "pty",
+	};
+
+	let child;
+	try {
+		child = spawnInteractive(config.piCommand, args, {
+			cwd: config.cwd,
+			env,
+			cols: host.cols,
+			rows: host.rows,
+			allowPipeFallback: config.env?.AGENT_BOARD_ALLOW_PIPE_FALLBACK === "1" || config.env?.AGENT_VIEW_ALLOW_PIPE_FALLBACK === "1",
+		});
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		update({ state: "failed", endedAt: Date.now(), exitCode: 1, error: message });
+		markRowFailed(config.root, config.viewId, `PTY host failed: ${message}`);
+		process.exit(1);
+	}
+	childPid = child.pid ?? null;
+	update({ childPid, state: "alive" });
+
+	child.onData((data) => {
+		screenLogBytes = appendBoundedScreenLog(screenLog, data, screenLogBytes, screenLogLimits);
+		broadcast({ type: "output", data });
+	});
+	child.onExit((code) => {
+		exitCode = code ?? 0;
+		update({ state: stopping ? "exited" : "exited", endedAt: Date.now(), exitCode, childPid: null });
+		broadcast({ type: "exit", exitCode });
+		setTimeout(() => process.exit(exitCode ?? 0), 50).unref?.();
+	});
+	child.onError((err) => {
+		update({ state: "failed", endedAt: Date.now(), exitCode: 1, error: err instanceof Error ? err.message : String(err) });
+		broadcast({ type: "error", message: host.error || "child error" });
+		setTimeout(() => process.exit(1), 50).unref?.();
+	});
+
+	const server = createServer((socket) => {
+		clients.add(socket);
+		update({ attachedEver: true });
+		socket.write(JSON.stringify({ type: "hello", status: host }) + "\n");
+		let buffer = "";
+		socket.on("data", (chunk) => {
+			buffer += chunk.toString("utf8");
+			const lines = buffer.split("\n");
+			buffer = lines.pop() ?? "";
+			for (const line of lines) handleClientLine(line, socket);
+		});
+		socket.on("close", () => {
+			clients.delete(socket);
+			update();
+		});
+		socket.on("error", () => {
+			clients.delete(socket);
+			update();
+		});
+	});
+	server.on("error", (err) => {
+		update({ state: "failed", endedAt: Date.now(), error: err instanceof Error ? err.message : String(err), exitCode: 1 });
+		try { child.kill("SIGTERM"); } catch {}
+		process.exit(1);
+	});
+	server.listen(socketPath, () => update({ socketPath, state: "alive" }));
+
+	function handleClientLine(line, socket) {
+		if (!line.trim()) return;
+		let msg;
+		try { msg = JSON.parse(line); } catch { return send(socket, { type: "error", message: "invalid json" }); }
+		switch (msg.type) {
+			case "hello":
+				send(socket, { type: "hello", status: host });
+				break;
+			case "input":
+				if (typeof msg.data === "string") child.write(msg.data);
+				break;
+			case "resize": {
+				const cols = clampInt(msg.cols, 20, 300, host.cols);
+				const rows = clampInt(msg.rows, 5, 120, host.rows);
+				child.resize(cols, rows);
+				update({ cols, rows });
+				break;
+			}
+			case "interrupt":
+				child.write("\x1b");
+				break;
+			case "terminate":
+				stopping = true;
+				child.kill("SIGTERM");
+				setTimeout(() => child.kill("SIGKILL"), 4000).unref?.();
+				break;
+			case "detach":
+				socket.end();
+				break;
+			case "get_status":
+				send(socket, { type: "status", status: host });
+				break;
+		}
+	}
+
+	const heartbeat = setInterval(() => {
+		if (host.state === "alive") update();
+	}, HEARTBEAT_MS);
+	heartbeat.unref?.();
+
+	const shutdown = () => {
+		stopping = true;
+		try { server.close(); } catch {}
+		try { if (existsSync(socketPath)) unlinkSync(socketPath); } catch {}
+		try { child.kill("SIGTERM"); } catch {}
+		setTimeout(() => process.exit(0), 100).unref?.();
+	};
+	process.on("SIGTERM", shutdown);
+	process.on("SIGINT", shutdown);
+}
+
+function spawnInteractive(command, args, opts) {
+	ensureNodePtySpawnHelperExecutable(requireForPty);
+	if (pty?.spawn) {
+		try {
+			const proc = pty.spawn(command, args, {
+				name: "xterm-256color",
+				cols: opts.cols,
+				rows: opts.rows,
+				cwd: opts.cwd,
+				env: opts.env,
+			});
+			return {
+				pid: proc.pid ?? null,
+				write: (s) => proc.write(s),
+				resize: (cols, rows) => proc.resize(cols, rows),
+				kill: (signal) => proc.kill(signal),
+				onData: (fn) => proc.onData(fn),
+				onExit: (fn) => proc.onExit((e) => fn(e.exitCode ?? 0)),
+				onError: () => {},
+			};
+		} catch (err) {
+			if (!opts.allowPipeFallback) throw err;
+		}
+	}
+	if (!opts.allowPipeFallback) throw new Error("node-pty is unavailable");
+
+	const proc = spawn(command, args, { cwd: opts.cwd, env: opts.env, stdio: ["pipe", "pipe", "pipe"] });
+	return {
+		pid: proc.pid ?? null,
+		write: (s) => proc.stdin.write(s),
+		resize: () => {},
+		kill: (signal) => proc.kill(signal),
+		onData: (fn) => {
+			proc.stdout.on("data", (c) => fn(c.toString()));
+			proc.stderr.on("data", (c) => fn(c.toString()));
+		},
+		onExit: (fn) => proc.on("close", (code) => fn(code ?? 0)),
+		onError: (fn) => proc.on("error", fn),
+	};
+}
+
+function send(socket, msg) {
+	socket.write(JSON.stringify(msg) + "\n");
+}
+
+function clampInt(value, min, max, fallback) {
+	const n = Number(value);
+	if (!Number.isFinite(n)) return fallback;
+	return Math.max(min, Math.min(max, Math.floor(n)));
+}
+
+
+function markRowFailed(root, viewId, message) {
+	const now = Date.now();
+	const state = readState(root, viewId) ?? {
+		version: 1,
+		viewId,
+		currentRunId: null,
+		semanticState: "queued",
+		processState: "exited",
+		summary: "Queued",
+		lastActivityAt: now,
+		updatedAt: now,
+		needsInput: false,
+		hasError: false,
+		latestAssistantPreview: "",
+		latestTool: null,
+		question: null,
+		pendingQuestions: [],
+		error: null,
+	};
+	state.semanticState = "failed";
+	state.processState = "exited";
+	state.summary = message;
+	state.hasError = true;
+	state.needsInput = false;
+	state.error = message;
+	state.updatedAt = now;
+	state.lastActivityAt = now;
+	writeState(root, state);
+}
+
+function failEarly(message) {
+	try { appendLine("/tmp/pi-agent-board-pty-runner.err", message); } catch {}
+	process.stderr.write(`${message}\n`);
+	process.exit(2);
+}
+
+main();

package/runner/state-runner.mjs

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+/**
+ * Detached auto-state classifier.
+ *
+ * Reads the latest assistant turn from evidence/state, asks a cheap model to classify
+ * the terminal bucket, and updates state.json (and status.json when a run id exists).
+ * Safe best-effort: on model failure it falls back to the same heuristic classifier.
+ */
+import { spawn } from "node:child_process";
+import { readJson } from "../src/core/atomic.mjs";
+import { appendDiagnostic } from "../src/core/diagnostics.mjs";
+import { applyAutoStateToStatus, applyAutoStateToViewState, autoStateEnabled, autoStateFromModelOrHeuristic, autoStateModel, buildAutoStatePrompt, heuristicAutoState } from "../src/core/auto-state.mjs";
+import { finalizeEvidence, readEvidence, summarizeEvidence, writeEvidence } from "../src/core/evidence.mjs";
+import { readState, readStatus, writeState, writeStatus } from "../src/core/store.mjs";
+
+async function main() {
+	const configPath = process.argv[2];
+	if (!configPath) process.exit(2);
+	/** @type {import("../src/core/types.mjs").AutoStateConfig|null} */
+	const config = readJson(configPath, null);
+	if (!config || !autoStateEnabled()) process.exit(0);
+
+	const state = readState(config.root, config.viewId);
+	if (!state || state.processState === "alive" || state.semanticState === "failed" || state.semanticState === "stopped") process.exit(0);
+
+	const evidence = readEvidence(config.root, config.viewId);
+	const latest = latestEvidenceText(evidence) || state.latestAssistantPreview || state.summary || "";
+	if (!latest.trim()) process.exit(0);
+
+	if (state.autoState?.source === "model" && state.autoState.textHash === heuristicAutoState(latest).textHash) process.exit(0);
+
+	const model = autoStateModel();
+	let classification = heuristicAutoState(latest, { lastAgentActivityAt: state.lastAgentActivityAt ?? null });
+	if (model) {
+		const prompt = buildAutoStatePrompt(latest);
+		const out = await runOneShot(
+			config.piCommand,
+			[...config.piArgsPrefix, "--mode", "json", "-p", "--no-session", "--model", model, prompt],
+			{ timeoutMs: 15000, cwd: config.cwd, env: sanitizedEnv() },
+		);
+		classification = autoStateFromModelOrHeuristic(out, latest, { lastAgentActivityAt: state.lastAgentActivityAt ?? null });
+	}
+
+	let changed = false;
+	if (config.runId) {
+		const status = readStatus(config.root, config.viewId, config.runId);
+		if (status) {
+			changed = applyAutoStateToStatus(status, classification, Date.now()) || changed;
+			status.evidenceSummary = summarizeEvidence(finalizeEvidence(evidence, status, Date.now()));
+			writeStatus(config.root, status);
+		}
+	}
+	const latestState = readState(config.root, config.viewId) ?? state;
+	changed = applyAutoStateToViewState(latestState, classification, Date.now()) || changed;
+	finalizeEvidence(evidence, { semanticState: latestState.semanticState, usage: null }, Date.now());
+	latestState.review = summarizeEvidence(evidence);
+	writeEvidence(config.root, evidence);
+	writeState(config.root, latestState);
+	if (changed) {
+		appendDiagnostic(config.root, config.viewId, { source: "service", runId: config.runId, code: "auto_state_classified", message: "Auto-state classifier updated row state", details: { kind: classification.kind, confidence: classification.confidence, source: classification.source, reason: classification.reason } });
+	}
+}
+
+/** @param {import("../src/core/types.mjs").EvidenceSnapshot} evidence */
+function latestEvidenceText(evidence) {
+	return evidence.assistantEvidence?.[evidence.assistantEvidence.length - 1]?.text ?? "";
+}
+
+function sanitizedEnv() {
+	const env = { ...process.env };
+	delete env.AGENT_BOARD_CHILD;
+	delete env.AGENT_VIEW_CHILD;
+	delete env.AGENT_BOARD_VIEW_ID;
+	delete env.AGENT_VIEW_VIEW_ID;
+	delete env.AGENT_BOARD_HOSTED;
+	delete env.AGENT_VIEW_HOSTED;
+	return env;
+}
+
+/**
+ * @param {string} command
+ * @param {string[]} args
+ * @param {{ timeoutMs?: number, cwd?: string, env?: NodeJS.ProcessEnv }} [opts]
+ */
+function runOneShot(command, args, opts = {}) {
+	return new Promise((resolve) => {
+		let out = "";
+		let settled = false;
+		const child = spawn(command, args, { cwd: opts.cwd, env: opts.env ?? process.env, stdio: ["ignore", "pipe", "ignore"] });
+		let buf = "";
+		const finish = () => {
+			if (settled) return;
+			settled = true;
+			resolve(out);
+		};
+		child.stdout.on("data", (c) => {
+			buf += c.toString();
+			const lines = buf.split("\n");
+			buf = lines.pop() ?? "";
+			for (const line of lines) {
+				try {
+					const e = JSON.parse(line);
+					if (e?.type === "message_end" && e.message?.role === "assistant") {
+						for (const b of e.message.content ?? []) if (b.type === "text") out += b.text;
+					}
+				} catch {
+					/* ignore */
+				}
+			}
+		});
+		child.on("close", finish);
+		child.on("error", finish);
+		setTimeout(() => {
+			try { child.kill("SIGKILL"); } catch {}
+			finish();
+		}, opts.timeoutMs ?? 20000).unref?.();
+	});
+}
+
+main().catch(() => process.exit(0));

package/runner/title-runner.mjs

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+/**
+ * Detached title-runner shim.
+ *
+ * Best-effort only: generates a short GPT-4o title from the initial task prompt and updates
+ * the row's meta name if the user has not already renamed it.
+ */
+import { spawn } from "node:child_process";
+import { readJson } from "../src/core/atomic.mjs";
+import { readMeta, writeMeta } from "../src/core/store.mjs";
+import { DEFAULT_TITLE_MODEL, DEFAULT_TITLE_THINKING_LEVEL, normalizeGeneratedTitle, titlePrompt } from "../src/core/title.mjs";
+
+function main() {
+	const configPath = process.argv[2];
+	if (!configPath) process.exit(2);
+	/** @type {import("../src/core/types.mjs").TitleConfig|null} */
+	const config = readJson(configPath, null);
+	if (!config?.viewId || !config.prompt) process.exit(2);
+
+	maybeGenerateTitle(config)
+		.catch(() => {})
+		.finally(() => process.exit(0));
+}
+
+async function maybeGenerateTitle(config) {
+	const configured = process.env.AGENT_BOARD_TITLE_MODEL ?? process.env.AGENT_VIEW_TITLE_MODEL;
+	if (configured === "off") return;
+	const model = config.model ?? configured ?? DEFAULT_TITLE_MODEL;
+	const thinking = process.env.AGENT_BOARD_TITLE_THINKING_LEVEL ?? process.env.AGENT_VIEW_TITLE_THINKING_LEVEL ?? DEFAULT_TITLE_THINKING_LEVEL;
+	const prompt = titlePrompt(config.prompt);
+	const args = [...config.piArgsPrefix, "--mode", "json", "-p", "--no-session", "--model", model];
+	if (thinking && thinking !== "off") args.push("--thinking", thinking);
+	args.push(prompt);
+	const out = await runOneShot(config.piCommand, args, 15000);
+	const title = normalizeGeneratedTitle(out.trim().split("\n").slice(-1)[0]?.trim(), config.fallbackName);
+	if (!title || title === config.fallbackName) return;
+
+	const meta = readMeta(config.root, config.viewId);
+	if (!meta) return;
+	if (meta.name !== config.fallbackName) return;
+	meta.name = title;
+	writeMeta(config.root, meta);
+}
+
+function runOneShot(command, args, timeoutMs = 20000) {
+	return new Promise((resolve) => {
+		let out = "";
+		const child = spawn(command, args, { stdio: ["ignore", "pipe", "ignore"] });
+		let buf = "";
+		child.stdout.on("data", (c) => {
+			buf += c.toString();
+			const lines = buf.split("\n");
+			buf = lines.pop() ?? "";
+			for (const line of lines) {
+				try {
+					const e = JSON.parse(line);
+					if (e?.type === "message_end" && e.message?.role === "assistant") {
+						for (const b of e.message.content ?? []) {
+							if (b.type === "text") out += b.text;
+						}
+					}
+				} catch {
+					/* ignore */
+				}
+			}
+		});
+		child.on("close", () => resolve(out));
+		child.on("error", () => resolve(""));
+		setTimeout(() => {
+			try {
+				child.kill("SIGKILL");
+			} catch {
+				/* ignore */
+			}
+			resolve(out);
+		}, timeoutMs).unref?.();
+	});
+}
+
+main();

package/scripts/patch-vulns.mjs

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+/**
+ * postinstall: patch vulnerable transitive dependencies that are locked behind
+ * @earendil-works/pi-coding-agent's npm-shrinkwrap.json (which prevents npm
+ * "overrides" from taking effect).
+ *
+ * Vulnerabilities patched:
+ * - brace-expansion <=5.0.7 → 5.0.8 (GHSA-3jxr-9vmj-r5cp, GHSA-mh99-v99m-4gvg)
+ * - protobufjs 7.5.0–7.6.4 → 7.6.5 (GHSA-j3f2-48v5-ccww)
+ */
+import { execSync } from "node:child_process";
+import { existsSync, rmSync, mkdirSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const root = join(dirname(fileURLToPath(import.meta.url)), "..");
+const nested = join(
+  root,
+  "node_modules",
+  "@earendil-works",
+  "pi-coding-agent",
+  "node_modules",
+);
+
+const patches = [
+  { name: "brace-expansion", version: "5.0.8" },
+  { name: "protobufjs", version: "7.6.5" },
+];
+
+for (const { name, version } of patches) {
+  const target = join(nested, name);
+  if (!existsSync(target)) {
+    console.log(`[patch-vulns] ${name} not found nested, skipping`);
+    continue;
+  }
+
+  console.log(`[patch-vulns] patching ${name} → ${version}`);
+  rmSync(target, { recursive: true, force: true });
+  mkdirSync(target, { recursive: true });
+
+  // Install the patched version into a temp dir, then move it into place
+  const tmp = join(root, `.patch-tmp-${name}`);
+  rmSync(tmp, { recursive: true, force: true });
+  mkdirSync(tmp, { recursive: true });
+
+  try {
+    execSync(`npm install ${name}@${version} --prefix "${tmp}" --ignore-scripts`, {
+      stdio: "pipe",
+      cwd: root,
+    });
+    const installed = join(tmp, "node_modules", name);
+    rmSync(target, { recursive: true, force: true });
+    execSync(`mv "${installed}" "${target}"`);
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+}
+
+console.log("[patch-vulns] done");