@foxden-app/foxclaw 0.5.78 → 0.6.3

package/.env.example

@@ -60,6 +60,17 @@ TELEGRAM_PREVIEW_THROTTLE_MS=800
 THREAD_LIST_LIMIT=10
 CODEX_CLI_BIN=/absolute/path/to/codex
 
+# Optional OpenCode bridge. This starts a second, independent Telegram bot
+# alongside every existing Codex runtime; never reuse a TG_BOT_TOKEN here.
+# FoxClaw manages a password-protected `opencode serve` bound to 127.0.0.1.
+# OPENCODE_BOT_TOKEN=<different_telegram_bot_token>
+# OPENCODE_CLI_BIN=/absolute/path/to/opencode
+# Optional fixed Basic Auth password. If omitted, FoxClaw generates one and
+# stores it with the managed server state (mode 0600).
+# OPENCODE_SERVER_PASSWORD=
+# OPENCODE_SERVER_STATE_PATH=
+# OPENCODE_SERVER_LOG_PATH=
+
 # Optional cross-node Codex auth sync.
 # Disabled by default. When enabled, FoxClaw uses Telegram Bot-to-Bot private
 # messages to move encrypted auth bundles between nodes. Enable Bot-to-Bot

package/CHANGELOG.md

@@ -2,6 +2,44 @@
 
 All notable FoxClaw changes are listed here. Each release note is bilingual so GitHub Releases and the npm package are useful to both Chinese and English readers.
 
+## 0.6.3 - 2026-08-09
+
+### 中文
+- 修复 Codex app-server 重启只终止 Node 包装进程、未终止同一 detached 进程组内原生 Codex 子进程的问题。认证刷新或手动重载后，不再遗留旧服务持有 thread writer lock 并触发 `already has an active writer`。
+- 托管服务关闭现在先向整个进程组发送 `SIGTERM`，超时后升级为 `SIGKILL`；强制终止后仍存活会明确失败并阻止新实例叠加启动。加入忽略 `SIGTERM` 的父子进程树回归测试。
+
+### English
+- Fixed Codex app-server restarts terminating only the Node wrapper while leaving the native Codex child alive in the same detached process group. Auth refreshes and manual reloads no longer leave an old server holding a thread writer lock and causing `already has an active writer`.
+- Managed shutdown now sends `SIGTERM` to the whole process group, escalates to `SIGKILL` on timeout, and fails explicitly instead of starting another instance if the group still survives. Added a regression test with a parent/child process tree that ignores `SIGTERM`.
+
+## 0.6.2 - 2026-08-09
+
+### 中文
+- 修复 OpenCode 流式刷新并发竞态：Telegram 首次发送尚未返回时，后续增量与结束事件会排队复用同一消息，不再把 `/home`、半截路径和最终路径拆成多条或重复发送；观察流和工具状态也使用同一串行保证。
+- `/models` 改为 OpenCode 原生习惯的 Provider → Model 两层选择；`/setup` 对齐 Codex Bot 的同消息交互，集中显示并切换模型、variant、Agent/单次 Plan、权限和运行中新消息策略。
+- 补齐可保持语义的菜单：原生 `/undo`/`redo`、`/review`、归档恢复，显式 `/steer`/`queue`/`takeover`，以及 Rich、Voice、MCP Apps、Plugins、Hooks、Features 和 Provider auth 状态。Codex 专属账户、配额、Goal、Remote、设备登录与升级协调入口保留在菜单中，并说明不可等价支持的原因和替代操作。
+
+### English
+- Fixed an OpenCode streaming race. When the first Telegram send is still pending, later deltas and completion now serialize onto the same message instead of emitting `/home`, partial paths, and duplicated final output. Watch streams and tool status use the same serialization guarantee.
+- Changed `/models` to a native-style two-level Provider → Model selector. `/setup` now matches the Codex bot's in-place interaction and centralizes model, variant, Agent/one-shot Plan, access, and active-message behavior.
+- Added every semantics-preserving menu path: native `/undo`/`redo`, `/review`, archive restore, explicit `/steer`/`queue`/`takeover`, Rich, Voice, MCP Apps, Plugins, Hooks, Features, and provider-auth status. Codex-only account, quota, Goal, Remote, device-login, and update-coordinator entries remain visible with precise limitations and replacement workflows.
+
+## 0.6.1 - 2026-08-09
+
+### 中文
+- 新增独立 `OPENCODE_BOT_TOKEN` runtime，在不替换、不降级现有 Codex Bot 的前提下，由 Telegram 驱动本机 `opencode serve` 会话。支持全局会话列表、编号打开、观察、历史、Fork、Diff、压缩、文件搜索、Skills、MCP、Provider 与安全配置摘要。
+- 对齐 OpenCode 1.18.15 当前 HTTP/SSE 契约：使用 `/global/health`、跨目录 `/global/event`、`permission.asked`、`question.asked` 以及当前 reply API；加入 SSE 重连、漏事件轮询兜底、崩溃后托管进程重连和跨目录待审批/提问恢复。
+- Telegram 体验覆盖流式消息合并、最终 Rich Markdown、工具进度清理、图片/文件附件、模型与 variant、Agent/单次 Plan、read-only/default/full-access、运行中 steer/queue、审批按钮和多问题回答。`/undo`、`/rollback` 明确不做语义近似。
+- `opencode serve` 只绑定 `127.0.0.1` 并强制 Basic Auth；未配置密码时自动生成，以 `0600` 写入状态文件。OpenCode 必须使用不同的 Telegram Bot token，`doctor` 会做 CLI 与 token 隔离检查。
+- `v0.6.0` 保留为被回退的干扰提交快照，因此实际新实现使用 `0.6.1`，不复用同一版本号。
+
+### English
+- Added an independent `OPENCODE_BOT_TOKEN` runtime that drives local `opencode serve` sessions from Telegram without replacing or reducing existing Codex bots. It covers global session listing, numbered open, watch, history, fork, diff, compaction, file search, skills, MCP, providers, and a redacted config summary.
+- Aligned with the current OpenCode 1.18.15 HTTP/SSE contract: `/global/health`, cross-directory `/global/event`, `permission.asked`, `question.asked`, and current reply endpoints. Added SSE reconnects, polling fallback, managed-process reattachment after crashes, and cross-directory pending-request recovery.
+- Added merged streaming, final Rich Markdown, transient tool progress, image/file attachments, models and variants, Agent/one-shot Plan, three access presets, active-turn steer/queue, approval buttons, and multi-question answers. `/undo` and `/rollback` explicitly avoid semantic approximation.
+- `opencode serve` binds only to `127.0.0.1` and always uses Basic Auth. FoxClaw generates a password when omitted and writes state with mode `0600`. OpenCode requires a separate Telegram bot token, and `doctor` checks both CLI availability and token isolation.
+- `v0.6.0` remains the tagged snapshot of the reverted interference commit, so the corrected implementation is versioned `0.6.1` instead of reusing the same release number.
+
 ## 0.5.78 - 2026-07-12
 
 ### 中文

