@bbigbang/runtime-acp 0.1.0

package/dist/db/uiPrefStore.d.ts

@@ -0,0 +1,4 @@
+import type { Db } from './db.js';
+import type { UiMode } from '../gateway/types.js';
+export declare function getUiMode(db: Db, bindingKey: string): UiMode | null;
+export declare function setUiMode(db: Db, bindingKey: string, mode: UiMode): void;

package/dist/db/uiPrefStore.js

@@ -0,0 +1,18 @@
+export function getUiMode(db, bindingKey) {
+    const row = db
+        .prepare('SELECT mode FROM ui_prefs WHERE binding_key = ?')
+        .get(bindingKey);
+    if (!row)
+        return null;
+    return row.mode === 'summary' ? 'summary' : 'verbose';
+}
+export function setUiMode(db, bindingKey, mode) {
+    const now = Date.now();
+    db.prepare(`
+    INSERT INTO ui_prefs(binding_key, mode, created_at, updated_at)
+    VALUES(?, ?, ?, ?)
+    ON CONFLICT(binding_key) DO UPDATE SET
+      mode = excluded.mode,
+      updated_at = excluded.updated_at
+    `).run(bindingKey, mode, now, now);
+}

package/dist/gateway/bindingRuntime.d.ts

@@ -0,0 +1,113 @@
+import type { Db } from '../db/db.js';
+import type { OutboundSink, UiMode } from './types.js';
+export interface RuntimeConfig {
+    acpAgentCommand: string;
+    acpAgentArgs: string[];
+    acpPromptTimeoutMs: number;
+    uiJsonMaxChars: number;
+}
+import { type PermissionRequest } from '../acp/client.js';
+import type { InitializeResult, McpServerEntry } from '../acp/types.js';
+import { ToolAuth, type ToolKind } from './toolAuth.js';
+import type { WorkspaceLockManager } from '../runtime/workspaceLockManager.js';
+export declare class BindingRuntime {
+    private readonly db;
+    private readonly config;
+    private readonly toolAuth;
+    private readonly sessionKey;
+    private readonly bindingKey;
+    private readonly client;
+    private init;
+    private acpSessionId;
+    private sessionSystemPromptText;
+    private queue;
+    private activeSink;
+    private pendingPermission;
+    private pendingPermissionActorUserId;
+    private currentRunId;
+    private currentRunLastSeq;
+    private currentUiMode;
+    private currentActorUserId;
+    private sinkWriteQueue;
+    private toolCallTitles;
+    private toolCallTextBreaks;
+    private readonly workspaceRoot;
+    private readonly agentCommand;
+    private readonly agentArgs;
+    private readonly env?;
+    private activeDisabledToolKinds;
+    private readonly channelBridgeMcpEntry?;
+    constructor(params: {
+        db: Db;
+        config: RuntimeConfig;
+        toolAuth: ToolAuth;
+        sessionKey: string;
+        bindingKey: string;
+        workspaceRoot: string;
+        agentCommand?: string;
+        agentArgs?: string[];
+        env?: Record<string, string>;
+        disabledToolKinds?: ToolKind[];
+        acpRpc?: import('../acp/stdio.js').StdioProcess;
+        channelBridgeMcpEntry?: McpServerEntry;
+        workspaceLockManager?: WorkspaceLockManager;
+    });
+    close(): void;
+    private setActiveDisabledToolKinds;
+    private isToolKindDisabled;
+    private enqueueSinkWrite;
+    private flushSinkWriteQueue;
+    ensureInitialized(): Promise<InitializeResult>;
+    ensureSessionId(): Promise<string>;
+    ensureSessionIdWithPrompt(systemPromptText?: string): Promise<string>;
+    getLoadSupported(): boolean;
+    getPendingPermission(): PermissionRequest | null;
+    selectPermissionOption(idx: number, sink: OutboundSink, actorUserId?: string): Promise<void>;
+    hasSessionId(): boolean;
+    decidePermission(params: {
+        decision: 'allow' | 'deny';
+        requestId?: string;
+        actorUserId?: string;
+    }): Promise<{
+        ok: boolean;
+        message: string;
+    }>;
+    denyPermission(sink: OutboundSink, actorUserId?: string): Promise<void>;
+    respondToPermission(requestId: string, decision: 'allow' | 'deny', actorUserId?: string): Promise<boolean>;
+    hasPendingPermission(): boolean;
+    cancelCurrentRun(runId?: string): Promise<boolean>;
+    private resetAcpSession;
+    private promptOnce;
+    prompt(params: {
+        runId: string;
+        promptText: string;
+        promptResources?: Array<{
+            uri: string;
+            mimeType?: string;
+        }>;
+        sink: OutboundSink;
+        uiMode: UiMode;
+        disabledToolKinds?: ToolKind[];
+        systemPromptText?: string;
+        contextText?: string;
+        resumeContextText?: string;
+        recoveryContextText?: string;
+        actorUserId?: string;
+        onPrepared?: (prepared: {
+            sessionId: string;
+            isFreshSession: boolean;
+            effectiveSystemPromptText?: string;
+            effectiveContextText?: string;
+        }) => void | Promise<void>;
+    }): Promise<{
+        stopReason: string;
+        lastSeq: number;
+        isFreshSession: boolean;
+        sessionId: string;
+        effectiveSystemPromptText?: string;
+        effectiveContextText?: string;
+    }>;
+    private isPermissionActorAuthorized;
+    private buildToolUiEvent;
+    private shouldBreakTextStreamForToolUpdate;
+}