@foxden-app/foxclaw 0.5.78 → 0.6.3

package/dist/opencode/events.d.ts

@@ -0,0 +1,61 @@
+import type { Event, PermissionRequest, QuestionRequest, SessionStatus } from '@opencode-ai/sdk/v2';
+export interface OpencodeTextEvent {
+    kind: 'text';
+    sessionId: string;
+    messageId: string;
+    partId: string;
+    text: string;
+    delta: string | null;
+}
+export interface OpencodeToolEvent {
+    kind: 'tool';
+    sessionId: string;
+    messageId: string;
+    partId: string;
+    callId: string;
+    tool: string;
+    status: string;
+    title: string | null;
+    error: string | null;
+}
+export type OpencodeBridgeEvent = OpencodeTextEvent | OpencodeToolEvent | {
+    kind: 'permission';
+    request: PermissionRequest;
+} | {
+    kind: 'permissionResolved';
+    sessionId: string;
+    requestId: string;
+} | {
+    kind: 'question';
+    request: QuestionRequest;
+} | {
+    kind: 'questionResolved';
+    sessionId: string;
+    requestId: string;
+} | {
+    kind: 'status';
+    sessionId: string;
+    status: SessionStatus;
+} | {
+    kind: 'idle';
+    sessionId: string;
+} | {
+    kind: 'error';
+    sessionId: string | null;
+    message: string;
+};
+/**
+ * Turns OpenCode's public SSE events into the small, stable event surface used
+ * by the Telegram bridge. State is intentionally kept here so reconnect and
+ * delta handling can be tested without starting a real server.
+ */
+export declare class OpencodeEventNormalizer {
+    private readonly roles;
+    private readonly textByPart;
+    private readonly sessionByMessage;
+    reset(): void;
+    accept(event: Event): OpencodeBridgeEvent[];
+    private normalizePart;
+    private clearSession;
+}
+export declare function formatOpencodeError(error: unknown): string;

package/dist/opencode/events.js

@@ -0,0 +1,145 @@
+/**
+ * Turns OpenCode's public SSE events into the small, stable event surface used
+ * by the Telegram bridge. State is intentionally kept here so reconnect and
+ * delta handling can be tested without starting a real server.
+ */
+export class OpencodeEventNormalizer {
+    roles = new Map();
+    textByPart = new Map();
+    sessionByMessage = new Map();
+    reset() {
+        this.roles.clear();
+        this.textByPart.clear();
+        this.sessionByMessage.clear();
+    }
+    accept(event) {
+        switch (event.type) {
+            case 'message.updated': {
+                this.roles.set(event.properties.info.id, event.properties.info.role);
+                this.sessionByMessage.set(event.properties.info.id, event.properties.info.sessionID);
+                return [];
+            }
+            case 'message.part.delta': {
+                if (event.properties.field !== 'text' || this.roles.get(event.properties.messageID) !== 'assistant') {
+                    return [];
+                }
+                const key = partKey(event.properties.messageID, event.properties.partID);
+                const text = `${this.textByPart.get(key) ?? ''}${event.properties.delta}`;
+                this.textByPart.set(key, text);
+                return [{
+                        kind: 'text',
+                        sessionId: event.properties.sessionID,
+                        messageId: event.properties.messageID,
+                        partId: event.properties.partID,
+                        text,
+                        delta: event.properties.delta,
+                    }];
+            }
+            case 'message.part.updated':
+                return this.normalizePart(event.properties.part);
+            case 'permission.asked':
+                return [{ kind: 'permission', request: event.properties }];
+            case 'permission.replied':
+                return [{
+                        kind: 'permissionResolved',
+                        sessionId: event.properties.sessionID,
+                        requestId: event.properties.requestID,
+                    }];
+            case 'question.asked':
+                return [{ kind: 'question', request: event.properties }];
+            case 'question.replied':
+            case 'question.rejected':
+                return [{
+                        kind: 'questionResolved',
+                        sessionId: event.properties.sessionID,
+                        requestId: event.properties.requestID,
+                    }];
+            case 'session.status':
+                if (event.properties.status.type === 'idle')
+                    this.clearSession(event.properties.sessionID);
+                return [{ kind: 'status', sessionId: event.properties.sessionID, status: event.properties.status }];
+            case 'session.idle':
+                this.clearSession(event.properties.sessionID);
+                return [{ kind: 'idle', sessionId: event.properties.sessionID }];
+            case 'session.error':
+                if (event.properties.sessionID)
+                    this.clearSession(event.properties.sessionID);
+                return [{
+                        kind: 'error',
+                        sessionId: event.properties.sessionID ?? null,
+                        message: formatOpencodeError(event.properties.error),
+                    }];
+            default:
+                return [];
+        }
+    }
+    normalizePart(part) {
+        if (part.type === 'text') {
+            if (this.roles.get(part.messageID) !== 'assistant')
+                return [];
+            const key = partKey(part.messageID, part.id);
+            const previous = this.textByPart.get(key) ?? '';
+            this.textByPart.set(key, part.text);
+            if (part.text === previous)
+                return [];
+            return [{
+                    kind: 'text',
+                    sessionId: part.sessionID,
+                    messageId: part.messageID,
+                    partId: part.id,
+                    text: part.text,
+                    delta: part.text.startsWith(previous) ? part.text.slice(previous.length) : null,
+                }];
+        }
+        if (part.type !== 'tool')
+            return [];
+        const state = part.state;
+        return [{
+                kind: 'tool',
+                sessionId: part.sessionID,
+                messageId: part.messageID,
+                partId: part.id,
+                callId: part.callID,
+                tool: part.tool,
+                status: state.status,
+                title: 'title' in state && typeof state.title === 'string' ? state.title : null,
+                error: state.status === 'error' ? state.error : null,
+            }];
+    }
+    clearSession(sessionId) {
+        for (const [messageId, owner] of this.sessionByMessage) {
+            if (owner !== sessionId)
+                continue;
+            this.sessionByMessage.delete(messageId);
+            this.roles.delete(messageId);
+            for (const key of this.textByPart.keys()) {
+                if (key.startsWith(`${messageId}:`))
+                    this.textByPart.delete(key);
+            }
+        }
+    }
+}
+function partKey(messageId, partId) {
+    return `${messageId}:${partId}`;
+}
+export function formatOpencodeError(error) {
+    if (!error)
+        return 'OpenCode session failed';
+    if (typeof error === 'string')
+        return error;
+    if (typeof error === 'object') {
+        const record = error;
+        if (typeof record.data?.message === 'string')
+            return record.data.message;
+        if (typeof record.message === 'string')
+            return record.message;
+        if (typeof record.name === 'string')
+            return record.name;
+    }
+    try {
+        return JSON.stringify(error);
+    }
+    catch {
+        return String(error);
+    }
+}