package/README.md

@@ -4,7 +4,7 @@
 
 **狸爪：一个更适配编程需求的移动端 Codex 控制器。**
 
-FoxClaw（狸爪）的目标很直接：让你用手机控制本机的 Codex，把移动端变成一个真正能用的 web coding 入口。Telegram 或微信负责交互，`codex app-server` 负责本地执行；你发任务、看进度、批审批、切线程，Codex 在电脑上继续写代码。
+FoxClaw（狸爪）的目标很直接：让你用手机控制本机的 Codex 或 OpenCode，把移动端变成一个真正能用的 web coding 入口。Telegram 或微信负责交互，`codex app-server` / `opencode serve` 负责本地执行；你发任务、看进度、批审批、切线程，Agent 在电脑上继续写代码。
 
 这适合你离开办公桌去吃饭、在旅途中、在跑步机上，或者陪小孩逛公园的时候继续工作。人可以离开电脑，Codex 不必停；它会把关键进展、错误、审批请求和最终结果同步回手机。
 
@@ -120,6 +120,22 @@ FoxClaw 只响应 `TG_ALLOWED_USER_ID` 的消息——把机器人拉进群不
 
 </details>
 
+## OpenCode 独立 Bot（0.6.1+）
+
+现有 Codex Bot 不需要改。再向 `@BotFather` 创建一个独立机器人，把 token 写入：
+
+```dotenv
+OPENCODE_BOT_TOKEN=234567:different-opencode-bot-token
+# 可选；默认从 PATH 查找
+OPENCODE_CLI_BIN=/absolute/path/to/opencode
+```
+
+重启 FoxClaw 后，这个 Bot 会连接本机受 Basic Auth 保护、仅监听 `127.0.0.1` 的 `opencode serve`。未设置 `OPENCODE_SERVER_PASSWORD` 时，FoxClaw 自动生成密码并以 `0600` 保存到托管状态文件。`OPENCODE_BOT_TOKEN` 不能与 `TG_BOT_TOKENS` / `TG_BOT_TOKEN` 复用，否则两个 long-poll runtime 会争抢同一个 Telegram update。
+
+OpenCode Bot 保留与 Codex Bot 相同的主要操作习惯：直接发消息或附件、`/new`、`/threads` + `/open <编号>`、`/watch`、同消息内刷新的 `/setup`、Provider → Model 两层模型选择、variant、Agent/单次 Plan、三档权限、运行中 `/steer`/`/queue`/`/takeover`、流式合并、工具进度、审批按钮和问题选项。`/undo`/`/redo`、`/review` 与归档使用 OpenCode 原生 API；`/apps` 对应 MCP，Plugins、Hooks、Features 和语音入口也保持可用。Codex 账户、配额、Goal、Remote 和 Fast service tier 没有 OpenCode serve 等价 API，保留菜单入口并明确说明替代操作。
+
+OpenCode 自身的 Provider 登录仍在本机终端完成，例如 `opencode auth`。运行 `foxclaw doctor` 会在配置了 OpenCode Bot 时额外检查 OpenCode CLI 和 token 隔离。
+
 ## 多账号切换
 
 FoxClaw 的一大特色是自动多账号切换。当一个账号触发用量限制时，FoxClaw 会自动切换到下一个可用账号继续工作。

