@wu529778790/open-im 1.6.8-beta.2 → 1.6.9-alpha.0

package/README.md

@@ -59,10 +59,18 @@ The config file is stored at `~/.open-im/config.json` by default.
 
 ## Graphical Config Page
 
-- Default URL: `http://127.0.0.1:39282`
-- `open-im start` also serves the local configuration page
-- `open-im dev` only opens the page automatically when setup is incomplete
-- If configuration already exists and you want to open the page manually, use `open-im start`
+Open the config page at **http://127.0.0.1:39282** (or the URL shown after `open-im start`). The page includes:
+
+- **Dashboard** – Configured / Enabled platform count and service status (Idle or Running)
+- **Platforms** – Enable and configure Telegram, Feishu, QQ, WeCom, and DingTalk (credentials, proxy, per-platform AI tool, allowed user IDs). Each platform has a “Test Configuration” button.
+- **AI Tooling** – **General**: default AI tool (Claude / Codex / CodeBuddy), work directory, hook port, log level. **Per-tool tabs**: Claude (CLI path, timeout, proxy, config path, ANTHROPIC_* fields), Codex (CLI path, timeout, proxy), CodeBuddy (CLI path, timeout).
+- **Service control** – Validate config, Save, Start bridge, Stop bridge.
+
+WeChat is not in the web UI; configure it in `~/.open-im/config.json` or via `open-im init` if needed.
+
+- `open-im start` serves the config page and the bridge.
+- `open-im dev` opens the page automatically only when setup is incomplete.
+- To open the page when config already exists, run `open-im start` and visit the URL above.
 
 ## Session Behavior
 
@@ -267,7 +275,7 @@ Notes on DingTalk: the current implementation uses a hybrid model of "Stream Mod
 
 - Plain text replies in a session are sent through `sessionWebhook`
 - If `cardTemplateId` is configured, the app will try AI assistant `prepare/update/finish` streaming cards; if that fails, it falls back to plain text. In custom bot or regular group scenarios, the interactive card API may return `param.error`, so single-message streaming updates are not available there yet
-- Startup and shutdown notifications are sent to the most recently active DingTalk conversation. After a cold start, if no DingTalk conversation has interacted with the service yet, there is no target to notify
+- Startup and shutdown notifications are not sent to DingTalk (the OpenAPI robot API does not support proactive messages in the same way). Other platforms (e.g. Telegram, Feishu, WeCom) still receive lifecycle notifications when configured
 
 DingTalk AI card templates are already compatible with the official "Search Result Card" template and use the variables `lastMessage`, `content`, `resources`, `users`, and `flowStatus`. If you use that template, no template changes are required for streaming updates.
 

package/README.zh-CN.md

@@ -59,10 +59,18 @@ open-im start
 
 ## 图形化配置页面
 
-- 默认地址：`http://127.0.0.1:39282`
-- `open-im start` 会同时提供本地配置页面
+在浏览器中打开 **http://127.0.0.1:39282**（或执行 `open-im start` 后提示的地址），页面结构如下：
+
+- **概览** – 已配置/已启用平台数量、服务状态（未启动或运行中）
+- **平台配置** – 启用并填写 Telegram、飞书、QQ、企业微信、钉钉的凭证（Bot Token/App ID/Secret、代理、该平台使用的 AI 工具、白名单用户 ID）。每个平台提供「校验配置」按钮
+- **AI 工具配置** – **公共**：默认 AI 工具（Claude / Codex / CodeBuddy）、工作目录、Hook 端口、日志级别。**分工具**：Claude（CLI 路径、超时、代理、配置路径、ANTHROPIC_* 等）、Codex（CLI 路径、超时、代理）、CodeBuddy（CLI 路径、超时）
+- **服务控制** – 校验配置、保存、启动桥接、停止桥接
+
+微信暂不在网页中配置，如需使用请在 `~/.open-im/config.json` 中手动配置或通过 `open-im init` 引导。
+
+- `open-im start` 会同时启动桥接服务并提供该配置页
 - `open-im dev` 仅在未完成配置时自动打开页面
-- 已有配置但想手动打开时，使用 `open-im start`
+- 已有配置但想手动打开时，执行 `open-im start` 后访问上述地址即可
 
 ## 会话说明
 
