@gajae-code/coding-agent 0.3.0 → 0.3.2

package/src/modes/bridge/bridge-ui-context.ts

@@ -0,0 +1,200 @@
+import type {
+	ExtensionUIContext,
+	ExtensionUIDialogOptions,
+	ExtensionWidgetContent,
+	ExtensionWidgetOptions,
+	TerminalInputHandler,
+} from "../../extensibility/extensions";
+import type { UiRequestBroker, UiRequestCancelled, UiRequestResolution } from "../shared/agent-wire/ui-request-broker";
+import type { BridgeUiResult } from "../shared/agent-wire/ui-result";
+import { isUiUnsupported, isUiValue } from "../shared/agent-wire/ui-result";
+import { type Theme, theme } from "../theme/theme";
+
+export type BridgeUiRequestPayload =
+	| { kind: "select"; title: string; options: string[]; timeout?: number }
+	| { kind: "confirm"; title: string; message: string; timeout?: number }
+	| { kind: "input"; title: string; placeholder?: string; timeout?: number }
+	| { kind: "editor"; title: string; prefill?: string; promptStyle?: boolean }
+	| { kind: "notify"; message: string; type?: "info" | "warning" | "error" }
+	| { kind: "status"; key: string; text: string | undefined }
+	| { kind: "widget"; key: string; lines: string[] | undefined; placement?: "aboveEditor" | "belowEditor" }
+	| { kind: "title"; title: string }
+	| { kind: "set_editor_text"; text: string }
+	| { kind: "unsupported"; capability: string; reason: string };
+
+export type BridgeUiBroker = UiRequestBroker<BridgeUiRequestPayload, BridgeUiResult<unknown>>;
+export type BridgeUiEmitter = (payload: BridgeUiRequestPayload) => void;
+
+function isBrokerCancelled(resolution: UiRequestResolution<BridgeUiResult<unknown>>): resolution is UiRequestCancelled {
+	return resolution.status === "cancelled";
+}
+
+function timeoutFor(dialogOptions: ExtensionUIDialogOptions | undefined): number | undefined {
+	return dialogOptions?.timeout;
+}
+
+export class BridgeExtensionUIContext implements ExtensionUIContext {
+	readonly #broker: BridgeUiBroker;
+	readonly #emit: BridgeUiEmitter;
+
+	constructor(options: { broker: BridgeUiBroker; emit: BridgeUiEmitter }) {
+		this.#broker = options.broker;
+		this.#emit = options.emit;
+	}
+
+	#emitUnsupported(capability: string, reason: string): void {
+		this.#emit({ kind: "unsupported", capability, reason });
+	}
+
+	async select(
+		title: string,
+		options: string[],
+		dialogOptions?: ExtensionUIDialogOptions,
+	): Promise<string | undefined> {
+		const result = await this.#broker.request(
+			{ kind: "select", title, options, timeout: timeoutFor(dialogOptions) },
+			{ timeoutMs: timeoutFor(dialogOptions), signal: dialogOptions?.signal },
+		);
+		if (isBrokerCancelled(result)) {
+			if (result.reason === "timeout") dialogOptions?.onTimeout?.();
+			return undefined;
+		}
+		if (isUiValue(result) && typeof result.value === "string") return result.value;
+		return undefined;
+	}
+
+	async confirm(title: string, message: string, dialogOptions?: ExtensionUIDialogOptions): Promise<boolean> {
+		const result = await this.#broker.request(
+			{ kind: "confirm", title, message, timeout: timeoutFor(dialogOptions) },
+			{ timeoutMs: timeoutFor(dialogOptions), signal: dialogOptions?.signal },
+		);
+		if (isBrokerCancelled(result)) {
+			if (result.reason === "timeout") dialogOptions?.onTimeout?.();
+			return false;
+		}
+		if (isUiValue(result) && typeof result.value === "boolean") return result.value;
+		return false;
+	}
+
+	async input(
+		title: string,
+		placeholder?: string,
+		dialogOptions?: ExtensionUIDialogOptions,
+	): Promise<string | undefined> {
+		const result = await this.#broker.request(
+			{ kind: "input", title, placeholder, timeout: timeoutFor(dialogOptions) },
+			{ timeoutMs: timeoutFor(dialogOptions), signal: dialogOptions?.signal },
+		);
+		if (isBrokerCancelled(result)) {
+			if (result.reason === "timeout") dialogOptions?.onTimeout?.();
+			return undefined;
+		}
+		if (isUiValue(result) && typeof result.value === "string") return result.value;
+		return undefined;
+	}
+
+	notify(message: string, type?: "info" | "warning" | "error"): void {
+		this.#emit({ kind: "notify", message, type });
+	}
+
+	onTerminalInput(_handler: TerminalInputHandler): () => void {
+		this.#emitUnsupported("ui.terminal_input", "Raw terminal input is not supported by the bridge protocol yet");
+		return () => {};
+	}
+
+	setStatus(key: string, text: string | undefined): void {
+		this.#emit({ kind: "status", key, text });
+	}
+
+	setWorkingMessage(message?: string): void {
+		this.#emit({ kind: "status", key: "working", text: message });
+	}
+
+	setWidget(key: string, content: ExtensionWidgetContent, options?: ExtensionWidgetOptions): void {
+		if (content === undefined || Array.isArray(content)) {
+			this.#emit({ kind: "widget", key, lines: content, placement: options?.placement });
+			return;
+		}
+		this.#emitUnsupported("ui.widget.component", "Component factory widgets are local-only and not serializable");
+	}
+
+	setFooter(_factory?: unknown): void {
+		this.#emitUnsupported("ui.footer.component", "Footer component factories are local-only and not serializable");
+	}
+
+	setHeader(_factory?: unknown): void {
+		this.#emitUnsupported("ui.header.component", "Header component factories are local-only and not serializable");
+	}
+
+	setTitle(title: string): void {
+		this.#emit({ kind: "title", title });
+	}
+
+	async custom<T>(): Promise<T> {
+		this.#emitUnsupported("ui.custom.component", "Custom focused components are local-only and not serializable");
+		throw new Error("Custom focused components are local-only and not serializable through bridge UI context");
+	}
+
+	setEditorText(text: string): void {
+		this.#emit({ kind: "set_editor_text", text });
+	}
+
+	pasteToEditor(text: string): void {
+		this.setEditorText(text);
+	}
+
+	getEditorText(): string {
+		this.#emitUnsupported(
+			"ui.editor.get_text",
+			"Synchronous editor reads are local-only and not supported by bridge UI context",
+		);
+		throw new Error("Synchronous editor reads are local-only and not supported by bridge UI context");
+	}
+
+	async editor(
+		title: string,
+		prefill?: string,
+		dialogOptions?: ExtensionUIDialogOptions,
+		editorOptions?: { promptStyle?: boolean },
+	): Promise<string | undefined> {
+		const result = await this.#broker.request(
+			{ kind: "editor", title, prefill, promptStyle: editorOptions?.promptStyle },
+			{ timeoutMs: timeoutFor(dialogOptions), signal: dialogOptions?.signal },
+		);
+		if (isBrokerCancelled(result)) {
+			if (result.reason === "timeout") dialogOptions?.onTimeout?.();
+			return undefined;
+		}
+		if (isUiUnsupported(result)) return undefined;
+		if (isUiValue(result) && typeof result.value === "string") return result.value;
+		return undefined;
+	}
+
+	setEditorComponent(_factory?: unknown): void {
+		this.#emitUnsupported("ui.editor.component", "Custom editor components are local-only and not serializable");
+	}
+
+	get theme(): Theme {
+		return theme;
+	}
+
+	getAllThemes(): Promise<{ name: string; path: string | undefined }[]> {
+		return Promise.resolve([]);
+	}
+
+	getTheme(_name: string): Promise<Theme | undefined> {
+		return Promise.resolve(undefined);
+	}
+
+	setTheme(_theme: string | Theme): Promise<{ success: boolean; error?: string }> {
+		return Promise.resolve({ success: false, error: "Theme switching is not supported by bridge UI context yet" });
+	}
+
+	getToolsExpanded(): boolean {
+		return false;
+	}
+
+	setToolsExpanded(_expanded: boolean): void {
+		this.#emitUnsupported("ui.tools_expanded", "Tool expansion state is not supported by bridge UI context yet");
+	}
+}

