@junghanacs/entwurf 0.12.0

package/scripts/fixtures/probe-mcp-server.ts

@@ -0,0 +1,33 @@
+// Tiny stdio MCP server used ONLY by smoke-acp-mcp-live (S2g LIVE 1).
+//
+// It exposes ONE tool — `probe_nonce` — that returns a per-run secret nonce
+// supplied via the PROBE_NONCE env var. The smoke registers this server in a
+// scratch `.pi/settings.json` under `entwurfProvider.mcpServers` and asks the
+// ACP model to CALL the tool and echo the nonce. If the operator mcpServers
+// passthrough (S2g) works, the ACP child spawns this server, the tool is visible
+// in the session schema, and the model's reply carries the nonce. If passthrough
+// is broken (the pre-S2g hardcoded `mcpServers:[]`), the tool never exists and
+// the nonce cannot appear.
+//
+// Lives under the repo's scripts/fixtures/ so its `@modelcontextprotocol/sdk`
+// import resolves against the repo node_modules even though the server is spawned
+// (by the claude ACP child) with an arbitrary scratch cwd. Deliberately minimal:
+// no identity / env coupling beyond PROBE_NONCE, so a failure isolates to "did
+// the operator mcpServers reach newSession" — not to entwurf-bridge wiring.
+
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+const server = new McpServer({ name: "probe", version: "0.0.1" });
+
+server.tool(
+	"probe_nonce",
+	"Return this session's secret probe nonce. Call this when asked for the probe nonce.",
+	{},
+	async () => ({
+		content: [{ type: "text", text: `PROBE_NONCE=${process.env.PROBE_NONCE ?? "MISSING"}` }],
+	}),
+);
+
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/scripts/gnew-rpc-drive.ts

