@agent-link/agent 0.1.202 → 0.1.206

package/dist/backends/types.d.ts

@@ -0,0 +1,379 @@
+/**
+ * Backend abstraction for AgentLink.
+ *
+ * Stage 1: defines the interface only. ClaudeBackend implementation lives in
+ * agent/src/claude.ts (refactor to backends/claude/* is a follow-up PR).
+ */
+export type BackendType = 'claude' | 'codex';
+export declare const KNOWN_BACKEND_TYPES: readonly BackendType[];
+/**
+ * Backend-neutral file attachment for `UserTurnInput.files`.
+ * Defined here (not in claude.ts) so the boundary stays clean.
+ * (PR3 will re-export this as `ChatFile` from claude.ts for back-compat;
+ * not yet wired in Stage 1.)
+ */
+export interface BackendFileAttachment {
+    name: string;
+    mimeType: string;
+    /** base64-encoded content */
+    data: string;
+}
+/**
+ * Backend-neutral history message — fully opaque from the backend interface's
+ * point of view. Concrete backends (Claude's `{ role, content, ... }`,
+ * Codex's event records) all flow through unchanged; the wire/UI layer
+ * narrows as needed. PR3 will define the normalized shape if/when needed.
+ */
+export type BackendHistoryMessage = Record<string, unknown>;
+/**
+ * Backend-neutral session listing entry. Carries identity required for
+ * cross-backend routing — `backendType` + `backendSessionId` together
+ * uniquely identify a session.
+ */
+export interface BackendSessionInfo {
+    /** Composite identity for routing / resume. */
+    session: BackendSessionRef;
+    /** Display title (custom title > derived). */
+    title: string;
+    /** Optional user-set custom title (separate from derived). */
+    customTitle?: string;
+    /** Short preview of last message (UI hint). */
+    preview?: string;
+    /** Epoch ms of last activity. */
+    lastModified: number;
+}
+/** Backend-neutral session identifier. Avoids leaking `claudeSessionId` into shared code. */
+export interface BackendSessionRef {
+    backendType: BackendType;
+    /** Stable id used for routing, listing, resume. For Claude: claudeSessionId. For Codex: Thread.id. */
+    backendSessionId: string;
+    /** `backendThreadId === backendSessionId` for Claude (single-thread sessions). Codex sets it to `Thread.id`, distinct from session id. */
+    backendThreadId?: string | null;
+    /** Provider's raw id, kept for debugging / cross-backend migration. */
+    providerSessionId?: string | null;
+}
+/** Backend-neutral sandbox / permission mode. Each backend maps internally. */
+export type SandboxMode = 'safe' | 'workspace' | 'unrestricted';
+/**
+ * Named union for per-conversation permission modes (PR4-C, Codex finding C).
+ * Mirrors claude.ts:806 — backends declare which values they support via
+ * `capabilities.controls.permissionMode`.
+ */
+export type PermissionMode = 'normal' | 'acceptEdits' | 'auto' | 'default' | 'plan';
+/**
+ * Result of a `restartSession` call (PR4-C). `wasTurnActive` drives
+ * `execution_cancelled` emission in connection.ts.
+ */
+export interface BackendRestartResult {
+    /** New backend session id after restart, or null if conv was empty. */
+    claudeSessionId: string | null;
+    /** Whether a turn was in flight when restart fired. */
+    wasTurnActive: boolean;
+    /** Backend-internal history snapshot (opaque). */
+    history?: unknown;
+}
+/** Options for `restartSession` / `createPlaceholderSession` (PR4-C). */
+export interface RestartOpts {
+    planMode?: boolean;
+    brainMode?: boolean;
+    permissionMode?: PermissionMode;
+}
+/** Capability descriptor with optional per-feature details. */
+export interface Capability<TDetails = unknown> {
+    supported: boolean;
+    details?: TDetails;
+}
+export interface BackendCapabilities {
+    lifecycle: {
+        persistentProcess: boolean;
+        resumableSessions: boolean;
+        concurrentTurns: boolean;
+        backgroundTurns: boolean;
+        fork: Capability;
+        compaction: Capability;
+    };
+    approvals: {
+        command: Capability;
+        fileChange: Capability;
+        permissions: Capability;
+        genericTool: Capability;
+        userInput: Capability;
+    };
+    streaming: {
+        text: boolean;
+        reasoning: Capability;
+        plan: Capability;
+        usage: Capability<{
+            incremental: boolean;
+        }>;
+        processOutput: Capability;
+        fsWatch: Capability;
+        remoteControl: Capability<{
+            statusEvents: boolean;
+        }>;
+    };
+    history: {
+        list: boolean;
+        read: boolean;
+        rename: boolean;
+        delete: boolean;
+        search: boolean;
+    };
+    models: {
+        list: Capability;
+        switchPerSession: boolean;
+        switchPerTurn: boolean;
+    };
+    tools: {
+        /** Item kinds this backend emits (e.g. 'Read','Write','Bash' for Claude; 'command_execution','file_change' for Codex). */
+        itemTypes: string[];
+        fallbackRenderer: boolean;
+        specializedRenderers: string[];
+    };
+    integrations: {
+        accountInfo: Capability;
+        codeReview: Capability;
+        mcpManagement: Capability;
+        hooks: Capability;
+        personalitySwitch: Capability;
+        skills: Capability;
+    };
+    sandboxModes: SandboxMode[];
+    /** PR4-C: per-conversation user-action controls. */
+    controls: {
+        setModel: Capability;
+        restartSession: Capability;
+        brainMode: Capability;
+        planMode: Capability;
+        permissionMode: Capability<{
+            modes: PermissionMode[];
+        }>;
+        isCompacting: Capability;
+    };
+}
+/** Approval / confirmation requests from the backend to the user. */
+export type ApprovalRequest = {
+    kind: 'command';
+    command: string;
+    cwd?: string;
+    reason?: string;
+} | {
+    kind: 'file_change';
+    summary: string;
+    changes?: unknown;
+} | {
+    kind: 'permissions';
+    permissions: unknown;
+    reason?: string;
+} | {
+    kind: 'tool';
+    toolName: string;
+    input: unknown;
+    reason?: string;
+};
+export type UserInputSource = 'ask_user_question' | 'mcp_elicitation' | 'tool_request_user_input';
+export interface UserInputQuestion {
+    question: string;
+    header?: string;
+    options: Array<{
+        label: string;
+        description?: string;
+    }>;
+    multiSelect?: boolean;
+}
+export interface UserInputRequest {
+    questions: UserInputQuestion[];
+    source: UserInputSource;
+}
+export interface UsageInfo {
+    inputTokens?: number;
+    outputTokens?: number;
+    cacheReadInputTokens?: number;
+    cacheCreationInputTokens?: number;
+    totalCostUsd?: number;
+}
+/** Normalized tool event (start / update / result). */
+export interface NormalizedToolEvent {
+    id: string;
+    name: string;
+    /** Backend item kind (e.g. 'Read','Bash','command_execution','file_change'). */
+    itemKind?: string;
+    input?: unknown;
+    output?: unknown;
+    isError?: boolean;
+    status?: 'in_progress' | 'completed' | 'error';
+}
+export type NormalizedEvent = {
+    type: 'session_started';
+    session: BackendSessionRef;
+} | {
+    type: 'turn_started';
+    session: BackendSessionRef;
+    turnId?: string;
+} | {
+    type: 'text_delta';
+    session: BackendSessionRef;
+    text: string;
+} | {
+    type: 'tool_started';
+    session: BackendSessionRef;
+    tool: NormalizedToolEvent;
+} | {
+    type: 'tool_updated';
+    session: BackendSessionRef;
+    tool: NormalizedToolEvent;
+} | {
+    type: 'tool_completed';
+    session: BackendSessionRef;
+    tool: NormalizedToolEvent;
+} | {
+    type: 'plan_delta';
+    session: BackendSessionRef;
+    plan: unknown;
+} | {
+    type: 'reasoning_delta';
+    session: BackendSessionRef;
+    text: string;
+} | {
+    type: 'compact_started';
+    session: BackendSessionRef;
+} | {
+    type: 'compact_completed';
+    session: BackendSessionRef;
+} | {
+    type: 'usage_update';
+    session: BackendSessionRef;
+    usage: UsageInfo;
+} | {
+    type: 'fs_changed';
+    session: BackendSessionRef;
+    paths: string[];
+} | {
+    type: 'process_output';
+    session: BackendSessionRef;
+    processId: string;
+    chunk: string;
+} | {
+    type: 'process_exited';
+    session: BackendSessionRef;
+    processId: string;
+    exitCode: number;
+} | {
+    type: 'approval_requested';
+    session: BackendSessionRef;
+    requestId: string;
+    request: ApprovalRequest;
+} | {
+    type: 'user_input_requested';
+    session: BackendSessionRef;
+    requestId: string;
+    request: UserInputRequest;
+} | {
+    type: 'turn_completed';
+    session: BackendSessionRef;
+    usage?: UsageInfo;
+} | {
+    type: 'turn_cancelled';
+    session: BackendSessionRef;
+} | {
+    type: 'error';
+    session?: BackendSessionRef;
+    message: string;
+};
+export interface StartOpts {
+    workDir: string;
+    /** Backend-neutral permission mode; backend maps to its own sandbox/permission flags. */
+    permissions?: {
+        mode: SandboxMode;
+        additionalWritableDirs?: string[];
+    };
+}
+export interface EnsureSessionOpts {
+    conversationId: string;
+    workDir: string;
+    resumeSessionId?: string;
+    /** Optional metadata that backends with rich session metadata (Claude's `recapId`, `briefingDate` etc.) can store. */
+    metadata?: Record<string, unknown>;
+}
+export interface UserTurnInput {
+    text: string;
+    files?: BackendFileAttachment[];
+    /**
+     * Backend-specific per-turn metadata. ClaudeBackend forwards these as
+     * `HandleChatOptions` (brainMode, recapId, briefingDate, devops*, projectName,
+     * icmId, etc.). Codex/other backends may ignore unknown keys. The runtime
+     * passes this through opaquely; only the backend interprets it.
+     */
+    metadata?: Record<string, unknown>;
+}
+export interface ApprovalAnswer {
+    requestId: string;
+    decision: 'allow' | 'deny';
+    reason?: string;
+}
+export interface UserInputAnswer {
+    requestId: string;
+    /** questionText -> selected option label */
+    answers: Record<string, string>;
+}
+export type EventListener = (event: NormalizedEvent) => void;
+/**
+ * Backend interface. Methods marked optional are capability-gated: callers must
+ * check `capabilities` before invoking. Required methods all backends must
+ * implement (even if as no-ops or throws).
+ */
+export interface AgentBackend {
+    readonly type: BackendType;
+    readonly capabilities: BackendCapabilities;
+    start(opts: StartOpts): Promise<void>;
+    shutdown(): Promise<void>;
+    ensureSession(opts: EnsureSessionOpts): Promise<BackendSessionRef>;
+    startTurn(session: BackendSessionRef, input: UserTurnInput): Promise<void>;
+    interruptTurn(session: BackendSessionRef): Promise<void>;
+    shutdownSession?(session: BackendSessionRef): Promise<void>;
+    answerUserInput(answer: UserInputAnswer): void;
+    answerApproval(answer: ApprovalAnswer): void;
+    listSessions(workDir: string): Promise<BackendSessionInfo[]>;
+    readSession(workDir: string, session: BackendSessionRef): Promise<BackendHistoryMessage[]>;
+    renameSession?(workDir: string, session: BackendSessionRef, title: string): Promise<boolean>;
+    deleteSession?(workDir: string, session: BackendSessionRef): Promise<boolean>;
+    compact?(session: BackendSessionRef): Promise<void>;
+    fork?(session: BackendSessionRef, fromMessageId?: string): Promise<BackendSessionRef>;
+    getAccountInfo?(): Promise<{
+        usage?: UsageInfo;
+        limits?: unknown;
+    }>;
+    listModels?(): Promise<Array<{
+        id: string;
+        label?: string;
+    }>>;
+    /**
+     * PR4-C (Codex finding B): keyed by conversationId, NOT BackendSessionRef.
+     * Passing null targets the global default model. claude.ts uses
+     * `pendingModels.set(convId, model)` for not-yet-started conversations
+     * — the convId must be passed straight through.
+     */
+    setModel?(conversationId: string | null, model: string | null): void;
+    getEffectiveModel?(conversationId?: string): string | null;
+    isCompacting?(conversationId?: string): boolean;
+    /** Returns null if no conversation exists for convId (caller should fall
+     *  back to createPlaceholderSession). */
+    restartSession?(conversationId: string, opts?: RestartOpts): BackendRestartResult | null;
+    /** Create a placeholder + workDir entry so the next ensureSession picks
+     *  up sticky preferences. Used when no live conversation exists. */
+    createPlaceholderSession?(conversationId: string, workDir: string, opts?: RestartOpts): void;
+    /** True if the backend currently has a live conversation for convId. */
+    hasConversation?(conversationId: string): boolean;
+    on(listener: EventListener): () => void;
+}
+/** Helper: minimal capabilities object for a stub/unknown backend. */
+export declare function emptyCapabilities(): BackendCapabilities;
+/**
+ * Capabilities declared by the ClaudeBackend adapter (current implementation
+ * as of 2026-05-09). These reflect what the adapter exposes through the
+ * AgentBackend interface — not the full surface of the underlying claude CLI.
+ * For example, claude.ts has restartConversation and an interactive /compact
+ * flow, but neither is wired through AgentBackend.fork / AgentBackend.compact
+ * yet, so both are reported as unsupported.
+ */
+export declare function claudeCapabilities(): BackendCapabilities;