package/src/modes/bridge/event-stream.ts

@@ -0,0 +1,70 @@
+import type { BridgeFrameEnvelope } from "../shared/agent-wire/protocol";
+
+const encoder = new TextEncoder();
+const DEFAULT_REPLAY_LIMIT = 1_000;
+
+function encodeSseFrame(frame: BridgeFrameEnvelope): Uint8Array {
+	return encoder.encode(`data: ${JSON.stringify(frame)}\n\n`);
+}
+
+export class BridgeEventStream {
+	#frames: BridgeFrameEnvelope[] = [];
+	#subscribers = new Set<ReadableStreamDefaultController<Uint8Array>>();
+	#replayLimit: number;
+
+	constructor(replayLimit = DEFAULT_REPLAY_LIMIT) {
+		this.#replayLimit = replayLimit;
+	}
+	get frameCount(): number {
+		return this.#frames.length;
+	}
+
+	publish(frame: BridgeFrameEnvelope): void {
+		this.#frames.push(frame);
+		if (this.#frames.length > this.#replayLimit) this.#frames.splice(0, this.#frames.length - this.#replayLimit);
+		const encoded = encodeSseFrame(frame);
+		for (const controller of this.#subscribers) {
+			try {
+				controller.enqueue(encoded);
+			} catch {
+				this.#subscribers.delete(controller);
+			}
+		}
+	}
+
+	response(lastSeq = 0): Response {
+		let streamController: ReadableStreamDefaultController<Uint8Array> | undefined;
+		const stream = new ReadableStream<Uint8Array>({
+			start: controller => {
+				streamController = controller;
+				const first = this.#frames[0];
+				if (first && lastSeq > 0 && first.seq > lastSeq + 1) {
+					controller.enqueue(
+						encodeSseFrame({
+							protocol_version: first.protocol_version,
+							session_id: first.session_id,
+							seq: first.seq - 1,
+							frame_id: `reset-${first.seq}`,
+							type: "reset",
+							payload: { reason: "replay_window_exceeded", first_seq: first.seq },
+						}),
+					);
+				}
+				for (const frame of this.#frames) {
+					if (frame.seq > lastSeq) controller.enqueue(encodeSseFrame(frame));
+				}
+				this.#subscribers.add(controller);
+			},
+			cancel: () => {
+				if (streamController) this.#subscribers.delete(streamController);
+			},
+		});
+		return new Response(stream, {
+			headers: {
+				"Content-Type": "text/event-stream",
+				"Cache-Control": "no-cache",
+				Connection: "keep-alive",
+			},
+		});
+	}
+}

package/src/modes/components/custom-editor.ts

@@ -1,4 +1,5 @@
 import { Editor, type KeyId, matchesKey, parseKittySequence } from "@gajae-code/tui";
+import { BracketedPasteHandler } from "@gajae-code/tui/bracketed-paste";
 import type { AppKeybinding } from "../../config/keybindings";
 
 type ConfigurableEditorAction = Extract<
@@ -40,6 +41,11 @@ const DEFAULT_ACTION_KEYS: Record<ConfigurableEditorAction, KeyId[]> = {
 	"app.clipboard.copyPrompt": ["alt+shift+c"],
 };
 
+const PASTE_DECISION_TIMEOUT_MS = 5_000;
+const PENDING_PASTE_INPUT_MAX = 64;
+
+type PastePendingClearReason = "timeout" | "queue-limit";
+
 /**
  * Custom editor that handles configurable app-level shortcuts for coding-agent.
  */
@@ -63,6 +69,10 @@ export class CustomEditor extends Editor {
 	onCopyPrompt?: () => void;
 	/** Called when the configured image-paste shortcut is pressed. */
 	onPasteImage?: () => Promise<boolean>;
+	/** Called before bracketed paste content is inserted. Return true to consume it. */
+	onPasteText?: (text: string) => boolean | Promise<boolean>;
+	/** Called when async paste handling drops queued input instead of replaying it. */
+	onPastePendingInputCleared?: (reason: PastePendingClearReason, droppedInputCount: number) => void;
 	/** Called when the configured dequeue shortcut is pressed. */
 	onDequeue?: () => void;
 	/** Called when Caps Lock is pressed. */
@@ -73,6 +83,11 @@ export class CustomEditor extends Editor {
 	#actionKeys = new Map<ConfigurableEditorAction, KeyId[]>(
 		Object.entries(DEFAULT_ACTION_KEYS).map(([action, keys]) => [action as ConfigurableEditorAction, [...keys]]),
 	);
+	#pasteHandler = new BracketedPasteHandler();
+	#pasteDecisionPending = false;
+	#pasteDecisionToken = 0;
+	#pasteDecisionTimeout: NodeJS.Timeout | undefined;
+	#pendingPasteInput: string[] = [];
 
 	setActionKeys(action: ConfigurableEditorAction, keys: KeyId[]): void {
 		this.#actionKeys.set(action, [...keys]);
@@ -108,7 +123,84 @@ export class CustomEditor extends Editor {
 		this.#customKeyHandlers.clear();
 	}
 
+	#clearPasteDecisionTimeout(): void {
+		if (this.#pasteDecisionTimeout) {
+			clearTimeout(this.#pasteDecisionTimeout);
+			this.#pasteDecisionTimeout = undefined;
+		}
+	}
+
+	#clearPendingPasteState(): number {
+		this.#clearPasteDecisionTimeout();
+		this.#pasteDecisionPending = false;
+		this.#pasteDecisionToken += 1;
+		const droppedInputCount = this.#pendingPasteInput.length;
+		this.#pendingPasteInput = [];
+		return droppedInputCount;
+	}
+
+	#startPasteDecisionTimeout(token: number): void {
+		this.#clearPasteDecisionTimeout();
+		this.#pasteDecisionTimeout = setTimeout(() => {
+			if (token !== this.#pasteDecisionToken) return;
+			const droppedInputCount = this.#clearPendingPasteState();
+			this.onPastePendingInputCleared?.("timeout", droppedInputCount);
+		}, PASTE_DECISION_TIMEOUT_MS);
+		this.#pasteDecisionTimeout.unref?.();
+	}
+
+	dispose(): void {
+		this.#clearPendingPasteState();
+		this.#pasteHandler = new BracketedPasteHandler();
+	}
+
+	#drainPendingPasteInput(initialInput?: string): void {
+		if (initialInput && initialInput.length > 0) {
+			this.handleInput(initialInput);
+		}
+		while (!this.#pasteDecisionPending) {
+			const nextInput = this.#pendingPasteInput.shift();
+			if (nextInput === undefined) break;
+			this.handleInput(nextInput);
+		}
+	}
+
+	#handleBracketedPaste(pasteContent: string, remaining: string): void {
+		const applyPasteResult = (token: number, handled: boolean | undefined) => {
+			if (token !== this.#pasteDecisionToken) return;
+			this.#clearPasteDecisionTimeout();
+			if (!handled) {
+				super.handleInput(`\x1b[200~${pasteContent}\x1b[201~`);
+			}
+			this.#pasteDecisionPending = false;
+			this.#drainPendingPasteInput(remaining);
+		};
+		const pasteResult = this.onPasteText?.(pasteContent);
+
+		if (pasteResult instanceof Promise) {
+			const token = this.#pasteDecisionToken + 1;
+			this.#pasteDecisionToken = token;
+			this.#pasteDecisionPending = true;
+			this.#startPasteDecisionTimeout(token);
+			void pasteResult.then(
+				handled => applyPasteResult(token, handled),
+				() => applyPasteResult(token, false),
+			);
+		} else {
+			applyPasteResult(this.#pasteDecisionToken, pasteResult);
+		}
+	}
+
 	handleInput(data: string): void {
+		if (this.#pasteDecisionPending) {
+			this.#pendingPasteInput.push(data);
+			if (this.#pendingPasteInput.length > PENDING_PASTE_INPUT_MAX) {
+				const droppedInputCount = this.#clearPendingPasteState();
+				this.onPastePendingInputCleared?.("queue-limit", droppedInputCount);
+			}
+			return;
+		}
+
 		const parsed = parseKittySequence(data);
 		if (parsed && (parsed.modifier & 64) !== 0 && this.onCapsLock) {
 			// Caps Lock is modifier bit 64
@@ -116,6 +208,15 @@ export class CustomEditor extends Editor {
 			return;
 		}
 
+		if (this.onPasteText) {
+			const paste = this.#pasteHandler.process(data);
+			if (paste.handled) {
+				if (paste.pasteContent !== undefined) {
+					this.#handleBracketedPaste(paste.pasteContent, paste.remaining);
+				}
+				return;
+			}
+		}
 		// Intercept configured image paste (async - fires and handles result)
 		if (this.#matchesAction(data, "app.clipboard.pasteImage") && this.onPasteImage) {
 			void this.onPasteImage();