@foxden-app/foxclaw 0.12.0 → 0.13.1

package/dist/opencode/adapter.js

@@ -1,6 +1,6 @@
 import { EventEmitter } from 'node:events';
 import { formatSdkError } from './client.js';
-import { buildAttachmentPrompt } from '../telegram/media.js';
+import { buildAttachmentPrompt } from '../core/attachment_files.js';
 export class OpencodeEngineAdapter {
     client;
     defaultModel;
@@ -49,6 +49,8 @@ export class OpencodeEngineAdapter {
         }
         let finalResult = null;
         let turnError = null;
+        let accumulatedResponse = '';
+        let cleanup = () => { };
         const resultWaiters = [];
         const resolveWaiters = (res) => {
             while (resultWaiters.length > 0) {
@@ -68,8 +70,9 @@ export class OpencodeEngineAdapter {
                 }
                 if (cancelled)
                     return;
-                let accumulatedResponse = '';
                 const onEvent = (ev) => {
+                    if (cancelled)
+                        return;
                     if ('sessionId' in ev && ev.sessionId === sessionId) {
                         if (ev.kind === 'text') {
                             if (ev.delta) {
@@ -111,7 +114,7 @@ export class OpencodeEngineAdapter {
                         }
                     }
                 };
-                const cleanup = () => {
+                cleanup = () => {
                     this.client.off('event', onEvent);
                 };
                 this.client.on('event', onEvent);
@@ -138,19 +141,35 @@ export class OpencodeEngineAdapter {
                 }
             }
             catch (err) {
+                cleanup();
                 turnError = err instanceof Error ? err : new Error(String(err));
                 emitter.emit('error', turnError);
                 resolveWaiters(null);
             }
         };
-        void run();
+        const running = run();
+        let cancelling;
         return {
-            turnId: sessionId ?? undefined,
+            get turnId() { return sessionId ?? undefined; },
             cancel: () => {
-                cancelled = true;
-                if (sessionId) {
-                    void this.client.getClient().session.abort({ sessionID: sessionId }).catch(() => { });
-                }
+                if (finalResult)
+                    return Promise.resolve();
+                cancelling ??= (async () => {
+                    cancelled = true;
+                    await running;
+                    if (finalResult)
+                        return;
+                    if (sessionId) {
+                        const result = await this.client.getClient().session.abort({ sessionID: sessionId });
+                        if (result.error)
+                            throw new Error(formatSdkError(result.error));
+                    }
+                    cleanup();
+                    finalResult = { kind: 'result', status: 'INTERRUPTED', response: accumulatedResponse, conversationId: sessionId };
+                    emitter.emit('result', finalResult);
+                    resolveWaiters(finalResult);
+                })();
+                return cancelling.catch(error => { cancelling = undefined; throw error; });
             },
             waitForResult: async () => {
                 if (finalResult)

package/dist/opencode/controller.js

@@ -91,7 +91,7 @@ export class OpencodeBridgeCore {
     async stop() {
         if (!this.started)
             return;
-        this.bot.stop();
+        await this.bot.stop();
         for (const turn of this.activeTurns.values())
             this.clearTurnTimers(turn);
         for (const watch of this.watchers.values()) {

package/dist/store/channel_inbox.d.ts

@@ -0,0 +1,14 @@
+import type { DatabaseSync } from 'node:sqlite';
+import type { ChannelInbound } from '../core/channel_events.js';
+export interface InboxEntry {
+    id: string;
+    inbound: ChannelInbound;
+}
+/** Durable intake precedes business classification and acknowledgement to the transport. */
+export declare class ChannelInbox {
+    private readonly db;
+    constructor(db: DatabaseSync);
+    accept(id: string, inbound: ChannelInbound): boolean;
+    complete(id: string): void;
+    pending(): InboxEntry[];
+}

package/dist/store/channel_inbox.js

@@ -0,0 +1,21 @@
+/** Durable intake precedes business classification and acknowledgement to the transport. */
+export class ChannelInbox {
+    db;
+    constructor(db) {
+        this.db = db;
+        db.exec(`CREATE TABLE IF NOT EXISTS channel_inbox (
+      receipt_id TEXT PRIMARY KEY, scope_id TEXT NOT NULL, payload TEXT,
+      completed_at INTEGER, created_at INTEGER NOT NULL);
+      CREATE INDEX IF NOT EXISTS channel_inbox_pending ON channel_inbox(completed_at, created_at);`);
+        db.prepare('DELETE FROM channel_inbox WHERE completed_at < ?').run(Date.now() - 90 * 86400_000);
+    }
+    accept(id, inbound) {
+        this.db.prepare('INSERT OR IGNORE INTO channel_inbox VALUES (?, ?, ?, NULL, ?)').run(id, inbound.event.scopeId, JSON.stringify(inbound), Date.now());
+        return this.db.prepare('SELECT completed_at FROM channel_inbox WHERE receipt_id = ?').get(id)?.completed_at === null;
+    }
+    complete(id) { this.db.prepare('UPDATE channel_inbox SET payload = NULL, completed_at = ? WHERE receipt_id = ?').run(Date.now(), id); }
+    pending() {
+        return this.db.prepare('SELECT receipt_id, payload FROM channel_inbox WHERE completed_at IS NULL ORDER BY created_at, receipt_id').all()
+            .map(row => ({ id: String(row.receipt_id), inbound: JSON.parse(String(row.payload)) }));
+    }
+}

package/dist/store/database.d.ts

@@ -1,4 +1,6 @@
-import type { AccessPresetValue, ActiveTurnMessageMode, AppLocale, CachedThread, ChatSessionSettings, CollaborationModeValue, GuidedPlanSessionRecord, GuidedPlanSessionState, PendingAttachmentBatchRecord, PendingAttachmentBatchStatus, PendingApprovalRecord, QueuedTurnInputRecord, QueuedTurnInputStatus, ReasoningEffortValue, ThreadBinding } from '../types.js';
+import { ChannelInbox } from './channel_inbox.js';
+import { TaskJournal } from './task_journal.js';
+import type { AccessPresetValue, ActiveTurnMessageMode, AppLocale, CachedThread, ChatSessionSettings, CollaborationModeValue, GuidedPlanSessionRecord, GuidedPlanSessionState, PendingAttachmentBatchRecord, PendingAttachmentBatchStatus, PendingApprovalRecord, QueuedTurnInputRecord, QueuedTurnInputStatus, ThreadBinding } from '../types.js';
 import type { CumulativeTokenTotals, CumulativeTokenUsageRecord, TokenUsageDelta } from './token_usage.js';
 export interface ActiveTurnPreviewRecord {
     turnId: string;
@@ -50,6 +52,8 @@ export interface CodexAuthPoolStats {
 export type CodexAuthCandidateState = 'active' | 'needs_repair';
 export declare class BridgeStore {
     private db;
+    readonly taskJournal: TaskJournal;
+    readonly channelInbox: ChannelInbox;
     constructor(dbPath: string);
     getTelegramOffset(botKey: string): number;
     setTelegramOffset(botKey: string, updateId: number): void;
@@ -71,9 +75,9 @@ export declare class BridgeStore {
         threadId: string;
     }>;
     getChatSettings(chatId: string): ChatSessionSettings | null;
-    setChatSettings(chatId: string, model: string | null, reasoningEffort: ReasoningEffortValue | null, locale?: AppLocale | null): void;
+    setChatSettings(chatId: string, model: string | null, reasoningEffort: string | null, locale?: AppLocale | null): void;
     setChatModel(chatId: string, model: string | null): void;
-    setChatEffort(chatId: string, effort: ReasoningEffortValue | null): void;
+    setChatEffort(chatId: string, effort: string | null): void;
     /** Persist an adapter-advertised reasoning id without imposing Codex's vocabulary. */
     setChatEngineEffort(chatId: string, effort: string | null): void;
     setChatLocale(chatId: string, locale: AppLocale): void;

package/dist/store/database.js

@@ -1,12 +1,18 @@
 import path from 'node:path';
 import fs from 'node:fs';
 import { DatabaseSync } from 'node:sqlite';
+import { ChannelInbox } from './channel_inbox.js';
+import { TaskJournal } from './task_journal.js';
 import { migrateLegacyBridgeScopeIds } from './migrate_bridge_scope.js';
 export class BridgeStore {
     db;
+    taskJournal;
+    channelInbox;
     constructor(dbPath) {
         fs.mkdirSync(path.dirname(dbPath), { recursive: true });
         this.db = new DatabaseSync(dbPath);
+        this.taskJournal = new TaskJournal(this.db);
+        this.channelInbox = new ChannelInbox(this.db);
         this.db.exec(`
       CREATE TABLE IF NOT EXISTS telegram_offsets (
         bot_key TEXT PRIMARY KEY,
@@ -405,8 +411,7 @@ export class BridgeStore {
     }
     /** Persist an adapter-advertised reasoning id without imposing Codex's vocabulary. */
     setChatEngineEffort(chatId, effort) {
-        const current = this.getChatSettings(chatId);
-        this.writeChatSettings(chatId, current?.model ?? null, effort, current?.locale ?? null, current?.accessPreset ?? null, current?.collaborationMode ?? null, current?.serviceTier ?? null, current?.activeTurnMessageMode ?? null, current?.activeBackendId ?? null);
+        this.setChatEffort(chatId, effort);
     }
     setChatLocale(chatId, locale) {
         const current = this.getChatSettings(chatId);

package/dist/store/task_journal.d.ts

@@ -0,0 +1,32 @@
+import type { DatabaseSync } from 'node:sqlite';
+import type { ChannelTextEvent } from '../core/channel_events.js';
+import type { EngineTurnRequest, EngineTurnResult } from '../core/engine_spi.js';
+export type TaskState = 'accepted' | 'queued' | 'running' | 'awaiting_confirmation' | 'delivery_pending' | 'completed' | 'failed' | 'cancelled';
+export interface JournalTask {
+    id: string;
+    backendId: string;
+    state: TaskState;
+    event: ChannelTextEvent;
+    sourcePrompt: string;
+    request: EngineTurnRequest;
+    queueId: string | null;
+    previewMessageId: number;
+    result: EngineTurnResult | null;
+    delivery: string[];
+    deliveredChunks: number;
+    error: string | null;
+    createdAt: number;
+    updatedAt: number;
+}
+/** Original inputs, native outcome and delivery progress are distinct durable facts. */
+export declare class TaskJournal {
+    private readonly db;
+    constructor(db: DatabaseSync);
+    atomic<T>(operation: () => T): T;
+    insert(task: JournalTask): void;
+    get(id: string): JournalTask | null;
+    listUnfinished(scopeId?: string): JournalTask[];
+    findReceipt(event: ChannelTextEvent, prompt: string): JournalTask | null;
+    forQueue(queueId: string): JournalTask | null;
+    update(id: string, state: TaskState, patch?: Partial<Omit<JournalTask, 'id' | 'backendId' | 'createdAt' | 'state'>>): JournalTask;
+}

package/dist/store/task_journal.js

@@ -0,0 +1,70 @@
+const transitions = {
+    accepted: ['queued', 'running', 'awaiting_confirmation', 'failed', 'cancelled'],
+    queued: ['running', 'failed', 'cancelled'],
+    running: ['running', 'awaiting_confirmation', 'delivery_pending', 'failed', 'cancelled'],
+    awaiting_confirmation: ['accepted', 'running', 'cancelled'],
+    delivery_pending: ['delivery_pending', 'completed', 'failed', 'cancelled'],
+    completed: [], failed: [], cancelled: [],
+};
+const unfinished = ['accepted', 'queued', 'running', 'awaiting_confirmation', 'delivery_pending'];
+/** Original inputs, native outcome and delivery progress are distinct durable facts. */
+export class TaskJournal {
+    db;
+    constructor(db) {
+        this.db = db;
+        db.exec(`CREATE TABLE IF NOT EXISTS engine_task_journal (
+      task_id TEXT PRIMARY KEY, scope_id TEXT NOT NULL, backend_id TEXT NOT NULL,
+      state TEXT NOT NULL, queue_id TEXT, record_json TEXT NOT NULL,
+      created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL);
+      CREATE INDEX IF NOT EXISTS engine_task_journal_scope_state ON engine_task_journal(scope_id, state, created_at);
+      CREATE INDEX IF NOT EXISTS engine_task_journal_receipt ON engine_task_journal(scope_id, json_extract(record_json, '$.event.messageId'));`);
+    }
+    atomic(operation) {
+        this.db.exec('SAVEPOINT task_journal_change');
+        try {
+            const result = operation();
+            this.db.exec('RELEASE task_journal_change');
+            return result;
+        }
+        catch (error) {
+            this.db.exec('ROLLBACK TO task_journal_change; RELEASE task_journal_change');
+            throw error;
+        }
+    }
+    insert(task) {
+        this.db.prepare(`INSERT INTO engine_task_journal VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(task.id, task.event.scopeId, task.backendId, task.state, task.queueId, JSON.stringify(task), task.createdAt, task.updatedAt);
+    }
+    get(id) {
+        const row = this.db.prepare('SELECT record_json FROM engine_task_journal WHERE task_id = ?').get(id);
+        return row ? JSON.parse(String(row.record_json)) : null;
+    }
+    listUnfinished(scopeId) {
+        const placeholders = unfinished.map(() => '?').join(',');
+        const rows = this.db.prepare(`SELECT record_json FROM engine_task_journal WHERE state IN (${placeholders})${scopeId ? ' AND scope_id = ?' : ''} ORDER BY created_at, task_id`).all(...unfinished, ...(scopeId ? [scopeId] : []));
+        return rows.map(row => JSON.parse(String(row.record_json)));
+    }
+    findReceipt(event, prompt) {
+        if (event.messageId <= 0 || event.userId === 'system')
+            return null;
+        const row = this.db.prepare(`SELECT record_json FROM engine_task_journal WHERE scope_id = ?
+      AND json_extract(record_json, '$.event.messageId') = ? AND json_extract(record_json, '$.event.chatId') = ?
+      AND json_extract(record_json, '$.sourcePrompt') = ? LIMIT 1`).get(event.scopeId, event.messageId, event.chatId, prompt);
+        return row ? JSON.parse(String(row.record_json)) : null;
+    }
+    forQueue(queueId) {
+        const row = this.db.prepare('SELECT record_json FROM engine_task_journal WHERE queue_id = ?').get(queueId);
+        return row ? JSON.parse(String(row.record_json)) : null;
+    }
+    update(id, state, patch = {}) {
+        const previous = this.get(id);
+        if (!previous)
+            throw new Error(`Unknown task: ${id}`);
+        if (previous.state !== state && !transitions[previous.state].includes(state))
+            throw new Error(`Invalid task transition: ${previous.state} -> ${state}`);
+        if (['completed', 'failed', 'cancelled'].includes(previous.state))
+            throw new Error(`Task already resolved: ${id}`);
+        const next = { ...previous, ...patch, state, updatedAt: Date.now() };
+        this.db.prepare(`UPDATE engine_task_journal SET state = ?, queue_id = ?, record_json = ?, updated_at = ? WHERE task_id = ? AND state = ?`).run(state, next.queueId, JSON.stringify(next), next.updatedAt, id, previous.state);
+        return next;
+    }
+}

package/dist/telegram/api.d.ts

@@ -9,8 +9,8 @@ export interface TelegramRemoteFile {
     file_size?: number;
     file_path?: string;
 }
-export declare function isTransientNetworkError(err: unknown): boolean;
-export declare function callTelegramApi<T>(botToken: string, method: string, body: Record<string, unknown>): Promise<TelegramApiResult<T>>;
+export { isTransientNetworkError } from '../core/network_errors.js';
+export declare function callTelegramApi<T>(botToken: string, method: string, body: Record<string, unknown>, signal?: AbortSignal): Promise<TelegramApiResult<T>>;
 export declare function callTelegramMultipartApi<T>(botToken: string, method: string, fields: Record<string, string>, files: Array<{
     fieldName: string;
     filename: string;

package/dist/telegram/api.js

@@ -1,33 +1,13 @@
+import { setTimeout as delay } from 'node:timers/promises';
 import fs from 'node:fs';
 import http from 'node:http';
 import https from 'node:https';
 import path from 'node:path';
 import { pipeline } from 'node:stream/promises';
 const DEFAULT_API_BASE_URL = 'https://api.telegram.org';
-export function isTransientNetworkError(err) {
-    if (!err)
-        return false;
-    const msg = String(err.message || err).toLowerCase();
-    return (msg.includes('client network socket disconnected') ||
-        msg.includes('econnreset') ||
-        msg.includes('etimedout') ||
-        msg.includes('eai_again') ||
-        msg.includes('enotfound') ||
-        msg.includes('econnrefused') ||
-        msg.includes('socket hang up') ||
-        msg.includes('timed out') ||
-        msg.includes('timeout') ||
-        msg.includes('network socket disconnected') ||
-        msg.includes('network error') ||
-        msg.includes('fetch failed') ||
-        msg.includes('und_err_') ||
-        msg.includes('read tcp') ||
-        msg.includes('connection timed out') ||
-        msg.includes('broken pipe') ||
-        msg.includes('ehostunreach') ||
-        msg.includes('enetunreach'));
-}
-function callTelegramApiOnce(botToken, method, body) {
+export { isTransientNetworkError } from '../core/network_errors.js';
+import { isTransientNetworkError } from '../core/network_errors.js';
+function callTelegramApiOnce(botToken, method, body, signal) {
     const payload = JSON.stringify(body);
     const endpoint = telegramApiUrl(botToken, method);
     return new Promise((resolve, reject) => {
@@ -37,7 +17,7 @@ function callTelegramApiOnce(botToken, method, body) {
                 'content-type': 'application/json',
                 'content-length': Buffer.byteLength(payload),
             },
-            signal: AbortSignal.timeout(telegramApiTimeoutMs(false)),
+            signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(telegramApiTimeoutMs(false))]) : AbortSignal.timeout(telegramApiTimeoutMs(false)),
         }, (response) => {
             response.on('error', reject);
             const chunks = [];
@@ -62,17 +42,19 @@ function callTelegramApiOnce(botToken, method, body) {
         request.end();
     });
 }
-export async function callTelegramApi(botToken, method, body) {
+export async function callTelegramApi(botToken, method, body, signal) {
     const maxAttempts = method === 'getUpdates' ? 1 : 4;
     let lastError;
     for (let attempt = 1; attempt <= maxAttempts; attempt++) {
         try {
-            return await callTelegramApiOnce(botToken, method, body);
+            signal?.throwIfAborted();
+            return await callTelegramApiOnce(botToken, method, body, signal);
         }
         catch (err) {
+            signal?.throwIfAborted();
             lastError = err;
             if (attempt < maxAttempts && isTransientNetworkError(err)) {
-                await new Promise((r) => setTimeout(r, Math.min(3000, 500 * Math.pow(2, attempt - 1))));
+                await delay(Math.min(3000, 500 * Math.pow(2, attempt - 1)), undefined, { signal });
                 continue;
             }
             throw err;

package/dist/telegram/gateway.d.ts

@@ -1,28 +1,15 @@
+import type { ChannelInbound } from '../core/channel_events.js';
 import { EventEmitter } from 'node:events';
 import { type TelegramRemoteFile } from './api.js';
 import type { BridgeStore } from '../store/database.js';
 import type { Logger } from '../logger.js';
-import type { TelegramMessageEntity } from './addressing.js';
 import type { TelegramInboundAttachment } from './media.js';
 import type { TelegramInputRichMessage } from './rich.js';
 export type TelegramCommandProvider = (locale: 'en' | 'zh') => Array<{
     command: string;
     description: string;
 }>;
-export interface TelegramTextEvent {
-    chatId: string;
-    topicId: number | null;
-    scopeId: string;
-    chatType: string;
-    userId: string;
-    text: string;
-    messageId: number;
-    mediaGroupId?: string | null;
-    attachments: TelegramInboundAttachment[];
-    entities: TelegramMessageEntity[];
-    replyToBot: boolean;
-    languageCode?: string;
-}
+export type { ChannelTextEvent as TelegramTextEvent } from '../core/channel_events.js';
 export interface TelegramPeerDocumentEvent {
     chatId: string;
     userId: string;
@@ -31,16 +18,7 @@ export interface TelegramPeerDocumentEvent {
     text: string;
     attachment: TelegramInboundAttachment;
 }
-export interface TelegramCallbackEvent {
-    chatId: string;
-    topicId: number | null;
-    scopeId: string;
-    userId: string;
-    data: string;
-    callbackQueryId: string;
-    messageId: number;
-    languageCode?: string;
-}
+export type { ChannelCallbackEvent as TelegramCallbackEvent } from '../core/channel_events.js';
 export declare class TelegramGateway extends EventEmitter {
     private readonly botToken;
     private readonly allowedUserId;
@@ -50,7 +28,15 @@ export declare class TelegramGateway extends EventEmitter {
     private readonly logger;
     private readonly namespacedScopes;
     private readonly commandProvider;
+    private inboundConsumer;
+    private readonly generations;
+    setInboundConsumer(consumer: (id: string, inbound: ChannelInbound) => Promise<void>): () => void;
+    registerGeneration(draftId: number, scopeId: string, taskId: string, chatId: string, topicId: number | null): void;
+    releaseGeneration(draftId: number): void;
+    private dispatchInbound;
     private running;
+    private polling;
+    private pollAbort;
     private botKey;
     private botUsername;
     private botUserId;
@@ -60,7 +46,7 @@ export declare class TelegramGateway extends EventEmitter {
     initializeIdentity(): Promise<string>;
     resolveUsername(): Promise<string | null>;
     start(): Promise<void>;
-    stop(): void;
+    stop(): Promise<void>;
     sendMessage(chatId: string, text: string, inlineKeyboard?: Array<Array<{
         text: string;
         callback_data: string;
@@ -76,7 +62,7 @@ export declare class TelegramGateway extends EventEmitter {
     sendDocument(chatId: string, filename: string, contents: Buffer, caption?: string): Promise<number>;
     sendVoice(chatId: string, filename: string, contents: Buffer, caption?: string, messageThreadId?: number | null, contentType?: string): Promise<number>;
     sendMessageDraft(chatId: string, draftId: number, text: string, messageThreadId?: number | null): Promise<void>;
-    sendRichMessageDraft(chatId: string, draftId: number, richMessage: TelegramInputRichMessage, messageThreadId?: number | null): Promise<void>;
+    sendRichMessageDraft(chatId: string, draftId: number, richMessage: TelegramInputRichMessage, messageThreadId?: number | null, canStop?: boolean): Promise<void>;
     editMessage(chatId: string, messageId: number, text: string, inlineKeyboard?: Array<Array<{
         text: string;
         callback_data: string;