@wu529778790/open-im 1.10.9-beta.21 → 1.10.9-beta.22

package/dist/adapters/opencode-adapter.d.ts

@@ -0,0 +1,10 @@
+/**
+ * OpenCode Adapter — run tasks through OpenCode CLI (`opencode run`)
+ */
+import type { RunCallbacks, RunHandle, RunOptions, ToolAdapter } from './tool-adapter.interface.js';
+export declare class OpenCodeAdapter implements ToolAdapter {
+    private cliPath;
+    readonly toolId = "opencode";
+    constructor(cliPath: string);
+    run(prompt: string, sessionId: string | undefined, workDir: string, callbacks: RunCallbacks, options?: RunOptions): RunHandle;
+}

package/dist/adapters/opencode-adapter.js

@@ -0,0 +1,45 @@
+/**
+ * OpenCode Adapter — run tasks through OpenCode CLI (`opencode run`)
+ */
+import { runOpenCode } from '../opencode/cli-runner.js';
+export class OpenCodeAdapter {
+    cliPath;
+    toolId = 'opencode';
+    constructor(cliPath) {
+        this.cliPath = cliPath;
+    }
+    run(prompt, sessionId, workDir, callbacks, options) {
+        return runOpenCode(this.cliPath, prompt, sessionId, workDir, {
+            onText: callbacks.onText,
+            onThinking: callbacks.onThinking,
+            onToolUse: callbacks.onToolUse,
+            onComplete: (raw) => {
+                const result = {
+                    success: raw.success,
+                    result: raw.result,
+                    accumulated: raw.accumulated,
+                    cost: raw.cost,
+                    durationMs: raw.durationMs,
+                    model: raw.model,
+                    numTurns: raw.numTurns,
+                    toolStats: raw.toolStats,
+                };
+                callbacks.onComplete(result);
+            },
+            onError: (err) => {
+                const msg = typeof err === 'string' ? err : String(err);
+                const friendly = msg.includes('session not found') ||
+                    msg.includes('Session not found') ||
+                    msg.includes('no sessions found')
+                    ? 'OpenCode 会话已失效，旧 session 已清理。请直接重试当前请求。'
+                    : msg;
+                callbacks.onError(friendly);
+            },
+            onSessionId: callbacks.onSessionId,
+            onSessionInvalid: callbacks.onSessionInvalid,
+        }, {
+            skipPermissions: options?.skipPermissions,
+            model: options?.model,
+        });
+    }
+}

package/dist/adapters/registry.js

@@ -2,6 +2,7 @@ import { getConfiguredAiCommands } from '../config.js';
 import { ClaudeSDKAdapter, configureClaudeSdkSessionIdle } from './claude-sdk-adapter.js';
 import { CodexAdapter } from './codex-adapter.js';
 import { CodeBuddyAdapter } from './codebuddy-adapter.js';
+import { OpenCodeAdapter } from './opencode-adapter.js';
 import { createLogger } from '../logger.js';
 import { destroyAllLiveChildren } from '../shared/process-kill.js';
 const log = createLogger('Registry');
@@ -24,6 +25,10 @@ export function initAdapters(config) {
             log.info('CodeBuddy CLI adapter enabled');
             adapters.set('codebuddy', new CodeBuddyAdapter(config.codebuddyCliPath));
         }
