@gajae-code/coding-agent 0.2.5 → 0.3.1

package/src/modes/controllers/input-controller.ts

@@ -1,4 +1,5 @@
 import * as fs from "node:fs/promises";
+import * as path from "node:path";
 import { type AgentMessage, ThinkingLevel } from "@gajae-code/agent-core";
 import type { AutocompleteProvider, SlashCommand } from "@gajae-code/tui";
 import { $env, sanitizeText } from "@gajae-code/utils";
@@ -13,7 +14,7 @@ import { SKILL_PROMPT_MESSAGE_TYPE, type SkillPromptDetails } from "../../sessio
 import { executeBuiltinSlashCommand } from "../../slash-commands/builtin-registry";
 import { copyToClipboard, readImageFromClipboard } from "../../utils/clipboard";
 import { getEditorCommand, openInEditor } from "../../utils/external-editor";
-import { ensureSupportedImageInput } from "../../utils/image-loading";
+import { ensureSupportedImageInput, ImageInputTooLargeError, loadImageInput } from "../../utils/image-loading";
 import { resizeImage } from "../../utils/image-resize";
 import { generateSessionTitle, setSessionTerminalTitle } from "../../utils/title-generator";
 
@@ -22,6 +23,8 @@ interface Expandable {
 }
 
 const INTERACTIVE_ABORT_CLEANUP_TIMEOUT_MS = 5_000;
