@gajae-code/coding-agent 0.3.0 → 0.3.1

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";
@@ -330,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;
@@ -525,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();
 
@@ -1843,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;
@@ -1944,6 +1962,7 @@ export class InteractiveMode implements InteractiveModeContext {
 			nextEditor.setHistoryStorage(this.historyStorage);
 		}
 		nextEditor.setText(previousText);
+		previousEditor.dispose();
 
 		this.editorContainer.clear();
 		this.editor = nextEditor;
@@ -2317,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();
+	}
+}

package/src/modes/rpc/host-tools.ts

@@ -1,186 +1 @@
-import type { AgentTool, AgentToolResult, AgentToolUpdateCallback } from "@gajae-code/agent-core";
-import type { Static, TSchema } from "@gajae-code/ai";
-import { Snowflake } from "@gajae-code/utils";
-import { applyToolProxy } from "../../extensibility/tool-proxy";
-import type { Theme } from "../../modes/theme/theme";
-import type {
-	RpcHostToolCallRequest,
-	RpcHostToolCancelRequest,
-	RpcHostToolDefinition,
-	RpcHostToolResult,
-	RpcHostToolUpdate,
-} from "./rpc-types";
-
-type RpcHostToolOutput = (frame: RpcHostToolCallRequest | RpcHostToolCancelRequest) => void;
-
-type PendingHostToolCall = {
-	resolve: (result: AgentToolResult<unknown>) => void;
-	reject: (error: Error) => void;
-	onUpdate?: AgentToolUpdateCallback<unknown>;
-};
-
-function isAgentToolResult(value: unknown): value is AgentToolResult<unknown> {
-	if (!value || typeof value !== "object") return false;
-	const content = (value as { content?: unknown }).content;
-	return Array.isArray(content);
-}
-
-export function isRpcHostToolResult(value: unknown): value is RpcHostToolResult {
-	if (!value || typeof value !== "object") return false;
-	const frame = value as { type?: unknown; id?: unknown; result?: unknown };
-	return frame.type === "host_tool_result" && typeof frame.id === "string" && isAgentToolResult(frame.result);
-}
-
-export function isRpcHostToolUpdate(value: unknown): value is RpcHostToolUpdate {
-	if (!value || typeof value !== "object") return false;
-	const frame = value as { type?: unknown; id?: unknown; partialResult?: unknown };
-	return frame.type === "host_tool_update" && typeof frame.id === "string" && isAgentToolResult(frame.partialResult);
-}
-
-class RpcHostToolAdapter<TParams extends TSchema = TSchema, TTheme extends Theme = Theme>
-	implements AgentTool<TParams, unknown, TTheme>
-{
-	declare name: string;
-	declare label: string;
-	declare description: string;
-	declare parameters: TParams;
-	readonly strict = true;
-	concurrency: "shared" | "exclusive" = "shared";
-	#bridge: RpcHostToolBridge;
-	#definition: RpcHostToolDefinition;
-
-	constructor(definition: RpcHostToolDefinition, bridge: RpcHostToolBridge) {
-		this.#definition = definition;
-		this.#bridge = bridge;
-		applyToolProxy(definition, this);
-	}
-
-	execute(
-		toolCallId: string,
-		params: Static<TParams>,
-		signal?: AbortSignal,
-		onUpdate?: AgentToolUpdateCallback<unknown>,
-	): Promise<AgentToolResult<unknown>> {
-		return this.#bridge.requestExecution(
-			this.#definition,
-			toolCallId,
-			params as Record<string, unknown>,
-			signal,
-			onUpdate,
-		);
-	}
-}
-
-export class RpcHostToolBridge {
-	#output: RpcHostToolOutput;
-	#definitions = new Map<string, RpcHostToolDefinition>();
-	#pendingCalls = new Map<string, PendingHostToolCall>();
-
-	constructor(output: RpcHostToolOutput) {
-		this.#output = output;
-	}
-
-	getToolNames(): string[] {
-		return Array.from(this.#definitions.keys());
-	}
-
-	setTools(tools: RpcHostToolDefinition[]): AgentTool[] {
-		this.#definitions = new Map(tools.map(tool => [tool.name, tool]));
-		return tools.map(tool => new RpcHostToolAdapter(tool, this));
-	}
-
-	handleResult(frame: RpcHostToolResult): boolean {
-		const pending = this.#pendingCalls.get(frame.id);
-		if (!pending) return false;
-		this.#pendingCalls.delete(frame.id);
-		if (frame.isError) {
-			const text = frame.result.content
-				.filter(
-					(item): item is { type: "text"; text: string } => item.type === "text" && typeof item.text === "string",
-				)
-				.map(item => item.text)
-				.join("\n")
-				.trim();
-			pending.reject(new Error(text || "Host tool execution failed"));
-			return true;
-		}
-		pending.resolve(frame.result);
-		return true;
-	}
-
-	handleUpdate(frame: RpcHostToolUpdate): boolean {
-		const pending = this.#pendingCalls.get(frame.id);
-		if (!pending) return false;
-		pending.onUpdate?.(frame.partialResult);
-		return true;
-	}
-
-	requestExecution(
-		definition: RpcHostToolDefinition,
-		toolCallId: string,
-		args: Record<string, unknown>,
-		signal?: AbortSignal,
-		onUpdate?: AgentToolUpdateCallback<unknown>,
-	): Promise<AgentToolResult<unknown>> {
-		if (signal?.aborted) {
-			return Promise.reject(new Error(`Host tool "${definition.name}" was aborted`));
-		}
-
-		const id = Snowflake.next() as string;
-		const { promise, resolve, reject } = Promise.withResolvers<AgentToolResult<unknown>>();
-		let settled = false;
-
-		const cleanup = () => {
-			signal?.removeEventListener("abort", onAbort);
-			this.#pendingCalls.delete(id);
-		};
-
-		const onAbort = () => {
-			if (settled) return;
-			settled = true;
-			cleanup();
-			this.#output({
-				type: "host_tool_cancel",
-				id: Snowflake.next() as string,
-				targetId: id,
-			});
-			reject(new Error(`Host tool "${definition.name}" was aborted`));
-		};
-
-		signal?.addEventListener("abort", onAbort, { once: true });
-		this.#pendingCalls.set(id, {
-			resolve: result => {
-				if (settled) return;
-				settled = true;
-				cleanup();
-				resolve(result);
-			},
-			reject: error => {
-				if (settled) return;
-				settled = true;
-				cleanup();
-				reject(error);
-			},
-			onUpdate,
-		});
-
-		this.#output({
-			type: "host_tool_call",
-			id,
-			toolCallId,
-			toolName: definition.name,
-			arguments: args,
-		});
-
-		return promise;
-	}
-
-	rejectAllPending(message: string): void {
-		const error = new Error(message);
-		const pendingCalls = Array.from(this.#pendingCalls.values());
-		this.#pendingCalls.clear();
-		for (const pending of pendingCalls) {
-			pending.reject(error);
-		}
-	}
-}
+export * from "../shared/agent-wire/host-tool-bridge";

