@gajae-code/coding-agent 0.10.2 → 0.11.1

package/src/modes/shared/agent-wire/scopes.ts

@@ -1,94 +0,0 @@
-/**
- * Coarse bridge authorization scopes for RPC commands.
- *
- * The v1 bridge exposes a network-reachable control surface, so every
- * `RpcCommand` must be assigned to one coarse scope before any REST handler can
- * dispatch it. The registry is intentionally typed as `Record<RpcCommandType,
- * BridgeCommandScope>` so adding a new RPC command without a scope is a compile
- * failure.
- */
-import type { RpcCommand } from "../../rpc/rpc-types";
-
-export type RpcCommandType = RpcCommand["type"];
-
-export type BridgeCommandScope =
-	| "prompt"
-	| "control"
-	| "bash"
-	| "export"
-	| "session"
-	| "model"
-	| "message:read"
-	| "host_tools"
-	| "host_uri"
-	| "admin";
-export const BRIDGE_COMMAND_SCOPES: readonly BridgeCommandScope[] = [
-	"prompt",
-	"control",
-	"bash",
-	"export",
-	"session",
-	"model",
-	"message:read",
-	"host_tools",
-	"host_uri",
-	"admin",
-];
-
-const RPC_COMMAND_SCOPE_REGISTRY: Record<RpcCommandType, BridgeCommandScope> = {
-	prompt: "prompt",
-	steer: "prompt",
-	follow_up: "prompt",
-	abort: "prompt",
-	abort_and_prompt: "prompt",
-	new_session: "session",
-	get_state: "message:read",
-	set_todos: "control",
-	set_host_tools: "host_tools",
-	set_host_uri_schemes: "host_uri",
-	get_pending_workflow_gates: "message:read",
-	set_capabilities: "control",
-	set_model: "model",
-	set_default_model_selection: "model",
-	cycle_model: "model",
-	get_available_models: "model",
-	set_thinking_level: "model",
-	cycle_thinking_level: "model",
-	set_steering_mode: "control",
-	set_follow_up_mode: "control",
-	set_interrupt_mode: "control",
-	compact: "control",
-	set_auto_compaction: "control",
-	set_auto_retry: "control",
-	abort_retry: "control",
-	bash: "bash",
-	abort_bash: "bash",
-	get_session_stats: "message:read",
-	export_html: "export",
-	switch_session: "session",
-	branch: "session",
-	get_branch_messages: "session",
-	get_last_assistant_text: "message:read",
-	set_session_name: "session",
-	handoff: "admin",
-	get_messages: "message:read",
-	get_login_providers: "admin",
-	login: "admin",
-	negotiate_unattended: "control",
-	workflow_gate_response: "control",
-};
-
-export const RPC_COMMAND_TYPES: readonly RpcCommandType[] = Object.keys(RPC_COMMAND_SCOPE_REGISTRY) as RpcCommandType[];
-export function isRpcCommandType(value: unknown): value is RpcCommandType {
-	return typeof value === "string" && value in RPC_COMMAND_SCOPE_REGISTRY;
-}
-
-export const MANDATORY_FLOOR_COMMAND_SCOPES: readonly BridgeCommandScope[] = ["prompt"];
-
-export function scopeForRpcCommand(type: RpcCommandType): BridgeCommandScope {
-	return RPC_COMMAND_SCOPE_REGISTRY[type];
-}
-
-export function isRpcCommandAllowed(type: RpcCommandType, scopes: ReadonlySet<BridgeCommandScope>): boolean {
-	return scopes.has(scopeForRpcCommand(type));
-}

package/src/modes/shared/agent-wire/session-registry.ts