@@ -267,7 +275,7 @@ codebuddy login
 
 - 会话内普通文本回复默认走 `sessionWebhook`
 - 若配置了 `cardTemplateId`，会尝试 AI 助理 `prepare/update/finish` 流式卡片；失败则 fallback 为普通文本（自定义机器人/普通群场景下互动卡片 API 报 `param.error`，暂不支持单条流式更新）
-- 启动/关闭通知会发给最近一次已互动的钉钉会话；如果服务冷启动后还没有任何钉钉会话互动过，则没有可用目标可发
+- 启动/关闭通知不会发给钉钉（OpenAPI 机器人接口不支持主动发消息）；其他已配置平台（如 Telegram、飞书、企业微信）仍会收到生命周期通知
 
 钉钉 AI 卡片模板：已适配官方「搜索结果卡片」模板，使用变量 `lastMessage`、`content`、`resources`、`users`、`flowStatus`。若使用该模板，无需修改模板即可实现流式更新。
 

package/dist/adapters/claude-cli-adapter.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Claude Code CLI Adapter - run tasks through Claude Code CLI (`claude -p`)
+ * Uses same permission hook as Codex; supports IM permission when hook is configured.
+ * usePersistentCLI 时采用 Happy 式：直连 spawn 真实 CLI（不用 wrapper），一会话用 -r 延续，stderr 推到 IM。
+ */
+import type { RunCallbacks, RunHandle, RunOptions, ToolAdapter } from './tool-adapter.interface.js';
+export declare class ClaudeCLIAdapter implements ToolAdapter {
+    private cliPath;
+    private usePersistentCLI;
+    readonly toolId = "claude-cli";
+    constructor(cliPath: string, usePersistentCLI?: boolean);
+    run(prompt: string, sessionId: string | undefined, workDir: string, callbacks: RunCallbacks, options?: RunOptions): RunHandle;
+}

package/dist/adapters/claude-cli-adapter.js

@@ -0,0 +1,56 @@
+/**
+ * Claude Code CLI Adapter - run tasks through Claude Code CLI (`claude -p`)
+ * Uses same permission hook as Codex; supports IM permission when hook is configured.
+ * usePersistentCLI 时采用 Happy 式：直连 spawn 真实 CLI（不用 wrapper），一会话用 -r 延续，stderr 推到 IM。
+ */
+import { runClaudeCLI } from '../claude-cli/cli-runner.js';
+export class ClaudeCLIAdapter {
+    cliPath;
+    usePersistentCLI;
+    toolId = 'claude-cli';
+    constructor(cliPath, usePersistentCLI = false) {
+        this.cliPath = cliPath;
+        this.usePersistentCLI = usePersistentCLI;
+    }
+    run(prompt, sessionId, workDir, callbacks, options) {
+        const opts = {
+            skipPermissions: options?.skipPermissions,
+            permissionMode: options?.permissionMode,
+            timeoutMs: options?.timeoutMs,
+            model: options?.model,
+            chatId: options?.chatId,
+            hookPort: options?.hookPort,
+        };
+        const claudeCallbacks = {
+            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('Authentication') || msg.includes('login') || msg.includes('auth')
+                    ? 'Claude CLI 需要先登录。请在终端运行 claude auth login。'
+                    : msg.includes('not found') || msg.includes('ENOENT')
+                        ? '未找到 Claude CLI，请安装并确保在 PATH 中（如 npm i -g @anthropic-ai/claude-code）。'
+                        : msg;
+                callbacks.onError(friendly);
+            },
+            onSessionId: callbacks.onSessionId,
+            onSessionInvalid: callbacks.onSessionInvalid,
+            onStderr: callbacks.onStderr,
+        };
+        return runClaudeCLI(this.cliPath, prompt, sessionId, workDir, claudeCallbacks, opts);
+    }
+}

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

@@ -1,7 +1,8 @@
 import type { RunCallbacks, RunHandle, RunOptions, ToolAdapter } from './tool-adapter.interface.js';
 export declare class CodeBuddyAdapter implements ToolAdapter {
     private cliPath;
+    private usePersistentCLI;
     readonly toolId = "codebuddy";
-    constructor(cliPath: string);
+    constructor(cliPath: string, usePersistentCLI?: boolean);
     run(prompt: string, sessionId: string | undefined, workDir: string, callbacks: RunCallbacks, options?: RunOptions): RunHandle;
 }