+        if (aiCommand === 'opencode') {
+            log.info('OpenCode CLI adapter enabled');
+            adapters.set('opencode', new OpenCodeAdapter(config.opencodeCliPath));
+        }
     }
 }
 export function getAdapter(aiCommand) {

package/dist/commands/handler.js

@@ -189,12 +189,13 @@ export class CommandHandler {
     }
     getAiVersion(aiCommand) {
         if (aiCommand === 'claude') {
-            // Claude 使用 SDK，返回 SDK 版本
             return Promise.resolve('SDK Mode');
         }
         const cmd = aiCommand === 'codex'
             ? this.deps.config.codexCliPath
-            : this.deps.config.codebuddyCliPath;
+            : aiCommand === 'opencode'
+                ? this.deps.config.opencodeCliPath
+                : this.deps.config.codebuddyCliPath;
         return new Promise((resolve) => {
             execFile(cmd, ['--version'], { timeout: 5000 }, (err, stdout) => {
                 resolve(err ? '未知' : (stdout?.toString().trim() || '未知'));

package/dist/config/types.d.ts

@@ -1,6 +1,6 @@
 import type { LogLevel } from '../logger.js';
 export type Platform = 'clawbot' | 'dingtalk' | 'feishu' | 'qq' | 'telegram' | 'wework' | 'workbuddy';
-export type AiCommand = 'claude' | 'codex' | 'codebuddy';
+export type AiCommand = 'claude' | 'codex' | 'codebuddy' | 'opencode';
 export interface Config {
     enabledPlatforms: Platform[];
     telegramBotToken?: string;
@@ -24,6 +24,7 @@ export interface Config {
     clawbotAllowedUserIds: string[];
     codexCliPath: string;
     codebuddyCliPath: string;
+    opencodeCliPath: string;
     /** Claude 访问 API 的代理（如 http://127.0.0.1:7890） */
     claudeProxy?: string;
     /** Codex 访问 chatgpt.com 的代理（如 http://127.0.0.1:7890） */
@@ -182,6 +183,9 @@ export interface FileToolCodex {
 export interface FileToolCodeBuddy {
     cliPath?: string;
 }
+export interface FileToolOpenCode {
+    cliPath?: string;
+}
 export interface FileConfig {
     telegramBotToken?: string;
     feishuAppId?: string;
@@ -203,6 +207,7 @@ export interface FileConfig {
         claude?: FileToolClaude;
         codex?: FileToolCodex;
         codebuddy?: FileToolCodeBuddy;
+        opencode?: FileToolOpenCode;
     };
     logDir?: string;
     logLevel?: LogLevel;

package/dist/config-web.js

@@ -351,6 +351,7 @@ function buildInitialPayload(file) {
             claudeProxy: file.tools?.claude?.proxy ?? "",
             codexCliPath: file.tools?.codex?.cliPath ?? "codex",
             codebuddyCliPath: file.tools?.codebuddy?.cliPath ?? "codebuddy",
+            opencodeCliPath: file.tools?.opencode?.cliPath ?? "opencode",
             codexProxy: file.tools?.codex?.proxy ?? "",
             codexApiKey: (() => {
                 if (process.env.OPENAI_API_KEY)
@@ -505,6 +506,7 @@ function createProbeConfig(values) {
         logLevel: "INFO",
         telemetry: { enabled: true },
         codebuddyCliPath: "codebuddy",
+        opencodeCliPath: "opencode",
         platforms: {},
         ...values,
     };
@@ -704,6 +706,10 @@ function toFileConfig(payload, existing) {
                 ...existing.tools?.codebuddy,
                 cliPath: clean(payload.ai.codebuddyCliPath) ?? "codebuddy",
             },
+            opencode: {
+                ...existing.tools?.opencode,
+                cliPath: clean(payload.ai.opencodeCliPath) ?? "opencode",
+            },
         },
         platforms: {
             ...existing.platforms,

package/dist/config.js

@@ -231,6 +231,8 @@ export function loadConfig() {
             }
         }
     }
+    const topencode = file.tools?.opencode ?? {};
+    const opencodeCliPath = process.env.OPENCODE_CLI_PATH ?? topencode.cliPath ?? 'opencode';
     const claudeWorkDir = process.env.CLAUDE_WORK_DIR ?? tc.workDir ?? process.cwd();
     const skipPermissions = process.env.OPEN_IM_SKIP_PERMISSIONS === 'false'
         ? false
@@ -563,6 +565,7 @@ export function loadConfig() {
         clawbotAllowedUserIds,
         codexCliPath,
         codebuddyCliPath,
+        opencodeCliPath,
         claudeProxy,
         codexProxy,
         claudeWorkDir,

package/dist/opencode/cli-runner.d.ts

@@ -0,0 +1,32 @@
+/**
+ * OpenCode CLI runner — spawns `opencode run` in non-interactive mode.
+ *
+ * OpenCode outputs plain text to stdout. Session continuation uses `-s <id>`.
+ */
+export interface OpenCodeRunCallbacks {
+    onText: (accumulated: string) => void;
+    onThinking?: (accumulated: string) => void;
+    onToolUse?: (toolName: string, toolInput?: Record<string, unknown>) => void;
+    onComplete: (result: {
+        success: boolean;
+        result: string;
+        accumulated: string;
+        cost: number;
+        durationMs: number;
+        model?: string;
+        numTurns: number;
+        toolStats: Record<string, number>;
+    }) => void;
+    onError: (error: string) => void;
+    onSessionId?: (sessionId: string) => void;
+    onSessionInvalid?: () => void;
+}
+export interface OpenCodeRunOptions {
+    skipPermissions?: boolean;
+    model?: string;
+}
+export interface OpenCodeRunHandle {
+    abort: () => void;
+}
+export declare function buildOpenCodeArgs(prompt: string, sessionId: string | undefined, workDir: string, options?: OpenCodeRunOptions): string[];
+export declare function runOpenCode(cliPath: string, prompt: string, sessionId: string | undefined, workDir: string, callbacks: OpenCodeRunCallbacks, options?: OpenCodeRunOptions): OpenCodeRunHandle;

package/dist/opencode/cli-runner.js

@@ -0,0 +1,161 @@
+/**
+ * OpenCode CLI runner — spawns `opencode run` in non-interactive mode.
+ *
+ * OpenCode outputs plain text to stdout. Session continuation uses `-s <id>`.
+ */
+import { spawn } from 'node:child_process';
+import { createInterface } from 'node:readline';
+import { createLogger } from '../logger.js';
+import { processEnvForNonClaudeCliChild } from '../config/file-io.js';
+import { killProcessTree, trackChild } from '../shared/process-kill.js';
+const log = createLogger('OpenCodeCli');
+export function buildOpenCodeArgs(prompt, sessionId, workDir, options) {
+    const args = ['run'];
+    // Working directory
+    args.push('--dir', workDir);
+    // Session continuation
+    if (sessionId) {
+        args.push('--session', sessionId);
+    }
+    // Model override
+    if (options?.model) {
+        args.push('--model', options.model);
+    }
+    // Skip permissions
+    if (options?.skipPermissions) {
+        args.push('--dangerously-skip-permissions');
+    }
+    // Prompt as positional argument
+    args.push(prompt);
+    return args;
+}
+export function runOpenCode(cliPath, prompt, sessionId, workDir, callbacks, options) {
+    const args = buildOpenCodeArgs(prompt, sessionId, workDir, options);
+    const env = processEnvForNonClaudeCliChild();
+    log.info(`Spawning OpenCode: path=${cliPath}, cwd=${workDir}, session=${sessionId ?? 'new'}`);
+    const child = spawn(cliPath, args, {
+        cwd: workDir,
+        detached: process.platform !== 'win32',
+        stdio: ['pipe', 'pipe', 'pipe'],
+        env,
+        windowsHide: process.platform === 'win32',
+    });
+    trackChild(child);
+    // Close stdin — prompt is passed as argument
+    child.stdin?.end();
+    let accumulated = '';
+    let completed = false;
+    const toolStats = {};
+    const startTime = Date.now();
+    const rl = createInterface({ input: child.stdout });
+    const MAX_STDERR_HEAD = 4 * 1024;
+    const MAX_STDERR_TAIL = 6 * 1024;
+    let stderrHead = '';
+    let stderrTail = '';
+    let stderrTotal = 0;
+    let stderrHeadFull = false;
+    child.stderr?.on('data', (chunk) => {
+        const text = chunk.toString();
+        stderrTotal += text.length;
+        if (!stderrHeadFull) {
+            const room = MAX_STDERR_HEAD - stderrHead.length;
+            if (room > 0) {
+                stderrHead += text.slice(0, room);
+                if (stderrHead.length >= MAX_STDERR_HEAD)
+                    stderrHeadFull = true;
+            }
+        }
+        stderrTail += text;
+        if (stderrTail.length > MAX_STDERR_TAIL) {
+            stderrTail = stderrTail.slice(-MAX_STDERR_TAIL);
+        }
+        log.debug(`[stderr] ${text.trimEnd()}`);
+    });
+    rl.on('line', (line) => {
+        if (completed)
+            return;
+        // OpenCode outputs plain text — accumulate each line
+        const trimmed = line.trim();
+        if (!trimmed)
+            return;
+        // Skip spinner lines (ANSI escape sequences or common spinner chars)
+        if (/^[⠀-⣿\s⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏▪●◆⬤◉⬤⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]+$/.test(trimmed))
+            return;
+        accumulated += (accumulated ? '\n' : '') + line;
+        callbacks.onText(accumulated);
+    });
+    // Also capture stdout as a raw stream for binary-like streaming
+    child.stdout?.on('data', (chunk) => {
+        // The readline interface handles line-by-line, but we also
+        // want to capture any partial data for streaming updates
+        const text = chunk.toString();
+        if (!completed && text.trim()) {
+            log.debug(`[stdout chunk] ${text.substring(0, 200)}`);
+        }
+    });
+    let exitCode = null;
+    let rlClosed = false;
+    let childClosed = false;
+    const finalize = () => {
+        if (!rlClosed || !childClosed)
+            return;
+        if (completed)
+            return;
+        if (exitCode !== null && exitCode !== 0) {
+            let errMsg = '';
+            if (stderrTotal > 0) {
+                if (!stderrHeadFull) {
+                    errMsg = stderrHead;
+                }
+                else if (stderrTotal <= MAX_STDERR_HEAD + MAX_STDERR_TAIL) {
+                    errMsg = stderrHead + stderrTail.slice(stderrTail.length - (stderrTotal - MAX_STDERR_HEAD));
+                }
+                else {
+                    errMsg =
+                        stderrHead +
+                            `\n\n... (omitted ${stderrTotal - MAX_STDERR_HEAD - MAX_STDERR_TAIL} bytes) ...\n\n` +
+                            stderrTail;
+                }
+            }
+            if (sessionId &&
+                (errMsg.includes('session not found') ||
+                    errMsg.includes('Session not found') ||
+                    errMsg.includes('no sessions found'))) {
+                callbacks.onSessionInvalid?.();
+            }
+            callbacks.onError(errMsg || `OpenCode exited with code ${exitCode}`);
+            return;
+        }
+        // Exit code 0 but no onComplete fired yet — treat accumulated text as result
+        if (!completed) {
+            completed = true;
+            callbacks.onComplete({
+                success: true,
+                result: accumulated,
+                accumulated,
+                cost: 0,
+                durationMs: Date.now() - startTime,
+                numTurns: 1,
+                toolStats,
+            });
+        }
+    };
+    rl.on('close', () => {
+        rlClosed = true;
+        finalize();
+    });
+    child.on('close', (code) => {
+        exitCode = code;
+        childClosed = true;
+        finalize();
+    });
+    child.on('error', (err) => {
+        log.error('OpenCode spawn error:', err);
+        callbacks.onError(`Failed to start OpenCode: ${err.message}`);
+    });
+    return {
+        abort: () => {
+            killProcessTree(child);
+        },
+    };
+}

package/dist/session/session-manager.d.ts

@@ -1,4 +1,4 @@
-type ToolId = 'claude' | 'codex' | 'codebuddy';
+type ToolId = 'claude' | 'codex' | 'codebuddy' | 'opencode';
 interface ConvHistoryEntry {
     convId: string;
     totalTurns: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wu529778790/open-im",
-  "version": "1.10.9-beta.21",
+  "version": "1.10.9-beta.22",
   "description": "Multi-platform IM bridge for AI CLI tools (Claude, Codex, CodeBuddy)",
   "type": "module",
   "main": "dist/index.js",