package/README_EN.md

@@ -4,7 +4,7 @@
 
 **A mobile Codex controller built for real programming workflows.**
 
-FoxClaw turns your phone into a practical web coding cockpit for your local Codex. Telegram or Weixin handles the chat interface, `codex app-server` handles local execution, and you can send tasks, inspect progress, approve actions, switch threads, and keep working without opening a laptop.
+FoxClaw turns your phone into a practical web coding cockpit for local Codex or OpenCode. Telegram or Weixin handles the chat interface, `codex app-server` / `opencode serve` handles local execution, and you can send tasks, inspect progress, approve actions, switch sessions, and keep working without opening a laptop.
 
 It is built for the moments when you leave your desk for lunch, commute, travel, use a treadmill, or take the kids to the park. You can step away from the keyboard while Codex keeps coding and sends progress, errors, approval requests, and final results back to your phone.
 
@@ -120,6 +120,22 @@ FoxClaw accepts messages only from `TG_ALLOWED_USER_ID`. Putting the bot in a gr
 
 </details>
 
+## Independent OpenCode Bot (0.6.1+)
+
+Your existing Codex bots remain unchanged. Create one more independent bot with `@BotFather` and configure:
+
+```dotenv
+OPENCODE_BOT_TOKEN=234567:different-opencode-bot-token
+# Optional; defaults to PATH lookup
+OPENCODE_CLI_BIN=/absolute/path/to/opencode
+```
+
+After FoxClaw restarts, this bot uses a managed `opencode serve` protected by Basic Auth and bound only to `127.0.0.1`. When `OPENCODE_SERVER_PASSWORD` is unset, FoxClaw generates one and saves it in the managed state file with mode `0600`. Never reuse a token from `TG_BOT_TOKENS` / `TG_BOT_TOKEN`, because two long-poll runtimes would compete for the same Telegram updates.
+
+The OpenCode bot preserves the main Codex-bot habits: plain messages and attachments, `/new`, `/threads` plus numbered `/open`, `/watch`, an in-place `/setup` panel, a two-level Provider → Model selector, variants, Agent/one-shot Plan, three access presets, active-turn `/steer`/`queue`/`takeover`, merged streaming, tool progress, approval buttons, and question options. `/undo`/`redo`, `/review`, and archive operations use native OpenCode APIs; `/apps` maps to MCP, while Plugins, Hooks, Features, and voice entry points remain available. Codex account, quota, Goal, Remote, and Fast service-tier commands have no OpenCode serve equivalent, so their menu entries explain the limitation and replacement workflow.
+
+Provider authentication remains an OpenCode terminal operation, such as `opencode auth`. When an OpenCode bot is configured, `foxclaw doctor` also checks the OpenCode CLI and token isolation.
+
 ## Multi-Account Rotation
 
 A key FoxClaw feature is automatic multi-account switching. When one account's usage limit is triggered, FoxClaw automatically switches to the next available account and continues working.

