@bbigbang/runtime-acp 0.1.0

package/dist/gateway/history.d.ts

@@ -0,0 +1,7 @@
+import type { Db } from '../db/db.js';
+export declare function buildReplayContextFromRecentRuns(db: Db, params: {
+    sessionKey: string;
+    excludeRunId: string;
+    maxRuns: number;
+    maxChars: number;
+}): string;

package/dist/gateway/history.js

@@ -0,0 +1,146 @@
+export function buildReplayContextFromRecentRuns(db, params) {
+    const runs = db
+        .prepare(`
+      SELECT run_id as runId,
+             prompt_text as promptText,
+             stop_reason as stopReason,
+             error,
+             started_at as startedAt
+        FROM runs
+       WHERE session_key = ? AND run_id != ?
+       ORDER BY started_at DESC
+       LIMIT ?
+      `)
+        .all(params.sessionKey, params.excludeRunId, params.maxRuns);
+    const chronological = runs.slice().reverse();
+    const assistantLabel = getSessionAssistantLabel(db, params.sessionKey) ?? 'Assistant';
+    const blocks = [];
+    for (const run of chronological) {
+        const rows = db
+            .prepare('SELECT payload_json as payloadJson FROM events WHERE run_id = ? AND method = ? ORDER BY seq ASC')
+            .all(run.runId, 'session/update');
+        let assistantText = '';
+        for (const row of rows) {
+            try {
+                const payload = JSON.parse(row.payloadJson);
+                const update = payload?.update;
+                if (update?.sessionUpdate !== 'agent_message_chunk')
+                    continue;
+                assistantText += update?.content?.text ?? '';
+            }
+            catch {
+                // ignore malformed rows
+            }
+        }
+        const assistantLine = assistantText.trim()
+            ? assistantText.trim()
+            : run.error
+                ? `[error] ${run.error}`
+                : run.stopReason && run.stopReason !== 'handoff_bootstrap'
+                    ? `[stop_reason] ${run.stopReason}`
+                    : '';
+        const normalizedUserText = normalizeReplayUserText(run.promptText);
+        if (normalizedUserText) {
+            blocks.push(`User: ${normalizedUserText}`);
+        }
+        if (assistantLine)
+            blocks.push(`${assistantLabel}: ${assistantLine}`);
+    }
+    const raw = blocks.join('\n');
+    if (!raw.trim())
+        return '';
+    const header = 'Context (previous messages, for continuity after restart/GC):\n';
+    const full = header + raw;
+    if (full.length <= params.maxChars)
+        return full;
+    return header + raw.slice(Math.max(0, raw.length - params.maxChars));
+}
+function stripReplyContract(promptText) {
+    if (!promptText.startsWith('[Reply contract]'))
+        return promptText;
+    const splitIndex = promptText.indexOf('\n\n');
+    return splitIndex >= 0 ? promptText.slice(splitIndex + 2) : promptText;
+}
+function normalizeComparableReplayText(value) {
+    return (value ?? '').replace(/\s+/g, ' ').trim();
+}
+function extractPromptSection(promptText, marker, stopMarkers) {
+    const start = promptText.indexOf(marker);
+    if (start < 0)
+        return null;
+    const remainder = promptText.slice(start + marker.length);
+    let end = remainder.length;
+    for (const stopMarker of stopMarkers) {
+        const idx = remainder.indexOf(stopMarker);
+        if (idx >= 0 && idx < end)
+            end = idx;
+    }
+    const body = remainder.slice(0, end).trim();
+    return body || null;
+}
+function extractTaskAttachmentSection(promptText) {
+    const start = promptText.indexOf('\n\n[Task attachment');
+    if (start < 0)
+        return null;
+    const remainder = promptText.slice(start + 2);
+    let end = remainder.length;
+    for (const stopMarker of ['\n\n[Triggered message metadata]\n', '\n\nRules:\n']) {
+        const idx = remainder.indexOf(stopMarker);
+        if (idx >= 0 && idx < end)
+            end = idx;
+    }
+    const section = remainder.slice(0, end).trim();
+    return section || null;
+}
+function extractTriggeredMessageBody(promptText) {
+    const marker = '[Triggered message body]\n';
+    const start = promptText.indexOf(marker);
+    if (start < 0)
+        return null;
+    const remainder = promptText.slice(start + marker.length);
+    // DM task handoff prompts append a Rules block after the original trigger text.
+    // Keep ordinary user messages intact even if they literally contain "Rules:".
+    const rulesIndex = promptText.includes('[DM Task Thread Handoff]')
+        ? remainder.lastIndexOf('\n\nRules:\n')
+        : -1;
+    const body = (rulesIndex >= 0 ? remainder.slice(0, rulesIndex) : remainder).trim();
+    return body || null;
+}
+function buildTaskHandoffReplayUserText(promptText) {
+    if (!promptText.includes('[DM Task Thread Handoff]') && !promptText.includes('[Channel Task Thread Handoff]')) {
+        return null;
+    }
+    const triggerBody = extractTriggeredMessageBody(promptText);
+    const taskBrief = extractPromptSection(promptText, 'Task brief / goal / done criteria:\n', ['\n\n[Task attachment', '\n\n[Triggered message metadata]\n', '\n\nRules:\n']);
+    const attachmentSection = extractTaskAttachmentSection(promptText);
+    if (!taskBrief && !attachmentSection)
+        return triggerBody;
+    const sameBriefAsTrigger = taskBrief
+        && triggerBody
+        && normalizeComparableReplayText(taskBrief) === normalizeComparableReplayText(triggerBody);
+    if (sameBriefAsTrigger) {
+        return attachmentSection
+            ? [triggerBody, attachmentSection].filter(Boolean).join('\n\n')
+            : triggerBody;
+    }
+    const parts = [];
+    if (taskBrief)
+        parts.push(`Task brief / goal / done criteria:\n${taskBrief}`);
+    if (attachmentSection)
+        parts.push(attachmentSection);
+    if (triggerBody)
+        parts.push(`Original trigger:\n${triggerBody}`);
+    return parts.length > 0 ? parts.join('\n\n') : null;
+}
+function normalizeReplayUserText(promptText) {
+    const stripped = stripReplyContract(promptText).trim();
+    return buildTaskHandoffReplayUserText(stripped) ?? extractTriggeredMessageBody(stripped) ?? stripped;
+}
+function getSessionAssistantLabel(db, sessionKey) {
+    const row = db.prepare('SELECT system_prompt_text as systemPromptText FROM sessions WHERE session_key = ?').get(sessionKey);
+    const promptText = row?.systemPromptText?.trim();
+    if (!promptText)
+        return null;
+    const match = /You are "([^"]+)"/.exec(promptText);
+    return match?.[1]?.trim() || null;
+}