@@ -0,0 +1,211 @@
+#!/usr/bin/env -S node --experimental-strip-types
+/**
+ * gnew-rpc-drive — sequential RPC driver for the /gnew E2E smoke.
+ *
+ * pi's native RPC `prompt` is async (it `void session.prompt(...)` and returns
+ * immediately), so a blind printf pipe can race a follow-up get_state ahead of
+ * the switch. This driver enforces ordering: it waits for each response before
+ * sending the next command.
+ *
+ * Base flow (0 tokens — `/gnew` is a slash command intercepted by session.prompt
+ * BEFORE any model turn, so NO agent_start should appear):
+ *   g1: get_state            → capture BEFORE sessionId
+ *   p1: prompt "/gnew"       → wait for the prompt response (the in-process switch
+ *                              completes inside the command handler, before this
+ *                              response fires)
+ *   g2: get_state            → capture AFTER sessionId / sessionFile / msgCount
+ *
+ * Optional self turn (T3 backend identity, ~1 turn — pass a 5th arg `selfPrompt`):
+ *   p2: prompt <selfPrompt>  → drive one model turn that calls entwurf_self; scan
+ *                              the stream for the identity envelope and capture
+ *                              every sessionId it reports (proves PI_SESSION_ID
+ *                              reached the backend MCP child AFTER the switch).
+ *
+ * Emits a single JSON object on stdout for the bash smoke to assert against.
+ *
+ * Usage: node --experimental-strip-types gnew-rpc-drive.ts <sessionId> <provider> <model> [timeoutMs] [selfPrompt]
+ */
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import readline from "node:readline";
+import { fileURLToPath } from "node:url";
+
+const ENTWURF_DIR = path.join(os.homedir(), ".pi", "entwurf-control");
+const listSockets = (): string[] => {
+	try {
+		return fs.readdirSync(ENTWURF_DIR).filter((f) => f.endsWith(".sock"));
+	} catch {
+		return [];
+	}
+};
+
+const [sessionId, provider, model, timeoutMsArg, selfPrompt] = process.argv.slice(2);
+if (!sessionId || !provider || !model) {
+	process.stderr.write("usage: gnew-rpc-drive.ts <sessionId> <provider> <model> [timeoutMs] [selfPrompt]\n");
+	process.exit(2);
+}
+const timeoutMs = Number(timeoutMsArg) || 90_000;
+const wantSelf = typeof selfPrompt === "string" && selfPrompt.length > 0;
+const REPO_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const REPO_EXTENSION_ARGS = ["--no-extensions", "-e", REPO_ROOT] as const;
+
+interface DriveResult {
+	before: string | null;
+	after: string | null;
+	afterFile: string | null;
+	afterMsgCount: number | null;
+	promptOk: boolean;
+	agentStartSeen: boolean;
+	extensionErrors: Array<{ path: unknown; event: unknown; error: unknown }>;
+	socketsAfterSwitch: string[];
+	selfEnvelopeSessionIds: string[];
+	selfTurnEnded: boolean;
+	timedOut: boolean;
+}
+
+const result: DriveResult = {
+	before: null,
+	after: null,
+	afterFile: null,
+	afterMsgCount: null,
+	promptOk: false,
+	agentStartSeen: false,
+	extensionErrors: [],
+	// Control sockets present right after the switch, while pi is still alive (the
+	// socket vanishes on shutdown, so it can only be observed mid-run). Proves
+	// startControlServer rebound to the new garden id and dropped the old one.
+	socketsAfterSwitch: [],
+	selfEnvelopeSessionIds: [],
+	selfTurnEnded: false,
+	timedOut: false,
+};
+
+const child = spawn(
+	"pi",
+	[
+		...REPO_EXTENSION_ARGS,
+		"--session-id",
+		sessionId,
+		"--entwurf-control",
+		"--provider",
+		provider,
+		"--model",
+		model,
+		"--mode",
+		"rpc",
+	],
+	{ stdio: ["pipe", "pipe", "inherit"] },
+);
+
+const send = (obj: Record<string, unknown>): void => {
+	child.stdin?.write(`${JSON.stringify(obj)}\n`);
+};
+
+// phases: 0 await g1 · 1 await prompt/gnew · 2 await g2 · 3 self turn (optional) · 4 done
+let phase = 0;
+// finish() can be reached from three racing paths — the timeout timer, child
+// `exit`, and the normal phase-2/phase-3 completion. Guard so the single result
+// JSON is emitted exactly once; a double emit would tear the bash JSON parse.
+let finished = false;
+const finish = (): void => {
+	if (finished) return;
+	finished = true;
+	clearTimeout(timer);
+	try {
+		child.stdin?.end();
+	} catch {
+		/* best-effort */
+	}
+	process.stdout.write(`${JSON.stringify(result)}\n`);
+	setTimeout(() => {
+		try {
+			child.kill("SIGTERM");
+		} catch {
+			/* best-effort */
+		}
+		process.exit(0);
+	}, 1500);
+};
+
+const timer = setTimeout(() => {
+	result.timedOut = true;
+	finish();
+}, timeoutMs);
+
+const rl = readline.createInterface({ input: child.stdout! });
+rl.on("line", (line: string) => {
+	const trimmed = line.trim();
+	if (!trimmed) return;
+	let evt: Record<string, unknown>;
+	try {
+		evt = JSON.parse(trimmed) as Record<string, unknown>;
+	} catch {
+		return;
+	}
+
+	if (evt.type === "agent_start") result.agentStartSeen = true;
+	if (evt.type === "extension_error") {
+		result.extensionErrors.push({ path: evt.extensionPath, event: evt.event, error: evt.error });
+	}
+
+	// entwurf_self identity envelope: streamed as a tool result embedded as a STRING
+	// inside the message event, so its JSON quotes are escaped (\"sessionId\":...) —
+	// match the garden-id TOKEN instead (alphanumerics, never escaped). The envelope
+	// is marked by `agentId` (get_state never emits it); the only garden-shaped token
+	// in it is the sessionId (= the backend MCP child's PI_SESSION_ID after the switch).
+	if (phase === 3 && trimmed.includes("agentId")) {
+		const m = trimmed.match(/\d{8}T\d{6}-[0-9a-f]{6}/g);
+		if (m) {
+			for (const id of m) {
+				if (!result.selfEnvelopeSessionIds.includes(id)) result.selfEnvelopeSessionIds.push(id);
+			}
+		}
+	}
+	if (phase === 3 && evt.type === "agent_end") {
+		result.selfTurnEnded = true;
+		finish();
+		return;
+	}
+
+	if (evt.type !== "response") return;
+	const data = (evt.data ?? null) as { sessionId?: string; sessionFile?: string; messageCount?: number } | null;
+
+	if (phase === 0 && evt.command === "get_state") {
+		result.before = data?.sessionId ?? null;
+		phase = 1;
+		send({ type: "prompt", message: "/gnew", id: "p1" });
+		return;
+	}
+	if (phase === 1 && evt.command === "prompt") {
+		result.promptOk = evt.success === true;
+		phase = 2;
+		send({ type: "get_state", id: "g2" });
+		return;
+	}
+	if (phase === 2 && evt.command === "get_state") {
+		result.after = data?.sessionId ?? null;
+		result.afterFile = data?.sessionFile ?? null;
+		result.afterMsgCount = data?.messageCount ?? null;
+		result.socketsAfterSwitch = listSockets(); // pi still alive here — snapshot now
+		if (wantSelf) {
+			phase = 3;
+			send({ type: "prompt", message: selfPrompt, id: "p2" });
+		} else {
+			phase = 4;
+			finish();
+		}
+	}
+});
+
+child.on("error", (err: Error) => {
+	process.stderr.write(`gnew-rpc-drive: spawn failed: ${err.message}\n`);
+	process.exit(2);
+});
+child.on("exit", () => {
+	if (phase < 4) finish();
+});
+
+// kick off
+send({ type: "get_state", id: "g1" });