package/dist/codex_app/client.d.ts

@@ -176,4 +176,5 @@ export declare class CodexAppClient extends EventEmitter {
     private clearServerState;
     private clearServerStateForPid;
 }
+export declare function terminateManagedProcessGroup(pid: number, gracefulTimeoutMs?: number, forcedTimeoutMs?: number): Promise<'not-running' | 'terminated' | 'killed'>;
 export {};

package/dist/codex_app/client.js

@@ -710,24 +710,24 @@ export class CodexAppClient extends EventEmitter {
         const state = this.readServerState();
         const pid = child?.pid ?? state?.pid ?? null;
         this.child = null;
-        this.clearServerState();
-        if (pid === null || !isProcessAlive(pid)) {
+        if (pid === null || !isManagedProcessGroupAlive(pid)) {
+            this.clearServerState();
             return;
         }
         try {
-            process.kill(pid, 'SIGTERM');
+            const result = await terminateManagedProcessGroup(pid);
+            if (result === 'killed') {
+                this.logger.warn('codex.app-server.force_killed', { pid });
+            }
         }
         catch (error) {
             this.logger.warn('codex.app-server.kill_failed', {
                 pid,
                 error: error instanceof Error ? error.message : String(error),
             });
-            return;
-        }
-        const exited = await waitForProcessExit(pid, 3000);
-        if (!exited) {
-            this.logger.warn('codex.app-server.kill_timeout', { pid });
+            throw error;
         }
+        this.clearServerStateForPid(pid);
     }
     openServerLogFiles() {
         fs.mkdirSync(path.dirname(this.serverLogPath), { recursive: true });
@@ -831,15 +831,66 @@ function isProcessAlive(pid) {
         return error.code === 'EPERM';
     }
 }
-async function waitForProcessExit(pid, timeoutMs) {
+export async function terminateManagedProcessGroup(pid, gracefulTimeoutMs = 3000, forcedTimeoutMs = 2000) {
+    if (!isManagedProcessGroupAlive(pid)) {
+        return 'not-running';
+    }
+    signalManagedProcessGroup(pid, 'SIGTERM');
+    if (await waitForProcessGroupExit(pid, gracefulTimeoutMs)) {
+        return 'terminated';
+    }
+    signalManagedProcessGroup(pid, 'SIGKILL');
+    if (await waitForProcessGroupExit(pid, forcedTimeoutMs)) {
+        return 'killed';
+    }
+    throw new Error(`Codex app-server process group ${pid} did not exit after SIGKILL`);
+}
+function signalManagedProcessGroup(pid, signal) {
+    try {
+        process.kill(-pid, signal);
+    }
+    catch (error) {
+        if (error.code !== 'ESRCH') {
+            throw error;
+        }
+        try {
+            process.kill(pid, signal);
+        }
+        catch (fallbackError) {
+            if (fallbackError.code !== 'ESRCH') {
+                throw fallbackError;
+            }
+        }
+    }
+}
+function isManagedProcessGroupAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0) {
+        return false;
+    }
+    try {
+        process.kill(-pid, 0);
+        return true;
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === 'EPERM') {
+            return true;
+        }
+        if (code === 'ESRCH') {
+            return isProcessAlive(pid);
+        }
+        throw error;
+    }
+}
+async function waitForProcessGroupExit(pid, timeoutMs) {
     const started = Date.now();
     while (Date.now() - started < timeoutMs) {
-        if (!isProcessAlive(pid)) {
+        if (!isManagedProcessGroupAlive(pid)) {
             return true;
         }
         await sleep(100);
     }
-    return !isProcessAlive(pid);
+    return !isManagedProcessGroupAlive(pid);
 }
 function mapThread(raw) {
     return {

package/dist/config.d.ts

@@ -7,6 +7,8 @@ export declare const DEFAULT_LOG_PATH: string;
 export declare const DEFAULT_LOCK_PATH: string;
 export declare const DEFAULT_CODEX_APP_SERVER_STATE_PATH: string;
 export declare const DEFAULT_CODEX_APP_SERVER_LOG_PATH: string;
+export declare const DEFAULT_OPENCODE_SERVER_STATE_PATH: string;
+export declare const DEFAULT_OPENCODE_SERVER_LOG_PATH: string;
 export declare const DEFAULT_CODEX_TELEGRAM_HOME: string;
 export declare const DEFAULT_AUTH_SYNC_STATE_PATH: string;
 export declare const DEFAULT_AUTH_SYNC_TEMP_DIR: string;
@@ -35,6 +37,11 @@ export interface AppConfig {
     codexApiDefaultProvider: string | null;
     codexAppSyncOnOpen: boolean;
     codexAppSyncOnTurnComplete: boolean;
+    opencodeBotToken: string | null;
+    opencodeCliBin: string;
+    opencodeServerPassword: string | null;
+    opencodeServerStatePath: string;
+    opencodeServerLogPath: string;
     storePath: string;
     logLevel: LogLevel;
     defaultCwd: string;
@@ -93,6 +100,7 @@ export interface CodexApiProviderConfig {
 }
 export declare function loadConfig(): AppConfig;
 export declare function buildCodexApiProviderOverrides(providers: readonly CodexApiProviderConfig[], defaultProviderId?: string | null): string[];
+export declare function validateOpencodeBotToken(token: string | null, codexTokens: readonly string[]): void;
 export declare function parseCodexApiProviders(raw: string | undefined): CodexApiProviderConfig[];
 export declare function selectDefaultRuntimeBotToken(configuredTokens: string[], legacyToken: string | null): string | null;
 export declare function ensureAppDirs(config: AppConfig): void;

package/dist/config.js

@@ -10,6 +10,8 @@ export const DEFAULT_LOG_PATH = path.join(APP_HOME, 'logs', 'service.log');
 export const DEFAULT_LOCK_PATH = path.join(APP_HOME, 'runtime', 'bridge.lock');
 export const DEFAULT_CODEX_APP_SERVER_STATE_PATH = path.join(APP_HOME, 'runtime', 'codex-app-server.json');
 export const DEFAULT_CODEX_APP_SERVER_LOG_PATH = path.join(APP_HOME, 'logs', 'codex-app-server.log');
+export const DEFAULT_OPENCODE_SERVER_STATE_PATH = path.join(APP_HOME, 'runtime', 'opencode-server.json');
+export const DEFAULT_OPENCODE_SERVER_LOG_PATH = path.join(APP_HOME, 'logs', 'opencode-server.log');
 export const DEFAULT_CODEX_TELEGRAM_HOME = path.join(APP_HOME, 'codex', 'telegram');
 export const DEFAULT_AUTH_SYNC_STATE_PATH = path.join(APP_HOME, 'runtime', 'auth-sync.json');
 export const DEFAULT_AUTH_SYNC_TEMP_DIR = path.join(APP_HOME, 'runtime', 'auth-sync');
@@ -51,6 +53,8 @@ export function loadConfig() {
     if (tgBotTokens.length === 0) {
         throw new Error('TG_BOT_TOKENS or TG_BOT_TOKEN is required');
     }
+    const opencodeBotToken = optional('OPENCODE_BOT_TOKEN');
+    validateOpencodeBotToken(opencodeBotToken, tgBotTokens);
     const config = {
         tgBotToken: tgBotTokens[0],
         tgBotTokens,
@@ -72,6 +76,11 @@ export function loadConfig() {
         codexApiDefaultProvider: optionalSanitizedProviderId(process.env.CODEX_API_DEFAULT_PROVIDER),
         codexAppSyncOnOpen: boolEnv('CODEX_APP_SYNC_ON_OPEN', true),
         codexAppSyncOnTurnComplete: boolEnv('CODEX_APP_SYNC_ON_TURN_COMPLETE', false),
+        opencodeBotToken,
+        opencodeCliBin: process.env.OPENCODE_CLI_BIN || resolveCommand('opencode') || 'opencode',
+        opencodeServerPassword: optional('OPENCODE_SERVER_PASSWORD'),
+        opencodeServerStatePath: process.env.OPENCODE_SERVER_STATE_PATH || DEFAULT_OPENCODE_SERVER_STATE_PATH,
+        opencodeServerLogPath: process.env.OPENCODE_SERVER_LOG_PATH || DEFAULT_OPENCODE_SERVER_LOG_PATH,
         storePath: process.env.STORE_PATH || DEFAULT_STORE_PATH,
         logLevel: parseLogLevel(process.env.LOG_LEVEL || 'info'),
         defaultCwd: process.env.DEFAULT_CWD || process.cwd(),
@@ -140,6 +149,13 @@ export function buildCodexApiProviderOverrides(providers, defaultProviderId = nu
     }
     return overrides;
 }
+export function validateOpencodeBotToken(token, codexTokens) {
+    if (!token)
+        return;
+    if (codexTokens.includes(token)) {
+        throw new Error('OPENCODE_BOT_TOKEN must use a different bot from TG_BOT_TOKENS/TG_BOT_TOKEN');
+    }
+}
 export function parseCodexApiProviders(raw) {
     if (!raw?.trim())
         return [];
@@ -249,6 +265,8 @@ export function ensureAppDirs(config) {
         path.dirname(config.lockPath),
         path.dirname(config.codexAppServerStatePath),
         path.dirname(config.codexAppServerLogPath),
+        path.dirname(config.opencodeServerStatePath),
+        path.dirname(config.opencodeServerLogPath),
         path.dirname(config.authSyncStatePath),
     ];
     if (config.authSyncEnabled) {

package/dist/i18n.d.ts

@@ -1457,4 +1457,8 @@ export declare function getTelegramCommands(locale: AppLocale): Array<{
     command: string;
     description: string;
 }>;
+export declare function getOpencodeTelegramCommands(locale: AppLocale): Array<{
+    command: string;
+    description: string;
+}>;
 export {};

package/dist/i18n.js

@@ -1507,3 +1507,40 @@ export function getTelegramCommands(locale) {
         { command: 'interrupt', description: t(locale, 'cmd_desc_interrupt') },
     ];
 }
+export function getOpencodeTelegramCommands(locale) {
+    const descriptions = locale === 'zh' ? {
+        help: '查看命令', setup: 'OpenCode 设置', status: '桥接状态', update: '请改用 Codex Bot', threads: '最近会话', open: '打开会话',
+        watch: '观察会话', unwatch: '停止观察', new: '新建会话', models: '模型列表', model: '选择模型',
+        effort: '推理档位', fast: 'Fast 能力说明', mode: 'Agent 或 Plan', plan: '下一轮 Plan', agent: '选择 Agent', permissions: '权限设置',
+        active: '运行中新消息', steer: '引导当前回复', queue: '排队下一轮', takeover: '中断并接管',
+        history: '最近消息', files: '查找文件', fork: 'Fork 会话', undo: '原生回退', redo: '原生重做', rename: '重命名会话',
+        review: '原生代码审查', archive: '归档当前会话', unarchive: '恢复归档会话', rich: '富文本测试', voice: '朗读文本或发送语音',
+        diff: '会话文件变更', where: '当前会话信息', reveal: '当前会话信息', compact: '压缩上下文', loaded: '已加载会话', skills: 'OpenCode Skills',
+        mcp: 'MCP 状态', apps: 'MCP 应用', provider: '模型 Provider', auth: 'Provider 认证状态', auth_reload: '无 OpenCode 等价 API',
+        account: '无 OpenCode 账户 API', quota: '无 OpenCode 配额 API', login_device: '请用终端 opencode auth', goal: '无 OpenCode Goal 原语', remote: 'Codex Remote 专用',
+        plugins: 'OpenCode Plugins', hooks: 'Plugin hooks', features: '实验能力', config: '配置摘要', approve: '待审批', answer: '待回答', interrupt: '中断回复',
+    } : {
+        help: 'Show commands', setup: 'OpenCode settings', status: 'Bridge status', update: 'Use the Codex bot', threads: 'Recent sessions', open: 'Open a session',
+        watch: 'Watch a session', unwatch: 'Stop watching', new: 'New session', models: 'Model list', model: 'Select model',
+        effort: 'Reasoning variant', fast: 'Fast capability note', mode: 'Agent or Plan', plan: 'Plan next turn', agent: 'Select agent', permissions: 'Access settings',
+        active: 'Active-turn messages', steer: 'Steer active turn', queue: 'Queue next turn', takeover: 'Interrupt and take over',
+        history: 'Recent messages', files: 'Find files', fork: 'Fork session', undo: 'Native undo', redo: 'Native redo', rename: 'Rename session',
+        review: 'Native code review', archive: 'Archive current session', unarchive: 'Restore archived session', rich: 'Rich-text test', voice: 'Read text or send voice',
+        diff: 'Session file changes', where: 'Current session', reveal: 'Current session', compact: 'Compact context', loaded: 'Loaded sessions', skills: 'OpenCode skills',
+        mcp: 'MCP status', apps: 'MCP apps', provider: 'Model providers', auth: 'Provider auth status', auth_reload: 'No OpenCode equivalent',
+        account: 'No OpenCode account API', quota: 'No OpenCode quota API', login_device: 'Use opencode auth terminal', goal: 'No OpenCode Goal primitive', remote: 'Codex Remote only',
+        plugins: 'OpenCode plugins', hooks: 'Plugin hooks', features: 'Experimental capabilities', config: 'Config summary', approve: 'Pending approvals', answer: 'Pending questions', interrupt: 'Stop active turn',
+    };
+    const localized = descriptions;
+    const codexMenu = getTelegramCommands(locale).map((entry) => ({
+        command: entry.command,
+        description: localized[entry.command] ?? entry.description,
+    }));
+    const shared = new Set(codexMenu.map((entry) => entry.command));
+    return [
+        ...codexMenu,
+        ...Object.entries(localized)
+            .filter(([command]) => !shared.has(command))
+            .map(([command, description]) => ({ command, description })),
+    ];
+}

package/dist/main.js

@@ -552,7 +552,7 @@ function truncateStatusLine(value, maxLength) {
     return normalized.length <= maxLength ? normalized : `${normalized.slice(0, Math.max(0, maxLength - 1))}…`;
 }
 async function runServeCli() {
-    const [{ BridgeMessagingRouter }, { TelegramMessagingPort }, { WeixinChannelAdapter }, { WeixinMessagingPort }, { attachIlinkRuntimeFromBridgeLogger }, { loadWeixinAccount }, { Logger }, { BridgeStore }, { TelegramGateway }, { CodexAppClient }, { BridgeSessionCore }, { TelegramChannelAdapter }, { AuthCandidateMirror }, { CrossNodeAuthSync },] = await Promise.all([
+    const [{ BridgeMessagingRouter }, { TelegramMessagingPort }, { WeixinChannelAdapter }, { WeixinMessagingPort }, { attachIlinkRuntimeFromBridgeLogger }, { loadWeixinAccount }, { Logger }, { BridgeStore }, { TelegramGateway }, { CodexAppClient }, { BridgeSessionCore }, { TelegramChannelAdapter }, { AuthCandidateMirror }, { CrossNodeAuthSync }, { OpencodeTelegramRuntime },] = await Promise.all([
         import('./channels/bridge_messaging_router.js'),
         import('./channels/telegram/telegram_messaging_port.js'),
         import('./channels/weixin/weixin_channel_adapter.js'),
@@ -567,6 +567,7 @@ async function runServeCli() {
         import('./channels/telegram/telegram_channel_adapter.js'),
         import('./auth/mirror.js'),
         import('./auth/cross_node_sync.js'),
+        import('./opencode/runtime.js'),
     ]);
     const config = loadConfig();
     const logger = new Logger(config.logLevel, config.logPath);
@@ -581,8 +582,14 @@ async function runServeCli() {
     let managedApps = [];
     let activeAuthMirror = null;
     let activeAuthSync = null;
+    let activeOpencodeRuntime = null;
     try {
         store = new BridgeStore(config.storePath);
+        if (config.opencodeBotToken) {
+            activeOpencodeRuntime = new OpencodeTelegramRuntime(config, store, logger);
+            await activeOpencodeRuntime.start();
+            logger.info('opencode.bridge.started', activeOpencodeRuntime.getRuntimeStatus());
+        }
         if (config.tgMultiBotMode) {
             const seeds = [];
             const canonicalAuthDir = config.codexAuthDir ?? config.codexHome ?? path.join(os.homedir(), '.codex');
@@ -881,6 +888,7 @@ async function runServeCli() {
                 await weixinAdapter?.stop();
                 await activeWeixinCore?.stop();
                 await Promise.all(runtimes.map((runtime) => runtime.telegram.stop()));
+                await activeOpencodeRuntime?.stop();
                 writeAggregateStatus(false);
                 await Promise.all(managedApps.map((app) => app.stop({ terminateServer: true }).catch((error) => {
                     logger.warn('codex.app-server.stop_failed', { error: serializeError(error) });
@@ -1060,6 +1068,7 @@ async function runServeCli() {
             singleMirror?.stop();
             await weixinAdapter?.stop();
             await telegram.stop();
+            await activeOpencodeRuntime?.stop();
             writeRuntimeStatus(config.statusPath, {
                 running: false,
                 connected: false,
@@ -1093,6 +1102,7 @@ async function runServeCli() {
         await weixinAdapter?.stop().catch(() => { });
         await activeWeixinCore?.stop().catch(() => { });
         await Promise.allSettled(activeTelegramAdapters.map((adapter) => adapter.stop()));
+        await activeOpencodeRuntime?.stop().catch(() => { });
         await Promise.allSettled(managedApps.map((app) => app.stop({ terminateServer: true })));
         store?.close();
         processLock.release();
@@ -1778,6 +1788,15 @@ function runDoctorChecks() {
         ['telegram bot token(s) configured', Boolean(process.env.TG_BOT_TOKENS?.trim() || process.env.TG_BOT_TOKEN?.trim())],
         ['telegram allowed user configured', Boolean(process.env.TG_ALLOWED_USER_ID)],
     ];
+    if (process.env.OPENCODE_BOT_TOKEN?.trim()) {
+        const configuredOpencodeBin = process.env.OPENCODE_CLI_BIN;
+        checks.push(['opencode cli available', hasConfiguredCodexBin(configuredOpencodeBin) || hasCommand('opencode')]);
+        const codexTokens = [
+            ...(process.env.TG_BOT_TOKENS ?? '').split(','),
+            process.env.TG_BOT_TOKEN ?? '',
+        ].map((value) => value.trim()).filter(Boolean);
+        checks.push(['OpenCode uses an independent Telegram bot', !codexTokens.includes(process.env.OPENCODE_BOT_TOKEN.trim())]);
+    }
     if (process.env.WX_ENABLED === 'true' || process.env.WX_ENABLED === '1') {
         const accountsDir = process.env.WEIXIN_ACCOUNTS_DIR || path.join(APP_HOME, 'weixin', 'accounts');
         let hasAccounts = false;

package/dist/opencode/client.d.ts

@@ -0,0 +1,66 @@
+import { EventEmitter } from 'node:events';
+import { type OpencodeClient } from '@opencode-ai/sdk/v2';
+import type { Logger } from '../logger.js';
+import { type OpencodeBridgeEvent } from './events.js';
+export interface OpencodeServerRuntimeStatus {
+    pid: number | null;
+    port: number | null;
+    running: boolean;
+    connected: boolean;
+    url: string | null;
+    version: string | null;
+    managed: boolean;
+}
+export interface OpencodeAppClientEvents {
+    event: [event: OpencodeBridgeEvent];
+    connected: [];
+    disconnected: [detail: {
+        source: string;
+        message?: string;
+    }];
+}
+/** Owns one password-protected localhost `opencode serve` process. */
+export declare class OpencodeAppClient extends EventEmitter<OpencodeAppClientEvents> {
+    private readonly cliBin;
+    private readonly configuredPassword;
+    private readonly statePath;
+    private readonly logPath;
+    private readonly logger;
+    private readonly childEnv;
+    private readonly normalizer;
+    private client;
+    private child;
+    private serverState;
+    private connected;
+    private sseAbort;
+    private sseLoop;
+    private readonly pollers;
+    private desiredRunning;
+    private starting;
+    private reconnectTimer;
+    constructor(cliBin: string, configuredPassword: string | null, statePath: string, logPath: string, logger: Logger, childEnv?: NodeJS.ProcessEnv | null);
+    getClient(): OpencodeClient;
+    isConnected(): boolean;
+    getServerStatus(): OpencodeServerRuntimeStatus;
+    start(): Promise<void>;
+    stop(options?: {
+        terminateServer?: boolean;
+    }): Promise<void>;
+    restart(): Promise<void>;
+    watchSessionUntilIdle(sessionId: string, directory: string): void;
+    recoverPendingRequests(directories: readonly string[]): Promise<void>;
+    private pollSession;
+    private attachPersistedServer;
+    private spawnServer;
+    private adoptServer;
+    private startSseLoop;
+    private runSseLoop;
+    private acceptEvent;
+    private recoverPendingForDirectory;
+    private handleDisconnect;
+    private scheduleReconnect;
+    private writeState;
+    private readState;
+    private clearStateForPid;
+}
+export declare function formatSdkError(error: unknown): string;