@gajae-code/coding-agent 0.10.2 → 0.11.1

package/dist/types/modes/shared/agent-wire/unattended-session.d.ts

@@ -1,127 +0,0 @@
-/**
- * Session-level unattended control plane (#323 / G011 emission side).
- *
- * Bridges the gate EMISSION side (skill runtimes / ask tool emitting gates) to
- * the gate ANSWER side (the external agent's `workflow_gate_response` over RPC):
- *
- *  - `emitGate(input)` opens a gate on the durable broker, emits the gate frame
- *    to the transport, and returns a promise that resolves with the agent's
- *    answer once it arrives.
- *  - `resolveGate(response)` (called from RPC dispatch) validates + resolves the
- *    gate on the broker; the broker's `advance` hook resolves the pending
- *    `emitGate` promise with the answer.
- *
- * Also implements the dispatch-facing {@link RpcUnattendedControlPlane} so the
- * RPC server can route `negotiate_unattended` + `workflow_gate_response` here.
- */
-import type { Model } from "@gajae-code/ai";
-import type { AskSelectedAckOutcome } from "../../../tools";
-import type { RpcCommand, RpcUnattendedAccepted, RpcUnattendedDeclaration, RpcWorkflowGate, RpcWorkflowGateResolution, RpcWorkflowGateResponse } from "../../rpc/rpc-types";
-import type { RpcUnattendedControlPlane } from "./command-dispatch";
-import { type UnattendedAbortHooks, type UnattendedAuditEvent, UnattendedRunController } from "./unattended-run-controller";
-import { type GateStore, type OpenGateInput } from "./workflow-gate-broker";
-export interface WorkflowGateTerminalController {
-    completeGateInteractions(gateId: string): void | Promise<void>;
-    cancelGateInteractions(gateId: string, reason: string): void | Promise<void>;
-}
-export interface WorkflowGateTerminalEvent {
-    gateId: string;
-    kind: "accepted" | "cancelled";
-    origin?: "rpc" | "bridge" | "other" | "telegram_notification";
-    reason?: string;
-}
-export interface NotificationGateResolutionOptions {
-    interactionActionId: string;
-    replyReceiptId: string;
-    answerJson: string;
-    idempotencyKey?: string;
-    requestSelectedAck(input: {
-        replyReceiptId: string;
-        actionId: string;
-        commitKey: string;
-        daemonDeadlineAt: number;
-        hostTimeoutMs: number;
-    }): Promise<AskSelectedAckOutcome>;
-    resolveClaim(): void;
-    closeClaimInvalid(reason: string): void;
-}
-export interface AskSelectedAckRecoveryParticipant {
-    requestRecoveredAskSelectedAck(input: {
-        sessionId: string;
-        actionId: string;
-        commitKey: string;
-        deadlineAt: number;
-        hostTimeoutMs: number;
-    }): Promise<AskSelectedAckOutcome>;
-}
-/**
- * Derive an explicit `providerSupportsTokenCostMetrics` capability from the
- * active model so unattended negotiation fails closed when token/cost usage
- * cannot be accounted for (#606). Callers that omit a model — or whose model is
- * configured to suppress streaming usage (`compat.supportsUsageInStreaming:
- * false`) — get `false`, which the controller refuses with
- * `unsupported_budget_metric`.
- */
-export declare function modelSupportsTokenCostMetrics(model: Model | undefined): boolean;
-/** Minimal surface a skill runtime / ask tool uses to emit a gate and await its answer. */
-export interface WorkflowGateEmitter {
-    /** True only when unattended mode has been negotiated. */
-    isUnattended(): boolean;
-    /** Open + emit a gate; resolves with the agent's answer (from workflow_gate_response). */
-    emitGate(input: OpenGateInput): Promise<unknown>;
-    /**
-     * Optional bridge surface (present on {@link UnattendedSessionControlPlane}) that
-     * lets an in-process extension observe emitted gates and answer them — used by
-     * the notifications SDK to resolve a real ask gate from a remote reply.
-     */
-    onGateEmitted?(listener: (gate: RpcWorkflowGate) => void): () => void;
-    resolveGate?(response: RpcWorkflowGateResponse): Promise<RpcWorkflowGateResolution>;
-    resolveGateFromNotification?(response: RpcWorkflowGateResponse, options: NotificationGateResolutionOptions): Promise<RpcWorkflowGateResolution>;
-    registerGateTerminalController?(controller: WorkflowGateTerminalController): () => void;
-    listPendingGates?(): RpcWorkflowGate[];
-    setAckRecoveryParticipant?(participant: AskSelectedAckRecoveryParticipant | null): void;
-}
-export interface UnattendedSessionOptions {
-    runId: string;
-    sessionId?: string;
-    /** Emit a workflow_gate frame to the transport so the agent receives it. */
-    emitFrame: (gate: RpcWorkflowGate) => void;
-    /** Durable gate store; defaults to in-memory. */
-    store?: GateStore;
-    /** Audit sink for controller + gate events. */
-    audit?: (event: UnattendedAuditEvent | {
-        event: string;
-        [k: string]: unknown;
-    }) => void;
-    abortHooks?: UnattendedAbortHooks;
-    /** Whether the active provider reports token/cost usage (fail-closed when false/omitted). */
-    providerSupportsTokenCostMetrics?: boolean;
-    /** Snapshot live cumulative usage after a dispatch or turn, for budget reconciliation. */
-    getUsageSnapshot?: () => {
-        tokens?: number;
-        costUsd?: number;
-    };
-}
-export declare class UnattendedSessionControlPlane implements RpcUnattendedControlPlane, WorkflowGateEmitter {
-    #private;
-    private readonly opts;
-    constructor(opts: UnattendedSessionOptions);
-    isUnattended(): boolean;
-    /** Observe every emitted gate (e.g. so an extension can map an ask to its gate_id). */
-    onGateEmitted(listener: (gate: RpcWorkflowGate) => void): () => void;
-    get controller(): UnattendedRunController | undefined;
-    registerGateTerminalController(controller: WorkflowGateTerminalController): () => void;
-    setAckRecoveryParticipant(participant: AskSelectedAckRecoveryParticipant | null): void;
-    negotiate(declaration: RpcUnattendedDeclaration): RpcUnattendedAccepted;
-    preflightCommand(command: RpcCommand): void;
-    reconcileUsage(phase?: string): void;
-    resolveGate(response: RpcWorkflowGateResponse): Promise<RpcWorkflowGateResolution>;
-    resolveGateFromNotification(response: RpcWorkflowGateResponse, options: NotificationGateResolutionOptions): Promise<RpcWorkflowGateResolution>;
-    startRecoveryOnce(options?: {
-        participantGraceMs?: number;
-    }): Promise<void>;
-    dispose(reason?: string): void;
-    listPendingGates(): import("../../rpc/rpc-types").RpcWorkflowGate[];
-    emitGate(input: OpenGateInput): Promise<unknown>;
-    recover(): Promise<void>;
-}