package/dist/gateway/sessionStore.d.ts

@@ -0,0 +1,79 @@
+import type { Db } from '../db/db.js';
+export type Platform = 'discord' | 'telegram' | 'feishu' | 'web' | 'node';
+export type StoredClaudeSessionModeId = 'default' | 'acceptEdits' | 'plan' | 'bypassPermissions';
+export declare const SHARED_CHAT_SCOPE_USER_ID = "__chat_scope__";
+export type ConversationKey = {
+    platform: Platform;
+    chatId: string;
+    threadId: string | null;
+    userId: string;
+    scopeUserId?: string | null;
+};
+export type SessionBinding = {
+    bindingKey: string;
+    sessionKey: string;
+};
+export declare function bindingKeyFromConversationKey(key: ConversationKey): string;
+export declare function bindingScopeUserId(key: ConversationKey): string;
+export declare function getBinding(db: Db, key: ConversationKey): SessionBinding | null;
+export declare function upsertBinding(db: Db, key: ConversationKey, sessionKey: string): SessionBinding;
+export declare function deleteBinding(db: Db, key: ConversationKey): void;
+export declare function createSession(db: Db, params: {
+    sessionKey: string;
+    agentCommand: string;
+    agentArgs: string[];
+    cwd: string;
+    loadSupported: boolean;
+    claudeModeId?: StoredClaudeSessionModeId | null;
+    claudeModelId?: string | null;
+}): void;
+export declare function updateAcpSessionId(db: Db, sessionKey: string, acpSessionId: string): void;
+export declare function updateSessionRuntimeState(db: Db, params: {
+    sessionKey: string;
+    acpSessionId: string;
+    systemPromptText?: string | null;
+}): void;
+export declare function clearAcpSessionId(db: Db, sessionKey: string): void;
+export declare function updateLoadSupported(db: Db, sessionKey: string, loadSupported: boolean): void;
+export declare function updateSessionCwd(db: Db, sessionKey: string, cwd: string): void;
+export declare function updateSessionAgentConfig(db: Db, params: {
+    sessionKey: string;
+    agentCommand: string;
+    agentArgs: string[];
+}): void;
+export declare function getSession(db: Db, sessionKey: string): {
+    sessionKey: string;
+    agentCommand: string;
+    agentArgsJson: string;
+    acpSessionId: string | null;
+    systemPromptText: string | null;
+    cwd: string;
+    loadSupported: number;
+    claudeModeId: StoredClaudeSessionModeId | null;
+    claudeModelId: string | null;
+} | null;
+export declare function updateClaudeSessionControls(db: Db, params: {
+    sessionKey: string;
+    claudeModeId?: StoredClaudeSessionModeId | null;
+    claudeModelId?: string | null;
+}): void;
+export declare function insertClaudeSessionUserMessage(db: Db, params: {
+    sessionKey: string;
+    runId?: string | null;
+    messageUuid: string;
+}): void;
+export declare function getLatestClaudeSessionUserMessage(db: Db, sessionKey: string): {
+    messageUuid: string;
+    runId: string | null;
+    createdAt: number;
+} | null;
+export declare function createRun(db: Db, params: {
+    runId: string;
+    sessionKey: string;
+    promptText: string;
+}): void;
+export declare function finishRun(db: Db, params: {
+    runId: string;
+    stopReason?: string;
+    error?: string;
+}): void;

