@gajae-code/coding-agent 0.3.0 → 0.3.2

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

@@ -26,13 +26,14 @@ import { buildInitialMessage } from "./cli/initial-message";
 import { runListModelsCommand } from "./cli/list-models";
 import { selectSession } from "./cli/session-picker";
 import { findConfigFile } from "./config";
+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 { 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";
@@ -194,11 +195,59 @@ export interface AcpSessionFactoryOptions {
 	sessionDir?: string;
 	authStorage: AuthStorage;
 	modelRegistry: ModelRegistry;
-	parsedArgs: Pick<Args, "apiKey">;
+	parsedArgs: Pick<Args, "apiKey" | "default" | "model" | "mpreset" | "thinking">;
 	rawArgs: string[];
 	createSession: (options: CreateAgentSessionOptions) => Promise<CreateAgentSessionResult>;
 }
 
+export async function applyStartupModelProfiles(args: {
+	session: AgentSession;
+	settings: Settings;
+	modelRegistry: ModelRegistry;
+	parsedArgs: Pick<Args, "default" | "model" | "mpreset" | "thinking">;
+	startupModel?: CreateAgentSessionOptions["model"];
+	startupThinkingLevel?: CreateAgentSessionOptions["thinkingLevel"];
+}): Promise<void> {
+	const applyProfile = async (profileName: string, persistDefault: boolean): Promise<void> => {
+		await activateModelProfile(
+			{ session: args.session, modelRegistry: args.modelRegistry, settings: args.settings, profileName },
+			{ persistDefault },
+		);
+	};
+
+	// Capture the explicitly-selected startup model BEFORE profile activation can
+	// override it. startupModel covers the eager path; session.model covers the
+	// deferred `--model <pattern>` path resolved inside createAgentSession.
+	const explicitModel = args.parsedArgs.model ? (args.startupModel ?? args.session.model) : undefined;
+
+	const defaultProfile = args.settings.get("modelProfile.default");
+	if (defaultProfile) {
+		await applyProfile(defaultProfile, false);
+	}
+	if (args.parsedArgs.mpreset) {
+		await applyProfile(args.parsedArgs.mpreset, args.parsedArgs.default === true);
+	}
+
+	// Explicit CLI --model/--thinking must win over any activated profile.
+	if (explicitModel) {
+		await args.session.setModelTemporary(explicitModel, args.startupThinkingLevel ?? args.parsedArgs.thinking);
+	} else if (args.parsedArgs.thinking && args.session.model) {
+		await args.session.setModelTemporary(args.session.model, args.parsedArgs.thinking);
+	}
+}
+
+export async function applyStartupModelProfilesOrExit(
+	args: Parameters<typeof applyStartupModelProfiles>[0],
+): Promise<void> {
+	try {
+		await applyStartupModelProfiles(args);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		process.stderr.write(`${chalk.red(`Error: ${message}`)}\n`);
+		process.exit(1);
+	}
+}
+
 /**
  * Build the per-`session/new` factory used by ACP mode.
  *
@@ -225,6 +274,14 @@ export function createAcpSessionFactory(args: AcpSessionFactoryOptions): AcpSess
 			hasUI: false,
 			enableMCP: false,
 		});
+		await applyStartupModelProfilesOrExit({
+			session: nextSession,
+			settings: nextSettings,
+			modelRegistry: args.modelRegistry,
+			parsedArgs: args.parsedArgs,
+			startupModel: args.baseOptions.model,
+			startupThinkingLevel: args.baseOptions.thinkingLevel,
+		});
 		if (args.parsedArgs.apiKey && !args.baseOptions.model && nextSession.model) {
 			args.authStorage.setRuntimeApiKey(nextSession.model.provider, args.parsedArgs.apiKey);
 		}
@@ -707,21 +764,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 () => {
@@ -864,6 +935,15 @@ export async function runRootCommand(
 			authStorage.setRuntimeApiKey(session.model.provider, parsedArgs.apiKey);
 		}
 
+		await applyStartupModelProfilesOrExit({
+			session,
+			settings: settingsInstance,
+			modelRegistry,
+			parsedArgs,
+			startupModel: sessionOptions.model,
+			startupThinkingLevel: sessionOptions.thinkingLevel,
+		});
+
 		if (modelFallbackMessage) {
 			notifs.push({ kind: "warn", message: modelFallbackMessage });
 		}
@@ -894,6 +974,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,
+					},
+				),
+			);
+		},
+	};
+}