@@ -1,109 +0,0 @@
-/**
- * Cross-process registry of running gjc RPC sessions (issue 10).
- *
- * Each live RPC server writes a record under `<agent-dir>/rpc-sessions/<id>.json`
- * on start and removes it on shutdown, so a separate process can discover which
- * sessions are alive (and, once persistence lands in issue 09, how to reach
- * them). Listing reaps records whose owning process is no longer alive, so a
- * crashed server never leaves a permanent phantom entry.
- */
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import { getAgentDir } from "@gajae-code/utils";
-
-export type RpcSessionTransport = "stdio" | "bridge" | "socket";
-
-export interface RpcSessionRecord {
-	sessionId: string;
-	pid: number;
-	transport: RpcSessionTransport;
-	cwd: string;
-	model?: string;
-	/** ISO-8601 start timestamp. */
-	startedAt: string;
-	/** Reachable endpoint for persistent transports (issue 09); absent for stdio. */
-	endpoint?: string;
-}
-
-/** Registry directory: `<agent-dir>/rpc-sessions` (honors GJC_CODING_AGENT_DIR via getAgentDir). */
-function rpcSessionsDir(agentDir?: string): string {
-	return path.join(agentDir ?? getAgentDir(), "rpc-sessions");
-}
-
-function recordPath(sessionId: string, agentDir?: string): string {
-	return path.join(rpcSessionsDir(agentDir), `${sessionId}.json`);
-}
-
-/**
- * Write (or replace) the registry record for a session. The record is written to
- * a same-directory temp file and atomically renamed into place so a concurrent
- * reader never observes (and reaps) a partially-written record.
- */
-export async function registerRpcSession(record: RpcSessionRecord, agentDir?: string): Promise<string> {
-	const file = recordPath(record.sessionId, agentDir);
-	// `.tmp` suffix keeps the staging file out of the `*.json` listing/reaping path.
-	const staging = `${file}.${process.pid}.tmp`;
-	await Bun.write(staging, JSON.stringify(record));
-	await fs.rename(staging, file);
-	return file;
-}
-
-/** Remove a session's registry record. Best-effort: a missing file is not an error. */
-export async function unregisterRpcSession(sessionId: string, agentDir?: string): Promise<void> {
-	await fs.rm(recordPath(sessionId, agentDir), { force: true });
-}
-
-function isProcessAlive(pid: number): boolean {
-	if (!Number.isInteger(pid) || pid <= 0) return false;
-	try {
-		// Signal 0 performs error checking without delivering a signal.
-		process.kill(pid, 0);
-		return true;
-	} catch (err) {
-		// ESRCH => no such process (dead). EPERM => alive but owned by another user.
-		return (err as NodeJS.ErrnoException).code === "EPERM";
-	}
-}
-
-function parseRecord(raw: string): RpcSessionRecord | undefined {
-	let obj: Partial<RpcSessionRecord>;
-	try {
-		obj = JSON.parse(raw) as Partial<RpcSessionRecord>;
-	} catch {
-		return undefined;
-	}
-	if (typeof obj.sessionId !== "string" || typeof obj.pid !== "number") return undefined;
-	return obj as RpcSessionRecord;
-}
-
-/**
- * List live RPC sessions, reaping records whose process is gone or whose file is
- * unparseable. Returns records sorted by `startedAt` ascending.
- */
-export async function listRpcSessions(agentDir?: string): Promise<RpcSessionRecord[]> {
-	const dir = rpcSessionsDir(agentDir);
-	let entries: string[];
-	try {
-		entries = await fs.readdir(dir);
-	} catch {
-		return [];
-	}
-	const live: RpcSessionRecord[] = [];
-	for (const entry of entries) {
-		if (!entry.endsWith(".json")) continue;
-		const file = path.join(dir, entry);
-		let raw: string;
-		try {
-			raw = await fs.readFile(file, "utf8");
-		} catch {
-			continue;
-		}
-		const record = parseRecord(raw);
-		if (!record || !isProcessAlive(record.pid)) {
-			await fs.rm(file, { force: true });
-			continue;
-		}
-		live.push(record);
-	}
-	return live.sort((a, b) => a.startedAt.localeCompare(b.startedAt));
-}