package/dist/gateway/sessionStore.js

@@ -0,0 +1,126 @@
+// Shared scope marker for group/channel conversations.
+export const SHARED_CHAT_SCOPE_USER_ID = '__chat_scope__';
+export function bindingKeyFromConversationKey(key) {
+    return [
+        key.platform,
+        key.chatId,
+        key.threadId ?? '-',
+        bindingScopeUserId(key),
+    ].join(':');
+}
+export function bindingScopeUserId(key) {
+    return key.scopeUserId?.trim() ? key.scopeUserId : key.userId;
+}
+export function getBinding(db, key) {
+    const bindingKey = bindingKeyFromConversationKey(key);
+    const row = db
+        .prepare('SELECT binding_key as bindingKey, session_key as sessionKey FROM bindings WHERE binding_key = ?')
+        .get(bindingKey);
+    return row ?? null;
+}
+export function upsertBinding(db, key, sessionKey) {
+    const bindingKey = bindingKeyFromConversationKey(key);
+    const now = Date.now();
+    db.prepare(`
+    INSERT INTO bindings(binding_key, platform, chat_id, thread_id, user_id, session_key, created_at, updated_at)
+    VALUES(?, ?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(binding_key) DO UPDATE SET
+      session_key = excluded.session_key,
+      updated_at = excluded.updated_at
+    `).run(bindingKey, key.platform, key.chatId, key.threadId, bindingScopeUserId(key), sessionKey, now, now);
+    return { bindingKey, sessionKey };
+}
+export function deleteBinding(db, key) {
+    const bindingKey = bindingKeyFromConversationKey(key);
+    // Bindings are referenced by several tables; delete dependents first.
+    db.prepare('DELETE FROM jobs WHERE binding_key = ?').run(bindingKey);
+    db.prepare('DELETE FROM tool_policies WHERE binding_key = ?').run(bindingKey);
+    db.prepare('DELETE FROM tool_allow_prefixes WHERE binding_key = ?').run(bindingKey);
+    db.prepare('DELETE FROM ui_prefs WHERE binding_key = ?').run(bindingKey);
+    db.prepare('DELETE FROM delivery_checkpoints WHERE binding_key = ?').run(bindingKey);
+    db.prepare('DELETE FROM bindings WHERE binding_key = ?').run(bindingKey);
+}
+export function createSession(db, params) {
+    const now = Date.now();
+    db.prepare(`
+    INSERT INTO sessions(session_key, agent_command, agent_args_json, acp_session_id, load_supported, cwd, claude_mode_id, claude_model_id, created_at, updated_at)
+    VALUES(?, ?, ?, NULL, ?, ?, ?, ?, ?, ?)
+    `).run(params.sessionKey, params.agentCommand, JSON.stringify(params.agentArgs), params.loadSupported ? 1 : 0, params.cwd, params.claudeModeId ?? null, params.claudeModelId ?? null, now, now);
+}
+export function updateAcpSessionId(db, sessionKey, acpSessionId) {
+    const now = Date.now();
+    db.prepare('UPDATE sessions SET acp_session_id = ?, updated_at = ? WHERE session_key = ?').run(acpSessionId, now, sessionKey);
+}
+export function updateSessionRuntimeState(db, params) {
+    const now = Date.now();
+    db.prepare('UPDATE sessions SET acp_session_id = ?, system_prompt_text = ?, updated_at = ? WHERE session_key = ?').run(params.acpSessionId, params.systemPromptText ?? null, now, params.sessionKey);
+}
+export function clearAcpSessionId(db, sessionKey) {
+    const now = Date.now();
+    db.prepare('UPDATE sessions SET acp_session_id = NULL, system_prompt_text = NULL, updated_at = ? WHERE session_key = ?').run(now, sessionKey);
+    db.prepare('DELETE FROM claude_session_user_messages WHERE session_key = ?').run(sessionKey);
+}
+export function updateLoadSupported(db, sessionKey, loadSupported) {
+    const now = Date.now();
+    db.prepare('UPDATE sessions SET load_supported = ?, updated_at = ? WHERE session_key = ?').run(loadSupported ? 1 : 0, now, sessionKey);
+}
+export function updateSessionCwd(db, sessionKey, cwd) {
+    const now = Date.now();
+    db.prepare('UPDATE sessions SET cwd = ?, updated_at = ? WHERE session_key = ?').run(cwd, now, sessionKey);
+}
+export function updateSessionAgentConfig(db, params) {
+    const now = Date.now();
+    db.prepare(`
+    UPDATE sessions
+       SET agent_command = ?,
+           agent_args_json = ?,
+           acp_session_id = NULL,
+           system_prompt_text = NULL,
+           updated_at = ?
+     WHERE session_key = ?
+    `).run(params.agentCommand, JSON.stringify(params.agentArgs), now, params.sessionKey);
+}
+export function getSession(db, sessionKey) {
+    const row = db
+        .prepare(`SELECT session_key as sessionKey,
+              agent_command as agentCommand,
+              agent_args_json as agentArgsJson,
+              acp_session_id as acpSessionId,
+              system_prompt_text as systemPromptText,
+              cwd,
+              load_supported as loadSupported,
+              claude_mode_id as claudeModeId,
+              claude_model_id as claudeModelId
+         FROM sessions
+        WHERE session_key = ?`)
+        .get(sessionKey);
+    return row ?? null;
+}
+export function updateClaudeSessionControls(db, params) {
+    const now = Date.now();
+    db.prepare(`UPDATE sessions
+        SET claude_mode_id = ?,
+            claude_model_id = ?,
+            updated_at = ?
+      WHERE session_key = ?`).run(params.claudeModeId ?? null, params.claudeModelId ?? null, now, params.sessionKey);
+}
+export function insertClaudeSessionUserMessage(db, params) {
+    db.prepare(`INSERT OR REPLACE INTO claude_session_user_messages(session_key, run_id, message_uuid, created_at)
+     VALUES(?, ?, ?, ?)`).run(params.sessionKey, params.runId ?? null, params.messageUuid, Date.now());
+}
+export function getLatestClaudeSessionUserMessage(db, sessionKey) {
+    const row = db.prepare(`SELECT message_uuid as messageUuid,
+            run_id as runId,
+            created_at as createdAt
+       FROM claude_session_user_messages
+      WHERE session_key = ?
+      ORDER BY created_at DESC, rowid DESC
+      LIMIT 1`).get(sessionKey);
+    return row ?? null;
+}
+export function createRun(db, params) {
+    db.prepare('INSERT INTO runs(run_id, session_key, prompt_text, started_at) VALUES(?, ?, ?, ?)').run(params.runId, params.sessionKey, params.promptText, Date.now());
+}
+export function finishRun(db, params) {
+    db.prepare('UPDATE runs SET ended_at = ?, stop_reason = ?, error = ? WHERE run_id = ?').run(Date.now(), params.stopReason ?? null, params.error ?? null, params.runId);
+}