package/dist/opencode/runtime.d.ts

@@ -0,0 +1,14 @@
+import type { AppConfig } from '../config.js';
+import type { Logger } from '../logger.js';
+import type { BridgeStore } from '../store/database.js';
+import { OpencodeBridgeCore } from './controller.js';
+/** Keeps the optional OpenCode Telegram bot lifecycle out of the Codex runtime branches. */
+export declare class OpencodeTelegramRuntime {
+    private readonly bot;
+    private readonly app;
+    private readonly core;
+    constructor(config: AppConfig, store: BridgeStore, logger: Logger);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    getRuntimeStatus(): ReturnType<OpencodeBridgeCore['getRuntimeStatus']>;
+}

package/dist/opencode/runtime.js

@@ -0,0 +1,29 @@
+import { TelegramMessagingPort } from '../channels/telegram/telegram_messaging_port.js';
+import { getOpencodeTelegramCommands } from '../i18n.js';
+import { TelegramGateway } from '../telegram/gateway.js';
+import { OpencodeAppClient } from './client.js';
+import { OpencodeBridgeCore } from './controller.js';
+/** Keeps the optional OpenCode Telegram bot lifecycle out of the Codex runtime branches. */
+export class OpencodeTelegramRuntime {
+    bot;
+    app;
+    core;
+    constructor(config, store, logger) {
+        if (!config.opencodeBotToken)
+            throw new Error('OPENCODE_BOT_TOKEN is required for the OpenCode runtime');
+        this.bot = new TelegramGateway(config.opencodeBotToken, config.tgAllowedUserId, config.tgAllowedChatId, config.telegramPollIntervalMs, store, logger, true, getOpencodeTelegramCommands);
+        this.app = new OpencodeAppClient(config.opencodeCliBin, config.opencodeServerPassword, config.opencodeServerStatePath, config.opencodeServerLogPath, logger);
+        this.core = new OpencodeBridgeCore(config, store, logger, this.bot, this.app, new TelegramMessagingPort(this.bot));
+        this.core.registerInboundHandlers();
+    }
+    async start() {
+        await this.bot.initializeIdentity();
+        await this.core.start();
+    }
+    async stop() {
+        await this.core.stop();
+    }
+    getRuntimeStatus() {
+        return this.core.getRuntimeStatus();
+    }
+}

package/dist/store/database.d.ts