+const CLIPBOARD_TEMP_IMAGE_FILE_PATTERN = /^clipboard-\d{4}-\d{2}-\d{2}-\d{6}-[A-Za-z0-9]+\.(?:png|jpe?g|gif|webp)$/i;
+const MACOS_CLIPBOARD_TEMP_DIR_PATTERN = /^\/var\/folders\/[^/]+\/[^/]+\/T$/;
 
 function isExpandable(obj: unknown): obj is Expandable {
 	return typeof obj === "object" && obj !== null && "setExpanded" in obj && typeof obj.setExpanded === "function";
@@ -30,8 +33,17 @@ function isExpandable(obj: unknown): obj is Expandable {
 export class InputController {
 	constructor(private ctx: InteractiveModeContext) {}
 
-	#abortInteractive(): Promise<void> {
-		return this.ctx.session.abort({ timeoutMs: INTERACTIVE_ABORT_CLEANUP_TIMEOUT_MS });
+	/** Set after a first Esc silently consumes a queued steer. Kept until the
+	 *  queued steer is either cancelled by a second Esc or drained by continuation,
+	 *  so abort cleanup going idle cannot turn the second Esc into an idle action. */
+	#steerConsumePending = false;
+
+	#abortInteractive(options?: { silent?: boolean }): Promise<void> {
+		return this.ctx.session.abort({
+			timeoutMs: INTERACTIVE_ABORT_CLEANUP_TIMEOUT_MS,
+			cause: "user_interrupt",
+			silent: options?.silent,
+		});
 	}
 
 	setupKeyHandlers(): void {
@@ -40,6 +52,7 @@ export class InputController {
 			Boolean(
 				this.ctx.loadingAnimation ||
 					this.ctx.hasActiveBtw() ||
+					(this.#steerConsumePending && this.ctx.session.hasQueuedSteering) ||
 					this.ctx.session.isStreaming ||
 					this.ctx.session.isCompacting ||
 					this.ctx.session.isGeneratingHandoff ||
@@ -54,6 +67,17 @@ export class InputController {
 			if (this.ctx.hasActiveBtw() && this.ctx.handleBtwEscape()) {
 				return;
 			}
+			if (this.#steerConsumePending) {
+				if (this.ctx.session.hasQueuedSteering) {
+					// Second Esc before the scheduled steer continuation drains the
+					// queue: restore/drop the queued steer and perform a real abort,
+					// even if abort cleanup already made the session look idle.
+					this.#steerConsumePending = false;
+					this.restoreQueuedMessagesToEditor({ abort: true });
+					return;
+				}
+				this.#steerConsumePending = false;
+			}
 			if (this.ctx.loadingAnimation) {
 				if (this.ctx.cancelPendingSubmission()) {
 					return;
@@ -73,7 +97,15 @@ export class InputController {
 				this.ctx.isPythonMode = false;
 				this.ctx.updateEditorBorderColor();
 			} else if (this.ctx.session.isStreaming) {
-				void this.#abortInteractive();
+				if (this.ctx.session.hasQueuedSteering && !this.#steerConsumePending) {
+					// First Esc with a queued steer: silently consume it and
+					// auto-continue via steer-on-interrupt instead of stalling on
+					// "Operation aborted".
+					this.#steerConsumePending = true;
+					void this.#abortInteractive({ silent: true });
+				} else {
+					void this.#abortInteractive();
+				}
 			} else if (!this.ctx.editor.getText().trim()) {
 				// Double-interrupt with empty editor triggers /tree, /branch, or nothing based on setting
 				const action = settings.get("doubleEscapeAction");
@@ -132,6 +164,13 @@ export class InputController {
 			this.ctx.keybindings.getKeys("app.clipboard.copyPrompt"),
 		);
 		this.ctx.editor.onCopyPrompt = () => this.handleCopyPrompt();
+		this.ctx.editor.onPasteText = text => this.handleTextPaste(text);
+		this.ctx.editor.onPastePendingInputCleared = (reason, droppedInputCount) => {
+			const reasonText = reason === "timeout" ? "timed out" : "exceeded the input queue limit";
+			this.ctx.showWarning(
+				`Paste handling ${reasonText}; discarded ${droppedInputCount} buffered input event${droppedInputCount === 1 ? "" : "s"}.`,
+			);
+		};
 		this.ctx.editor.setActionKeys("app.tools.expand", this.ctx.keybindings.getKeys("app.tools.expand"));
 		this.ctx.editor.onExpandTools = () => this.toggleToolOutputExpansion();
 		this.ctx.editor.setActionKeys("app.message.dequeue", this.ctx.keybindings.getKeys("app.message.dequeue"));
@@ -170,6 +209,9 @@ export class InputController {
 		for (const key of this.ctx.keybindings.getKeys("app.session.observe")) {
 			this.ctx.editor.setCustomKeyHandler(key, () => this.ctx.showSessionObserver());
 		}
+		for (const key of this.ctx.keybindings.getKeys("app.jobs.open")) {
+			this.ctx.editor.setCustomKeyHandler(key, () => this.ctx.showJobsOverlay());
+		}
 
 		this.ctx.editor.onChange = (text: string) => {
 			const wasBashMode = this.ctx.isBashMode;
@@ -568,6 +610,14 @@ export class InputController {
 			this.ctx.retryLoader.stop();
 			this.ctx.retryLoader = undefined;
 		}
+		if (this.ctx.retryCountdownTimer) {
+			clearInterval(this.ctx.retryCountdownTimer);
+			this.ctx.retryCountdownTimer = undefined;
+		}
+		if (this.ctx.retryEscapeHandler) {
+			this.ctx.editor.onEscape = this.ctx.retryEscapeHandler;
+			this.ctx.retryEscapeHandler = undefined;
+		}
 		this.ctx.statusContainer.clear();
 		this.ctx.statusLine.dispose();
 
@@ -594,6 +644,55 @@ export class InputController {
 		process.kill(0, "SIGTSTP");
 	}
 
+	handleTextPaste(text: string): boolean | Promise<boolean> {
+		const imagePath = this.#getPastedImagePathCandidate(text);
+		return imagePath ? this.#attachPastedImagePath(imagePath) : false;
+	}
+
+	async #attachPastedImagePath(imagePath: string): Promise<boolean> {
+		try {
+			const image = await loadImageInput({
+				path: imagePath,
+				cwd: this.ctx.sessionManager.getCwd(),
+				autoResize: this.ctx.settings.get("images.autoResize"),
+			});
+			if (!image) {
+				this.ctx.showStatus("Unsupported pasted clipboard image file");
+				return true;
+			}
+
+			this.ctx.pendingImages.push({
+				type: "image",
+				data: image.data,
+				mimeType: image.mimeType,
+			});
+			this.ctx.editor.insertText(`${this.#nextImagePlaceholder()} `);
+			this.ctx.showStatus(`Attached image: ${path.basename(image.resolvedPath)}`, { dim: true });
+			this.ctx.ui.requestRender();
+			return true;
+		} catch (error) {
+			if (error instanceof ImageInputTooLargeError) {
+				this.ctx.showStatus(error.message);
+				return true;
+			}
+			this.ctx.showStatus("Failed to attach pasted clipboard image");
+			return true;
+		}
+	}
+
+	#getPastedImagePathCandidate(text: string): string | undefined {
+		const resolvedPath = path.resolve(text.trim());
+		const parentDir = path.dirname(resolvedPath);
+		const isClipboardTempPath =
+			(parentDir === "/tmp" || MACOS_CLIPBOARD_TEMP_DIR_PATTERN.test(parentDir)) &&
+			CLIPBOARD_TEMP_IMAGE_FILE_PATTERN.test(path.basename(resolvedPath));
+		return isClipboardTempPath ? resolvedPath : undefined;
+	}
+
+	#nextImagePlaceholder(): string {
+		return `[image ${this.ctx.pendingImages.length}]`;
+	}
+
 	async handleImagePaste(): Promise<boolean> {
 		try {
 			const image = await readImageFromClipboard();
@@ -608,7 +707,7 @@ export class InputController {
 					this.ctx.showStatus(`Unsupported clipboard image format: ${image.mimeType}`);
 					return false;
 				}
-				if (settings.get("images.autoResize")) {
+				if (this.ctx.settings.get("images.autoResize")) {
 					try {
 						const resized = await resizeImage({
 							type: "image",
@@ -626,10 +725,7 @@ export class InputController {
 					data: imageData.data,
 					mimeType: imageData.mimeType,
 				});
-				// Insert placeholder at cursor like Anthropic model does
-				const imageNum = this.ctx.pendingImages.length;
-				const placeholder = `[Image #${imageNum}]`;
-				this.ctx.editor.insertText(`${placeholder} `);
+				this.ctx.editor.insertText(`${this.#nextImagePlaceholder()} `);
 				this.ctx.ui.requestRender();
 				return true;
 			}

package/src/modes/controllers/selector-controller.ts

@@ -41,6 +41,7 @@ import { AgentDashboard } from "../components/agent-dashboard";
 import { AssistantMessageComponent } from "../components/assistant-message";
 import { ExtensionDashboard } from "../components/extensions";
 import { HistorySearchComponent } from "../components/history-search";
+import { JobsOverlayComponent } from "../components/jobs-overlay";
 import { ModelSelectorComponent, type ModelSelectorSelection } from "../components/model-selector";
 import { OAuthSelectorComponent } from "../components/oauth-selector";
 import { PluginSelectorComponent } from "../components/plugin-selector";
@@ -55,14 +56,16 @@ import { ThemeSelectorComponent } from "../components/theme-selector";
 import { ToolExecutionComponent } from "../components/tool-execution";
 import { TreeSelectorComponent } from "../components/tree-selector";
 import { UserMessageSelectorComponent } from "../components/user-message-selector";
+import type { JobsObserver } from "../jobs-observer";
 import type { SessionObserverRegistry } from "../session-observer-registry";
 
-const CALLBACK_SERVER_PROVIDERS = new Set<OAuthProvider>([
+const CALLBACK_SERVER_PROVIDERS = new Set<string>([
 	"anthropic",
 	"openai-codex",
 	"gitlab-duo",
 	"google-gemini-cli",
 	"google-antigravity",
+	"xai",
 ]);
 
 const MANUAL_LOGIN_TIP = "Tip: You can complete pairing with /login <redirect URL>.";
@@ -1149,4 +1152,31 @@ export class SelectorController {
 		this.ctx.ui.setFocus(selector);
 		this.ctx.ui.requestRender();
 	}
+
+	/**
+	 * Jobs overlay: navigate ongoing monitor + cron jobs (Monitors then Crons,
+	 * newest-first), drill into per-type detail, and cancel/delete with a y/N
+	 * confirm. Built from nested SelectLists (list -> detail -> confirm) so focus
+	 * stays on the active SelectList.
+	 */
+	showJobsOverlay(observer: JobsObserver): void {
+		let overlay: JobsOverlayComponent | undefined;
+		const close = () => {
+			this.ctx.editorContainer.clear();
+			this.ctx.editorContainer.addChild(this.ctx.editor);
+			this.ctx.ui.setFocus(this.ctx.editor);
+			this.ctx.ui.requestRender();
+		};
+		overlay = new JobsOverlayComponent(observer, {
+			close,
+			requestRender: () => {
+				if (overlay) this.ctx.ui.setFocus(overlay.getFocus());
+				this.ctx.ui.requestRender();
+			},
+		});
+		this.ctx.editorContainer.clear();
+		this.ctx.editorContainer.addChild(overlay);
+		this.ctx.ui.setFocus(overlay.getFocus());
+		this.ctx.ui.requestRender();
+	}
 }

package/src/modes/index.ts

@@ -5,6 +5,7 @@ import { postmortem } from "@gajae-code/utils";
  * Run modes for the coding agent.
  */
 export { runAcpMode } from "./acp";
+export { runBridgeMode } from "./bridge/bridge-mode";
 export { InteractiveMode, type InteractiveModeOptions } from "./interactive-mode";
 export { type PrintModeOptions, runPrintMode } from "./print-mode";
 export {

package/src/modes/interactive-mode.ts

@@ -28,6 +28,7 @@ import {
 } from "@gajae-code/tui";
 import { APP_NAME, adjustHsv, getProjectDir, hsvToRgb, isEnoent, logger, postmortem, prompt } from "@gajae-code/utils";
 import chalk from "chalk";
+import { AsyncJobManager } from "../async";
 import { KeybindingsManager } from "../config/keybindings";
 import { isSettingsInitialized, type Settings, settings } from "../config/settings";
 import { DEFAULT_GJC_DEFINITION_NAMES } from "../defaults/gjc-defaults";
@@ -88,6 +89,7 @@ import { InputController } from "./controllers/input-controller";
 import { SelectorController } from "./controllers/selector-controller";
 import { SSHCommandController } from "./controllers/ssh-command-controller";
 import { TodoCommandController } from "./controllers/todo-command-controller";
+import { JobsObserver } from "./jobs-observer";
 import { OAuthManualInputManager } from "./oauth-manual-input";
 import { SessionObserverRegistry } from "./session-observer-registry";
 import { interruptHint } from "./shared";
@@ -276,6 +278,7 @@ export class InteractiveMode implements InteractiveModeContext {
 	}
 	autoCompactionEscapeHandler?: () => void;
 	retryEscapeHandler?: () => void;
+	retryCountdownTimer?: ReturnType<typeof setInterval>;
 	unsubscribe?: () => void;
 	onInputCallback?: (input: SubmittedUserInput) => void;
 	optimisticUserMessageSignature: string | undefined = undefined;
@@ -329,6 +332,7 @@ export class InteractiveMode implements InteractiveModeContext {
 	#voicePreviousUseTerminalCursor: boolean | null = null;
 	#resizeHandler?: () => void;
 	#observerRegistry: SessionObserverRegistry;
+	#jobsObserver?: JobsObserver;
 	#eventBus?: EventBus;
 	#eventBusUnsubscribers: Array<() => void> = [];
 	#welcomeComponent?: WelcomeComponent;
@@ -524,6 +528,19 @@ export class InteractiveMode implements InteractiveModeContext {
 			this.ui.requestRender();
 		});
 
+		// Event-driven monitor/cron jobs widget. Scoped to this session's owner so
+		// overlay actions cannot mutate another agent's background work.
+		const jobManager = AsyncJobManager.instance();
+		if (jobManager) {
+			const jobsObserver = new JobsObserver(jobManager, this.session.getAgentId());
+			this.#jobsObserver = jobsObserver;
+			this.statusLine.setJobs(jobsObserver.getSnapshot());
+			jobsObserver.onChange(() => {
+				this.statusLine.setJobs(jobsObserver.getSnapshot());
+				this.ui.requestRender();
+			});
+		}
+
 		// Load initial todos
 		await this.#loadTodoList();
 
@@ -1842,6 +1859,8 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.#observerRegistry.dispose();
 		this.#eventController.dispose();
 		this.statusLine.dispose();
+		this.#jobsObserver?.dispose();
+		this.editor.dispose();
 		if (this.#resizeHandler) {
 			process.stdout.removeListener("resize", this.#resizeHandler);
 			this.#resizeHandler = undefined;
@@ -1943,6 +1962,7 @@ export class InteractiveMode implements InteractiveModeContext {
 			nextEditor.setHistoryStorage(this.historyStorage);
 		}
 		nextEditor.setText(previousText);
+		previousEditor.dispose();
 
 		this.editorContainer.clear();
 		this.editor = nextEditor;
@@ -2316,6 +2336,14 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.#selectorController.showSessionObserver(this.#observerRegistry);
 	}
 
+	showJobsOverlay(): void {
+		if (!this.#jobsObserver) {
+			this.showStatus("Background jobs are unavailable in this session");
+			return;
+		}
+		this.#selectorController.showJobsOverlay(this.#jobsObserver);
+	}
+
 	resetObserverRegistry(): void {
 		this.#observerRegistry.resetSessions();
 		this.#observerRegistry.setMainSession(this.sessionManager.getSessionFile() ?? undefined);

package/src/modes/jobs-observer.ts

@@ -0,0 +1,204 @@
+/**
+ * JobsObserver
+ *
+ * Single, event-driven aggregator over the two background-work sources surfaced
+ * by the status-line jobs widget and the jobs overlay:
+ *  - monitor jobs (bash jobs started by the `monitor` tool, tracked in `AsyncJobManager`)
+ *  - cron jobs (tracked in the cron module's owner-scoped schedule store)
+ *
+ * It subscribes to change hooks on both sources (no polling), debounces bursts
+ * to a microtask, and exposes a precomputed snapshot so the status-line render
+ * loop never scans the underlying stores. A failure latch keeps the widget red
+ * until `acknowledgeFailures()` is called (when the overlay opens), so a failed
+ * job that evicts before the user looks is not silently lost.
+ */
+import type { AsyncJob, AsyncJobManager } from "../async";
+import { deleteCronJobById, listCronSnapshots, onCronChange } from "../tools/cron";
+
+export type JobsWorstState = "none" | "running" | "failed";
+
+export interface MonitorJobView {
+	id: string;
+	label: string;
+	status: AsyncJob["status"];
+	startTime: number;
+}
+
+export interface CronJobView {
+	id: string;
+	humanSchedule: string;
+	cronExpression: string;
+	prompt: string;
+	recurring: boolean;
+	nextFireAt?: number;
+	createdAt: number;
+}
+
+export interface JobsSnapshot {
+	monitors: MonitorJobView[];
+	crons: CronJobView[];
+	activeMonitorCount: number;
+	activeCronCount: number;
+	worstState: JobsWorstState;
+	failedUnacknowledged: boolean;
+}
+
+export const EMPTY_JOBS_SNAPSHOT: JobsSnapshot = {
+	monitors: [],
+	crons: [],
+	activeMonitorCount: 0,
+	activeCronCount: 0,
+	worstState: "none",
+	failedUnacknowledged: false,
+};
+
+export class JobsObserver {
+	readonly #manager: AsyncJobManager;
+	readonly #ownerId: string | undefined;
+	readonly #unsubscribers: Array<() => void> = [];
+	readonly #listeners = new Set<() => void>();
+	#failedUnacknowledged = false;
+	#notifyScheduled = false;
+	#disposed = false;
+	#snapshot: JobsSnapshot = EMPTY_JOBS_SNAPSHOT;
+	readonly #acknowledgedFailedIds = new Set<string>();
+
+	constructor(manager: AsyncJobManager, ownerId: string | undefined) {
+		this.#manager = manager;
+		this.#ownerId = ownerId;
+		this.#unsubscribers.push(manager.onChange(() => this.#onUpstreamChange()));
+		this.#unsubscribers.push(onCronChange(() => this.#onUpstreamChange()));
+		this.#recompute();
+	}
+
+	/** Subscribe to debounced change events. Returns an unsubscribe function. */
+	onChange(cb: () => void): () => void {
+		this.#listeners.add(cb);
+		return () => {
+			this.#listeners.delete(cb);
+		};
+	}
+
+	#onUpstreamChange(): void {
+		if (this.#disposed) return;
+		this.#recompute();
+		if (this.#notifyScheduled) return;
+		this.#notifyScheduled = true;
+		queueMicrotask(() => {
+			this.#notifyScheduled = false;
+			if (this.#disposed) return;
+			this.#emit();
+		});
+	}
+
+	#emit(): void {
+		for (const cb of this.#listeners) {
+			try {
+				cb();
+			} catch {
+				// Listener errors are isolated; a bad subscriber must not break others.
+			}
+		}
+	}
+
+	#listMonitorJobs(): AsyncJob[] {
+		const filter = this.#ownerId ? { ownerId: this.#ownerId } : undefined;
+		return this.#manager.getAllJobs(filter).filter(job => job.type === "bash" && job.metadata?.monitor === true);
+	}
+
+	/**
+	 * Recompute and store the snapshot. Called on construction and on every
+	 * upstream change; the status-line render path only reads the stored
+	 * snapshot (never scans the manager/cron stores).
+	 */
+	#recompute(): void {
+		const monitorJobs = this.#listMonitorJobs();
+		const presentIds = new Set(monitorJobs.map(job => job.id));
+		// Prune acknowledged ids whose jobs have been evicted.
+		for (const id of this.#acknowledgedFailedIds) {
+			if (!presentIds.has(id)) this.#acknowledgedFailedIds.delete(id);
+		}
+		// Sticky failure latch: set when an unacknowledged failed monitor is seen
+		// (including at construction); stays set even after the failed job evicts,
+		// until acknowledgeFailures() clears it.
+		const hasUnacknowledgedFailure = monitorJobs.some(
+			job => job.status === "failed" && !this.#acknowledgedFailedIds.has(job.id),
+		);
+		if (hasUnacknowledgedFailure) this.#failedUnacknowledged = true;
+
+		const activeMonitors = monitorJobs.filter(job => job.status === "running");
+		const cronSnapshots = listCronSnapshots(this.#ownerId);
+		const monitors: MonitorJobView[] = monitorJobs
+			.map(job => ({ id: job.id, label: job.label, status: job.status, startTime: job.startTime }))
+			.sort((a, b) => b.startTime - a.startTime);
+		const crons: CronJobView[] = cronSnapshots
+			.map(snapshot => ({
+				id: snapshot.id,
+				humanSchedule: snapshot.humanSchedule,
+				cronExpression: snapshot.cron_expression,
+				prompt: snapshot.prompt,
+				recurring: snapshot.recurring,
+				nextFireAt: snapshot.nextFireAt,
+				createdAt: snapshot.createdAt,
+			}))
+			.sort((a, b) => b.createdAt - a.createdAt);
+		const worstState: JobsWorstState = this.#failedUnacknowledged
+			? "failed"
+			: activeMonitors.length > 0 || crons.length > 0
+				? "running"
+				: "none";
+		this.#snapshot = {
+			monitors,
+			crons,
+			activeMonitorCount: activeMonitors.length,
+			activeCronCount: crons.length,
+			worstState,
+			failedUnacknowledged: this.#failedUnacknowledged,
+		};
+	}
+
+	/** Return the precomputed snapshot (recomputed on each upstream change). */
+	getSnapshot(): JobsSnapshot {
+		return this.#snapshot;
+	}
+
+	/** Clear the failure latch (called when the user opens the jobs overlay). */
+	acknowledgeFailures(): void {
+		for (const job of this.#listMonitorJobs()) {
+			if (job.status === "failed") this.#acknowledgedFailedIds.add(job.id);
+		}
+		if (!this.#failedUnacknowledged) return;
+		this.#failedUnacknowledged = false;
+		this.#recompute();
+		this.#emit();
+	}
+
+	/** Cancel a running monitor job. Returns true when the job was cancelled. */
+	cancelMonitor(id: string): boolean {
+		return this.#manager.cancel(id);
+	}
+
+	/** Delete a visible scheduled cron job. Returns true when removed. */
+	deleteCron(id: string): boolean {
+		return deleteCronJobById(this.#ownerId, id);
+	}
+
+	/** Bounded tail of a monitor job's captured output (for the detail view). */
+	getMonitorOutput(id: string): string {
+		const slice = this.#manager.readOutputSince(id, 0, this.#ownerId ? { ownerId: this.#ownerId } : undefined);
+		return slice?.text ?? "";
+	}
+
+	dispose(): void {
+		this.#disposed = true;
+		for (const unsubscribe of this.#unsubscribers) {
+			try {
+				unsubscribe();
+			} catch {
+				// best-effort teardown
+			}
+		}
+		this.#unsubscribers.length = 0;
+		this.#listeners.clear();
+	}
+}