package/src/modes/shared/agent-wire/ui-request-broker.ts

@@ -1,150 +0,0 @@
-/**
- * Transport-neutral request/response broker for UI and permission surfaces.
- *
- * The bridge protocol has one authoritative responder per session. Requests are
- * correlated by id, resolved exactly once, cancelled on timeout/disconnect, and
- * protected by an owner token so observers cannot race approvals.
- */
-import { randomUUID } from "node:crypto";
-
-export type UiRequestCancelReason = "timeout" | "abort" | "disconnect";
-
-export interface UiRequestCancelled {
-	status: "cancelled";
-	reason: UiRequestCancelReason;
-}
-
-export type UiRequestResolution<TResponse> = TResponse | UiRequestCancelled;
-
-export type UiBrokerResponseResult =
-	| { status: "accepted" }
-	| { status: "rejected"; code: "not_controller" | "already_resolved" | "unknown_request" };
-
-export interface UiRequestBrokerOptions<TRequest> {
-	emitRequest: (correlationId: string, request: TRequest) => void;
-}
-
-export interface UiRequestOptions {
-	correlationId?: string;
-	timeoutMs?: number;
-	signal?: AbortSignal;
-}
-
-interface PendingRequest<TResponse> {
-	resolve: (value: UiRequestResolution<TResponse>) => void;
-	timer: Timer | undefined;
-	onAbort: (() => void) | undefined;
-	signal: AbortSignal | undefined;
-}
-
-/**
- * Broker for one active session. v1 supports one controller token at a time;
- * other clients may observe frames but cannot answer correlated requests.
- */
-export class UiRequestBroker<TRequest, TResponse> {
-	readonly #emitRequest: (correlationId: string, request: TRequest) => void;
-	#ownerToken: string | undefined;
-	#pending = new Map<string, PendingRequest<TResponse>>();
-	#resolved = new Set<string>();
-
-	constructor(options: UiRequestBrokerOptions<TRequest>) {
-		this.#emitRequest = options.emitRequest;
-	}
-
-	get ownerToken(): string | undefined {
-		return this.#ownerToken;
-	}
-
-	get pendingCount(): number {
-		return this.#pending.size;
-	}
-
-	claimController(ownerToken: string = randomUUID()): { status: "claimed"; ownerToken: string } | { status: "busy" } {
-		if (this.#ownerToken) return { status: "busy" };
-		this.#ownerToken = ownerToken;
-		return { status: "claimed", ownerToken: this.#ownerToken };
-	}
-
-	releaseController(ownerToken: string): boolean {
-		if (ownerToken !== this.#ownerToken) return false;
-		this.#ownerToken = undefined;
-		return true;
-	}
-
-	request(request: TRequest, options: UiRequestOptions = {}): Promise<UiRequestResolution<TResponse>> {
-		const correlationId = options.correlationId ?? randomUUID();
-		if (this.#pending.has(correlationId) || this.#resolved.has(correlationId)) {
-			throw new Error(`Duplicate UI request correlation id: ${correlationId}`);
-		}
-
-		const { promise, resolve } = Promise.withResolvers<UiRequestResolution<TResponse>>();
-		let timer: Timer | undefined;
-		let onAbort: (() => void) | undefined;
-		const settle = (value: UiRequestResolution<TResponse>) => {
-			const pending = this.#pending.get(correlationId);
-			if (!pending) return;
-			this.#pending.delete(correlationId);
-			this.#resolved.add(correlationId);
-			if (pending.timer) clearTimeout(pending.timer);
-			if (pending.onAbort) pending.signal?.removeEventListener("abort", pending.onAbort);
-			pending.resolve(value);
-		};
-
-		if (options.timeoutMs !== undefined) {
-			timer = setTimeout(() => settle({ status: "cancelled", reason: "timeout" }), options.timeoutMs);
-		}
-		if (options.signal) {
-			onAbort = () => settle({ status: "cancelled", reason: "abort" });
-			if (options.signal.aborted) {
-				resolve({ status: "cancelled", reason: "abort" });
-				this.#resolved.add(correlationId);
-				return promise;
-			}
-			options.signal.addEventListener("abort", onAbort, { once: true });
-		}
-
-		this.#pending.set(correlationId, { resolve, timer, onAbort, signal: options.signal });
-		this.#emitRequest(correlationId, request);
-		return promise;
-	}
-
-	respond(correlationId: string, ownerToken: string, response: TResponse): UiBrokerResponseResult {
-		if (ownerToken !== this.#ownerToken) return { status: "rejected", code: "not_controller" };
-		const pending = this.#pending.get(correlationId);
-		if (!pending) {
-			return {
-				status: "rejected",
-				code: this.#resolved.has(correlationId) ? "already_resolved" : "unknown_request",
-			};
-		}
-		this.#pending.delete(correlationId);
-		this.#resolved.add(correlationId);
-		if (pending.timer) clearTimeout(pending.timer);
-		if (pending.onAbort) pending.signal?.removeEventListener("abort", pending.onAbort);
-		pending.resolve(response);
-		return { status: "accepted" };
-	}
-
-	cancelAll(reason: UiRequestCancelReason): void {
-		for (const correlationId of [...this.#pending.keys()]) {
-			this.cancel(correlationId, reason);
-		}
-	}
-
-	cancel(correlationId: string, reason: UiRequestCancelReason): boolean {
-		const pending = this.#pending.get(correlationId);
-		if (!pending) return false;
-		this.#pending.delete(correlationId);
-		this.#resolved.add(correlationId);
-		if (pending.timer) clearTimeout(pending.timer);
-		if (pending.onAbort) pending.signal?.removeEventListener("abort", pending.onAbort);
-		pending.resolve({ status: "cancelled", reason });
-		return true;
-	}
-
-	disconnectController(ownerToken: string): boolean {
-		if (!this.releaseController(ownerToken)) return false;
-		this.cancelAll("disconnect");
-		return true;
-	}
-}

package/src/modes/shared/agent-wire/ui-result.ts

@@ -1,48 +0,0 @@
-/**
- * Typed UI/manipulation result semantics for bridge-capability handling.
- *
- * `unsupported` is distinct from both a real value and user cancellation. This
- * prevents local-only or undeclared `ExtensionUIContext` surfaces from becoming
- * silent no-ops that look like user intent.
- */
-export interface BridgeUiValue<TValue> {
-	status: "value";
-	value: TValue;
-}
-
-export interface BridgeUiCancelled {
-	status: "cancelled";
-	reason?: "user" | "timeout" | "abort" | "disconnect";
-}
-
-export interface BridgeUiUnsupported {
-	status: "unsupported";
-	capability: string;
-	reason: string;
-}
-
-export type BridgeUiResult<TValue> = BridgeUiValue<TValue> | BridgeUiCancelled | BridgeUiUnsupported;
-
-export function uiValue<TValue>(value: TValue): BridgeUiValue<TValue> {
-	return { status: "value", value };
-}
-
-export function uiCancelled(reason?: BridgeUiCancelled["reason"]): BridgeUiCancelled {
-	return reason ? { status: "cancelled", reason } : { status: "cancelled" };
-}
-
-export function uiUnsupported(capability: string, reason: string): BridgeUiUnsupported {
-	return { status: "unsupported", capability, reason };
-}
-
-export function isUiUnsupported<TValue>(result: BridgeUiResult<TValue>): result is BridgeUiUnsupported {
-	return result.status === "unsupported";
-}
-
-export function isUiCancelled<TValue>(result: BridgeUiResult<TValue>): result is BridgeUiCancelled {
-	return result.status === "cancelled";
-}
-
-export function isUiValue<TValue>(result: BridgeUiResult<TValue>): result is BridgeUiValue<TValue> {
-	return result.status === "value";
-}