@yusukeshib/pi-babysit 0.3.9 → 0.3.11

package/README.md

@@ -95,6 +95,14 @@ Tail and search results are capped at 200 lines and clipped to 8 KB. Pattern
 search returns the latest matching lines with line numbers. Do not read a
 potentially large log file in full.
 
+Subagent logs also compact Pi's streaming `message_update` events before they
+are recorded. Pi repeats the complete growing assistant message and partial
+snapshot on every token; pi-babysit retains only the incremental delta while
+leaving authoritative `message_end`, tool, lifecycle, response, and error
+events untouched. This keeps long RPC sessions approximately linear in emitted
+content without changing final answers, completion detection, or follow-up
+behavior. Live `/babysit` and attach views render the retained deltas.
+
 All shell commands, including `pwd` and Git, are redirected to `babysit_run`.
 Set `PI_BABYSIT_ALLOW_BASH=1` only as an explicit emergency escape hatch.
 

package/format-stream.mjs

@@ -1,12 +1,11 @@
 #!/usr/bin/env node
 /**
- * format-stream.mjs — human-readable view for a `pi --mode json` event stream.
+ * format-stream.mjs — human-readable view for a `pi --mode rpc` event stream.
  *
- * babysit records the raw JSONL to its log (machine scrapers + `babysit log`
- * stay untouched); this filter only sits on the interactive attach path via
- * `babysit run --view-cmd`. It reads the JSONL on stdin and prints a colored,
- * incrementally-streamed transcript on stdout so a human attaching the tmux
- * pane sees turns, thinking, tool calls and answers instead of a JSON firehose.
+ * This filter sits on the interactive attach path via `babysit run --view-cmd`.
+ * It accepts both Pi's raw cumulative updates and pi-babysit's compact deltas,
+ * then prints a colored, incrementally streamed transcript so a human sees
+ * turns, thinking, tool calls and answers instead of a JSON firehose.
  */
 import * as readline from "node:readline";
 
@@ -52,8 +51,8 @@ function summarizeTool(name, a = {}) {
 }
 
 // Join the text of a given block kind ("text" or "thinking") in a message's
