@gajae-code/coding-agent 0.3.0 → 0.3.1

package/src/internal-urls/registry-helpers.ts

@@ -1,25 +1,28 @@
 /**
- * Shared helpers for internal-url protocol handlers that resolve IDs against
- * registered agent sessions.
+ * Shared helpers for internal-url protocol handlers that resolve session-scoped
+ * artifact IDs.
  */
-import { AgentRegistry } from "../registry/agent-registry";
+import * as path from "node:path";
+import type { ResolveContext } from "./types";
+
+function addDir(dirs: string[], dir: string | null | undefined): void {
+	if (!dir) return;
+	const normalized = path.resolve(dir);
+	if (!dirs.includes(normalized)) dirs.push(normalized);
+}
 
 /**
- * Snapshot of artifacts dirs for every registered session, deduped.
+ * Snapshot of artifacts dirs explicitly authorized for the calling session.
  *
- * Prefers `sessionManager.getArtifactsDir()` because subagents adopt their
- * parent's `ArtifactManager` and report the parent's dir there; dedup then
- * collapses parent + N subagents (the whole agent tree) to one entry. Falls
- * back to the raw session file (with the `.jsonl` suffix stripped) when no
- * live session reference is attached.
+ * Normal reads are scoped to the caller's artifacts directory. Parent/child
+ * agent tree sharing is allowed only when the caller supplies explicit
+ * authorized directories at the ResolveContext boundary. This intentionally
+ * does not enumerate AgentRegistry.global(); live but unrelated sessions are
+ * not an authorization source.
  */
