@gajae-code/coding-agent 0.12.11 → 0.12.12

package/src/extensibility/extensions/ouroboros-ooo-bridge.ts

@@ -0,0 +1,235 @@
+import type { MCPServerConnection, MCPToolCallResult } from "../../runtime-mcp";
+import { callTool, connectToServer, disconnectServer } from "../../runtime-mcp";
+import { createExactPrefixCommandBridge } from "./prefix-command-bridge";
+import type { ExtensionContext, InputEvent, InputEventResult } from "./types";
+
+const OUROBOROS_CLI_ENV = "OUROBOROS_CLI";
+const INTERVIEW_COMMAND = "ooo interview";
+const INTERVIEW_TOOL = "ouroboros_interview";
+const INTERVIEW_SESSION_PATTERN = /^interview_[A-Za-z0-9_-]+$/;
+
+interface OuroborosOooBridgeOptions {
+	connect?: typeof connectToServer;
+	callTool?: typeof callTool;
+	disconnect?: typeof disconnectServer;
+}
+
+interface InterviewState {
+	sessionId: string;
+}
+
+interface OuroborosOooBridgeHandler {
+	(event: InputEvent, ctx: ExtensionContext): Promise<InputEventResult>;
+	reset(): Promise<void>;
+}
+
+function resolveOuroborosCommand(): string {
+	return process.env[OUROBOROS_CLI_ENV]?.trim() || "ouroboros";
+}
+
+function interviewArgument(text: string): string | undefined {
+	if (text === INTERVIEW_COMMAND) return "";
+	if (text.startsWith(`${INTERVIEW_COMMAND} `) || text.startsWith(`${INTERVIEW_COMMAND}\t`)) {
+		return text.slice(INTERVIEW_COMMAND.length).trim();
+	}
+	return undefined;
+}
+
+function isOooCommand(text: string): boolean {
+	return text === "ooo" || text.startsWith("ooo ") || text.startsWith("ooo\t");
+}
+
+function isBuiltInControlInput(text: string): boolean {
+	return text === "." || text === "c" || text.startsWith("/");
+}
+
+function resetsInterviewState(text: string): boolean {
+	return /^\/(?:clear|drop|exit|new|quit)(?:\s|$)/.test(text);
+}
+
+function resultText(result: MCPToolCallResult): string {
+	return result.content
+		.filter(content => content.type === "text")
+		.map(content => content.text)
+		.join("\n\n")
+		.trim();
+}
+
+function resultMeta(result: MCPToolCallResult): Record<string, unknown> {
+	return result._meta ?? {};
+}
+
+function resultSessionId(result: MCPToolCallResult, text: string): string | undefined {
+	const metadataSessionId = resultMeta(result).session_id;
+	if (typeof metadataSessionId === "string" && INTERVIEW_SESSION_PATTERN.test(metadataSessionId)) {
+		return metadataSessionId;
+	}
+	const textSessionId = /\bSession(?: ID)?:\s*(interview_[A-Za-z0-9_-]+)/.exec(text)?.[1];
+	return textSessionId && INTERVIEW_SESSION_PATTERN.test(textSessionId) ? textSessionId : undefined;
+}
+
+function resultCompleted(result: MCPToolCallResult): boolean {
+	const meta = resultMeta(result);
+	return meta.completed === true || meta.phase === "complete";
+}
+
+export function createOuroborosOooBridge(options: OuroborosOooBridgeOptions = {}): OuroborosOooBridgeHandler {
+	const connect = options.connect ?? connectToServer;
+	const invoke = options.callTool ?? callTool;
+	const disconnect = options.disconnect ?? disconnectServer;
+	let interview: InterviewState | undefined;
+	let interviewCaptureActive = false;
+	let activeConnection: MCPServerConnection | undefined;
+	let pendingConnection: Promise<MCPServerConnection> | undefined;
+	let activeOperationAbort: AbortController | undefined;
+	let lifecycleGeneration = 0;
+	let operationTail: Promise<void> = Promise.resolve();
+
+	const commandBridge = createExactPrefixCommandBridge({
+		prefix: "ooo",
+		command: resolveOuroborosCommand(),
+		args: ["dispatch", "--runtime", "gjc"],
+	});
+
+	function assertCurrent(generation: number, signal: AbortSignal | undefined): void {
+		if (generation !== lifecycleGeneration || signal?.aborted) {
+			throw signal?.reason instanceof Error ? signal.reason : new Error("Ouroboros interview operation cancelled");
+		}
+	}
+
+	async function disconnectSafely(connection: MCPServerConnection | undefined): Promise<void> {
+		if (!connection) return;
+		try {
+			await disconnect(connection);
+		} catch {
+			// State is already fenced. A dead transport must not keep ordinary input captured.
+		}
+	}
+
+	async function resetInterview(): Promise<void> {
+		lifecycleGeneration++;
+		interviewCaptureActive = false;
+		const operationAbort = activeOperationAbort;
+		activeOperationAbort = undefined;
+		operationAbort?.abort(new Error("Ouroboros interview reset"));
+		const connectionToClose = activeConnection;
+		interview = undefined;
+		activeConnection = undefined;
+		pendingConnection = undefined;
+		await disconnectSafely(connectionToClose);
+	}
+
+	async function connection(ctx: ExtensionContext, generation: number): Promise<MCPServerConnection> {
+		assertCurrent(generation, ctx.signal);
+		if (activeConnection) return activeConnection;
+		const pending =
+			pendingConnection ??
+			connect(
+				"ouroboros-ooo-bridge",
+				{
+					type: "stdio",
+					command: resolveOuroborosCommand(),
+					args: ["mcp", "serve", "--runtime", "gjc"],
+					cwd: ctx.cwd,
+				},
+				{ signal: ctx.signal },
+			);
+		pendingConnection = pending;
+		try {
+			const connected = await pending;
+			try {
+				assertCurrent(generation, ctx.signal);
+			} catch (error) {
+				await disconnectSafely(connected);
+				throw error;
+			}
+			activeConnection = connected;
+			return connected;
+		} finally {
+			if (pendingConnection === pending) pendingConnection = undefined;
+		}
+	}
+
+	async function runInterview(text: string, ctx: ExtensionContext): Promise<InputEventResult> {
+		const operationAbort = new AbortController();
+		activeOperationAbort = operationAbort;
+		const operationSignal = ctx.signal ? AbortSignal.any([ctx.signal, operationAbort.signal]) : operationAbort.signal;
+		const operationContext: ExtensionContext = { ...ctx, signal: operationSignal };
+		const generation = lifecycleGeneration;
+		const abortHandler = () => {
+			void resetInterview();
+		};
+		ctx.signal?.addEventListener("abort", abortHandler, { once: true });
+		try {
+			const interviewConnection = await connection(operationContext, generation);
+			const commandArgument = interviewArgument(text);
+			const args: Record<string, unknown> = { cwd: ctx.cwd };
+			if (interview) {
+				args.session_id = interview.sessionId;
+				const answer = commandArgument === undefined ? text.trim() : commandArgument;
+				if (answer) args.answer = answer;
+			} else {
+				args.initial_context = commandArgument ?? "";
+			}
+
+			const result = await invoke(interviewConnection, INTERVIEW_TOOL, args, { signal: operationSignal });
+			assertCurrent(generation, operationSignal);
+			const output = resultText(result);
+			if (result.isError) throw new Error(output || "Ouroboros interview failed");
+
+			const sessionId = resultSessionId(result, output);
+			if (!resultCompleted(result)) {
+				if (!sessionId) throw new Error("Ouroboros interview response did not include a session ID");
+				interview = { sessionId };
+			} else {
+				await resetInterview();
+			}
+			return output ? { handled: true, text: output } : { handled: true };
+		} catch (error) {
+			await resetInterview();
+			if (!ctx.signal?.aborted) {
+				const message = error instanceof Error ? error.message : String(error);
+				ctx.ui?.notify(message, "error");
+			}
+			return { handled: true };
+		} finally {
+			ctx.signal?.removeEventListener("abort", abortHandler);
+			if (activeOperationAbort === operationAbort) activeOperationAbort = undefined;
+		}
+	}
+
+	function enqueueInterview(
+		text: string,
+		ctx: ExtensionContext,
+		explicitInterview: boolean,
+	): Promise<InputEventResult> {
+		const submissionGeneration = lifecycleGeneration;
+		const operation = operationTail.then(async () => {
+			if (submissionGeneration !== lifecycleGeneration) return { handled: true };
+			if (!explicitInterview && !interviewCaptureActive && !interview) return { handled: true };
+			return runInterview(text, ctx);
+		});
+		operationTail = operation.then(
+			() => undefined,
+			() => undefined,
+		);
+		return operation;
+	}
+
+	const handler = async (event: InputEvent, ctx: ExtensionContext): Promise<InputEventResult> => {
+		if (event.source !== undefined && event.source !== "interactive") return {};
+		if (isBuiltInControlInput(event.text)) {
+			if (resetsInterviewState(event.text)) await resetInterview();
+			return {};
+		}
+		const argument = interviewArgument(event.text);
+		const explicitInterview = argument !== undefined;
+		if (explicitInterview) interviewCaptureActive = true;
+		if (explicitInterview || ((interviewCaptureActive || interview) && !isOooCommand(event.text))) {
+			return enqueueInterview(event.text, ctx, explicitInterview);
+		}
+		return commandBridge(event, ctx);
+	};
+
+	return Object.assign(handler, { reset: resetInterview });
+}