package/dist/types/notifications/config.d.ts

@@ -1,132 +0,0 @@
-import type { Settings } from "../config/settings";
-/**
- * Env marker set by GJC's own programmatic separate-process child spawn sites
- * (team workers, harness RPC owners) and carrying the spawning session id.
- *
- * Presence — not the value — marks a session as GJC-spawned. It is consumed
- * (read once, then deleted from the child's own env) at startup so it is
- * per-spawn rather than dynastic: a grandchild is marked only if its own spawn
- * site marks it, never by inheriting a marked ancestor's environment.
- */
-export declare const SPAWN_PROVENANCE_ENV = "GJC_SPAWNED_BY_SESSION";
-export interface NotificationConfig {
-    enabled: boolean;
-    botToken?: string;
-    chatId?: string;
-    discord: {
-        botToken?: string;
-        channelId?: string;
-    };
-    slack: {
-        botToken?: string;
-        channelId?: string;
-    };
-    redact: boolean;
-    verbosity: "lean" | "verbose";
-    /**
-     * Which sessions may register a notification endpoint. `all` (default)
-     * preserves historical behavior; `primary` suppresses GJC-spawned children
-     * (those carrying {@link SPAWN_PROVENANCE_ENV}) unless they explicitly opt in.
-     */
-    sessionScope: "all" | "primary";
-    idleTimeoutMs: number;
-    rich: {
-        enabled: boolean;
-    };
-    richDraft: {
-        enabled: boolean;
-    };
-    topics: {
-        /**
-         * Optional Telegram forum-topic name template with `{repo}`, `{branch}`,
-         * and `{title}` placeholders. Unset preserves the built-in
-         * `{repo}/{branch} - {title}` composition (with its title/repo/branch
-         * fallbacks).
-         */
-        nameTemplate?: string;
-    };
-}
-/** Read typed config from Settings. */
-export declare function getNotificationConfig(settings: Settings): NotificationConfig;
-export declare function hasNonBlankValue(value: string | undefined): boolean;
-/** Is Telegram configured with usable non-blank boundary credentials? */
-export declare function isTelegramConfigured(cfg: NotificationConfig): cfg is NotificationConfig & {
-    botToken: string;
-    chatId: string;
-};
-/** Is global config sufficient for auto-on (enabled + at least one configured adapter)? */
-export declare function isGloballyConfigured(cfg: NotificationConfig): boolean;
-/**
- * Per-run opt-out for completion notifications, honored before settings lookups.
- *
- * `GJC_NOTIFY=off` (also `0` / `false`, case-insensitive) suppresses the
- * completion notification surface for this process only. `config.yml` is
- * untouched and child processes inherit the env var, which lets non-interactive
- * fleet runs (`gjc -p --no-session`) stay silent even when a user-level/global
- * completion notification configuration is enabled.
- */
-export declare function completionNotifyDisabledByEnv(env: NodeJS.ProcessEnv): boolean;
-/** Resolve whether the notifications extension should be registered at SDK startup. */
-export declare function shouldRegisterNotificationsExtension(input: {
-    env: NodeJS.ProcessEnv;
-    cfg?: NotificationConfig;
-    /** Task recursion depth; helper/subagent sessions must not spawn remote surfaces. */
-    taskDepth?: number;
-    /** Parent subagent id/prefix; present for helper/subagent sessions even when depth is omitted. */
-    parentTaskPrefix?: string;
-    /** Role-agent type/name; present for task sessions even if depth metadata is lost. */
-    currentAgentType?: string;
-    /**
-     * True when this session was launched by one of GJC's own programmatic
-     * separate-process child spawn sites (marked via {@link SPAWN_PROVENANCE_ENV}).
-     * Under `notifications.sessionScope = "primary"` such children are suppressed
-     * unless they explicitly opt in, so an interactive parent that fans out work
-     * does not flood the paired chat with topics for children the user never
-     * asked for. User-opened sessions (CLI/tmux/headless) never carry the marker.
-     */
-    spawnedByGjc?: boolean;
-}): boolean;
-/**
- * Resolve whether THIS session should run notifications.
- * Precedence (highest first):
- *  1) env.GJC_NOTIFICATIONS === "0"  -> false (hard opt-out)
- *  2) sessionDisabled === true       -> false (local /notify off)
- *  3) env.GJC_NOTIFICATIONS === "1" || env.GJC_NOTIFICATIONS_TOKEN present -> true (legacy explicit)
- *  4) isGloballyConfigured(cfg)      -> true (global auto-on)
- *  5) otherwise false
- */
-export declare function isSessionNotificationsEnabled(input: {
-    cfg: NotificationConfig;
-    env: NodeJS.ProcessEnv;
-    sessionDisabled: boolean;
-}): boolean;
-/** Mask a bot token for display: first 4 chars + "…" + "(len N)"; "(unset)" when undefined/empty. Never reveal full token. */
-export declare function maskToken(token: string | undefined): string;
-/** Stable non-reversible fingerprint of a token: sha256 hex, first 12 chars. */
-export declare function tokenFingerprint(token: string): string;
-/** Short session tag for display, e.g. last 6 chars of sessionId. */
-export declare function sessionTag(sessionId: string): string;
-export interface RedactableAction {
-    id: string;
-    kind: string;
-    sessionId: string;
-    question?: string;
-    options?: string[];
-    summary?: string;
-}
-/**
- * When redact is true, strip sensitive content for remote delivery:
- *  - ask: NOT redacted. An ask is an interactive prompt the human must read and
- *    answer on the remote surface; redacting its question/options would make it
- *    unanswerable, defeating remote answering. Asks are returned unchanged.
- *  - idle: summary removed, (no question/options).
- * When redact is false, return the action unchanged.
- *
- * Redaction still applies to streamed content frames (turn_stream, context_update,
- * image_attachment) which are suppressed at their emit sites, not here. Explicit
- * `telegram_send` file attachments are rejected before the file is read or forwarded.
- */
-export declare function buildRedactedAction(action: RedactableAction, opts: {
-    redact: boolean;
-    sessionTag: string;
-}): RedactableAction;

