@wu529778790/open-im 1.6.8-beta.2 → 1.6.9-beta.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/registry.js

@@ -1,5 +1,4 @@
 import { getConfiguredAiCommands } from '../config.js';
-import { ClaudeAdapter } from './claude-adapter.js';
 import { ClaudeSDKAdapter } from './claude-sdk-adapter.js';
 import { CodexAdapter } from './codex-adapter.js';
 import { CodeBuddyAdapter } from './codebuddy-adapter.js';
@@ -10,17 +9,8 @@ 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());
-            }
-            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') {
@@ -38,7 +28,6 @@ export function getAdapter(aiCommand) {
     return adapters.get(aiCommand);
 }
 export function cleanupAdapters() {
-    ClaudeAdapter.destroy();
     ClaudeSDKAdapter.destroy();
     adapters.clear();
 }

package/dist/config-web-page-script.js

@@ -667,7 +667,6 @@ export const PAGE_SCRIPT = String.raw `      const platformDefinitions = [
           codebuddyCliPath: getValue("ai-codebuddyCliPath"),
           hookPort: getNumber("ai-hookPort"),
           logLevel: getValue("ai-logLevel"),
-          useSdkMode: true,
         },
       });
 

package/dist/config-web.js

@@ -153,7 +153,6 @@ function buildInitialPayload(file) {
             hookPort: file.hookPort ?? 35801,
             logDir: file.logDir ?? "",
             logLevel: file.logLevel ?? "default",
-            useSdkMode: file.useSdkMode ?? true,
         },
     };
 }
@@ -277,7 +276,6 @@ function createProbeConfig(values) {
         hookPort: 35801,
         logDir: "",
         logLevel: "INFO",
-        useSdkMode: true,
         codebuddyCliPath: "codebuddy",
         platforms: {},
         ...values,
@@ -405,7 +403,6 @@ function toFileConfig(payload, existing) {
         hookPort: payload.ai.hookPort,
         logDir: payload.ai.logDir === undefined ? existing.logDir : clean(payload.ai.logDir),
         logLevel: payload.ai.logLevel === "default" ? undefined : payload.ai.logLevel,
-        useSdkMode: payload.ai.useSdkMode,
         tools: {
             claude: {
                 ...existing.tools?.claude,

package/dist/config.d.ts

@@ -45,8 +45,6 @@ export interface Config {
     hookPort: number;
     logDir: string;
     logLevel: LogLevel;
-    /** 是否使用 Agent SDK（进程内执行，无 spawn 开销，响应更快） */
-    useSdkMode: boolean;
     platforms: {
         telegram?: {
             enabled: boolean;
@@ -185,7 +183,6 @@ export interface FileConfig {
     hookPort?: number;
     logDir?: string;
     logLevel?: LogLevel;
-    useSdkMode?: boolean;
 }
 export declare const CONFIG_PATH: string;
 export declare function loadFileConfig(): FileConfig;

package/dist/config.js

@@ -428,14 +428,9 @@ export function loadConfig() {
     const hookPort = process.env.HOOK_PORT !== undefined
         ? parseInt(process.env.HOOK_PORT, 10) || 35801
         : file.hookPort ?? 35801;
-    // 当使用 Claude 时，强制使用 SDK 模式（更快，无需安装 CLI）
-    // 使用其他工具（codex/codebuddy）时，才根据配置决定
-    const useSdkMode = aiCommand === 'claude' || (process.env.USE_SDK_MODE !== undefined
-        ? process.env.USE_SDK_MODE === 'true'
-        : file.useSdkMode ?? true);
-    // 6. 校验 Claude API 凭证（SDK 模式需要）
+    // 6. 校验 Claude API 凭证（Claude 固定使用 Agent SDK）
     // 支持：官方 API Key、Auth Token、或自定义 API（第三方模型等，BASE_URL + token）
-    if (aiCommand === 'claude' && useSdkMode) {
+    if (aiCommand === 'claude') {
         const hasCreds = !!(process.env.ANTHROPIC_API_KEY ||
             process.env.ANTHROPIC_AUTH_TOKEN ||
             process.env.CLAUDE_CODE_OAUTH_TOKEN ||
@@ -542,49 +537,6 @@ export function loadConfig() {
             }
         }
     }
-    // 9. 校验 Claude CLI（SDK 模式不需要 CLI）
-    if (aiCommand === 'claude' && !useSdkMode) {
-        if (isAbsolute(claudeCliPath) || claudeCliPath.includes('/') || claudeCliPath.includes('\\')) {
-            try {
-                accessSync(claudeCliPath, constants.F_OK | constants.X_OK);
-            }
-            catch {
-                throw new Error(`Claude CLI 不可执行: ${claudeCliPath}`);
-            }
-        }
-        else {
-            // 检查命令是否存在（Windows 用 where，Unix 用 which）
-            const checkCommand = process.platform === 'win32' ? 'where' : 'which';
-            try {
-                execFileSync(checkCommand, [claudeCliPath], {
-                    stdio: 'pipe',
-                    windowsHide: process.platform === 'win32',
-                });
-            }
-            catch {
-                const installGuide = [
-                    '',
-                    '━━━ Claude CLI 未安装 ━━━',
-                    '',
-                    'open-im 需要 Claude Code CLI 才能运行。',
-                    '',
-                    '安装方法：',
-                    '',
-                    '  npm install -g @anthropic-ai/claude-code',
-                    '',
-                    '或者：',
-                    '  1. 访问 https://claude.ai/download',
-                    '  2. 下载并安装 Claude Code',
-                    '',
-                    '安装后重新运行，例如：',
-                    '  open-im dev',
-                    '  或 open-im start',
-                    '',
-                ].join('\n');
-                throw new Error(installGuide);
-            }
-        }
-    }
     // 7. 日志与平台配置
     const logDir = process.env.LOG_DIR ?? file.logDir ?? join(APP_HOME, 'logs');
     const logLevel = (process.env.LOG_LEVEL?.toUpperCase() ?? file.logLevel ?? 'INFO');
@@ -715,7 +667,6 @@ export function loadConfig() {
         hookPort,
         logDir,
         logLevel,
-        useSdkMode,
         platforms,
     };
 }

package/dist/service-control.test.js

@@ -1,4 +1,4 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 const { execFileSyncMock, existsSyncMock, readFileSyncMock, unlinkSyncMock, writeFileSyncMock, spawnMock } = vi.hoisted(() => ({
     execFileSyncMock: vi.fn(),
     existsSyncMock: vi.fn(),
@@ -19,9 +19,20 @@ vi.mock("node:fs", () => ({
 }));
 import { waitForBackgroundServiceReady } from "./service-control.js";
 describe("waitForBackgroundServiceReady", () => {
+    let killSpy;
     beforeEach(() => {
         vi.clearAllMocks();
+        // Windows: isRunning() uses execFileSync('tasklist', ...)
         execFileSyncMock.mockReturnValue(Buffer.from("node.exe 123 Console 1 10,000 K"));
+        // Non-Windows (e.g. CI): isRunning() uses process.kill(pid, 0); mock so it doesn't throw (pid 123 doesn't exist)
+        killSpy = vi.spyOn(process, "kill").mockImplementation((_pid, signal) => {
+            if (signal === 0)
+                return true;
+            throw new Error("process.kill mock: only sig=0 supported");
+        });
+    });
+    afterEach(() => {
+        killSpy.mockRestore();
     });
     it("returns once the worker pid is running and the port file appears", async () => {
         existsSyncMock.mockImplementation((target) => target.includes("worker.pid") || target.includes("open-im.port"));

package/dist/shared/ai-task.js

@@ -236,7 +236,7 @@ export function runAITask(deps, ctx, prompt, toolAdapter, platformAdapter) {
                 timeoutMs,
                 model: sessionManager.getModel(ctx.userId, ctx.threadId) ?? config.claudeModel,
                 chatId: ctx.chatId,
-                ...(toolId === 'claude' && config.useSdkMode ? {} : { hookPort: config.hookPort }),
+                ...(toolId === 'claude' ? {} : { hookPort: config.hookPort }),
                 ...(toolId === 'codex' && config.codexProxy ? { proxy: config.codexProxy } : {}),
             });
             return activeHandle;

package/dist/shared/ai-task.test.js

@@ -38,7 +38,6 @@ describe("runAITask", () => {
                 claudeTimeoutMs: 600000,
                 claudeSkipPermissions: false,
                 claudeModel: "",
-                useSdkMode: true,
                 hookPort: 35801,
                 codexProxy: "",
             },

package/package.json

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

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

@@ -1,26 +0,0 @@
-import type { ToolAdapter, RunCallbacks, RunOptions, RunHandle } from './tool-adapter.interface.js';
-export declare class ClaudeAdapter implements ToolAdapter {
-    private cliPath;
-    readonly toolId = "claude";
-    constructor(cliPath: string, adapterOptions?: {
-        useProcessPool?: boolean;
-        idleTimeoutMs?: number;
-    });
-    run(prompt: string, sessionId: string | undefined, workDir: string, callbacks: RunCallbacks, options?: RunOptions): RunHandle;
-    /**
-     * Get the number of cached entries in the pool.
-     */
-    static getCacheSize(): number;
-    /**
-     * Get the number of active processes in the pool.
-     */
-    static getActiveProcessCount(): number;
-    /**
-     * Terminate all cached entries and processes.
-     */
-    static terminateAll(): void;
-    /**
-     * Destroy the process pool and cleanup resources.
-     */
-    static destroy(): void;
-}

package/dist/adapters/claude-adapter.js

@@ -1,76 +0,0 @@
-import { runClaude } from '../claude/cli-runner.js';
-import { ClaudeProcessPool } from '../claude/process-pool.js';
-// Global process pool instance
-let processPool = null;
-export class ClaudeAdapter {
-    cliPath;
-    toolId = 'claude';
-    constructor(cliPath, adapterOptions) {
-        this.cliPath = cliPath;
-        const useProcessPool = adapterOptions?.useProcessPool ?? true;
-        const idleTimeoutMs = adapterOptions?.idleTimeoutMs ?? 2 * 60 * 1000; // 2 minutes default
-        if (useProcessPool && !processPool) {
-            // Initialize process pool with configurable idle timeout
-            processPool = new ClaudeProcessPool(idleTimeoutMs);
-        }
-    }
-    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,
-        };
-        // Use process pool if enabled and userId is available
-        if (processPool && opts.chatId) {
-            let aborted = false;
-            // Execute using process pool with userId from chatId
-            processPool
-                .execute(opts.chatId, sessionId, this.cliPath, prompt, workDir, callbacks, opts)
-                .catch((err) => {
-                if (!aborted && callbacks.onError) {
-                    callbacks.onError(err.message);
-                }
-            });
-            return {
-                abort: () => {
-                    aborted = true;
-                    processPool.terminate(opts.chatId, sessionId);
-                },
-            };
-        }
-        // Fall back to original implementation
-        return runClaude(this.cliPath, prompt, sessionId, workDir, callbacks, opts);
-    }
-    /**
-     * Get the number of cached entries in the pool.
-     */
-    static getCacheSize() {
-        return processPool?.size() ?? 0;
-    }
-    /**
-     * Get the number of active processes in the pool.
-     */
-    static getActiveProcessCount() {
-        return processPool?.activeCount() ?? 0;
-    }
-    /**
-     * Terminate all cached entries and processes.
-     */
-    static terminateAll() {
-        if (processPool) {
-            processPool.terminateAll();
-        }
-    }
-    /**
-     * Destroy the process pool and cleanup resources.
-     */
-    static destroy() {
-        if (processPool) {
-            processPool.destroy();
-            processPool = null;
-        }
-    }
-}

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

@@ -1,29 +0,0 @@
-export interface ClaudeRunCallbacks {
-    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;
-}
-export interface ClaudeRunOptions {
-    skipPermissions?: boolean;
-    permissionMode?: 'default' | 'acceptEdits' | 'plan';
-    timeoutMs?: number;
-    model?: string;
-    chatId?: string;
-    hookPort?: number;
-}
-export interface ClaudeRunHandle {
-    abort: () => void;
-}
-export declare function runClaude(cliPath: string, prompt: string, sessionId: string | undefined, workDir: string, callbacks: ClaudeRunCallbacks, options?: ClaudeRunOptions): ClaudeRunHandle;

package/dist/claude/cli-runner.js

@@ -1,231 +0,0 @@
-import { spawn } from "node:child_process";
-import { createInterface } from "node:readline";
-import { parseStreamLine, extractTextDelta, extractThinkingDelta, extractResult, } from "./stream-parser.js";
-import { isStreamInit, isContentBlockStart, isContentBlockDelta, isContentBlockStop, } from "./types.js";
-import { createLogger } from "../logger.js";
-const log = createLogger("CliRunner");
-export function runClaude(cliPath, prompt, sessionId, workDir, callbacks, options) {
-    const args = [
-        "-p",
-        "--output-format",
-        "stream-json",
-        "--verbose",
-        "--include-partial-messages",
-    ];
-    if (options?.skipPermissions) {
-        args.push("--dangerously-skip-permissions");
-    }
-    else if (options?.permissionMode) {
-        args.push("--permission-mode", options.permissionMode);
-    }
-    if (options?.model)
-        args.push("--model", options.model);
-    if (sessionId)
-        args.push("--resume", sessionId);
-    args.push("--", prompt);
-    const env = {};
-    for (const [k, v] of Object.entries(process.env)) {
-        // Skip CLAUDECODE to prevent nested session detection
-        if (k === "CLAUDECODE")
-            continue;
-        if (v !== undefined)
-            env[k] = v;
-    }
-    if (options?.chatId)
-        env.CC_IM_CHAT_ID = options.chatId;
-    if (options?.hookPort)
-        env.CC_IM_HOOK_PORT = String(options.hookPort);
-    // 使用 shell: false 直接 spawn，避免 shell 对参数按空格拆分
-    // （用户 prompt 如 "npm 你好" 在 shell: true 下会被拆成 "npm" 和 "你好"，CLI 只收到第一个）
-    log.info(`Spawning CLI: path=${cliPath}, platform=${process.platform}`);
-    const child = spawn(cliPath, args, {
-        cwd: workDir,
-        stdio: ["ignore", "pipe", "pipe"],
-        env,
-        windowsHide: process.platform === "win32",
-    });
-    log.info(`Claude CLI: pid=${child.pid}, cwd=${workDir}, session=${sessionId ?? "new"}`);
-    let accumulated = "";
-    let accumulatedThinking = "";
-    let completed = false;
-    let model = "";
-    const toolStats = {};
-    const pendingToolInputs = new Map();
-    const MAX_TIMEOUT = 2_147_483_647;
-    const timeoutMs = options?.timeoutMs && options.timeoutMs > 0
-        ? Math.min(options.timeoutMs, MAX_TIMEOUT)
-        : 0;
-    let timeoutHandle = null;
-    if (timeoutMs > 0) {
-        timeoutHandle = setTimeout(() => {
-            if (!completed && !child.killed) {
-                completed = true;
-                log.warn(`Claude CLI timeout after ${timeoutMs}ms, killing pid=${child.pid}`);
-                child.kill("SIGTERM");
-                callbacks.onError(`执行超时（${timeoutMs}ms），已终止进程`);
-            }
-        }, timeoutMs);
-    }
-    // stderr 截断：只保留首 4KB + 尾 6KB，减少 I/O 和内存
-    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);
-        }
-    });
-    const rl = createInterface({ input: child.stdout });
-    rl.on("line", (line) => {
-        const event = parseStreamLine(line);
-        if (!event)
-            return;
-        if (isStreamInit(event)) {
-            model = event.model;
-            callbacks.onSessionId?.(event.session_id);
-        }
-        const delta = extractTextDelta(event);
-        if (delta) {
-            accumulated += delta.text;
-            callbacks.onText(accumulated);
-            return;
-        }
-        const thinking = extractThinkingDelta(event);
-        if (thinking) {
-            accumulatedThinking += thinking.text;
-            callbacks.onThinking?.(accumulatedThinking);
-            return;
-        }
-        if (isContentBlockStart(event) &&
-            event.event.content_block?.type === "tool_use") {
-            const name = event.event.content_block.name;
-            if (name)
-                pendingToolInputs.set(event.event.index, { name, json: "" });
-            return;
-        }
-        if (isContentBlockDelta(event) &&
-            event.event.delta?.type === "input_json_delta") {
-            const pending = pendingToolInputs.get(event.event.index);
-            if (pending)
-                pending.json += event.event.delta.partial_json ?? "";
-            return;
-        }
-        if (isContentBlockStop(event)) {
-            const pending = pendingToolInputs.get(event.event.index);
-            if (pending) {
-                toolStats[pending.name] = (toolStats[pending.name] || 0) + 1;
-                let input;
-                try {
-                    input = JSON.parse(pending.json);
-                }
-                catch {
-                    /* empty */
-                }
-                callbacks.onToolUse?.(pending.name, input);
-                pendingToolInputs.delete(event.event.index);
-            }
-            return;
-        }
-        const result = extractResult(event);
-        if (result) {
-            completed = true;
-            if (timeoutHandle)
-                clearTimeout(timeoutHandle);
-            const fullResult = {
-                ...result,
-                accumulated,
-                model,
-                toolStats,
-            };
-            if (!accumulated && fullResult.result)
-                accumulated = fullResult.result;
-            callbacks.onComplete(fullResult);
-        }
-    });
-    let exitCode = null;
-    let rlClosed = false;
-    let childClosed = false;
-    const finalize = () => {
-        if (!rlClosed || !childClosed)
-            return;
-        if (timeoutHandle)
-            clearTimeout(timeoutHandle);
-        if (!completed) {
-            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... (省略 ${stderrTotal - MAX_STDERR_HEAD - MAX_STDERR_TAIL} 字节) ...\n\n` +
-                                stderrTail;
-                    }
-                }
-                callbacks.onError(errMsg || `Claude CLI exited with code ${exitCode}`);
-            }
-            else {
-                callbacks.onComplete({
-                    success: true,
-                    result: accumulated,
-                    accumulated,
-                    cost: 0,
-                    durationMs: 0,
-                    model,
-                    numTurns: 0,
-                    toolStats,
-                });
-            }
-        }
-    };
-    child.on("close", (code) => {
-        log.info(`Claude CLI closed: exitCode=${code}, pid=${child.pid}`);
-        exitCode = code;
-        childClosed = true;
-        finalize();
-    });
-    rl.on("close", () => {
-        rlClosed = true;
-        finalize();
-    });
-    child.on("error", (err) => {
-        const errorCode = err.code;
-        log.error(`Claude CLI spawn error: ${err.message}, code=${errorCode}, path=${cliPath}`);
-        if (timeoutHandle)
-            clearTimeout(timeoutHandle);
-        if (!completed) {
-            completed = true;
-            callbacks.onError(`Failed to start Claude CLI: ${err.message}`);
-        }
-        childClosed = true;
-        finalize();
-    });
-    return {
-        abort: () => {
-            if (timeoutHandle)
-                clearTimeout(timeoutHandle);
-            rl.close();
-            if (!child.killed)
-                child.kill("SIGTERM");
-        },
-    };
-}