package/scripts/lib/acp-child-cleanup.ts

@@ -0,0 +1,116 @@
+// Shared bounded child-process teardown for the LIVE smokes (ACP + entwurf-v2).
+//
+// WHY THIS EXISTS (test-infra, not a Phase-1/Phase-2 feature):
+// Every `smoke-acp-*-live.ts` carried its own copy of `terminateChild`, and
+// each copy ended its SIGKILL path with an UNBOUNDED `await exited`. When the
+// spawned child (or a grandchild ACP backend that still holds the stdio pipes)
+// never emits an "exit" event, that await hangs FOREVER — *after* the smoke has
+// already printed its PASS line. Individually the smokes pass; it is only this
+// post-PASS cleanup that wedges, which is exactly what froze the aggregate
+// `release-gate` runner (observed 2026-06-24: raw-turn PASS, then no further
+// output for >25min while the runner sat in cleanup).
+//
+// Crash-don't-warn (AGENTS.md): every wait here is BOUNDED, and if the child is
+// genuinely still alive after SIGKILL + a bounded grace we THROW. A leaked live
+// backend is broken tool state, not a warning. The only swallowed errors are
+// liveness PROBES (kill() / signal-0 / stdio destroy) — the one sanctioned use
+// of `catch {}` (environment probing), never control flow we lie about.
+
+import type { ChildProcess } from "node:child_process";
+
+const sleep = (ms: number): Promise<void> => new Promise((r) => setTimeout(r, ms));
+
+function destroyChildStdio(child: ChildProcess): void {
+	for (const stream of [child.stdin, child.stdout, child.stderr]) {
+		try {
+			stream?.destroy();
+		} catch {
+			// best-effort teardown; never load-bearing
+		}
+	}
+}
+
+export interface TerminateOptions {
+	/** Grace after SIGTERM before escalating to SIGKILL. */
+	graceMs?: number;
+	/** Bounded wait after SIGKILL before the signal-0 liveness probe. */
+	killWaitMs?: number;
+}
+
+/**
+ * Terminate a spawned smoke child with bounded waits and a loud failure.
+ *
+ * SIGTERM → grace → SIGKILL → bounded wait → signal-0 liveness probe.
+ * Returns when the child is gone (or was never alive); throws only if the
+ * child is provably STILL alive after SIGKILL + the bounded wait.
+ */
+export async function terminateChild(
+	child: ChildProcess,
+	{ graceMs = 2_000, killWaitMs = 2_000 }: TerminateOptions = {},
+): Promise<void> {
+	// Already reaped, but still close our side of the stdio pipes. With the SDK
+	// fluent connection a smoke can otherwise print PASS and keep Node alive on
+	// a retained pipe/read handle.
+	if (child.exitCode !== null || child.signalCode !== null) {
+		destroyChildStdio(child);
+		return;
+	}
+
+	const exited = new Promise<void>((resolve) => child.once("exit", () => resolve()));
+
+	try {
+		child.kill("SIGTERM");
+	} catch {
+		// kill() throws ESRCH when the process is already gone — treat as exited.
+		destroyChildStdio(child);
+		return;
+	}
+
+	const afterTerm = await Promise.race([
+		exited.then(() => "exited" as const),
+		sleep(graceMs).then(() => "timeout" as const),
+	]);
+	if (afterTerm === "exited") {
+		destroyChildStdio(child);
+		return;
+	}
+
+	// Grace elapsed — escalate. (The old bug: the wait AFTER this kill was
+	// unbounded `await exited`.)
+	try {
+		child.kill("SIGKILL");
+	} catch {
+		destroyChildStdio(child);
+		return; // raced to death between the grace race and this kill
+	}
+
+	// Release any stdio the helper may be pinning, so a missed "exit" event does
+	// not keep the event loop (and the pipes) alive. Probe-only — best effort.
+	destroyChildStdio(child);
+
+	const afterKill = await Promise.race([
+		exited.then(() => "exited" as const),
+		sleep(killWaitMs).then(() => "timeout" as const),
+	]);
+	if (afterKill === "exited") {
+		destroyChildStdio(child);
+		return;
+	}
+
+	// The "exit" event may simply have been missed even though the process is
+	// dead. Probe with signal 0: a throw (ESRCH/EPERM on a reaped pid) means the
+	// process is gone, so proceed; a clean return means it is genuinely alive.
+	const pid = child.pid;
+	if (pid === undefined) {
+		destroyChildStdio(child);
+		return; // never acquired a pid; nothing can leak
+	}
+	try {
+		process.kill(pid, 0);
+	} catch {
+		destroyChildStdio(child);
+		return; // gone — the exit event was just missed
+	}
+
+	throw new Error(`terminateChild: child pid=${pid} still alive after SIGKILL + ${killWaitMs}ms bounded wait`);
+}