@@ -60,6 +60,7 @@ export declare class BridgeStore {
     } | null;
     getBinding(chatId: string): ThreadBinding | null;
     setBinding(chatId: string, threadId: string, cwd: string | null): void;
+    listBindings(): ThreadBinding[];
     clearBinding(chatId: string): void;
     getChatSettings(chatId: string): ChatSessionSettings | null;
     setChatSettings(chatId: string, model: string | null, reasoningEffort: ReasoningEffortValue | null, locale?: AppLocale | null): void;

package/dist/store/database.js

@@ -287,6 +287,15 @@ export class BridgeStore {
       ON CONFLICT(chat_id) DO UPDATE SET thread_id = excluded.thread_id, cwd = excluded.cwd, updated_at = excluded.updated_at
     `).run(chatId, threadId, cwd, Date.now());
     }
+    listBindings() {
+        const rows = this.db.prepare('SELECT chat_id, thread_id, cwd, updated_at FROM chat_bindings ORDER BY updated_at DESC').all();
+        return rows.map((row) => ({
+            chatId: String(row.chat_id),
+            threadId: String(row.thread_id),
+            cwd: row.cwd === null ? null : String(row.cwd),
+            updatedAt: Number(row.updated_at),
+        }));
+    }
     clearBinding(chatId) {
         this.db.prepare('DELETE FROM chat_bindings WHERE chat_id = ?').run(chatId);
     }

package/dist/telegram/gateway.d.ts

@@ -5,6 +5,10 @@ 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;
@@ -45,11 +49,12 @@ export declare class TelegramGateway extends EventEmitter {
     private readonly store;
     private readonly logger;
     private readonly namespacedScopes;
+    private readonly commandProvider;
     private running;
     private botKey;
     private botUsername;
     private botUserId;
-    constructor(botToken: string, allowedUserId: string, allowedChatId: string | null, pollIntervalMs: number, store: BridgeStore, logger: Logger, namespacedScopes?: boolean);
+    constructor(botToken: string, allowedUserId: string, allowedChatId: string | null, pollIntervalMs: number, store: BridgeStore, logger: Logger, namespacedScopes?: boolean, commandProvider?: TelegramCommandProvider);
     get username(): string | null;
     get identity(): string | null;
     initializeIdentity(): Promise<string>;

package/dist/telegram/gateway.js

@@ -12,11 +12,12 @@ export class TelegramGateway extends EventEmitter {
     store;
     logger;
     namespacedScopes;
+    commandProvider;
     running = false;
     botKey;
     botUsername = null;
     botUserId = null;
-    constructor(botToken, allowedUserId, allowedChatId, pollIntervalMs, store, logger, namespacedScopes = false) {
+    constructor(botToken, allowedUserId, allowedChatId, pollIntervalMs, store, logger, namespacedScopes = false, commandProvider = getTelegramCommands) {
         super();
         this.botToken = botToken;
         this.allowedUserId = allowedUserId;
@@ -25,6 +26,7 @@ export class TelegramGateway extends EventEmitter {
         this.store = store;
         this.logger = logger;
         this.namespacedScopes = namespacedScopes;
+        this.commandProvider = commandProvider;
         this.botKey = `telegram:${crypto.createHash('sha256').update(this.botToken).digest('hex').slice(0, 8)}`;
     }
     get username() {
@@ -224,14 +226,14 @@ export class TelegramGateway extends EventEmitter {
     }
     async registerCommands() {
         await callTelegramApi(this.botToken, 'setMyCommands', {
-            commands: getTelegramCommands('zh'),
+            commands: this.commandProvider('zh'),
         });
         await callTelegramApi(this.botToken, 'setMyCommands', {
-            commands: getTelegramCommands('en'),
+            commands: this.commandProvider('en'),
             language_code: 'en',
         });
         await callTelegramApi(this.botToken, 'setMyCommands', {
-            commands: getTelegramCommands('zh'),
+            commands: this.commandProvider('zh'),
             language_code: 'zh',
         });
     }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@foxden-app/foxclaw",
-  "version": "0.5.78",
-  "description": "Foxden local execution claw for controlling Codex from trusted chat interfaces.",
+  "version": "0.6.3",
+  "description": "Foxden local execution claw for controlling Codex and OpenCode from trusted chat interfaces.",
   "type": "module",
   "main": "dist/main.js",
   "bin": {
@@ -55,6 +55,7 @@
     "prepack": "npm run build"
   },
   "dependencies": {
+    "@opencode-ai/sdk": "1.18.15",
     "dotenv": "^16.6.1",
     "qrcode-terminal": "^0.12.0"
   },