gsd-pi 2.76.0 → 2.77.0-dev.538325aea

package/packages/gsd-agent-modes/src/modes/print-mode.ts

@@ -0,0 +1,106 @@
+/**
+ * Print mode (single-shot): Send prompts, output result, exit.
+ *
+ * Used for:
+ * - `pi -p "prompt"` - text output
+ * - `pi --mode json "prompt"` - JSON event stream
+ */
+
+import type { AssistantMessage, ImageContent } from "@gsd/pi-ai";
+import type { AgentSession } from "@gsd/agent-core";
+import { createDefaultCommandContextActions } from "./shared/command-context-actions.js";
+
+/**
+ * Options for print mode.
+ */
+export interface PrintModeOptions {
+	/** Output mode: "text" for final response only, "json" for all events */
+	mode: "text" | "json";
+	/** Array of additional prompts to send after initialMessage */
+	messages?: string[];
+	/** First message to send (may contain @file content) */
+	initialMessage?: string;
+	/** Images to attach to the initial message */
+	initialImages?: ImageContent[];
+}
+
+/**
+ * Run in print (single-shot) mode.
+ * Sends prompts to the agent and outputs the result.
+ */
+export async function runPrintMode(session: AgentSession, options: PrintModeOptions): Promise<void> {
+	const { mode, messages = [], initialMessage, initialImages } = options;
+	if (mode === "json") {
+		const header = session.sessionManager.getHeader();
+		if (header) {
+			console.log(JSON.stringify(header));
+		}
+	}
+	// Set up extensions for print mode (no UI)
+	await session.bindExtensions({
+		commandContextActions: createDefaultCommandContextActions(session),
+		onError: (err) => {
+			console.error(`Extension error (${err.extensionPath}): ${err.error}`);
+		},
+	});
+
+	// Always subscribe to enable session persistence via _handleAgentEvent
+	const unsubscribe = session.subscribe((event) => {
+		// In JSON mode, output all events
+		if (mode === "json") {
+			console.log(JSON.stringify(event));
+		}
+	});
+
+	let exitCode = 0;
+
+	try {
+		// Send initial message with attachments
+		if (initialMessage) {
+			await session.prompt(initialMessage, { images: initialImages });
+		}
+
+		// Send remaining messages
+		for (const message of messages) {
+			await session.prompt(message);
+		}
+
+		// In text mode, output final response
+		if (mode === "text") {
+			const state = session.state;
+			const lastMessage = state.messages[state.messages.length - 1];
+
+			if (lastMessage?.role === "assistant") {
+				const assistantMsg = lastMessage as AssistantMessage;
+
+				// Check for error/aborted
+				if (assistantMsg.stopReason === "error" || assistantMsg.stopReason === "aborted") {
+					console.error(assistantMsg.errorMessage || `Request ${assistantMsg.stopReason}`);
+					exitCode = 1;
+				} else {
+					// Output text content
+					for (const content of assistantMsg.content) {
+						if (content.type === "text") {
+							console.log(content.text);
+						}
+					}
+				}
+			}
+		}
+
+		// Ensure stdout is fully flushed before returning
+		// This prevents race conditions where the process exits before all output is written
+		await new Promise<void>((resolve, reject) => {
+			process.stdout.write("", (err) => {
+				if (err) reject(err);
+				else resolve();
+			});
+		});
+	} finally {
+		unsubscribe();
+	}
+
+	if (exitCode !== 0) {
+		process.exit(exitCode);
+	}
+}

package/packages/gsd-agent-modes/src/modes/rpc/jsonl.ts