package/dist/claude/process-pool.d.ts

@@ -1,84 +0,0 @@
-export interface ClaudeRunCallbacks {
-    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;
-}
-export interface ClaudeResult {
-    success: boolean;
-    result: string;
-    accumulated: string;
-    cost: number;
-    durationMs: number;
-    model?: string;
-    numTurns: number;
-    toolStats: Record<string, number>;
-}
-export interface ClaudeRunOptions {
-    skipPermissions?: boolean;
-    permissionMode?: 'default' | 'acceptEdits' | 'plan';
-    timeoutMs?: number;
-    model?: string;
-    chatId?: string;
-    hookPort?: number;
-}
-/**
- * Process pool that manages cached session configurations.
- *
- * Since Claude CLI doesn't support persistent mode, we use this pool to:
- * 1. Cache active sessions for faster resume using --resume
- * 2. Track which sessions are actively being used
- * 3. Clean up stale entries
- *
- * The main benefit is that resumed sessions don't need to reload conversation history.
- */
-export declare class ClaudeProcessPool {
-    private entries;
-    private activeProcesses;
-    private cleanupTimer;
-    private readonly ttl;
-    constructor(ttlMs?: number);
-    /**
-     * Execute a prompt, reusing cached session if available.
-     */
-    execute(userId: string, sessionId: string | undefined, cliPath: string, prompt: string, workDir: string, callbacks: ClaudeRunCallbacks, options?: ClaudeRunOptions): Promise<ClaudeResult>;
-    /**
-     * Run a Claude CLI process for a single request.
-     */
-    private runProcess;
-    /**
-     * Clean up expired entries.
-     */
-    private cleanup;
-    /**
-     * Terminate the active process for a session.
-     */
-    terminate(userId: string, sessionId: string | undefined): void;
-    /**
-     * Terminate all active processes and clear cache.
-     */
-    terminateAll(): void;
-    /**
-     * Get the number of cached entries.
-     */
-    size(): number;
-    /**
-     * Get the number of active processes.
-     */
-    activeCount(): number;
-    /**
-     * Destroy the process pool and cleanup resources.
-     */
-    destroy(): void;
-}