package/dist/backends/types.js

@@ -0,0 +1,120 @@
+/**
+ * Backend abstraction for AgentLink.
+ *
+ * Stage 1: defines the interface only. ClaudeBackend implementation lives in
+ * agent/src/claude.ts (refactor to backends/claude/* is a follow-up PR).
+ */
+export const KNOWN_BACKEND_TYPES = ['claude', 'codex'];
+/** Helper: minimal capabilities object for a stub/unknown backend. */
+export function emptyCapabilities() {
+    const cap = () => ({ supported: false });
+    return {
+        lifecycle: {
+            persistentProcess: false,
+            resumableSessions: false,
+            concurrentTurns: false,
+            backgroundTurns: false,
+            fork: cap(),
+            compaction: cap(),
+        },
+        approvals: {
+            command: cap(),
+            fileChange: cap(),
+            permissions: cap(),
+            genericTool: cap(),
+            userInput: cap(),
+        },
+        streaming: {
+            text: false,
+            reasoning: cap(),
+            plan: cap(),
+            usage: { supported: false },
+            processOutput: cap(),
+            fsWatch: cap(),
+            remoteControl: { supported: false },
+        },
+        history: { list: false, read: false, rename: false, delete: false, search: false },
+        models: { list: cap(), switchPerSession: false, switchPerTurn: false },
+        tools: { itemTypes: [], fallbackRenderer: false, specializedRenderers: [] },
+        integrations: {
+            accountInfo: cap(),
+            codeReview: cap(),
+            mcpManagement: cap(),
+            hooks: cap(),
+            personalitySwitch: cap(),
+            skills: cap(),
+        },
+        sandboxModes: [],
+        controls: {
+            setModel: cap(),
+            restartSession: cap(),
+            brainMode: cap(),
+            planMode: cap(),
+            permissionMode: { supported: false },
+            isCompacting: cap(),
+        },
+    };
+}
+/**
+ * Capabilities declared by the ClaudeBackend adapter (current implementation
+ * as of 2026-05-09). These reflect what the adapter exposes through the
+ * AgentBackend interface — not the full surface of the underlying claude CLI.
+ * For example, claude.ts has restartConversation and an interactive /compact
+ * flow, but neither is wired through AgentBackend.fork / AgentBackend.compact
+ * yet, so both are reported as unsupported.
+ */
+export function claudeCapabilities() {
+    const yes = (details) => ({ supported: true, details });
+    const no = () => ({ supported: false });
+    return {
+        lifecycle: {
+            persistentProcess: true,
+            resumableSessions: true,
+            concurrentTurns: true, // multiple conversations = multiple processes
+            backgroundTurns: false,
+            fork: no(), // restartConversation exists but its signature doesn't match AgentBackend.fork
+            compaction: no(), // claude.ts has no programmatic compact API
+        },
+        approvals: {
+            command: no(), // Claude uses bypassPermissions; no per-command approval
+            fileChange: no(),
+            permissions: no(),
+            genericTool: yes(), // tool permission via permission-prompt-tool stdio
+            userInput: yes(), // AskUserQuestion via control_request
+        },
+        streaming: {
+            text: true,
+            reasoning: yes(), // thinking blocks
+            plan: yes(), // EnterPlanMode tool
+            usage: { supported: true, details: { incremental: false } },
+            processOutput: no(), // Bash background mode is approximated, not first-class
+            fsWatch: no(),
+            remoteControl: { supported: false },
+        },
+        history: { list: true, read: true, rename: true, delete: true, search: true },
+        models: { list: no(), switchPerSession: true, switchPerTurn: false },
+        tools: {
+            itemTypes: ['Read', 'Write', 'Edit', 'Bash', 'Glob', 'Grep', 'Task', 'Agent', 'WebFetch', 'WebSearch', 'TodoWrite'],
+            fallbackRenderer: true,
+            specializedRenderers: ['Edit', 'EnterPlanMode'],
+        },
+        integrations: {
+            accountInfo: no(),
+            codeReview: no(),
+            mcpManagement: no(),
+            hooks: no(),
+            personalitySwitch: no(),
+            skills: no(),
+        },
+        sandboxModes: ['unrestricted'], // Claude runs with bypassPermissions
+        controls: {
+            setModel: yes(),
+            restartSession: yes(),
+            brainMode: yes(),
+            planMode: yes(),
+            permissionMode: { supported: true, details: { modes: ['normal', 'acceptEdits', 'auto', 'default', 'plan'] } },
+            isCompacting: yes(),
+        },
+    };
+}
+//# sourceMappingURL=types.js.map