@@ -0,0 +1,58 @@
+import type { Readable } from "node:stream";
+import { StringDecoder } from "node:string_decoder";
+
+/**
+ * Serialize a single strict JSONL record.
+ *
+ * Framing is LF-only. Payload strings may contain other Unicode separators such as
+ * U+2028 and U+2029. Clients must split records on `\n` only.
+ */
+export function serializeJsonLine(value: unknown): string {
+	return `${JSON.stringify(value)}\n`;
+}
+
+/**
+ * Attach an LF-only JSONL reader to a stream.
+ *
+ * This intentionally does not use Node readline. Readline splits on additional
+ * Unicode separators that are valid inside JSON strings and therefore does not
+ * implement strict JSONL framing.
+ */
+export function attachJsonlLineReader(stream: Readable, onLine: (line: string) => void): () => void {
+	const decoder = new StringDecoder("utf8");
+	let buffer = "";
+
+	const emitLine = (line: string): void => {
+		onLine(line.endsWith("\r") ? line.slice(0, -1) : line);
+	};
+
+	const onData = (chunk: string | Buffer): void => {
+		buffer += typeof chunk === "string" ? chunk : decoder.write(chunk);
+
+		while (true) {
+			const newlineIndex = buffer.indexOf("\n");
+			if (newlineIndex === -1) {
+				return;
+			}
+
+			emitLine(buffer.slice(0, newlineIndex));
+			buffer = buffer.slice(newlineIndex + 1);
+		}
+	};
+
+	const onEnd = (): void => {
+		buffer += decoder.end();
+		if (buffer.length > 0) {
+			emitLine(buffer);
+			buffer = "";
+		}
+	};
+
+	stream.on("data", onData);
+	stream.on("end", onEnd);
+
+	return () => {
+		stream.off("data", onData);
+		stream.off("end", onEnd);
+	};
+}

package/packages/gsd-agent-modes/src/modes/rpc/remote-terminal.ts

@@ -0,0 +1,109 @@
+import type { Terminal } from "@gsd/pi-tui";
+
+export interface RemoteTerminalOptions {
+	onWrite: (data: string) => void;
+	initialColumns?: number;
+	initialRows?: number;
+}
+
+/**
+ * Browser-backed terminal transport for the bridge-hosted native TUI.
+ * It implements the pi-tui Terminal contract but forwards output over the
+ * RPC bridge instead of writing to process stdout.
+ */
+export class RemoteTerminal implements Terminal {
+	private inputHandler?: (data: string) => void;
+	private resizeHandler?: () => void;
+	private _columns: number;
+	private _rows: number;
+
+	constructor(private readonly options: RemoteTerminalOptions) {
+		this._columns = Math.max(1, options.initialColumns ?? 120);
+		this._rows = Math.max(1, options.initialRows ?? 30);
+	}
+
+	start(onInput: (data: string) => void, onResize: () => void): void {
+		this.inputHandler = onInput;
+		this.resizeHandler = onResize;
+	}
+
+	stop(): void {
+		this.inputHandler = undefined;
+		this.resizeHandler = undefined;
+	}
+
+	async drainInput(): Promise<void> {
+		// Browser transport has no local stdin buffer to drain.
+	}
+
+	write(data: string): void {
+		if (!data) return;
+		this.options.onWrite(data);
+	}
+
+	get columns(): number {
+		return this._columns;
+	}
+
+	get rows(): number {
+		return this._rows;
+	}
+
+	get isTTY(): boolean {
+		// RemoteTerminal renders to a browser-based terminal emulator via
+		// the RPC bridge — it behaves like a real TTY for rendering purposes.
+		return true;
+	}
+
+	get kittyProtocolActive(): boolean {
+		return false;
+	}
+
+	pushInput(data: string): void {
+		if (!data) return;
+		this.inputHandler?.(data);
+	}
+
+	resize(columns: number, rows: number): void {
+		const nextColumns = Math.max(1, Math.floor(columns));
+		const nextRows = Math.max(1, Math.floor(rows));
+		const changed = nextColumns !== this._columns || nextRows !== this._rows;
+		this._columns = nextColumns;
+		this._rows = nextRows;
+		if (changed) {
+			this.resizeHandler?.();
+		}
+	}
+
+	moveBy(lines: number): void {
+		if (lines > 0) {
+			this.write(`\x1b[${lines}B`);
+		} else if (lines < 0) {
+			this.write(`\x1b[${-lines}A`);
+		}
+	}
+
+	hideCursor(): void {
+		this.write("\x1b[?25l");
+	}
+
+	showCursor(): void {
+		this.write("\x1b[?25h");
+	}
+
+	clearLine(): void {
+		this.write("\x1b[K");
+	}
+
+	clearFromCursor(): void {
+		this.write("\x1b[J");
+	}
+
+	clearScreen(): void {
+		this.write("\x1b[2J\x1b[H");
+	}
+
+	setTitle(title: string): void {
+		this.write(`\x1b]0;${title}\x07`);
+	}
+}