package/dist/claude/process-pool.js

@@ -1,312 +0,0 @@
-import { spawn } from "node:child_process";
-import { createInterface } from "node:readline";
-import { createLogger } from "../logger.js";
-import { parseStreamLine, extractTextDelta, extractThinkingDelta, extractResult, } from "./stream-parser.js";
-import { isStreamInit, isContentBlockStart, isContentBlockDelta, isContentBlockStop, } from "./types.js";
-const log = createLogger("ProcessPool");
-/**
- * Process pool that manages cached session configurations.
- *
- * Since Claude CLI doesn't support persistent mode, we use this pool to:
- * 1. Cache active sessions for faster resume using --resume
- * 2. Track which sessions are actively being used
- * 3. Clean up stale entries
- *
- * The main benefit is that resumed sessions don't need to reload conversation history.
- */
-export class ClaudeProcessPool {
-    entries = new Map();
-    activeProcesses = new Map();
-    cleanupTimer = null;
-    ttl;
-    constructor(ttlMs = 2 * 60 * 1000) {
-        this.ttl = ttlMs;
-        log.info(`Process pool created with TTL: ${ttlMs}ms`);
-        // Periodic cleanup of expired entries
-        this.cleanupTimer = setInterval(() => {
-            this.cleanup();
-        }, 60 * 1000); // Every minute
-    }
-    /**
-     * Execute a prompt, reusing cached session if available.
-     */
-    async execute(userId, sessionId, cliPath, prompt, workDir, callbacks, options) {
-        const key = `${userId}:${sessionId || "default"}`;
-        // Update cache entry (tracks active sessions)
-        const entry = this.entries.get(key);
-        if (entry) {
-            entry.lastUsed = Date.now();
-        }
-        else {
-            this.entries.set(key, { lastUsed: Date.now() });
-        }
-        // Check if there's an active process for this session
-        const activePid = this.activeProcesses.get(key);
-        if (activePid && !activePid.killed) {
-            log.info(`Session has active process: key=${key}, pid=${activePid.pid}`);
-            // Wait a bit for the previous process to complete
-            await new Promise(resolve => setTimeout(resolve, 100));
-        }
-        // Run the Claude CLI process
-        return this.runProcess(key, cliPath, prompt, sessionId, workDir, callbacks, options || {});
-    }
-    /**
-     * Run a Claude CLI process for a single request.
-     */
-    runProcess(key, cliPath, prompt, sessionId, workDir, callbacks, options) {
-        return new Promise((resolve, reject) => {
-            const args = [
-                "-p",
-                "--output-format",
-                "stream-json",
-                "--verbose",
-                "--include-partial-messages",
-            ];
-            if (options.skipPermissions) {
-                args.push("--dangerously-skip-permissions");
-            }
-            else if (options.permissionMode) {
-                args.push("--permission-mode", options.permissionMode);
-            }
-            if (options.model)
-                args.push("--model", options.model);
-            if (sessionId)
-                args.push("--resume", sessionId);
-            args.push("--", prompt);
-            // Environment setup
-            const env = {};
-            for (const [k, v] of Object.entries(process.env)) {
-                if (k === "CLAUDECODE")
-                    continue;
-                if (v !== undefined)
-                    env[k] = v;
-            }
-            if (options.chatId)
-                env.CC_IM_CHAT_ID = options.chatId;
-            if (options.hookPort)
-                env.CC_IM_HOOK_PORT = String(options.hookPort);
-            // 使用 shell: false 直接 spawn，避免 shell 对参数按空格拆分
-            // （用户 prompt 如 "npm 你好" 在 shell: true 下会被拆成 "npm" 和 "你好"，CLI 只收到第一个）
-            const child = spawn(cliPath, args, {
-                cwd: workDir,
-                stdio: ["ignore", "pipe", "pipe"],
-                env,
-                windowsHide: process.platform === "win32",
-            });
-            log.info(`Started process: pid=${child.pid}, key=${key}`);
-            // Track active process
-            this.activeProcesses.set(key, child);
-            // State tracking
-            let accumulated = "";
-            let accumulatedThinking = "";
-            let model = "";
-            const toolStats = {};
-            const pendingToolInputs = new Map();
-            const startTime = Date.now();
-            // stderr 截断：只保留首 4KB + 尾 6KB
-            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);
-                }
-            });
-            const rl = createInterface({ input: child.stdout });
-            rl.on("line", (line) => {
-                const event = parseStreamLine(line);
-                if (!event)
-                    return;
-                if (isStreamInit(event)) {
-                    model = event.model;
-                    callbacks.onSessionId?.(event.session_id);
-                    return;
-                }
-                const delta = extractTextDelta(event);
-                if (delta) {
-                    accumulated += delta.text;
-                    callbacks.onText(accumulated);
-                    return;
-                }
-                const thinking = extractThinkingDelta(event);
-                if (thinking) {
-                    accumulatedThinking += thinking.text;
-                    callbacks.onThinking?.(accumulatedThinking);
-                    return;
-                }
-                if (isContentBlockStart(event) &&
-                    event.event.content_block?.type === "tool_use") {
-                    const name = event.event.content_block.name;
-                    if (name)
-                        pendingToolInputs.set(event.event.index, { name, json: "" });
-                    return;
-                }
-                if (isContentBlockDelta(event) &&
-                    event.event.delta?.type === "input_json_delta") {
-                    const pending = pendingToolInputs.get(event.event.index);
-                    if (pending)
-                        pending.json += event.event.delta.partial_json ?? "";
-                    return;
-                }
-                if (isContentBlockStop(event)) {
-                    const pending = pendingToolInputs.get(event.event.index);
-                    if (pending) {
-                        toolStats[pending.name] = (toolStats[pending.name] || 0) + 1;
-                        let input;
-                        try {
-                            input = JSON.parse(pending.json);
-                        }
-                        catch {
-                            /* empty */
-                        }
-                        callbacks.onToolUse?.(pending.name, input);
-                        pendingToolInputs.delete(event.event.index);
-                    }
-                    return;
-                }
-                const result = extractResult(event);
-                if (result) {
-                    const fullResult = {
-                        ...result,
-                        accumulated,
-                        model,
-                        toolStats,
-                    };
-                    if (!accumulated && fullResult.result) {
-                        accumulated = fullResult.result;
-                    }
-                    callbacks.onComplete(fullResult);
-                    resolve(fullResult);
-                }
-            });
-            let exitCode = null;
-            let rlClosed = false;
-            let childClosed = false;
-            let resolved = false;
-            const finalize = () => {
-                if (!rlClosed || !childClosed || resolved)
-                    return;
-                this.activeProcesses.delete(key);
-                resolved = true;
-                if (exitCode !== null && exitCode !== 0) {
-                    let errorMsg = "";
-                    if (stderrTotal > 0) {
-                        if (!stderrHeadFull) {
-                            errorMsg = stderrHead;
-                        }
-                        else if (stderrTotal <= MAX_STDERR_HEAD + MAX_STDERR_TAIL) {
-                            errorMsg =
-                                stderrHead +
-                                    stderrTail.slice(stderrTail.length - (stderrTotal - MAX_STDERR_HEAD));
-                        }
-                        else {
-                            errorMsg =
-                                stderrHead +
-                                    `\n\n... (省略 ${stderrTotal - MAX_STDERR_HEAD - MAX_STDERR_TAIL} 字节) ...\n\n` +
-                                    stderrTail;
-                        }
-                    }
-                    const msg = errorMsg || `Claude CLI exited with code ${exitCode}`;
-                    callbacks.onError(msg);
-                    reject(new Error(msg));
-                }
-                // If exitCode is 0 and we haven't resolved yet, the result was already sent
-                // via the extractResult handler. This is just cleanup.
-            };
-            child.on("close", (code) => {
-                log.info(`Process closed: code=${code}, pid=${child.pid}, key=${key}`);
-                exitCode = code;
-                childClosed = true;
-                finalize();
-            });
-            rl.on("close", () => {
-                rlClosed = true;
-                finalize();
-            });
-            child.on("error", (err) => {
-                log.error(`Process error: ${err.message}, pid=${child.pid}, key=${key}`);
-                this.activeProcesses.delete(key);
-                const errorMsg = `Failed to start Claude CLI: ${err.message}`;
-                callbacks.onError(errorMsg);
-                reject(new Error(errorMsg));
-            });
-        });
-    }
-    /**
-     * Clean up expired entries.
-     */
-    cleanup() {
-        const now = Date.now();
-        let cleaned = 0;
-        for (const [key, entry] of this.entries.entries()) {
-            if (now - entry.lastUsed > this.ttl) {
-                this.entries.delete(key);
-                cleaned++;
-            }
-        }
-        if (cleaned > 0) {
-            log.info(`Cleaned up ${cleaned} expired entries, ${this.entries.size} remaining`);
-        }
-    }
-    /**
-     * Terminate the active process for a session.
-     */
-    terminate(userId, sessionId) {
-        const key = `${userId}:${sessionId || "default"}`;
-        const child = this.activeProcesses.get(key);
-        if (child && !child.killed) {
-            child.kill("SIGTERM");
-            this.activeProcesses.delete(key);
-        }
-        // Also remove from cache
-        this.entries.delete(key);
-    }
-    /**
-     * Terminate all active processes and clear cache.
-     */
-    terminateAll() {
-        for (const child of this.activeProcesses.values()) {
-            if (!child.killed) {
-                child.kill("SIGTERM");
-            }
-        }
-        this.activeProcesses.clear();
-        this.entries.clear();
-    }
-    /**
-     * Get the number of cached entries.
-     */
-    size() {
-        return this.entries.size;
-    }
-    /**
-     * Get the number of active processes.
-     */
-    activeCount() {
-        return this.activeProcesses.size;
-    }
-    /**
-     * Destroy the process pool and cleanup resources.
-     */
-    destroy() {
-        if (this.cleanupTimer) {
-            clearInterval(this.cleanupTimer);
-            this.cleanupTimer = null;
-        }
-        this.terminateAll();
-    }
-}