package/src/extensibility/extensions/prefix-command-bridge.ts

@@ -86,7 +86,10 @@ export function createExactPrefixCommandBridge(options: ExactPrefixCommandBridge
 		process.env[recursionEnv] = nextRecursionDepth(recursionEnv);
 		try {
 			const result = await dispatch(options.command, [...args, event.text], ctx, { timeout });
-			if (result.code === 0) return { handled: true };
+			if (result.code === 0) {
+				const output = result.stdout.trim() || result.stderr.trim();
+				return output ? { handled: true, text: output } : { handled: true };
+			}
 			if (result.code === continueExitCode) return {};
 
 			const output =
@@ -118,11 +121,3 @@ export function createExactPrefixCommandBridge(options: ExactPrefixCommandBridge
 		}
 	};
 }
-
-export function createOuroborosOooBridge() {
-	return createExactPrefixCommandBridge({
-		prefix: "ooo",
-		command: "ouroboros",
-		args: ["dispatch"],
-	});
-}

package/src/extensibility/extensions/runner.ts

@@ -79,6 +79,16 @@ export function testSetExtensionHandlerTimeoutMs(timeoutMs: number): void {
 const EXTENSION_HANDLER_TIMEOUT = Symbol("extensionHandlerTimeout");
 
 const MAX_PENDING_CREDENTIAL_DISABLED = 32;
+function createHandlerContext(ctx: ExtensionContext, signal: AbortSignal): ExtensionContext {
+	const descriptors = Object.getOwnPropertyDescriptors(ctx);
+	descriptors.signal = {
+		configurable: true,
+		enumerable: true,
+		writable: true,
+		value: signal,
+	};
+	return Object.defineProperties({}, descriptors) as ExtensionContext;
+}
 
 /**
  * Events handled by the generic emit() method.
@@ -688,12 +698,14 @@ export class ExtensionRunner {
 		ext: Extension,
 		timeoutMs: number,
 	): Promise<TResult | undefined> {
-		let timeout: ReturnType<typeof setTimeout> | undefined;
+		let timeout: NodeJS.Timeout | undefined;
+		const abortController = new AbortController();
+		const handlerContext = createHandlerContext(ctx, abortController.signal);
 		try {
 			const timeoutPromise = new Promise<typeof EXTENSION_HANDLER_TIMEOUT>(resolve => {
 				timeout = setTimeout(() => resolve(EXTENSION_HANDLER_TIMEOUT), timeoutMs);
 			});
-			const handlerResult = await Promise.race([Promise.resolve(handler(event, ctx)), timeoutPromise]);
+			const handlerResult = await Promise.race([Promise.resolve(handler(event, handlerContext)), timeoutPromise]);
 			if (timeout !== undefined) {
 				clearTimeout(timeout);
 				timeout = undefined;
@@ -701,6 +713,7 @@ export class ExtensionRunner {
 
 			if (handlerResult === EXTENSION_HANDLER_TIMEOUT) {
 				const error = `handler timed out after ${timeoutMs}ms`;
+				abortController.abort(new Error(error));
 				logger.warn("Extension handler timed out", {
 					extensionPath: ext.path,
 					event: event.type,

package/src/extensibility/extensions/types.ts

@@ -352,6 +352,8 @@ export interface ExtensionContext {
 	hasUI: boolean;
 	/** Current working directory */
 	cwd: string;
+	/** Aborted when the runner stops waiting for this handler, including handler timeout. */
+	signal?: AbortSignal;
 	/** Session manager (read-only) */
 	sessionManager: ReadonlySessionManager;
 	/** Session classification supplied by the SDK for extension policy decisions. */

package/src/gjc-runtime/launch-tmux.ts

@@ -652,6 +652,56 @@ function renameTmuxWindow(
 	spawnSync(tmuxCommand, buildTmuxRenameWindowArgs(title, target), options);
 }
 
+interface TmuxWindowIdentity {
+	paneId: string;
+	windowId: string;
+	windowIndex: string;
+}
+
+function parseTmuxWindowIdentity(value: string): TmuxWindowIdentity | null {
+	const [paneId, windowId, windowIndex, extra] = value.trim().split("\t");
+	if (
+		extra !== undefined ||
+		paneId === undefined ||
+		windowId === undefined ||
+		windowIndex === undefined ||
+		!/^%\d+$/.test(paneId) ||
+		!/^@\d+$/.test(windowId) ||
+		!/^\d+$/.test(windowIndex)
+	)
+		return null;
+	return { paneId, windowId, windowIndex };
+}
+
+function quoteTmuxCommandArgument(value: string): string {
+	return `'${value.replaceAll("'", "'\\''")}'`;
+}
+
+function renameExistingTmuxWindow(
+	tmuxCommand: string,
+	paneId: string,
+	title: string,
+	spawnSync: TmuxSpawnSync,
+	options: TmuxSpawnOptions,
+): void {
+	if (!/^%\d+$/.test(paneId)) return;
+	const observed = spawnSync(
+		tmuxCommand,
+		["display-message", "-p", "-t", paneId, "#{pane_id}\t#{window_id}\t#{window_index}"],
+		options,
+	);
+	if (observed.exitCode !== 0) return;
+	const identity = parseTmuxWindowIdentity(observed.stdout ?? "");
+	if (!identity || identity.paneId !== paneId) return;
+
+	// `if-shell -F` evaluates the pane binding and inserts the rename into the
+	// same tmux command queue. The nested command targets the immutable window
+	// id, so an active-window switch or index reuse cannot redirect the rename.
+	const predicate = `#{&&:#{==:#{pane_id},${identity.paneId}},#{&&:#{==:#{window_id},${identity.windowId}},#{==:#{window_index},${identity.windowIndex}}}}`;
+	const command = `rename-window -t ${identity.windowId} -- ${quoteTmuxCommandArgument(title)}`;
+	spawnSync(tmuxCommand, ["if-shell", "-t", identity.paneId, "-F", predicate, command], options);
+}
+
 function renameExistingTmuxWindowIfNeeded(context: TmuxLaunchContext): void {
 	const env = context.env ?? process.env;
 	if (!env.TMUX || env[GJC_TMUX_LAUNCHED_ENV] === "1") return;
@@ -669,11 +719,13 @@ function renameExistingTmuxWindowIfNeeded(context: TmuxLaunchContext): void {
 	const tmuxAvailable = context.tmuxAvailable ?? Bun.which(tmuxCommand) !== null;
 	if (!tmuxAvailable) return;
 
+	const paneId = env.TMUX_PANE?.trim();
+	if (!paneId) return;
 	const cwd = context.cwd ?? process.cwd();
 	const branch = context.worktreeBranch ?? context.currentBranch ?? readCurrentBranch(cwd);
 	const title = buildGjcTmuxWindowTitle(context.project ?? cwd, branch);
 	const spawnSync = context.spawnSync ?? defaultSpawnSync;
-	renameTmuxWindow(tmuxCommand, title, spawnSync, {
+	renameExistingTmuxWindow(tmuxCommand, paneId, title, spawnSync, {
 		cwd,
 		env,
 		stdin: "pipe",