-// content array. message_update re-emits the whole (growing) message, so we
-// compare lengths against what we've already printed to append only the delta.
+// content array. Unfiltered RPC streams repeat the whole growing message;
+// pi-babysit's compact stream instead retains only assistantMessageEvent.delta.
 function blockText(content, kind) {
 	if (!Array.isArray(content)) return "";
 	let s = "";
@@ -75,15 +74,20 @@ const openBlock = () => {
 	out("\n");
 };
 
-function streamMessage(msg, fresh = false) {
-	if (!msg || msg.role !== "assistant") return;
-	const id = msg.id ?? `t${turn}`;
+function messageState(id = `t${turn}`, fresh = false) {
 	if (fresh) emitted.delete(id);
 	let st = emitted.get(id);
 	if (!st) {
 		st = { think: 0, text: 0, hThink: false, hText: false };
 		emitted.set(id, st);
 	}
+	return st;
+}
+
+function streamMessage(msg, fresh = false) {
+	if (!msg || msg.role !== "assistant") return;
+	const id = msg.id ?? `t${turn}`;
+	const st = messageState(id, fresh);
 	const think = blockText(msg.content, "thinking");
 	if (think.length > st.think) {
 		if (!st.hThink) {
@@ -106,6 +110,28 @@ function streamMessage(msg, fresh = false) {
 	}
 }
 
+function streamDelta(event) {
+	if (!event || typeof event.delta !== "string" || !event.delta) return;
+	const st = messageState();
+	if (event.type === "thinking_delta") {
+		if (!st.hThink) {
+			openBlock();
+			out(`${C.gray}[think] `);
+			st.hThink = true;
+		}
+		out(C.gray + event.delta + C.reset);
+		st.think += event.delta.length;
+	} else if (event.type === "text_delta") {
+		if (!st.hText) {
+			openBlock();
+			out(`${C.green}[text]${C.reset} `);
+			st.hText = true;
+		}
+		out(event.delta);
+		st.text += event.delta.length;
+	}
+}
+
 function usageLine(msg) {
 	const u = msg?.usage;
 	if (!u) return;
@@ -138,7 +164,8 @@ rl.on("line", (line) => {
 			streamMessage(ev.message, true);
 			break;
 		case "message_update":
-			streamMessage(ev.message);
+			if (ev.message) streamMessage(ev.message);
+			else streamDelta(ev.assistantMessageEvent);
 			break;
 		case "message_end":
 			streamMessage(ev.message);

package/index.ts

@@ -38,7 +38,7 @@ import * as path from "node:path";
 import { fileURLToPath } from "node:url";
 import type { ExtensionAPI, ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
 import { getMarkdownTheme } from "@earendil-works/pi-coding-agent";
-import { Box, Container, Markdown, Text } from "@earendil-works/pi-tui";
+import { Box, Markdown, Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 import { StringEnum } from "@earendil-works/pi-ai";
 import { type AgentConfig, type AgentScope, discoverAgents } from "./agents";
@@ -130,10 +130,10 @@ export function planSubagentSpawn(
 // apart from any other turn end (see isParkedToolResult / self-reap.ts).
 export const NOTIFY_MARKER = "[notify-on-exit]";
 
-// Human-readable view for the subagent JSONL stream when a human attaches.
-// babysit records the raw JSON to its log (parsers unaffected) and pipes only
-// the live attach view through this formatter. Set PI_BABYSIT_VIEW_CMD="" to
-// disable (raw JSON), or to a custom command to override.
+// Human-readable view for the compact subagent JSONL stream when a human
+// attaches. The RPC proxy removes cumulative streaming snapshots before both
+// recording and display; authoritative events remain intact for parsers. Set
+// PI_BABYSIT_VIEW_CMD="" to disable formatting, or provide a custom command.
 const EXT_DIR = path.dirname(fileURLToPath(import.meta.url));
 const shq = (s: string) => `'${s.replace(/'/g, `'\\''`)}'`;
 const VIEW_CMD =
@@ -634,7 +634,10 @@ export function summarizeNotificationCommand(command: string | undefined): strin
 			.trim()
 			.replace(/\r/g, "\\r")
 			.replace(/\n/g, "\\n")
-			.replace(/\t/g, "\\t") || "?";
+			.replace(/\t/g, "\\t")
+			.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x9F]/g, (char) =>
+				`\\x${char.charCodeAt(0).toString(16).toUpperCase().padStart(2, "0")}`,
+			) || "?";
 	const bytes = Buffer.from(preview, "utf8");
 	if (bytes.length <= NOTIFY_COMMAND_MAX_BYTES) return preview;
 	if (NOTIFY_COMMAND_MAX_BYTES === 0) return "";
@@ -674,6 +677,7 @@ interface ProcessCompletionMessage {
 		status: CompletionStatus;
 		runtime?: string;
 		logPath?: string;
+		command?: string;
 		count: number;
 		totalCount: number;
 		remainingCount: number;
@@ -683,6 +687,7 @@ interface ProcessCompletionMessage {
 			success: boolean;
 			status: CompletionStatus;
 			runtime: string;
+			command: string | undefined;
 			logPath: string;
 		}>;
 	};
@@ -791,6 +796,7 @@ export function buildProcessCompletionMessage(
 		success: notice.success,
 		status: notice.status,
 		runtime: notice.runtime,
+		command: notice.command,
 		logPath: notice.logPath,
 	}));
 	const single = totalCount === 1 ? batch[0] : undefined;
@@ -805,6 +811,7 @@ export function buildProcessCompletionMessage(
 			status,
 			runtime: single?.runtime,
 			logPath: single?.logPath,
+			command: single?.command,
 			count: batch.length,
 			totalCount,
 			remainingCount: totalCount - batch.length,
@@ -871,7 +878,7 @@ interface ToolCall {
 	name: string;
 	summary: string;
 }
-interface Progress {
+export interface Progress {
 	turns: number;
 	toolCalls: ToolCall[];
 	finalText: string;
@@ -914,7 +921,7 @@ function summarizeToolCall(name: string, args: Record<string, unknown>): string
 	}
 }
 
-function parseEvents(logText: string): Progress {
+export function parseEvents(logText: string): Progress {
 	const p: Progress = {
 		turns: 0,
 		toolCalls: [],
@@ -1122,13 +1129,21 @@ async function spawnSubagent(
 		"--timeout",
 		opts.timeout,
 	];
-	// Pretty-print the JSONL stream for humans who `attach`; the recorded log
-	// stays raw so parseEvents/`babysit log` are unaffected.
+	// Pretty-print the compact JSONL stream for humans who `attach`. The RPC
+	// proxy removes only cumulative streaming snapshots; authoritative final,
+	// tool, lifecycle, response, and error events remain intact for parseEvents.
 	if (VIEW_CMD.trim()) bsArgs.push("--view-cmd", VIEW_CMD);
 	if (opts.idleTimeout && opts.idleTimeout !== "none") {
 		bsArgs.push("--idle-timeout", opts.idleTimeout);
 	}
-	bsArgs.push("--", PI_BIN, ...piArgs);
+	bsArgs.push(
+		"--",
+		process.execPath,
+		path.join(EXT_DIR, "rpc-stream-proxy.mjs"),
+		"--",
+		PI_BIN,
+		...piArgs,
+	);
 
 	const r = await bs(bsArgs, {
 		cwd: opts.cwd,
@@ -1738,11 +1753,20 @@ export default function (pi: ExtensionAPI) {
 			status?: DisplayStatus;
 			success?: boolean;
 			exitCode?: number | null;
+			command?: string;
+			count?: number;
 		};
 		const status =
 			d.status ?? (d.success ? "success" : d.exitCode == null ? "terminated" : "failed");
+		const payload = d.command
+			? `  ${summarizeNotificationCommand(d.command)}`
+			: d.count && d.count > 1
+				? `  ×${d.count}`
+				: "";
+		const header = theme.fg("warning", theme.bold(`babysit_run COMMAND${payload}`));
 		const box = new Box(1, 1, (t) => theme.bg("toolSuccessBg", t));
-		box.addChild(new Text(renderStatus(status, theme, "babysit_run"), 0, 0));
+		box.addChild(new Text(header, 0, 0));
+		box.addChild(new Text(renderStatus(status, theme), 0, 0));
 		box.addChild(new Text(theme.fg("toolOutput", content), 0, 0));
 		return box;
 	});
@@ -2129,10 +2153,19 @@ export default function (pi: ExtensionAPI) {
 				},
 			};
 		},
-		// The result label already includes "babysit_run"; suppress the default
-		// call header so the tool name is not shown twice in adjacent lines.
-		renderCall() {
-			return new Container();
+		// Make the execution kind and payload identifiable before the result arrives.
+		// Use semantic theme colors rather than the fallback gray tool-call text.
+		renderCall(args, theme) {
+			const isSubagent = args.profile === "subagent";
+			const kind = isSubagent ? "AGENT" : "COMMAND";
+			const payload = isSubagent ? args.task : args.command;
+			const agent = isSubagent && args.agent ? ` [${args.agent}]` : "";
+			const title = theme.bold(`babysit_run ${kind}`);
+			const detail =
+				typeof payload === "string" && payload.length > 0
+					? `  ${summarizeNotificationCommand(payload)}`
+					: "";
+			return new Text(theme.fg("warning", `${title}${agent}${detail}`), 0, 0);
 		},
 		renderResult(result, { isPartial }, theme, context) {
 			const details = (result.details ?? {}) as {
@@ -2160,7 +2193,7 @@ export default function (pi: ExtensionAPI) {
 							: details.kind === "subagent" || content.includes(NOTIFY_MARKER)
 								? "started"
 								: "success");
-			const label = renderStatus(status, theme, "babysit_run");
+			const label = renderStatus(status, theme);
 			return new Text(content ? `${label}\n${theme.fg("toolOutput", content)}` : label, 0, 0);
 		},
 	});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yusukeshib/pi-babysit",
-  "version": "0.3.9",
+  "version": "0.3.11",
   "description": "Run any shell command and pi subagents under babysit, with context-safe captured output.",
   "keywords": [
     "pi-package",
@@ -23,6 +23,7 @@
     "agents.ts",
     "self-reap.ts",
     "format-stream.mjs",
+    "rpc-stream-proxy.mjs",
     "search-log.mjs",
     "README.md",
     "LICENSE"

package/rpc-stream-proxy.mjs

@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+/**
+ * Transparent stdin/stdout proxy for `pi --mode rpc`.
+ *
+ * Pi's `message_update` events repeat the entire growing assistant message and
+ * `assistantMessageEvent.partial` on every token. Those cumulative snapshots
+ * are useful only while streaming; `message_end` is the authoritative final
+ * message. Persisting every snapshot makes babysit logs grow quadratically.
+ *
+ * This proxy forwards stdin byte-for-byte and compacts only `message_update`
+ * lines on stdout. All final, tool, lifecycle, response, and error events pass
+ * through byte-for-byte.
+ */
+import { spawn } from "node:child_process";
+import { StringDecoder } from "node:string_decoder";
+import { pathToFileURL } from "node:url";
+
+export function compactRpcLine(line) {
+	if (!line.trimStart().startsWith("{")) return line;
+
+	let event;
+	try {
+		event = JSON.parse(line);
+	} catch {
+		return line;
+	}
+	if (event?.type !== "message_update") return line;
+
+	const { message: _cumulativeMessage, assistantMessageEvent, ...rest } = event;
+	if (!assistantMessageEvent || typeof assistantMessageEvent !== "object") {
+		return JSON.stringify(rest);
+	}
+	const { partial: _cumulativePartial, ...deltaEvent } = assistantMessageEvent;
+	return JSON.stringify({ ...rest, assistantMessageEvent: deltaEvent });
+}
+
+function transformRpcOutput(input, output) {
+	return new Promise((resolve, reject) => {
+		const decoder = new StringDecoder("utf8");
+		let buffered = "";
+
+		const write = (value) => {
+			if (!output.write(value)) input.pause();
+		};
+		output.on("drain", () => input.resume());
+		input.on("error", reject);
+		input.on("data", (chunk) => {
+			buffered += decoder.write(chunk);
+			for (;;) {
+				const newline = buffered.indexOf("\n");
+				if (newline < 0) break;
+				const line = buffered.slice(0, newline);
+				buffered = buffered.slice(newline + 1);
+				write(`${compactRpcLine(line)}\n`);
+			}
+		});
+		input.on("end", () => {
+			buffered += decoder.end();
+			if (buffered) write(compactRpcLine(buffered));
+			if (output.writableNeedDrain) output.once("drain", resolve);
+			else resolve();
+		});
+	});
+}
+
+function waitForDrain(stream) {
+	return stream.writableNeedDrain
+		? new Promise((resolve) => stream.once("drain", resolve))
+		: Promise.resolve();
+}
+
+export function runRpcProxy(argv = process.argv.slice(2)) {
+	const separator = argv.indexOf("--");
+	const command = separator >= 0 ? argv[separator + 1] : argv[0];
+	const args = separator >= 0 ? argv.slice(separator + 2) : argv.slice(1);
+	if (!command) {
+		console.error("Usage: rpc-stream-proxy.mjs -- <command> [args...]");
+		process.exitCode = 2;
+		return;
+	}
+
+	const child = spawn(command, args, {
+		cwd: process.cwd(),
+		env: process.env,
+		stdio: ["pipe", "pipe", "pipe"],
+	});
+
+	let transportFailed = false;
+	process.stdin.pipe(child.stdin);
+	// The RPC worker can exit or self-reap while a command is still arriving.
+	// Ignore the resulting pipe-close race so the proxy preserves the worker's
+	// actual exit code/signal instead of crashing with an unhandled EPIPE.
+	child.stdin.on("error", (error) => {
+		if (error?.code === "EPIPE" || error?.code === "ERR_STREAM_DESTROYED") return;
+		transportFailed = true;
+		console.error(`rpc stream proxy stdin failed: ${error.message}`);
+	});
+	const outputFlushed = transformRpcOutput(child.stdout, process.stdout);
+	child.stderr.pipe(process.stderr);
+
+	const forwardedSignals = ["SIGINT", "SIGTERM", "SIGHUP"];
+	const signalHandlers = new Map(
+		forwardedSignals.map((signal) => [signal, () => child.kill(signal)]),
+	);
+	for (const [signal, handler] of signalHandlers) process.on(signal, handler);
+	let spawnFailed = false;
+	child.on("error", (error) => {
+		spawnFailed = true;
+		console.error(`rpc stream proxy failed to start ${command}: ${error.message}`);
+	});
+	child.on("close", async (code, signal) => {
+		try {
+			await outputFlushed;
+			await Promise.all([waitForDrain(process.stdout), waitForDrain(process.stderr)]);
+		} catch (error) {
+			console.error(`rpc stream proxy output failed: ${error.message}`);
+			process.exitCode = 1;
+			return;
+		}
+		if (transportFailed) {
+			process.exitCode = 1;
+			return;
+		}
+		if (signal) {
+			for (const [forwarded, handler] of signalHandlers) process.off(forwarded, handler);
+			process.kill(process.pid, signal);
+			return;
+		}
+		process.exitCode = spawnFailed ? 1 : (code ?? 1);
+	});
+}
+
+const entry = process.argv[1] ? pathToFileURL(process.argv[1]).href : undefined;
+if (entry === import.meta.url) runRpcProxy();