-export function artifactsDirsFromRegistry(): string[] {
+export function authorizedArtifactsDirsFromContext(context?: ResolveContext): string[] {
 	const dirs: string[] = [];
-	for (const ref of AgentRegistry.global().list()) {
-		const dir =
-			ref.session?.sessionManager.getArtifactsDir() ?? (ref.sessionFile ? ref.sessionFile.slice(0, -6) : null);
-		if (!dir) continue;
-		if (!dirs.includes(dir)) dirs.push(dir);
-	}
+	addDir(dirs, context?.getArtifactsDir?.());
+	for (const dir of context?.getAuthorizedArtifactsDirs?.() ?? []) addDir(dirs, dir);
 	return dirs;
 }

package/src/internal-urls/types.ts

@@ -59,6 +59,10 @@ export interface ResolveContext {
 	cwd?: string;
 	/** Settings of the calling session (used by `issue://`/`pr://` for cache TTLs). */
 	settings?: unknown;
+	/** Artifacts directory of the calling session. */
+	getArtifactsDir?: () => string | null;
+	/** Additional artifacts directories explicitly authorized for this caller (for parent/child agent trees). */
+	getAuthorizedArtifactsDirs?: () => readonly string[];
 	/** Caller's abort signal. */
 	signal?: AbortSignal;
 }

package/src/lsp/client.ts

@@ -1,4 +1,5 @@
 import { isEnoent, logger, ptree, untilAborted } from "@gajae-code/utils";
+import { formatCrashDiagnosticNotice, writeCrashReport } from "../debug/crash-diagnostics";
 import { ToolAbortError, throwIfAborted } from "../tools/tool-errors";
 import { applyWorkspaceEdit } from "./edits";
 import { getLspmuxCommand, isLspmuxSupported } from "./lspmux";
@@ -486,7 +487,7 @@ export async function getOrCreateClient(config: ServerConfig, cwd: string, initT
 		clients.set(key, client);
 
 		// Register crash recovery - remove client on process exit
-		proc.exited.then(() => {
+		proc.exited.then(async () => {
 			clients.delete(key);
 			clientLocks.delete(key);
 			client.resolveProjectLoaded();
@@ -501,9 +502,24 @@ export async function getOrCreateClient(config: ServerConfig, cwd: string, initT
 					.filter(line => !/^\[\d{2}:\d{2}:\d{2} (?:INF|DBG|VRB)\]/.test(line))
 					.join("\n")
 					.trim();
+				const crashNotice = formatCrashDiagnosticNotice(
+					await writeCrashReport(
+						{
+							kind: "lsp",
+							command: [command, ...args],
+							exitCode: proc.exitCode,
+							stderr,
+							protocol: "lsp",
+						},
+						{ cwd },
+					),
+				);
+				const diagnosticSuffix = crashNotice ? `\n${crashNotice}` : "";
 				const code = proc.exitCode;
 				const err = new Error(
-					stderr ? `LSP server exited (code ${code}): ${stderr}` : `LSP server exited unexpectedly (code ${code})`,
+					stderr
+						? `LSP server exited (code ${code}): ${stderr}${diagnosticSuffix}`
+						: `LSP server exited unexpectedly (code ${code})${diagnosticSuffix}`,
 				);
 				for (const pending of client.pendingRequests.values()) {
 					pending.reject(err);

package/src/main.ts

@@ -32,7 +32,7 @@ import { getDefault, type SettingPath, Settings, settings } from "./config/setti
 import { initializeWithSettings } from "./discovery";
 import { exportFromFile } from "./export/html";
 import type { ExtensionUIContext } from "./extensibility/extensions/types";
-import { InteractiveMode, runAcpMode, runPrintMode, runRpcMode } from "./modes";
+import { InteractiveMode, runAcpMode, runBridgeMode, runPrintMode, runRpcMode } from "./modes";
 import { initTheme, stopThemeWatcher } from "./modes/theme/theme";
 import type { SubmittedUserInput } from "./modes/types";
 import type { MCPManager } from "./runtime-mcp";
@@ -707,21 +707,35 @@ export async function runRootCommand(
 		process.exit(0);
 	}
 
-	if ((parsedArgs.mode === "rpc" || parsedArgs.mode === "rpc-ui") && parsedArgs.fileArgs.length > 0) {
-		process.stderr.write(`${chalk.red("Error: @file arguments are not supported in RPC mode")}\n`);
+	if (
+		(parsedArgs.mode === "rpc" || parsedArgs.mode === "rpc-ui" || parsedArgs.mode === "bridge") &&
+		parsedArgs.fileArgs.length > 0
+	) {
+		process.stderr.write(`${chalk.red("Error: @file arguments are not supported in RPC or bridge mode")}\n`);
 		process.exit(1);
 	}
 
 	const cwd = getProjectDir();
 	const settingsInstance = deps.settings ?? (await logger.time("settings:init", Settings.init, { cwd }));
-	if (parsedArgs.mode === "rpc" || parsedArgs.mode === "rpc-ui" || parsedArgs.mode === "acp") {
+	if (
+		parsedArgs.mode === "rpc" ||
+		parsedArgs.mode === "rpc-ui" ||
+		parsedArgs.mode === "acp" ||
+		parsedArgs.mode === "bridge"
+	) {
 		applyRpcDefaultSettingOverrides(settingsInstance);
 	}
 	modelRegistry.applyConfiguredModelBindings(settingsInstance);
 	if (parsedArgs.noPty || parsedArgs.mode === "rpc-ui") {
 		Bun.env.PI_NO_PTY = "1";
 	}
-	if (parsedArgs.noTitle || parsedArgs.mode === "rpc" || parsedArgs.mode === "rpc-ui" || parsedArgs.mode === "acp") {
+	if (
+		parsedArgs.noTitle ||
+		parsedArgs.mode === "rpc" ||
+		parsedArgs.mode === "rpc-ui" ||
+		parsedArgs.mode === "acp" ||
+		parsedArgs.mode === "bridge"
+	) {
 		Bun.env.PI_NO_TITLE = "1";
 	}
 	const { pipedInput, fileText, fileImages } = await logger.time("prepareInitialMessage", async () => {
@@ -894,6 +908,8 @@ export async function runRootCommand(
 
 		if (mode === "rpc" || mode === "rpc-ui") {
 			await runRpcMode(session, mode === "rpc-ui" ? setToolUIContext : undefined);
+		} else if (mode === "bridge") {
+			await runBridgeMode(session, setToolUIContext);
 		} else if (isInteractive) {
 			const versionCheckPromise = checkForNewVersion(VERSION).catch(() => undefined);
 			const changelogMarkdown = await logger.time("main:getChangelogForDisplay", getChangelogForDisplay, parsedArgs);

package/src/modes/bridge/auth.ts

@@ -0,0 +1,41 @@
+import * as crypto from "node:crypto";
+
+export interface BridgeAuthConfig {
+	token: string;
+}
+
+export interface BridgeBindConfig {
+	hostname: string;
+	port: number;
+	tlsConfigured: boolean;
+}
+
+export function extractBearerToken(authorization: string | null | undefined): string | undefined {
+	if (!authorization) return undefined;
+	const trimmed = authorization.trim();
+	const match = /^Bearer\s+(.+)$/i.exec(trimmed);
+	const token = match?.[1]?.trim();
+	return token ? token : undefined;
+}
+
+export function isBridgeTokenAuthorized(authorization: string | null | undefined, config: BridgeAuthConfig): boolean {
+	const candidate = extractBearerToken(authorization);
+	if (candidate === undefined) return false;
+	const candidateBytes = Buffer.from(candidate, "utf8");
+	const expectedBytes = Buffer.from(config.token, "utf8");
+	return candidateBytes.length === expectedBytes.length && crypto.timingSafeEqual(candidateBytes, expectedBytes);
+}
+
+export function isLoopbackHost(hostname: string): boolean {
+	const normalized = hostname.trim().toLowerCase();
+	return normalized === "localhost" || normalized === "127.0.0.1" || normalized === "::1" || normalized === "[::1]";
+}
+
+export function assertSafeBridgeBind(config: BridgeBindConfig): void {
+	if (!config.tlsConfigured) {
+		throw new Error(
+			`Refusing to start bridge on ${config.hostname}:${config.port} without TLS configured. ` +
+				"Set GJC_BRIDGE_TLS_CERT and GJC_BRIDGE_TLS_KEY.",
+		);
+	}
+}

package/src/modes/bridge/bridge-client-bridge.ts

@@ -0,0 +1,47 @@
+import type {
+	ClientBridge,
+	ClientBridgePermissionOption,
+	ClientBridgePermissionOutcome,
+	ClientBridgePermissionToolCall,
+} from "../../session/client-bridge";
+import type { UiRequestBroker, UiRequestCancelled, UiRequestResolution } from "../shared/agent-wire/ui-request-broker";
+
+export interface BridgePermissionRequestPayload {
+	kind: "permission";
+	toolCall: ClientBridgePermissionToolCall;
+	options: ClientBridgePermissionOption[];
+}
+
+export type BridgePermissionBroker = UiRequestBroker<BridgePermissionRequestPayload, ClientBridgePermissionOutcome>;
+function isUiRequestCancelled(
+	resolution: UiRequestResolution<ClientBridgePermissionOutcome>,
+): resolution is UiRequestCancelled {
+	return "status" in resolution && resolution.status === "cancelled";
+}
+
+function toPermissionOutcome(
+	resolution: UiRequestResolution<ClientBridgePermissionOutcome>,
+): ClientBridgePermissionOutcome {
+	if (isUiRequestCancelled(resolution)) {
+		return { outcome: "cancelled" };
+	}
+	return resolution;
+}
+
+export function createBridgeClientBridge(broker: BridgePermissionBroker): ClientBridge {
+	return {
+		capabilities: { requestPermission: true },
+		deferAgentInitiatedTurns: true,
+		async requestPermission(toolCall, options, signal) {
+			return toPermissionOutcome(
+				await broker.request(
+					{ kind: "permission", toolCall, options },
+					{
+						correlationId: toolCall.toolCallId,
+						signal,
+					},
+				),
+			);
+		},
+	};
+}