package/src/harness-control-plane/rpc-adapter.ts

@@ -1,290 +0,0 @@
-/**
- * gajae-code RPC adapter + single-flight acceptance.
- *
- * The gajae-code harness is driven via `gjc --mode rpc` (see docs/rpc.md). Acceptance
- * is a PROTOCOL FACT, not an echo: a prompt is `accepted` only when the RPC command is
- * acked AND the next `agent_start` event arrives after the pre-submit cursor within the
- * timeout, with an idle + empty-queue pre-state. Ack alone never means accepted.
- *
- * The acceptance logic ({@link singleFlightAccept}) is decoupled from the transport via
- * the {@link HarnessRpc} interface so it is unit-testable with a fake, while
- * {@link GajaeCodeRpc} provides the real `gjc --mode rpc` subprocess implementation
- * (exercised by the M10 e2e suite).
- */
-import { type ChildProcessWithoutNullStreams, spawn } from "node:child_process";
-import { randomUUID } from "node:crypto";
-
-export interface RpcStateSnapshot {
-	isStreaming: boolean;
-	steeringQueueDepth: number;
-	followupQueueDepth: number;
-}
-
-/** Abstract handle to a live gajae-code RPC session. */
-export interface HarnessRpc {
-	getState(): Promise<RpcStateSnapshot>;
-	/** Send a prompt; resolves with the RPC command id and whether it was acked. Does NOT await agent_start. */
-	sendPrompt(prompt: string): Promise<{ commandId: string; ack: boolean }>;
-	/** Monotonic count of events observed so far (the acceptance cursor). */
-	eventCursor(): number;
-	/** Resolve when an `agent_start` event arrives strictly after `afterCursor`, else null on timeout. */
-	waitForAgentStart(afterCursor: number, timeoutMs: number): Promise<{ cursor: number } | null>;
-	close(): Promise<void>;
-	/** Subscribe to parsed event frames (non-ready, non-response), fired AFTER the cursor advances. Returns unsubscribe. */
-	onEventFrame?(listener: (frame: Record<string, unknown>) => void): () => void;
-	/** Whether the underlying RPC subprocess is still alive. */
-	isLive?(): boolean;
-	/** ISO timestamp of the last observed event frame, or null. */
-	lastFrameAt?(): string | null;
-	/** Final assistant text from the live session (for review-verdict extraction); null when unavailable. */
-	getLastAssistantText?(): Promise<string | null>;
-}
-
-export interface AcceptanceResult {
-	accepted: boolean;
-	reason: string;
-	commandId: string | null;
-	preSubmitCursor: number;
-	agentStartCursor: number | null;
-	preSubmitState: RpcStateSnapshot;
-}
-
-/**
- * Single-flight acceptance: idle + empty-queue pre-state, ack, then the NEXT
- * `agent_start` after the pre-submit cursor within `timeoutMs`.
- */
-export async function singleFlightAccept(
-	rpc: HarnessRpc,
-	prompt: string,
-	timeoutMs: number,
-): Promise<AcceptanceResult> {
-	const pre = await rpc.getState();
-	const preSubmitCursor = rpc.eventCursor();
-	if (pre.isStreaming || pre.steeringQueueDepth > 0 || pre.followupQueueDepth > 0) {
-		return {
-			accepted: false,
-			reason: "pre-state-not-idle",
-			commandId: null,
-			preSubmitCursor,
-			agentStartCursor: null,
-			preSubmitState: pre,
-		};
-	}
-	const { commandId, ack } = await rpc.sendPrompt(prompt);
-	if (!ack) {
-		return {
-			accepted: false,
-			reason: "no-ack",
-			commandId,
-			preSubmitCursor,
-			agentStartCursor: null,
-			preSubmitState: pre,
-		};
-	}
-	const started = await rpc.waitForAgentStart(preSubmitCursor, timeoutMs);
-	if (!started) {
-		return {
-			accepted: false,
-			reason: "no-agent-start-within-timeout",
-			commandId,
-			preSubmitCursor,
-			agentStartCursor: null,
-			preSubmitState: pre,
-		};
-	}
-	return {
-		accepted: true,
-		reason: "protocol-ack-single-flight",
-		commandId,
-		preSubmitCursor,
-		agentStartCursor: started.cursor,
-		preSubmitState: pre,
-	};
-}
-
-interface PendingResponse {
-	resolve: (value: Record<string, unknown>) => void;
-	reject: (error: Error) => void;
-}
-
-/**
- * Real adapter: spawns `gjc --mode rpc --session-dir <dir>` and speaks the JSONL
- * protocol from docs/rpc.md. Verified end-to-end in the M10 suite.
- */
-export class GajaeCodeRpc implements HarnessRpc {
-	#proc: ChildProcessWithoutNullStreams;
-	#buffer = "";
-	#cursor = 0;
-	#pending = new Map<string, PendingResponse>();
-	#agentStartCursors: number[] = [];
-	#waiters: {
-		afterCursor: number;
-		resolve: (v: { cursor: number } | null) => void;
-		timer: NodeJS.Timeout;
-	}[] = [];
-	#frameListeners: ((frame: Record<string, unknown>) => void)[] = [];
-	#lastFrameAt: string | null = null;
-	#alive = true;
-
-	constructor(opts: { sessionDir: string; command?: string[]; cwd?: string; env?: NodeJS.ProcessEnv }) {
-		const base = opts.command ?? ["gjc", "--mode", "rpc"];
-		const args = [...base.slice(1), "--session-dir", opts.sessionDir];
-		this.#proc = spawn(base[0], args, {
-			cwd: opts.cwd,
-			env: opts.env ?? process.env,
-			stdio: ["pipe", "pipe", "pipe"],
-		}) as ChildProcessWithoutNullStreams;
-		this.#proc.stdout.setEncoding("utf8");
-		this.#proc.stdout.on("data", chunk => this.#onData(chunk as string));
-		this.#proc.on("exit", () => {
-			this.#alive = false;
-		});
-		this.#proc.on("error", () => {
-			this.#alive = false;
-		});
-	}
-
-	#onData(chunk: string): void {
-		this.#buffer += chunk;
-		let idx = this.#buffer.indexOf("\n");
-		while (idx >= 0) {
-			const line = this.#buffer.slice(0, idx).trim();
-			this.#buffer = this.#buffer.slice(idx + 1);
-			if (line) this.#onFrame(line);
-			idx = this.#buffer.indexOf("\n");
-		}
-	}
-
-	#onFrame(line: string): void {
-		let frame: Record<string, unknown>;
-		try {
-			frame = JSON.parse(line) as Record<string, unknown>;
-		} catch {
-			return;
-		}
-		const type = frame.type;
-		if (type === "response") {
-			const id = typeof frame.id === "string" ? frame.id : undefined;
-			if (id && this.#pending.has(id)) {
-				const pending = this.#pending.get(id);
-				this.#pending.delete(id);
-				pending?.resolve(frame);
-			}
-			return;
-		}
-		if (type === "ready") return;
-		// Any other frame is a session/agent event: advance the cursor.
-		this.#cursor += 1;
-		this.#lastFrameAt = new Date().toISOString();
-		// Session events arrive as canonical `event` frames: the agent event type
-		// lives in `payload.event_type`. Non-event frames keep their flat `type`.
-		const effectiveType =
-			type === "event" && frame.payload && typeof frame.payload === "object"
-				? (frame.payload as { event_type?: unknown }).event_type
-				: type;
-		if (effectiveType === "agent_start") {
-			const cursor = this.#cursor;
-			this.#agentStartCursors.push(cursor);
-			this.#waiters = this.#waiters.filter(w => {
-				if (cursor > w.afterCursor) {
-					clearTimeout(w.timer);
-					w.resolve({ cursor });
-					return false;
-				}
-				return true;
-			});
-		}
-		// Fire-and-forget frame listeners (owner maps + emits). Never await; never let a listener kill the reader.
-		for (const listener of this.#frameListeners) {
-			try {
-				listener(frame);
-			} catch {
-				// swallow listener errors
-			}
-		}
-	}
-
-	#send(command: Record<string, unknown>): Promise<Record<string, unknown>> {
-		const id = randomUUID();
-		return new Promise((resolve, reject) => {
-			this.#pending.set(id, { resolve, reject });
-			this.#proc.stdin.write(`${JSON.stringify({ id, ...command })}\n`, err => {
-				if (err) {
-					this.#pending.delete(id);
-					reject(err);
-				}
-			});
-		});
-	}
-
-	onEventFrame(listener: (frame: Record<string, unknown>) => void): () => void {
-		this.#frameListeners.push(listener);
-		return () => {
-			this.#frameListeners = this.#frameListeners.filter(l => l !== listener);
-		};
-	}
-
-	isLive(): boolean {
-		return this.#alive;
-	}
-
-	lastFrameAt(): string | null {
-		return this.#lastFrameAt;
-	}
-
-	async getState(): Promise<RpcStateSnapshot> {
-		const res = await this.#send({ type: "get_state" });
-		const data = (res.data ?? {}) as Record<string, unknown>;
-		return {
-			isStreaming: Boolean(data.isStreaming),
-			steeringQueueDepth: typeof data.queuedMessageCount === "number" ? data.queuedMessageCount : 0,
-			followupQueueDepth: 0,
-		};
-	}
-
-	async getLastAssistantText(): Promise<string | null> {
-		const res = await this.#send({ type: "get_last_assistant_text" });
-		const data = (res.data ?? {}) as Record<string, unknown>;
-		return typeof data.text === "string" ? data.text : null;
-	}
-
-	async sendPrompt(prompt: string): Promise<{ commandId: string; ack: boolean }> {
-		const id = randomUUID();
-		const ackPromise = new Promise<Record<string, unknown>>((resolve, reject) => {
-			this.#pending.set(id, { resolve, reject });
-			this.#proc.stdin.write(`${JSON.stringify({ id, type: "prompt", message: prompt })}\n`, err => {
-				if (err) {
-					this.#pending.delete(id);
-					reject(err);
-				}
-			});
-		});
-		const res = await ackPromise;
-		return { commandId: id, ack: res.success === true };
-	}
-
-	eventCursor(): number {
-		return this.#cursor;
-	}
-
-	waitForAgentStart(afterCursor: number, timeoutMs: number): Promise<{ cursor: number } | null> {
-		const existing = this.#agentStartCursors.find(c => c > afterCursor);
-		if (existing !== undefined) return Promise.resolve({ cursor: existing });
-		return new Promise(resolve => {
-			const timer = setTimeout(() => {
-				this.#waiters = this.#waiters.filter(w => w.timer !== timer);
-				resolve(null);
-			}, timeoutMs);
-			this.#waiters.push({ afterCursor, resolve, timer });
-		});
-	}
-
-	async close(): Promise<void> {
-		try {
-			this.#proc.stdin.end();
-		} catch {
-			// ignore
-		}
-		this.#proc.kill();
-	}
-}

package/src/modes/bridge/auth.ts

@@ -1,41 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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,
-					},
-				),
-			);
-		},
-	};
-}