package/dist/backends/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/backends/types.ts"],"names":[],"mappings":"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"}

package/dist/claude.d.ts

@@ -74,9 +74,29 @@ export declare function removeCloseObserver(fn: CloseObserverFn): void;
 export declare function setCloseObserver(fn: CloseObserverFn): void;
 /** @deprecated Use removeCloseObserver() instead. Clears ALL close observers. */
 export declare function clearCloseObserver(): void;
-export declare function setSendFn(fn: SendFn): void;
+/**
+ * Subscribe a SendFn additively. Returns an unsubscribe function. Use this
+ * when multiple subscribers should each receive every outbound frame (e.g.
+ * the legacy connection.ts path and the ClaudeBackend adapter coexisting).
+ */
+export declare function addSendFn(fn: SendFn): () => void;
+/**
+ * Legacy replace-one semantics: clear all existing subscribers then install
+ * just this one. Returns an unsubscribe function. Existing call sites should
+ * migrate to {@link addSendFn} when they need additive behavior.
+ */
+export declare function setSendFn(fn: SendFn): () => void;
 type SessionStartedFn = (conversationId: string, claudeSessionId: string) => void;
-export declare function setOnSessionStarted(fn: SessionStartedFn): void;
+/**
+ * Subscribe a callback for every Claude session-started event additively.
+ * Returns an unsubscribe function.
+ */
+export declare function addOnSessionStarted(fn: SessionStartedFn): () => void;
+/**
+ * Legacy replace-one semantics for session-started subscriber. Existing call
+ * sites should migrate to {@link addOnSessionStarted}.
+ */
+export declare function setOnSessionStarted(fn: SessionStartedFn): () => void;
 /**
  * Set the model override for a conversation.
  * If the conversation has a claudeSessionId, persists to disk.

package/dist/claude.js

@@ -53,7 +53,21 @@ const conversations = new Map();
 const lastSessionIdsByConv = new Map();
 /** Pending model override per conversation (set before first message, before sessionId is known). */
 const pendingModels = new Map();