package/dist/adapters/codebuddy-adapter.js

@@ -1,12 +1,14 @@
 import { runCodeBuddy } from '../codebuddy/cli-runner.js';
 export class CodeBuddyAdapter {
     cliPath;
+    usePersistentCLI;
     toolId = 'codebuddy';
-    constructor(cliPath) {
+    constructor(cliPath, usePersistentCLI = false) {
         this.cliPath = cliPath;
+        this.usePersistentCLI = usePersistentCLI;
     }
     run(prompt, sessionId, workDir, callbacks, options) {
-        return runCodeBuddy(this.cliPath, prompt, sessionId, workDir, {
+        const codebuddyCallbacks = {
             onText: callbacks.onText,
             onThinking: callbacks.onThinking,
             onToolUse: callbacks.onToolUse,
@@ -37,11 +39,34 @@ export class CodeBuddyAdapter {
             },
             onSessionId: callbacks.onSessionId,
             onSessionInvalid: callbacks.onSessionInvalid,
-        }, {
+            onStderr: callbacks.onStderr,
+        };
+        const opts = {
             skipPermissions: options?.skipPermissions,
             permissionMode: options?.permissionMode,
             timeoutMs: options?.timeoutMs,
             model: options?.model,
-        });
+        };
+        return runCodeBuddy(this.cliPath, prompt, sessionId, workDir, {
+            onText: codebuddyCallbacks.onText,
+            onThinking: codebuddyCallbacks.onThinking,
+            onToolUse: codebuddyCallbacks.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: codebuddyCallbacks.onError,
+            onSessionId: codebuddyCallbacks.onSessionId,
+            onSessionInvalid: codebuddyCallbacks.onSessionInvalid,
+        }, opts);
     }
 }

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

@@ -1,10 +1,12 @@
 /**
  * Codex Adapter - run tasks through OpenAI Codex CLI (`codex exec`)
+ * usePersistentCLI 时采用 Happy 式：直连 spawn 真实 CLI（不用 wrapper），一会话用 --resume 延续，stderr 推到 IM。
  */
 import type { RunCallbacks, RunHandle, RunOptions, ToolAdapter } from "./tool-adapter.interface.js";
 export declare class CodexAdapter implements ToolAdapter {
     private cliPath;
+    private usePersistentCLI;
     readonly toolId = "codex";
-    constructor(cliPath: string);
+    constructor(cliPath: string, usePersistentCLI?: boolean);
     run(prompt: string, sessionId: string | undefined, workDir: string, callbacks: RunCallbacks, options?: RunOptions): RunHandle;
 }

package/dist/adapters/codex-adapter.js

@@ -1,12 +1,15 @@
 /**
  * Codex Adapter - run tasks through OpenAI Codex CLI (`codex exec`)
+ * usePersistentCLI 时采用 Happy 式：直连 spawn 真实 CLI（不用 wrapper），一会话用 --resume 延续，stderr 推到 IM。
  */
 import { runCodex } from "../codex/cli-runner.js";
 export class CodexAdapter {
     cliPath;
+    usePersistentCLI;
     toolId = "codex";
-    constructor(cliPath) {
+    constructor(cliPath, usePersistentCLI = false) {
         this.cliPath = cliPath;
+        this.usePersistentCLI = usePersistentCLI;
     }
     run(prompt, sessionId, workDir, callbacks, options) {
         const opts = {
@@ -18,7 +21,7 @@ export class CodexAdapter {
             hookPort: options?.hookPort,
             proxy: options?.proxy,
         };
-        return runCodex(this.cliPath, prompt, sessionId, workDir, {
+        const codexCallbacks = {
             onText: callbacks.onText,
             onThinking: callbacks.onThinking,
             onToolUse: callbacks.onToolUse,
@@ -54,6 +57,8 @@ export class CodexAdapter {
             },
             onSessionId: callbacks.onSessionId,
             onSessionInvalid: callbacks.onSessionInvalid,
-        }, opts);
+            onStderr: callbacks.onStderr,
+        };
+        return runCodex(this.cliPath, prompt, sessionId, workDir, codexCallbacks, opts);
     }
 }

package/dist/adapters/registry.js

@@ -1,6 +1,6 @@
 import { getConfiguredAiCommands } from '../config.js';
-import { ClaudeAdapter } from './claude-adapter.js';
 import { ClaudeSDKAdapter } from './claude-sdk-adapter.js';
+import { ClaudeCLIAdapter } from './claude-cli-adapter.js';
 import { CodexAdapter } from './codex-adapter.js';
 import { CodeBuddyAdapter } from './codebuddy-adapter.js';
 import { createLogger } from '../logger.js';
@@ -10,27 +10,24 @@ export function initAdapters(config) {
     adapters.clear();
     for (const aiCommand of getConfiguredAiCommands(config)) {
         if (aiCommand === 'claude') {
-            if (config.useSdkMode) {
-                log.info('Claude Agent SDK adapter enabled');
-                adapters.set('claude', new ClaudeSDKAdapter());
+            if (config.claudeUseCLI) {
+                log.info(config.usePersistentCLI ? 'Claude CLI adapter enabled (Happy-style: direct spawn, session resume)' : 'Claude CLI adapter enabled (IM permission + console output)');
+                adapters.set('claude', new ClaudeCLIAdapter(config.claudeCliPath, config.usePersistentCLI));
             }
             else {
-                log.info('Claude CLI adapter enabled');
-                adapters.set('claude', new ClaudeAdapter(config.claudeCliPath, {
-                    useProcessPool: true,
-                    idleTimeoutMs: 2 * 60 * 1000,
-                }));
+                log.info('Claude Agent SDK adapter enabled');
+                adapters.set('claude', new ClaudeSDKAdapter());
             }
             continue;
         }
         if (aiCommand === 'codex') {
-            log.info('Codex CLI adapter enabled');
-            adapters.set('codex', new CodexAdapter(config.codexCliPath));
+            log.info(config.usePersistentCLI ? 'Codex CLI adapter enabled (Happy-style: direct spawn, session resume)' : 'Codex CLI adapter enabled');
+            adapters.set('codex', new CodexAdapter(config.codexCliPath, config.usePersistentCLI));
             continue;
         }
         if (aiCommand === 'codebuddy') {
-            log.info('CodeBuddy CLI adapter enabled');
-            adapters.set('codebuddy', new CodeBuddyAdapter(config.codebuddyCliPath));
+            log.info(config.usePersistentCLI ? 'CodeBuddy CLI adapter enabled (Happy-style: direct spawn, session resume)' : 'CodeBuddy CLI adapter enabled');
+            adapters.set('codebuddy', new CodeBuddyAdapter(config.codebuddyCliPath, config.usePersistentCLI));
         }
     }
 }
@@ -38,7 +35,6 @@ export function getAdapter(aiCommand) {
     return adapters.get(aiCommand);
 }
 export function cleanupAdapters() {
-    ClaudeAdapter.destroy();
     ClaudeSDKAdapter.destroy();
     adapters.clear();
 }

package/dist/adapters/tool-adapter.interface.d.ts

@@ -20,10 +20,12 @@ export interface RunCallbacks {
     onSessionId?: (sessionId: string) => void;
     /** SDK 报 "No conversation found" 时调用，用于清除无效 session */
     onSessionInvalid?: () => void;
+    /** 常驻 CLI 模式：子进程 stderr（日志等）可推到 IM 展示 */
+    onStderr?: (data: string) => void;
 }
 export interface RunOptions {
     skipPermissions?: boolean;
-    /** Claude --permission-mode: default | acceptEdits | plan（yolo 时用 skipPermissions） */
+    /** Claude --permission-mode: default | acceptEdits | plan（bypassPermissions 时用 skipPermissions） */
     permissionMode?: 'default' | 'acceptEdits' | 'plan';
     timeoutMs?: number;
     model?: string;

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

@@ -0,0 +1,44 @@
+/**
+ * Claude Code CLI runner - spawn `claude -p` with hook for IM permission.
+ * Uses same permission-server as Codex; supports --permission-mode and HTTP PermissionRequest hook via --settings.
+ */
+export interface ClaudeCLIRunCallbacks {
+    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;
+    onStderr?: (data: string) => void;
+}
+export interface ClaudeCLIRunOptions {
+    skipPermissions?: boolean;
+    permissionMode?: 'default' | 'acceptEdits' | 'plan';
+    timeoutMs?: number;
+    model?: string;
+    chatId?: string;
+    hookPort?: number;
+}
+export interface ClaudeCLIRunHandle {
+    abort: () => void;
+}
+/** 供常驻包装进程使用：返回 spawn 参数（prompt 已在 args 中）。调用方需在 turn 结束后 unlink settingsPath。 */
+export interface ClaudeCLISpawnPayload {
+    executable: string;
+    args: string[];
+    cwd: string;
+    env: Record<string, string>;
+    settingsPath?: string;
+}
+export declare function buildClaudeSpawnPayload(cliPath: string, prompt: string, sessionId: string | undefined, workDir: string, options?: ClaudeCLIRunOptions): ClaudeCLISpawnPayload;
+export declare function runClaudeCLI(cliPath: string, prompt: string, sessionId: string | undefined, workDir: string, callbacks: ClaudeCLIRunCallbacks, options?: ClaudeCLIRunOptions): ClaudeCLIRunHandle;

package/dist/claude-cli/cli-runner.js

@@ -0,0 +1,172 @@
+/**
+ * Claude Code CLI runner - spawn `claude -p` with hook for IM permission.
+ * Uses same permission-server as Codex; supports --permission-mode and HTTP PermissionRequest hook via --settings.
+ */
+import { spawn } from 'node:child_process';
+import { writeFileSync, mkdirSync, unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+import { createLogger } from '../logger.js';
+import { tmpdir } from 'node:os';
+const log = createLogger('ClaudeCLI');
+const MAX_TIMEOUT_MS = 2_147_483_647;
+function buildClaudeArgs(prompt, sessionId, workDir, options) {
+    const args = ['-p', '--output-format', 'text'];
+    if (options?.model) {
+        args.push('--model', options.model);
+    }
+    if (options?.skipPermissions) {
+        args.push('--dangerously-skip-permissions');
+    }
+    else if (options?.permissionMode === 'plan') {
+        args.push('--permission-mode', 'plan');
+    }
+    else if (options?.permissionMode === 'acceptEdits') {
+        args.push('--permission-mode', 'acceptEdits');
+    }
+    else {
+        args.push('--permission-mode', 'default');
+    }
+    if (sessionId) {
+        args.push('-r', sessionId);
+    }
+    let settingsPath;
+    if (options?.chatId && options?.hookPort && !options?.skipPermissions) {
+        const baseDir = join(tmpdir(), 'open-im-claude-hooks');
+        mkdirSync(baseDir, { recursive: true });
+        settingsPath = join(baseDir, `hook-${Date.now()}-${Math.random().toString(36).slice(2, 10)}.json`);
+        const hookUrl = `http://127.0.0.1:${options.hookPort}/permission?chatId=${encodeURIComponent(options.chatId)}`;
+        const settings = {
+            hooks: {
+                PermissionRequest: [
+                    {
+                        matcher: '*',
+                        hooks: [{ type: 'http', url: hookUrl }],
+                    },
+                ],
+            },
+        };
+        writeFileSync(settingsPath, JSON.stringify(settings), 'utf-8');
+        args.push('--settings', settingsPath);
+    }
+    args.push(prompt);
+    return { args, settingsPath };
+}
+export function buildClaudeSpawnPayload(cliPath, prompt, sessionId, workDir, options) {
+    const { args, settingsPath } = buildClaudeArgs(prompt, sessionId, workDir, options);
+    const env = {};
+    for (const [k, v] of Object.entries(process.env)) {
+        if (v !== undefined)
+            env[k] = v;
+    }
+    return { executable: cliPath, args, cwd: workDir, env, settingsPath };
+}
+export function runClaudeCLI(cliPath, prompt, sessionId, workDir, callbacks, options) {
+    const payload = buildClaudeSpawnPayload(cliPath, prompt, sessionId, workDir, options);
+    const { executable, args, cwd: workDirResolved, env, settingsPath } = payload;
+    const timeoutMs = options?.timeoutMs && options.timeoutMs > 0
+        ? Math.min(options.timeoutMs, MAX_TIMEOUT_MS)
+        : 600_000;
+    log.info(`Spawning Claude CLI: path=${cliPath}, cwd=${workDirResolved}, session=${sessionId ?? 'new'}`);
+    const child = spawn(executable, args, {
+        cwd: workDirResolved,
+        stdio: ['pipe', 'pipe', 'pipe'],
+        env,
+        windowsHide: process.platform === 'win32',
+    });
+    let accumulated = '';
+    let completed = false;
+    const toolStats = {};
+    const startTime = Date.now();
+    let timeoutHandle = null;
+    const clearTimers = () => {
+        if (timeoutHandle) {
+            clearTimeout(timeoutHandle);
+            timeoutHandle = null;
+        }
+    };
+    const failAndTerminate = (message) => {
+        if (completed)
+            return;
+        completed = true;
+        clearTimers();
+        if (settingsPath) {
+            try {
+                unlinkSync(settingsPath);
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        if (!child.killed)
+            child.kill('SIGTERM');
+        callbacks.onError(message);
+    };
+    timeoutHandle = setTimeout(() => {
+        if (!completed && !child.killed) {
+            failAndTerminate(`执行超时（${timeoutMs}ms），已终止进程`);
+        }
+    }, timeoutMs);
+    child.stdout?.on('data', (chunk) => {
+        const text = chunk.toString();
+        accumulated += text;
+        callbacks.onText(accumulated);
+    });
+    let stderrBuf = '';
+    child.stderr?.on('data', (chunk) => {
+        const text = chunk.toString();
+        stderrBuf += text;
+        callbacks.onStderr?.(text);
+        log.debug(`[Claude CLI stderr] ${text.trimEnd()}`);
+    });
+    child.on('close', (code) => {
+        clearTimers();
+        if (settingsPath) {
+            try {
+                unlinkSync(settingsPath);
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        if (completed)
+            return;
+        completed = true;
+        if (code !== 0 && code !== null) {
+            const errMsg = stderrBuf ||
+                `Claude CLI exited with code ${code}`;
+            if (sessionId &&
+                (errMsg.includes('No session found') ||
+                    errMsg.includes('No conversation found') ||
+                    (errMsg.includes('session') && errMsg.includes('not found')))) {
+                callbacks.onSessionInvalid?.();
+            }
+            callbacks.onError(errMsg);
+            return;
+        }
+        callbacks.onComplete({
+            success: true,
+            result: accumulated,
+            accumulated,
+            cost: 0,
+            durationMs: Date.now() - startTime,
+            numTurns: 0,
+            toolStats,
+        });
+    });
+    child.on('error', (err) => {
+        log.error(`Claude CLI spawn error: ${err.message}`);
+        clearTimers();
+        if (!completed) {
+            completed = true;
+            callbacks.onError(`Failed to start Claude CLI: ${err.message}`);
+        }
+    });
+    return {
+        abort: () => {
+            completed = true;
+            clearTimers();
+            if (!child.killed)
+                child.kill('SIGTERM');
+        },
+    };
+}

package/dist/cli-persistent/claude-cli-persistent-runner.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Claude CLI 常驻运行器：通过包装进程维持一会话一进程，全量监听 stdout/stderr 并推到 IM。
+ * Claude 的 prompt 在 args 中，wrapper 发送空 prompt 即可。
+ */
+import { type ClaudeCLIRunCallbacks, type ClaudeCLIRunHandle, type ClaudeCLIRunOptions } from '../claude-cli/cli-runner.js';
+export declare function runClaudeCLIPersistent(cliPath: string, prompt: string, sessionId: string | undefined, workDir: string, callbacks: ClaudeCLIRunCallbacks, options?: ClaudeCLIRunOptions): ClaudeCLIRunHandle;

package/dist/cli-persistent/claude-cli-persistent-runner.js

@@ -0,0 +1,108 @@
+/**
+ * Claude CLI 常驻运行器：通过包装进程维持一会话一进程，全量监听 stdout/stderr 并推到 IM。
+ * Claude 的 prompt 在 args 中，wrapper 发送空 prompt 即可。
+ */
+import { unlinkSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createLogger } from '../logger.js';
+import { buildClaudeSpawnPayload, } from '../claude-cli/cli-runner.js';
+import { getOrCreatePersistentSession } from './session.js';
+import { END_PROMPT, TURN_DONE } from './cli-wrapper.js';
+const log = createLogger('ClaudeCLIPersistent');
+const DEFAULT_IDLE_MS = 10 * 60 * 1000;
+function getWrapperPath() {
+    const __dirname = dirname(fileURLToPath(import.meta.url));
+    const inDist = __dirname.includes('dist');
+    const ext = inDist ? 'js' : 'ts';
+    const wrapperPath = join(__dirname, `cli-wrapper.${ext}`);
+    if (inDist) {
+        return { command: process.execPath, args: [wrapperPath] };
+    }
+    return { command: 'npx', args: ['tsx', wrapperPath] };
+}
+export function runClaudeCLIPersistent(cliPath, prompt, sessionId, workDir, callbacks, options) {
+    const payload = buildClaudeSpawnPayload(cliPath, prompt, sessionId, workDir, options);
+    const settingsPath = payload.settingsPath;
+    const sessionKey = `claude-cli:${workDir}:${sessionId ?? 'new'}`;
+    let currentCallbacks = callbacks;
+    let turnDone = false;
+    let aborted = false;
+    let stdoutBuffer = '';
+    const startTime = Date.now();
+    const callbacksGetter = {
+        getCallbacks: () => {
+            const c = currentCallbacks;
+            return c
+                ? {
+                    onStdout(data) {
+                        if (aborted || !c)
+                            return;
+                        stdoutBuffer += data;
+                        const idx = stdoutBuffer.indexOf(TURN_DONE);
+                        if (idx >= 0) {
+                            const before = stdoutBuffer.slice(0, idx).trimEnd();
+                            turnDone = true;
+                            c.onComplete({
+                                success: true,
+                                result: before,
+                                accumulated: before,
+                                cost: 0,
+                                durationMs: Date.now() - startTime,
+                                numTurns: 0,
+                                toolStats: {},
+                            });
+                            currentCallbacks = undefined;
+                            if (settingsPath) {
+                                try {
+                                    unlinkSync(settingsPath);
+                                }
+                                catch {
+                                    /* ignore */
+                                }
+                            }
+                        }
+                        else {
+                            c.onText(stdoutBuffer);
+                        }
+                    },
+                    onStderr(data) {
+                        currentCallbacks?.onStderr?.(data);
+                    },
+                }
+                : undefined;
+        },
+    };
+    const wrapper = getWrapperPath();
+    const session = getOrCreatePersistentSession(sessionKey, {
+        command: wrapper.command,
+        args: wrapper.args,
+        cwd: workDir,
+        idleTimeoutMs: options?.timeoutMs && options.timeoutMs > 0 ? options.timeoutMs : DEFAULT_IDLE_MS,
+    }, callbacksGetter);
+    const payloadLine = JSON.stringify({
+        executable: payload.executable,
+        args: payload.args,
+        cwd: payload.cwd,
+        env: payload.env,
+    });
+    session.writeStdin(payloadLine + '\n' + END_PROMPT + '\n');
+    log.info(`Claude CLI persistent turn sent for sessionKey=${sessionKey}`);
+    return {
+        abort: () => {
+            aborted = true;
+            if (settingsPath) {
+                try {
+                    unlinkSync(settingsPath);
+                }
+                catch {
+                    /* ignore */
+                }
+            }
+            if (!turnDone && currentCallbacks) {
+                currentCallbacks.onError('已取消');
+                currentCallbacks = undefined;
+            }
+        },
+    };
+}

package/dist/cli-persistent/cli-wrapper.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 常驻 CLI 包装进程（Happy 同构）
+ *
+ * 从 stdin 读取「首行 JSON (spawn 参数) + prompt 至 <<<END_PROMPT>>>」，
+ * 对每个 prompt spawn 子进程、转发 stdout/stderr，子进程退出后写 TURN_DONE，再读下一轮。
+ * 桥接层只需维持本进程，即可实现「一直监听」并把所有控制台输出推到 IM。
+ */
+export declare const END_PROMPT = "<<<END_PROMPT>>>";
+export declare const TURN_DONE = "TURN_DONE";