package/dist/gateway/toolAuth.d.ts

@@ -0,0 +1,36 @@
+import type { Db } from '../db/db.js';
+export type ToolKind = 'read' | 'edit' | 'delete' | 'move' | 'search' | 'execute' | 'think' | 'fetch' | 'switch_mode' | 'other';
+export type PersistentToolPolicy = 'allow' | 'reject';
+export declare const TOOL_KINDS: ToolKind[];
+export declare function parseToolKind(value: unknown): ToolKind | null;
+export type ToolMatchContext = {
+    method?: string;
+    params?: unknown;
+    toolCall?: unknown;
+    workspaceRoot?: string;
+};
+export type ToolAllowPrefixRule = {
+    toolKind: ToolKind;
+    argPrefix: string;
+};
+export declare class ToolAuth {
+    private readonly db;
+    private readonly onceGrants;
+    constructor(db: Db);
+    grantOnce(sessionKey: string, toolKind: ToolKind, count?: number): void;
+    setPersistentPolicy(bindingKey: string, toolKind: ToolKind, policy: PersistentToolPolicy): void;
+    getPersistentPolicy(bindingKey: string, toolKind: ToolKind): PersistentToolPolicy | null;
+    listPersistentPolicies(bindingKey: string, policy?: PersistentToolPolicy): Array<{
+        toolKind: ToolKind;
+        policy: PersistentToolPolicy;
+    }>;
+    clearPersistentPolicy(bindingKey: string, toolKind: ToolKind, policy?: PersistentToolPolicy): boolean;
+    clearPersistentPolicies(bindingKey: string, policy?: PersistentToolPolicy): number;
+    setAllowPrefixRule(bindingKey: string, toolKind: ToolKind, argPrefix: string): void;
+    listAllowPrefixRules(bindingKey: string, toolKind?: ToolKind): ToolAllowPrefixRule[];
+    clearAllowPrefixRule(bindingKey: string, toolKind: ToolKind, argPrefix: string): boolean;
+    clearAllowPrefixRules(bindingKey: string, toolKind?: ToolKind): number;
+    evaluatePersistentPolicy(bindingKey: string, toolKind: ToolKind, context?: ToolMatchContext): PersistentToolPolicy | null;
+    consume(sessionKey: string, toolKind: ToolKind, context?: ToolMatchContext): boolean;
+    private matchesAllowPrefixRule;
+}