-let sendFn = () => { };
+// Multi-subscriber send fanout. Historically a single closure; switched to a
+// Set so multiple callers (e.g. ClaudeBackend adapter + connection.ts) can
+// each subscribe and receive every outbound frame. Each subscriber is invoked
+// in a try/catch so one throwing handler doesn't block the others.
+const sendFns = new Set();
+const sendFn = (msg) => {
+    for (const fn of sendFns) {
+        try {
+            fn(msg);
+        }
+        catch (e) {
+            console.error('[claude] sendFn subscriber threw', e);
+        }
+    }
+};
 const pendingControlRequests = new Map();
 const outputObservers = [];
 export function addOutputObserver(fn) {
@@ -89,12 +103,40 @@ export function setCloseObserver(fn) {
 export function clearCloseObserver() {
     closeObservers.length = 0;
 }
+/**
+ * Subscribe a SendFn additively. Returns an unsubscribe function. Use this
+ * when multiple subscribers should each receive every outbound frame (e.g.
+ * the legacy connection.ts path and the ClaudeBackend adapter coexisting).
+ */
+export function addSendFn(fn) {
+    sendFns.add(fn);
+    return () => { sendFns.delete(fn); };
+}
+/**
+ * Legacy replace-one semantics: clear all existing subscribers then install
+ * just this one. Returns an unsubscribe function. Existing call sites should
+ * migrate to {@link addSendFn} when they need additive behavior.
+ */
 export function setSendFn(fn) {
-    sendFn = fn;
+    sendFns.clear();
+    return addSendFn(fn);
 }
-let onSessionStarted = null;
+const sessionStartedFns = new Set();
+/**
+ * Subscribe a callback for every Claude session-started event additively.
+ * Returns an unsubscribe function.
+ */
+export function addOnSessionStarted(fn) {
+    sessionStartedFns.add(fn);
+    return () => { sessionStartedFns.delete(fn); };
+}
+/**
+ * Legacy replace-one semantics for session-started subscriber. Existing call
+ * sites should migrate to {@link addOnSessionStarted}.
+ */
 export function setOnSessionStarted(fn) {
-    onSessionStarted = fn;
+    sessionStartedFns.clear();
+    return addOnSessionStarted(fn);
 }
 /**
  * Set the model override for a conversation.
@@ -897,8 +939,14 @@ async function processOutput(child, state, stderr) {
                         // Notify web client so sidebar can refresh session list
                         sendWithConvId({ type: 'session_started', claudeSessionId: state.claudeSessionId });
                         // Check if this chat is linked to an action item → call CLI start
-                        if (onSessionStarted)
-                            onSessionStarted(state.conversationId, state.claudeSessionId);
+                        for (const fn of sessionStartedFns) {
+                            try {
+                                fn(state.conversationId, state.claudeSessionId);
+                            }
+                            catch (e) {
+                                console.error('[claude] onSessionStarted subscriber threw', e);
+                            }
+                        }
                         // Persist pending model to conversation-models.json now that we have a sessionId
                         const pendingModel = pendingModels.get(state.conversationId);
                         if (pendingModel) {