@sayknow-cli/coding-agent 0.3.12 → 0.3.15

package/src/modes/print-mode.ts

@@ -6,7 +6,7 @@
  * - `skc --mode json "prompt"` - JSON event stream
  */
 import { type AssistantMessage, type ImageContent, isContextOverflow } from "@sayknow-cli/ai";
-import { logger, sanitizeText } from "@sayknow-cli/utils";
+import { isKnownSinkPeerClosedError, logger, sanitizeText } from "@sayknow-cli/utils";
 import type { AgentSession } from "../session/agent-session";
 import { isSilentAbort } from "../session/messages";
 import { initializeExtensions } from "./runtime-init";
@@ -24,9 +24,8 @@ export interface PrintModeOptions {
 	/** Images to attach to the initial message */
 	initialImages?: ImageContent[];
 	/**
-	 * When true, an assistant error/abort does not call process.exit(); print mode
-	 * returns instead so the caller (e.g. RLM autonomous mode) can run its own
-	 * finalization/cleanup before the process exits.
+	 * When true, a terminal assistant error/abort leaves process exit status
+	 * untouched so the caller can run its own finalization and status handling.
 	 */
 	suppressProcessExit?: boolean;
 }
@@ -42,7 +41,7 @@ export interface PrintModeOptions {
  * events from the subscription and does not run this terminal-error branch, so
  * it is intentionally NOT covered by this exit code.
  */
-export const CONTEXT_OVERFLOW_EXIT_CODE = 2;
+export const CONTEXT_OVERFLOW_EXIT_CODE = 78;
 
 /**
  * Build an actionable stderr diagnostic for a terminal context-overflow error in
@@ -58,113 +57,250 @@ function formatContextOverflowError(message: AssistantMessage, autoCompactionEna
 	return `${guidance}${providerDetail}`;
 }
 
+/**
+ * Own process stdout only while print mode is actively writing. This lets this
+ * mode absorb a peer-closing its output pipe without changing error-listener
+ * ownership for the interactive/TUI and clipboard paths.
+ */
+function createPrintStdoutOwner(): {
+	write(chunk: string): void;
+	flush(): Promise<void>;
+	dispose(): void;
+} {
+	let epipeLatched = false;
+	let writeError: unknown;
+	let hasWriteError = false;
+	const pendingWrites = new Set<{ done: Promise<void>; settle(): void }>();
+
+	const isEpipe = (error: unknown): boolean => {
+		try {
+			return (error as NodeJS.ErrnoException | null | undefined)?.code === "EPIPE";
+		} catch {
+			return false;
+		}
+	};
+
+	const settlePendingWrites = (): void => {
+		for (const pending of [...pendingWrites]) pending.settle();
+	};
+
+	const handleWriteError = (error: unknown): void => {
+		// An EPIPE from this owned stdout sink proves its peer closed. A destroyed
+		// stream does not prove that independently, so it is tolerated only after
+		// this owner has already observed and latched an EPIPE.
+		if (isEpipe(error)) {
+			epipeLatched = true;
+			settlePendingWrites();
+			return;
+		}
+		if (epipeLatched && isKnownSinkPeerClosedError(error)) {
+			settlePendingWrites();
+			return;
+		}
+
+		if (!hasWriteError) {
+			writeError = error;
+			hasWriteError = true;
+		}
+		settlePendingWrites();
+	};
+
+	const onStdoutError = (error: Error): void => {
+		handleWriteError(error);
+	};
+	process.stdout.on("error", onStdoutError);
+
+	const waitForWrites = async (): Promise<void> => {
+		while (pendingWrites.size > 0) {
+			await Promise.all([...pendingWrites].map(pending => pending.done));
+		}
+	};
+
+	return {
+		write(chunk: string): void {
+			if (epipeLatched || hasWriteError) return;
+
+			let settled = false;
+			const completion = Promise.withResolvers<void>();
+			let pending: { done: Promise<void>; settle(): void };
+			pending = {
+				done: completion.promise,
+				settle: (): void => {
+					if (settled) return;
+					settled = true;
+					pendingWrites.delete(pending);
+					completion.resolve();
+				},
+			};
+			const complete = (error?: Error | null): void => {
+				if (settled) return;
+				if (error) handleWriteError(error);
+				pending.settle();
+			};
+
+			pendingWrites.add(pending);
+			try {
+				process.stdout.write(chunk, complete);
+			} catch (error) {
+				handleWriteError(error);
+				pending.settle();
+			}
+		},
+
+		async flush(): Promise<void> {
+			await waitForWrites();
+			if (!epipeLatched && !hasWriteError) {
+				this.write("");
+				await waitForWrites();
+			}
+			if (hasWriteError) throw writeError;
+		},
+
+		dispose(): void {
+			process.stdout.removeListener("error", onStdoutError);
+		},
+	};
+}
+
+async function writeStderrAndQuiesce(chunk: string): Promise<void> {
+	const completion = Promise.withResolvers<void>();
+	let settled = false;
+	const complete = (error?: unknown): void => {
+		if (settled) return;
+		settled = true;
+		if (error === undefined || error === null) completion.resolve();
+		else completion.reject(error);
+	};
+
+	try {
+		process.stderr.write(chunk, complete);
+	} catch (error) {
+		complete(error);
+	}
+	await completion.promise;
+}
+
+function throwCollectedErrors(errors: unknown[]): void {
+	const uniqueErrors = [...new Set(errors)];
+	if (uniqueErrors.length === 0) return;
+	if (uniqueErrors.length === 1) throw uniqueErrors[0];
+	throw new AggregateError(uniqueErrors, "Print mode failed while flushing output and disposing the session");
+}
+
 /**
  * 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;
+	const stdout = createPrintStdoutOwner();
+	const failures: unknown[] = [];
+	let unsubscribe: (() => void) | undefined;
 
-	// Emit session header for JSON mode
-	if (mode === "json") {
-		const header = session.sessionManager.getHeader();
-		if (header) {
-			process.stdout.write(`${JSON.stringify(header)}\n`);
+	try {
+		// Emit session header for JSON mode.
+		if (mode === "json") {
+			const header = session.sessionManager.getHeader();
+			if (header) stdout.write(`${JSON.stringify(header)}\n`);
 		}
-	}
-	// Set up extensions for print mode (no UI, no command context)
-	await initializeExtensions(session, {
-		reportSendError: (action, err) => {
-			process.stderr.write(
-				`Extension ${action === "extension_send" ? "sendMessage" : "sendUserMessage"} failed: ${err.message}\n`,
-			);
-		},
-		reportRuntimeError: err => {
-			process.stderr.write(`Extension error (${err.extensionPath}): ${err.error}\n`);
-		},
-	});
 
-	// Always subscribe to enable session persistence via _handleAgentEvent
-	session.subscribe(event => {
-		// In JSON mode, output all events
+		// Set up extensions for print mode (no UI, no command context).
+		await initializeExtensions(session, {
+			reportSendError: (action, err) => {
+				process.stderr.write(
+					`Extension ${action === "extension_send" ? "sendMessage" : "sendUserMessage"} failed: ${err.message}\n`,
+				);
+			},
+			reportRuntimeError: err => {
+				process.stderr.write(`Extension error (${err.extensionPath}): ${err.error}\n`);
+			},
+		});
+
+		// AgentSession persists events internally. Print mode only needs a listener
+		// when it must render the JSON event stream.
 		if (mode === "json") {
-			process.stdout.write(`${JSON.stringify(event)}\n`);
+			unsubscribe = session.subscribe(event => {
+				stdout.write(`${JSON.stringify(event)}\n`);
+			});
 		}
-	});
 
-	// Send initial message with attachments
-	if (initialMessage !== undefined) {
-		await logger.time("print:prompt:initial", () => session.prompt(initialMessage, { images: initialImages }));
-	}
+		// Send initial message with attachments.
+		if (initialMessage !== undefined) {
+			await logger.time("print:prompt:initial", () => session.prompt(initialMessage, { images: initialImages }));
+		}
 
-	// Send remaining messages
-	for (const message of messages) {
-		await logger.time("print:prompt:next", () => session.prompt(message));
-	}
+		// Send remaining messages.
+		for (const message of messages) {
+			await logger.time("print:prompt:next", () => session.prompt(message));
+		}
 
-	// In text mode, output final response
-	if (mode === "text") {
-		const state = session.state;
-		const lastMessage = state.messages.findLast(message => message.role === "assistant");
-
-		if (lastMessage?.role === "assistant") {
-			const assistantMsg = lastMessage as AssistantMessage;
-
-			// Check for error/aborted — skip silent-abort (plan-mode compaction transition)
-			if (
-				(assistantMsg.stopReason === "error" || assistantMsg.stopReason === "aborted") &&
-				!isSilentAbort(assistantMsg.errorMessage)
-			) {
-				// Context-overflow is an expected, recoverable-in-principle condition — not
-				// an opaque crash. Auto-compaction has already run inside session.prompt();
-				// if we still land here the request could not be made to fit. In this
-				// text-mode final-response path, surface an actionable diagnostic and a
-				// distinct exit code so text-mode (`skc -p`) callers can detect context
-				// exhaustion instead of parsing the raw provider error string. (JSON mode
-				// does not reach this branch and is intentionally out of scope.)
-				const isOverflow =
-					assistantMsg.stopReason === "error" && isContextOverflow(assistantMsg, session.model?.contextWindow);
-				const errorLine = isOverflow
-					? formatContextOverflowError(assistantMsg, session.autoCompactionEnabled)
-					: sanitizeText(assistantMsg.errorMessage || `Request ${assistantMsg.stopReason}`);
-				const exitCode = isOverflow ? CONTEXT_OVERFLOW_EXIT_CODE : 1;
-				const flushed = process.stderr.write(`${errorLine}\n`);
-				// When the caller owns finalization (RLM autonomous), return instead of
-				// exiting so its cleanup runs; the caller surfaces a non-zero exit itself.
-				if (!options.suppressProcessExit) {
-					if (flushed) {
-						process.exit(exitCode);
-					} else {
-						process.stderr.once("drain", () => process.exit(exitCode));
-					}
+		// In text mode, output final response.
+		if (mode === "text") {
+			const lastMessage = session.state.messages.findLast(message => message.role === "assistant");
+			if (lastMessage?.role === "assistant") {
+				const assistantMsg = lastMessage as AssistantMessage;
+				let printContent = true;
+
+				// Check for error/aborted — skip silent-abort (plan-mode compaction transition).
+				if (
+					(assistantMsg.stopReason === "error" || assistantMsg.stopReason === "aborted") &&
+					!isSilentAbort(assistantMsg.errorMessage)
+				) {
+					const isOverflow =
+						assistantMsg.stopReason === "error" && isContextOverflow(assistantMsg, session.model?.contextWindow);
+					const errorLine = isOverflow
+						? formatContextOverflowError(assistantMsg, session.autoCompactionEnabled)
+						: sanitizeText(assistantMsg.errorMessage || `Request ${assistantMsg.stopReason}`);
+					const exitCode = isOverflow ? CONTEXT_OVERFLOW_EXIT_CODE : 1;
+
+					if (!options.suppressProcessExit) process.exitCode = exitCode;
+					await writeStderrAndQuiesce(`${errorLine}\n`);
+					printContent = false;
 				}
-			}
 
-			if (
-				assistantMsg.errorMessage &&
-				assistantMsg.stopReason !== "error" &&
-				assistantMsg.stopReason !== "aborted"
-			) {
-				process.stderr.write(`${sanitizeText(assistantMsg.errorMessage)}\n`);
-			}
+				if (
+					assistantMsg.errorMessage &&
+					assistantMsg.stopReason !== "error" &&
+					assistantMsg.stopReason !== "aborted"
+				) {
+					await writeStderrAndQuiesce(`${sanitizeText(assistantMsg.errorMessage)}\n`);
+				}
 
-			// Output text content
-			for (const content of assistantMsg.content) {
-				if (content.type === "text") {
-					process.stdout.write(`${sanitizeText(content.text)}\n`);
+				if (printContent) {
+					for (const content of assistantMsg.content) {
+						if (content.type === "text") stdout.write(`${sanitizeText(content.text)}\n`);
+					}
 				}
 			}
 		}
-	}
 
-	// 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();
-		});
-	});
+		// Observe callback and stream errors from every preceding print-mode write.
+		await stdout.flush();
+	} catch (error) {
+		failures.push(error);
+	} finally {
+		// The JSON subscriber remains live while disposal emits its final events.
+		try {
+			await session.dispose();
+		} catch (error) {
+			failures.push(error);
+		}
+
+		// Disposal may have written JSON or delivered a late stdout error.
+		try {
+			await stdout.flush();
+		} catch (error) {
+			failures.push(error);
+		}
+
+		try {
+			unsubscribe?.();
+		} catch (error) {
+			failures.push(error);
+		} finally {
+			stdout.dispose();
+		}
+	}
 
-	await session.dispose();
+	throwCollectedErrors(failures);
 }

package/src/modes/rpc/rpc-client.ts

@@ -3,7 +3,13 @@
  *
  * Spawns the agent in RPC mode and provides a typed API for all operations.
  */
-import type { AgentEvent, AgentMessage, AgentToolResult, ThinkingLevel } from "@sayknow-cli/agent-core";
+import {
+	type AgentEvent,
+	type AgentMessage,
+	type AgentToolResult,
+	type ResolvedThinkingLevel,
+	ThinkingLevel,
+} from "@sayknow-cli/agent-core";
 import type { CompactionResult } from "@sayknow-cli/agent-core/compaction";
 import type { ImageContent, Model } from "@sayknow-cli/ai";
 import { isRecord, ptree, readJsonl } from "@sayknow-cli/utils";
@@ -64,6 +70,12 @@ export interface RpcClientOptions {
 
 export type ModelInfo = Pick<Model, "provider" | "id" | "contextWindow" | "reasoning" | "thinking">;
 
+export type RpcDefaultModelSelection = {
+	readonly provider: string;
+	readonly modelId: string;
+	readonly thinkingLevel: ResolvedThinkingLevel;
+};
+
 export type RpcEventListener = (event: AgentEvent) => void;
 export type RpcSessionEventListener = (event: AgentSessionEvent) => void;
 
@@ -94,6 +106,7 @@ export function defineRpcClientTool<
 }
 
 const agentWireEventTypes = new Set<AgentWireEventType>(AGENT_WIRE_EVENT_TYPES);
+const DEFAULT_MODEL_SELECTION_TIMEOUT_MS = 600_000;
 const coreAgentEventTypes = new Set<AgentEvent["type"]>([
 	"agent_start",
 	"agent_end",
@@ -107,6 +120,29 @@ const coreAgentEventTypes = new Set<AgentEvent["type"]>([
 	"tool_execution_end",
 ]);
 
+function isResolvedThinkingLevel(value: unknown): value is ResolvedThinkingLevel {
+	return (
+		value === ThinkingLevel.Off ||
+		value === ThinkingLevel.Minimal ||
+		value === ThinkingLevel.Low ||
+		value === ThinkingLevel.Medium ||
+		value === ThinkingLevel.High ||
+		value === ThinkingLevel.XHigh ||
+		value === ThinkingLevel.Max
+	);
+}
+
+function isDefaultModelSelection(value: unknown): value is RpcDefaultModelSelection {
+	return (
+		isRecord(value) &&
+		typeof value.provider === "string" &&
+		value.provider.trim().length > 0 &&
+		typeof value.modelId === "string" &&
+		value.modelId.trim().length > 0 &&
+		isResolvedThinkingLevel(value.thinkingLevel)
+	);
+}
+
 function isRpcResponse(value: unknown): value is RpcResponse {
 	if (!isRecord(value)) return false;
 	if (value.type !== "response") return false;
@@ -626,6 +662,27 @@ export class RpcClient {
 		return this.#getData(response);
 	}
 
+	async setDefaultModelSelection(
+		provider: string,
+		modelId: string,
+		thinkingLevel: ResolvedThinkingLevel,
+	): Promise<RpcDefaultModelSelection> {
+		const response = await this.#send(
+			{
+				type: "set_default_model_selection",
+				provider,
+				modelId,
+				thinkingLevel,
+			},
+			DEFAULT_MODEL_SELECTION_TIMEOUT_MS,
+		);
+		if (!response.success) return this.#getData(response);
+		if (response.command !== "set_default_model_selection" || !isDefaultModelSelection(response.data)) {
+			throw new Error("Invalid set_default_model_selection response");
+		}
+		return this.#getData(response);
+	}
+
 	/**
 	 * Cycle to next model.
 	 */