package/src/modes/rpc/host-uris.ts

@@ -1,235 +1 @@
-import { Snowflake } from "@gajae-code/utils";
-import { InternalUrlRouter } from "../../internal-urls";
-import type {
-	InternalResource,
-	InternalUrl,
-	ProtocolHandler,
-	ResolveContext,
-	WriteContext,
-} from "../../internal-urls/types";
-import type {
-	RpcHostUriCancelRequest,
-	RpcHostUriRequest,
-	RpcHostUriResult,
-	RpcHostUriSchemeDefinition,
-} from "./rpc-types";
-
-type RpcHostUriOutput = (frame: RpcHostUriRequest | RpcHostUriCancelRequest) => void;
-
-type PendingUriRequest = {
-	operation: "read" | "write";
-	url: string;
-	resolve: (frame: RpcHostUriResult) => void;
-	reject: (error: Error) => void;
-};
-
-/** Type guard for inbound `host_uri_result` frames coming from the host. */
-export function isRpcHostUriResult(value: unknown): value is RpcHostUriResult {
-	if (!value || typeof value !== "object") return false;
-	const frame = value as { type?: unknown; id?: unknown };
-	return frame.type === "host_uri_result" && typeof frame.id === "string";
-}
-
-/**
- * One handler instance per host-registered scheme. Delegates reads and (when
- * the scheme was registered as writable) writes to the bridge, which serializes
- * them over the RPC transport.
- */
-class RpcHostUriProtocolHandler implements ProtocolHandler {
-	readonly scheme: string;
-	readonly immutable: boolean;
-	readonly write?: (url: InternalUrl, content: string, context?: WriteContext) => Promise<void>;
-	readonly #bridge: RpcHostUriBridge;
-
-	constructor(definition: RpcHostUriSchemeDefinition, bridge: RpcHostUriBridge) {
-		this.scheme = definition.scheme;
-		this.immutable = definition.immutable === true;
-		this.#bridge = bridge;
-		if (definition.writable === true) {
-			this.write = (url, content, context) => this.#bridge.requestWrite(this.scheme, url, content, context);
-		}
-	}
-
-	resolve(url: InternalUrl, context?: ResolveContext): Promise<InternalResource> {
-		return this.#bridge.requestRead(this.scheme, url, context);
-	}
-}
-
-/**
- * Bidirectional bridge that lets the RPC host own a set of URI schemes.
- *
- * The host registers schemes via `set_host_uri_schemes`; the bridge installs
- * a `RpcHostUriProtocolHandler` per scheme into the process-global
- * {@link InternalUrlRouter}. Reads land on the read tool through the existing
- * router; writes are intercepted by the write tool and dispatched through
- * `requestWrite`.
- */
-export class RpcHostUriBridge {
-	#output: RpcHostUriOutput;
-	#router: InternalUrlRouter;
-	#definitions = new Map<string, RpcHostUriSchemeDefinition>();
-	#pending = new Map<string, PendingUriRequest>();
-
-	constructor(output: RpcHostUriOutput, router: InternalUrlRouter = InternalUrlRouter.instance()) {
-		this.#output = output;
-		this.#router = router;
-	}
-
-	getSchemes(): string[] {
-		return Array.from(this.#definitions.keys());
-	}
-
-	/**
-	 * Replace the registered set of host URI schemes. Previously registered
-	 * schemes that no longer appear in the new set are unregistered from the
-	 * router; surviving and new schemes get fresh handler instances.
-	 */
-	setSchemes(schemes: RpcHostUriSchemeDefinition[]): string[] {
-		const normalized = new Map<string, RpcHostUriSchemeDefinition>();
-		for (const raw of schemes) {
-			const scheme = typeof raw?.scheme === "string" ? raw.scheme.trim().toLowerCase() : "";
-			if (!scheme) {
-				throw new Error("Host URI scheme must be a non-empty string");
-			}
-			if (!/^[a-z][a-z0-9+.-]*$/.test(scheme)) {
-				throw new Error(`Host URI scheme contains invalid characters: ${raw.scheme}`);
-			}
-			normalized.set(scheme, {
-				scheme,
-				description: typeof raw.description === "string" ? raw.description : undefined,
-				writable: raw.writable === true,
-				immutable: raw.immutable === true,
-			});
-		}
-
-		for (const previous of this.#definitions.keys()) {
-			if (!normalized.has(previous)) {
-				this.#router.unregister(previous);
-			}
-		}
-		for (const definition of normalized.values()) {
-			this.#router.register(new RpcHostUriProtocolHandler(definition, this));
-		}
-		this.#definitions = normalized;
-		return Array.from(normalized.keys());
-	}
-
-	/**
-	 * Unregister every host scheme from the router and reject any in-flight
-	 * requests. Called on RPC shutdown to keep the global router clean for
-	 * subsequent sessions in the same process (used by tests).
-	 */
-	clear(message: string = "Host URI bridge shut down"): void {
-		for (const scheme of this.#definitions.keys()) {
-			this.#router.unregister(scheme);
-		}
-		this.#definitions.clear();
-		this.rejectAllPending(message);
-	}
-
-	/** Resolve a pending request by id; called by `rpc-mode` on inbound results. */
-	handleResult(frame: RpcHostUriResult): boolean {
-		const pending = this.#pending.get(frame.id);
-		if (!pending) return false;
-		this.#pending.delete(frame.id);
-		pending.resolve(frame);
-		return true;
-	}
-
-	rejectAllPending(message: string): void {
-		const error = new Error(message);
-		const pending = Array.from(this.#pending.values());
-		this.#pending.clear();
-		for (const entry of pending) {
-			entry.reject(error);
-		}
-	}
-
-	async requestRead(scheme: string, url: InternalUrl, context?: ResolveContext): Promise<InternalResource> {
-		const result = await this.#dispatch("read", url.href, undefined, context?.signal);
-		if (result.isError) {
-			throw new Error(result.error || result.content || `Host URI read failed for ${url.href}`);
-		}
-		const content = result.content ?? "";
-		const contentType = result.contentType ?? "text/plain";
-		const definition = this.#definitions.get(scheme);
-		return {
-			url: url.href,
-			content,
-			contentType,
-			size: Buffer.byteLength(content, "utf-8"),
-			notes: result.notes && result.notes.length > 0 ? [...result.notes] : undefined,
-			immutable: result.immutable ?? definition?.immutable === true,
-		};
-	}
-
-	async requestWrite(_scheme: string, url: InternalUrl, content: string, context?: WriteContext): Promise<void> {
-		const result = await this.#dispatch("write", url.href, content, context?.signal);
-		if (result.isError) {
-			throw new Error(result.error || result.content || `Host URI write failed for ${url.href}`);
-		}
-	}
-
-	#dispatch(
-		operation: "read" | "write",
-		url: string,
-		content: string | undefined,
-		signal: AbortSignal | undefined,
-	): Promise<RpcHostUriResult> {
-		if (signal?.aborted) {
-			return Promise.reject(new Error(`Host URI ${operation} for ${url} was aborted`));
-		}
-
-		const id = Snowflake.next() as string;
-		const { promise, resolve, reject } = Promise.withResolvers<RpcHostUriResult>();
-		let settled = false;
-
-		const cleanup = () => {
-			signal?.removeEventListener("abort", onAbort);
-			this.#pending.delete(id);
-		};
-
-		const onAbort = () => {
-			if (settled) return;
-			settled = true;
-			cleanup();
-			this.#output({
-				type: "host_uri_cancel",
-				id: Snowflake.next() as string,
-				targetId: id,
-			});
-			reject(new Error(`Host URI ${operation} for ${url} was aborted`));
-		};
-
-		signal?.addEventListener("abort", onAbort, { once: true });
-		this.#pending.set(id, {
-			operation,
-			url,
-			resolve: frame => {
-				if (settled) return;
-				settled = true;
-				cleanup();
-				resolve(frame);
-			},
-			reject: err => {
-				if (settled) return;
-				settled = true;
-				cleanup();
-				reject(err);
-			},
-		});
-
-		const frame: RpcHostUriRequest = {
-			type: "host_uri_request",
-			id,
-			operation,
-			url,
-		};
-		if (operation === "write") {
-			frame.content = content ?? "";
-		}
-		this.#output(frame);
-
-		return promise;
-	}
-}
+export * from "../shared/agent-wire/host-uri-bridge";