@gajae-code/coding-agent 0.5.0 → 0.5.1

package/src/main.ts

@@ -30,6 +30,7 @@ import { activateModelProfile } from "./config/model-profile-activation";
 import { ModelRegistry, ModelsConfigFile } from "./config/model-registry";
 import { resolveCliModel, resolveModelRoleValue, resolveModelScope, type ScopedModel } from "./config/model-resolver";
 import { getDefault, type SettingPath, Settings, settings } from "./config/settings";
+import { BUNDLED_GROK_BUILD_EXTENSION_ID, getBundledGrokBuildExtensionFactory } from "./defaults/gjc-grok-cli";
 import { initializeWithSettings } from "./discovery";
 import { exportFromFile } from "./export/html";
 import type { ExtensionUIContext } from "./extensibility/extensions/types";
@@ -742,7 +743,9 @@ export async function runRootCommand(
 		await runListModelsCommand({
 			modelRegistry,
 			cwd: getProjectDir(),
-			additionalExtensionPaths: [],
+			extensionFactories: [
+				{ factory: getBundledGrokBuildExtensionFactory(), name: BUNDLED_GROK_BUILD_EXTENSION_ID },
+			],
 			settingsExtensions: [],
 			disabledExtensionIds: [],
 			disableExtensionDiscovery: true,
@@ -975,7 +978,9 @@ export async function runRootCommand(
 
 		if (mode === "rpc" || mode === "rpc-ui") {
 			const { runRpcMode } = await import("./modes/rpc/rpc-mode");
-			await runRpcMode(session, mode === "rpc-ui" ? setToolUIContext : undefined);
+			await runRpcMode(session, mode === "rpc-ui" ? setToolUIContext : undefined, {
+				listen: parsedArgs.rpcListen,
+			});
 		} else if (mode === "bridge") {
 			const { runBridgeMode } = await import("./modes/bridge/bridge-mode");
 			await runBridgeMode(session, setToolUIContext);

package/src/modes/components/hook-selector.ts

@@ -3,6 +3,7 @@
  * Displays a list of string options with keyboard navigation.
  */
 import {
+	type AutocompleteProvider,
 	Container,
 	Editor,
 	Markdown,
@@ -73,6 +74,12 @@ export interface HookSelectorOptions {
 		optionLabel: string;
 		onSubmit: (text: string) => void;
 	};
+	/**
+	 * Autocomplete provider for the inline custom-input editor. When present,
+	 * the "Other (type your own)" editor gains the same `@` file-link and `/`
+	 * completion behavior as the main prompt editor.
+	 */
+	autocompleteProvider?: AutocompleteProvider;
 }
 
 class OutlinedList extends Container {
@@ -320,6 +327,7 @@ export class HookSelectorComponent extends Container {
 	#helpTextComponent: Text;
 	#baseHelpText: string;
 	#tui: TUI | undefined;
+	#autocompleteProvider: AutocompleteProvider | undefined;
 	constructor(
 		title: string,
 		options: string[],
@@ -342,6 +350,7 @@ export class HookSelectorComponent extends Container {
 		this.#outline = opts?.outline === true;
 		this.#customInput = opts?.customInput;
 		this.#tui = opts?.tui;
+		this.#autocompleteProvider = opts?.autocompleteProvider;
 
 		this.addChild(new DynamicBorder());
 		this.addChild(new Spacer(1));
@@ -491,6 +500,13 @@ export class HookSelectorComponent extends Container {
 
 	/** Keys while the inline custom-input editor is open below the option list. */
 	#handleInputModeKey(keyData: string, editor: Editor): void {
+		// While the autocomplete dropdown is open, every key belongs to the
+		// editor (navigate/apply/cancel the suggestion) instead of submitting
+		// or backing out of input mode.
+		if (editor.isAutocompleteOpen()) {
+			editor.handleInput(keyData);
+			return;
+		}
 		// Escape backs out to option selection instead of cancelling the dialog,
 		// so a stray Esc never throws away the question context.
 		if (matchesKey(keyData, "escape") || matchesAppInterrupt(keyData)) {
@@ -521,6 +537,9 @@ export class HookSelectorComponent extends Container {
 		editor.setBorderVisible(false);
 		editor.setPromptGutter("> ");
 		editor.disableSubmit = true;
+		if (this.#autocompleteProvider) {
+			editor.setAutocompleteProvider(this.#autocompleteProvider);
+		}
 		this.#inlineEditor = editor;
 		this.#inputArea.addChild(new Spacer(1));
 		this.#inputArea.addChild(editor);

package/src/modes/components/model-selector.ts

@@ -705,6 +705,15 @@ export class ModelSelectorComponent extends Container {
 		return this.#getMissingProviders(profileOrProfiles).length === 0;
 	}
 
+	/**
+	 * A preset group is a list of alternative presets, not an all-or-nothing
+	 * bundle. Treat the group as usable when at least one member preset has all
+	 * of its required providers authenticated.
+	 */
+	#isPresetGroupUsable(profiles: ModelProfileDefinition[]): boolean {
+		return profiles.some(profile => this.#isPresetAuthenticated(profile));
+	}
+
 	async #refreshProviderAuth(): Promise<void> {
 		const providers = new Set<string>();
 		for (const profiles of this.#getPresetGroups().values()) {
@@ -763,7 +772,7 @@ export class ModelSelectorComponent extends Container {
 				continue;
 			}
 			if (row.kind === "group") {
-				const authenticated = this.#isPresetAuthenticated(row.profiles);
+				const authenticated = this.#isPresetGroupUsable(row.profiles);
 				const mark = this.#providerAuthPending ? "…" : authenticated ? "✓" : "✗";
 				const label = `${mark} ${row.groupId}`;
 				const renderedLabel = selected ? theme.fg("accent", label) : authenticated ? label : theme.fg("dim", label);
@@ -1158,18 +1167,26 @@ export class ModelSelectorComponent extends Container {
 			this.#switchToModelMode();
 			return;
 		}
-		const missing =
-			row.kind === "group" ? this.#getMissingProviders(row.profiles) : this.#getMissingProviders(row.profile);
+		if (row.kind === "group") {
+			// A group is a list of alternative presets; only surface a login hint
+			// when none of its members are usable. A partially-usable group stays
+			// navigable so the user can drill in and pick a usable member.
+			if (!this.#isPresetGroupUsable(row.profiles)) {
+				const missing = this.#getMissingProviders(row.profiles);
+				this.#presetLoginHint = `Run ${missing.map(provider => `/login ${provider}`).join(", ")}`;
+				this.#renderPresetLanding();
+			}
+			return;
+		}
+		const missing = this.#getMissingProviders(row.profile);
 		if (missing.length > 0) {
 			this.#presetLoginHint = `Run ${missing.map(provider => `/login ${provider}`).join(", ")}`;
 			this.#renderPresetLanding();
 			return;
 		}
-		if (row.kind === "profile") {
-			this.#previewProfileName = row.profile.name;
-			this.#presetLoginHint = undefined;
-			this.#renderPresetLanding();
-		}
+		this.#previewProfileName = row.profile.name;
+		this.#presetLoginHint = undefined;
+		this.#renderPresetLanding();
 	}
 
 	#beginActionMenuOrSelect(item: ModelItem | CanonicalModelItem): void {

package/src/modes/components/status-line/segments.ts

@@ -66,7 +66,7 @@ function classifyProjectDir(pwd: string): { scratch: boolean; relative: string |
 const gajaeSegment: StatusLineSegment = {
 	id: "gajae",
 	render(_ctx) {
-		return { content: theme.fg("accent", "GJC"), visible: true };
+		return { content: theme.fg("accent", "🦞"), visible: true };
 	},
 };
 

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

@@ -13,6 +13,7 @@ import {
 import { Loader, Markdown, padding, Spacer, Text, visibleWidth } from "@gajae-code/tui";
 import { formatDuration, Snowflake, setProjectDir } from "@gajae-code/utils";
 import { $ } from "bun";
+import { jobElapsedMs } from "../../async";
 import { reset as resetCapabilities } from "../../capability";
 import { clearClaudePluginRootsCache } from "../../discovery/helpers";
 import { loadCustomShare } from "../../export/custom-share";
@@ -1279,7 +1280,7 @@ const BAR_WIDTH_MAX = 24;
 const BAR_WIDTH_MIN = 4;
 
 function renderJobLine(job: AsyncJobSnapshotItem, now: number): string {
-	const duration = formatDuration(Math.max(0, now - job.startTime));
+	const duration = formatDuration(jobElapsedMs(job, now));
 	const status = formatJobStatus(job.status);
 	return `${theme.fg("dim", job.id)} ${theme.fg("dim", `[${job.type}]`)} ${status} ${theme.fg("dim", `(${duration})`)}`;
 }
@@ -1538,7 +1539,7 @@ function resolveColumnWidth(count: number, available: number, trailing: number):
 	return ideal;
 }
 
-function renderUsageReports(
+export function renderUsageReports(
 	reports: UsageReport[],
 	uiTheme: typeof theme,
 	nowMs: number,
@@ -1592,17 +1593,35 @@ function renderUsageReports(
 
 		lines.push(uiTheme.bold(uiTheme.fg("accent", providerName)));
 
+		// Stable account column order shared across every window group, so each
+		// account keeps the same column in the 5h / 7d / ... rows. Rank accounts
+		// by total usage across their windows (a per-account value identical for
+		// every group), tie-broken by label for determinism.
+		const rankedAccounts = providerReports
+			.map(report => {
+				const [firstLimit] = report.limits;
+				return {
+					report,
+					total: report.limits.reduce((sum, limit) => sum + (resolveFraction(limit) ?? 0), 0),
+					label: firstLimit ? formatAccountLabel(firstLimit, report, 0) : formatUnlimitedReportLabel(report, 0),
+				};
+			})
+			.sort((a, b) => (a.total !== b.total ? b.total - a.total : a.label.localeCompare(b.label)));
+		const accountRank = new Map<UsageReport, number>();
+		rankedAccounts.forEach((entry, rank) => {
+			accountRank.set(entry.report, rank);
+		});
+
 		const renderableGroups = Array.from(limitGroups.values()).map(group => {
 			const entries = group.limits.map((limit, index) => ({
 				limit,
 				report: group.reports[index],
-				fraction: resolveFraction(limit),
 				index,
 			}));
 			entries.sort((a, b) => {
-				const aFraction = a.fraction ?? -1;
-				const bFraction = b.fraction ?? -1;
-				if (aFraction !== bFraction) return bFraction - aFraction;
+				const aRank = accountRank.get(a.report) ?? Number.MAX_SAFE_INTEGER;
+				const bRank = accountRank.get(b.report) ?? Number.MAX_SAFE_INTEGER;
+				if (aRank !== bRank) return aRank - bRank;
 				return a.index - b.index;
 			});
 			const sortedLimits = entries.map(entry => entry.limit);

package/src/modes/controllers/extension-ui-controller.ts

@@ -645,6 +645,9 @@ export class ExtensionUiController {
 				timeout: dialogOptions?.timeout,
 				onTimeout: dialogOptions?.onTimeout,
 				tui: this.ctx.ui,
+				// Share the main prompt editor's autocomplete provider so the
+				// inline "Other (type your own)" editor supports `@` file links.
+				autocompleteProvider: dialogOptions?.customInput ? this.ctx.editor.getAutocompleteProvider() : undefined,
 				outline: dialogOptions?.outline,
 				wrapFocused: dialogOptions?.wrapFocused,
 				scrollTitleRows,

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

@@ -70,6 +70,7 @@ const CALLBACK_SERVER_PROVIDERS = new Set<string>([
 	"google-gemini-cli",
 	"google-antigravity",
 	"xai",
+	"grok-build",
 ]);
 
 const MANUAL_LOGIN_TIP = "Tip: You can complete pairing with /login <redirect URL>.";

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

@@ -10,8 +10,10 @@
  * - Events: AgentSessionEvent objects streamed as they occur
  * - Extension UI: Extension UI requests are emitted, client responds with extension_ui_response
  */
+
+import * as fs from "node:fs/promises";
 import * as path from "node:path";
-import { $env, readLines, Snowflake } from "@gajae-code/utils";
+import { $pickenv, readLines, Snowflake } from "@gajae-code/utils";
 import type {
 	ExtensionUIContext,
 	ExtensionUIDialogOptions,
@@ -23,6 +25,7 @@ import { initializeExtensions } from "../runtime-init";
 import { dispatchRpcCommand } from "../shared/agent-wire/command-dispatch";
 import { AgentWireFrameSequencer, toAgentWireEventFrame } from "../shared/agent-wire/event-envelope";
 import { rpcError as error } from "../shared/agent-wire/responses";
+import { registerRpcSession, unregisterRpcSession } from "../shared/agent-wire/session-registry";
 import { defaultAuditPath, UnattendedAuditLog } from "../shared/agent-wire/unattended-audit";
 import { UnattendedSessionControlPlane } from "../shared/agent-wire/unattended-session";
 import { FileGateStore } from "../shared/agent-wire/workflow-gate-broker";
@@ -70,13 +73,15 @@ function parseValueDialogResponse(
 	return undefined;
 }
 
-function shouldEmitRpcTitles(): boolean {
-	const raw = $env.PI_RPC_EMIT_TITLE;
+export function shouldEmitRpcTitlesForTest(): boolean {
+	const raw = $pickenv("GJC_RPC_EMIT_TITLE", "PI_RPC_EMIT_TITLE");
 	if (!raw) return false;
 	const normalized = raw.trim().toLowerCase();
 	return normalized === "1" || normalized === "true" || normalized === "yes" || normalized === "on";
 }
 
+const shouldEmitRpcTitles = shouldEmitRpcTitlesForTest;
+
 function auditOutcomeFor(event: string): "accepted" | "rejected" | "denied" | "exceeded" | "aborted" | "info" {
 	if (event.includes("denied")) return "denied";
 	if (event.includes("exceeded")) return "exceeded";
@@ -156,6 +161,7 @@ export function requestRpcEditor(
 export async function runRpcMode(
 	session: AgentSession,
 	setToolUIContext?: (uiContext: ExtensionUIContext, hasUI: boolean) => void,
+	options?: { listen?: string },
 ): Promise<never> {
 	// Signal to RPC clients that the server is ready to accept commands
 	// Suppress terminal notifications: they write \x07 (BEL) or OSC sequences directly to
@@ -164,10 +170,18 @@ export async function runRpcMode(
 	// may write there.
 	process.env.PI_NOTIFICATIONS = "off";
 
-	process.stdout.write(`${JSON.stringify({ type: "ready" })}\n`);
+	// Frames go to a swappable sink: stdout for stdio, the active client socket for a
+	// persistent --listen (UDS) server. Defaults to stdout, so the stdio path is unchanged.
+	let frameSink = (line: string): void => {
+		process.stdout.write(line);
+	};
 	const output = (obj: RpcResponse | RpcExtensionUIRequest | object) => {
-		process.stdout.write(`${JSON.stringify(obj)}\n`);
+		frameSink(`${JSON.stringify(obj)}\n`);
 	};
+	// stdio announces readiness immediately; the UDS server announces it per client connection.
+	if (!options?.listen) {
+		output({ type: "ready" });
+	}
 	const emitRpcTitles = shouldEmitRpcTitles();
 	const decodeError = (err: unknown): string => (err instanceof Error ? err.message : String(err));
 
@@ -231,11 +245,20 @@ export async function runRpcMode(
 	// Shutdown request flag (wrapped in object to allow mutation with const)
 	const shutdownState = { requested: false };
 	let shutdownStarted = false;
+	// Tracks in-flight non-blocking command handlers so shutdown can drain them.
+	const inFlightCommands = new Set<Promise<void>>();
 	async function shutdown(exitCode: number, reason: string): Promise<never> {
 		if (shutdownStarted) {
 			process.exit(exitCode);
 		}
 		shutdownStarted = true;
+		// Let in-flight non-blocking commands (bash/compact/handoff) finish and emit
+		// their responses before teardown, bounded so a never-resolving login cannot
+		// wedge shutdown (issue 13).
+		if (inFlightCommands.size > 0) {
+			await Promise.race([Promise.allSettled([...inFlightCommands]), Bun.sleep(5000)]);
+		}
+		await unregisterRpcSession(session.sessionId).catch(() => {});
 		hostToolBridge.rejectAllPending(`${reason} before host tool execution completed`);
 		hostUriBridge.clear(`${reason} before host URI request completed`);
 		try {
@@ -399,7 +422,7 @@ export async function runRpcMode(
 		}
 
 		setTitle(title: string): void {
-			// Title updates are low-value noise for most RPC hosts; opt in via PI_RPC_EMIT_TITLE=1.
+			// Title updates are low-value noise for most RPC hosts; opt in via GJC_RPC_EMIT_TITLE=1.
 			if (!emitRpcTitles) return;
 			this.output({
 				type: "extension_ui_request",
@@ -514,6 +537,34 @@ export async function runRpcMode(
 			unattendedControlPlane,
 		});
 
+	// Cancellation commands must interrupt in-flight work, so they bypass the ordered
+	// queue and run immediately. Everything else runs through a serial chain so causal
+	// order is preserved (e.g. `get_state` after `bash` still observes the bash result)
+	// while the read loop itself never blocks — that is what lets a cancellation command
+	// reach a long-running `bash`/`compact`/`handoff`/`login` instead of being
+	// head-of-line-blocked behind it (issue 13).
+	const CANCELLATION_COMMANDS = new Set<RpcCommand["type"]>(["abort", "abort_bash", "abort_retry"]);
+	let orderedChain: Promise<void> = Promise.resolve();
+	const runCommand = async (command: RpcCommand): Promise<void> => {
+		try {
+			output(await handleCommand(command));
+		} catch (err) {
+			output(error(command.id, command.type, decodeError(err)));
+		}
+	};
+	const trackCommand = (task: Promise<void>): void => {
+		inFlightCommands.add(task);
+		void task.finally(() => inFlightCommands.delete(task));
+	};
+	const dispatchCommand = (command: RpcCommand): void => {
+		if (CANCELLATION_COMMANDS.has(command.type)) {
+			trackCommand(runCommand(command));
+			return;
+		}
+		orderedChain = orderedChain.then(() => runCommand(command));
+		trackCommand(orderedChain);
+	};
+
 	/**
 	 * Check if shutdown was requested and perform shutdown if so.
 	 * Called after handling each command when waiting for the next command.
@@ -523,59 +574,126 @@ export async function runRpcMode(
 		await shutdown(0, "RPC shutdown requested");
 	}
 
-	// Listen for JSONL input using Bun's stdin. Parse frame-by-frame so a malformed
-	// command reports a parse error without poisoning the whole long-lived RPC session.
+	// Parse + route a single inbound JSONL frame. Shared by the stdio reader and the
+	// persistent UDS server so both transports use the same command surface.
 	const inputDecoder = new TextDecoder("utf-8", { fatal: false });
-	for await (const line of readLines(Bun.stdin.stream())) {
-		const text = inputDecoder.decode(line).trim();
-		if (!text) continue;
-
+	async function handleInboundLine(text: string): Promise<void> {
 		let parsed: unknown;
 		try {
 			parsed = JSON.parse(text);
 		} catch (err) {
 			output(error(undefined, "parse", `Failed to parse command: ${decodeError(err)}`));
-			continue;
+			return;
 		}
-
 		try {
-			// Handle extension UI responses
 			if ((parsed as RpcExtensionUIResponse).type === "extension_ui_response") {
 				const response = parsed as RpcExtensionUIResponse;
-				const pending = pendingExtensionRequests.get(response.id);
-				if (pending) {
-					pending.resolve(response);
-				}
-				continue;
+				pendingExtensionRequests.get(response.id)?.resolve(response);
+				return;
 			}
-
 			if (isRpcHostToolResult(parsed)) {
 				hostToolBridge.handleResult(parsed);
-				continue;
+				return;
 			}
-
 			if (isRpcHostToolUpdate(parsed)) {
 				hostToolBridge.handleUpdate(parsed);
-				continue;
+				return;
 			}
-
 			if (isRpcHostUriResult(parsed)) {
 				hostUriBridge.handleResult(parsed);
-				continue;
+				return;
 			}
-
-			// Handle regular commands
-			const command = parsed as RpcCommand;
-			const response = await handleCommand(command);
-			output(response);
-
-			// Check for deferred shutdown request (idle between commands)
+			// Ordered commands run through a serial chain to preserve causal order; the
+			// reader never blocks, so cancellation commands stay responsive even while a
+			// long command is in flight (issue 13).
+			dispatchCommand(parsed as RpcCommand);
 			await checkShutdownRequested();
 		} catch (err) {
 			output(error(undefined, "parse", `Failed to parse command: ${decodeError(err)}`));
 		}
 	}
 
+	// Persistent UDS server (issue 09): keep the AgentSession alive across client
+	// reconnects instead of exiting on stdin EOF. Frames route to the active client
+	// socket; while no client is connected they are dropped (clients resync via
+	// get_state/get_messages on reconnect).
+	if (options?.listen) {
+		const socketPath = options.listen;
+		await fs.mkdir(path.dirname(socketPath), { recursive: true }).catch(() => {});
+		await fs.rm(socketPath, { force: true }).catch(() => {});
+		await registerRpcSession({
+			sessionId: session.sessionId,
+			pid: process.pid,
+			transport: "socket",
+			cwd: session.sessionManager.getCwd(),
+			model: session.model?.id,
+			startedAt: new Date().toISOString(),
+			endpoint: socketPath,
+		}).catch(() => {});
+
+		const noopSink = (_line: string): void => {};
+		let currentSocket: object | undefined;
+		let buf = "";
+		Bun.listen({
+			unix: socketPath,
+			socket: {
+				open(socket) {
+					currentSocket = socket;
+					buf = "";
+					frameSink = (line: string) => {
+						socket.write(line);
+					};
+					output({ type: "ready" });
+				},
+				data(socket, data) {
+					if (socket !== currentSocket) return;
+					buf += inputDecoder.decode(data);
+					while (true) {
+						const nl = buf.indexOf("\n");
+						if (nl < 0) break;
+						const text = buf.slice(0, nl).trim();
+						buf = buf.slice(nl + 1);
+						if (text) void handleInboundLine(text);
+					}
+				},
+				close(socket) {
+					if (socket === currentSocket) {
+						currentSocket = undefined;
+						frameSink = noopSink;
+					}
+				},
+				error() {},
+			},
+		});
+
+		const onSignal = (): void => {
+			void shutdown(0, "RPC socket server signal");
+		};
+		process.on("SIGINT", onSignal);
+		process.on("SIGTERM", onSignal);
+		// Block until an explicit shutdown (signal/extension) calls process.exit.
+		await new Promise<never>(() => {});
+		throw new Error("RPC socket server returned unexpectedly");
+	}
+
+	// Register this stdio RPC session so other processes can discover it (issue 10).
+	await registerRpcSession({
+		sessionId: session.sessionId,
+		pid: process.pid,
+		transport: "stdio",
+		cwd: session.sessionManager.getCwd(),
+		model: session.model?.id,
+		startedAt: new Date().toISOString(),
+	}).catch(() => {});
+
+	// Listen for JSONL input using Bun's stdin. Parse frame-by-frame so a malformed
+	// command reports a parse error without poisoning the whole long-lived RPC session.
+	for await (const line of readLines(Bun.stdin.stream())) {
+		const text = inputDecoder.decode(line).trim();
+		if (!text) continue;
+		await handleInboundLine(text);
+	}
+
 	// stdin closed — RPC client is gone, flush durable state and exit cleanly
 	await shutdown(0, "RPC client disconnected");
 	throw new Error("RPC shutdown returned unexpectedly");