@wu529778790/open-im 1.0.0 → 1.0.2-beta.0

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

@@ -2,6 +2,25 @@ import type { ToolAdapter, RunCallbacks, RunOptions, RunHandle } from './tool-ad
 export declare class ClaudeAdapter implements ToolAdapter {
     private cliPath;
     readonly toolId = "claude";
-    constructor(cliPath: string);
+    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,17 +1,75 @@
 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) {
+    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) {
-        return runClaude(this.cliPath, prompt, sessionId, workDir, callbacks, {
+        const opts = {
             skipPermissions: options?.skipPermissions,
             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/adapters/registry.d.ts

@@ -2,3 +2,7 @@ import type { Config } from '../config.js';
 import type { ToolAdapter } from './tool-adapter.interface.js';
 export declare function initAdapters(config: Config): void;
 export declare function getAdapter(aiCommand: string): ToolAdapter | undefined;
+/**
+ * Cleanup all adapter resources.
+ */
+export declare function cleanupAdapters(): void;

package/dist/adapters/registry.js

@@ -3,9 +3,20 @@ const adapters = new Map();
 export function initAdapters(config) {
     adapters.clear();
     if (config.aiCommand === 'claude') {
-        adapters.set('claude', new ClaudeAdapter(config.claudeCliPath));
+        // Enable process pool with 2 minute idle timeout
+        adapters.set('claude', new ClaudeAdapter(config.claudeCliPath, {
+            useProcessPool: true,
+            idleTimeoutMs: 2 * 60 * 1000, // 2 minutes
+        }));
     }
 }
 export function getAdapter(aiCommand) {
     return adapters.get(aiCommand);
 }
+/**
+ * Cleanup all adapter resources.
+ */
+export function cleanupAdapters() {
+    ClaudeAdapter.destroy();
+    adapters.clear();
+}

package/dist/claude/cli-runner.js

@@ -48,6 +48,7 @@ export function runClaude(cliPath, prompt, sessionId, workDir, callbacks, option
                 stdio: ["ignore", "pipe", "pipe"],
                 env,
                 shell: true,
+                windowsHide: true,
             });
         }
         else {

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

@@ -0,0 +1,83 @@
+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;
+    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

@@ -0,0 +1,291 @@
+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");
+            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);
+            // Platform-specific spawn
+            let child;
+            if (process.platform === "win32") {
+                const isGitBash = process.env.MSYSTEM ||
+                    process.env.MINGW_PREFIX ||
+                    process.env.SHELL?.includes("bash");
+                if (isGitBash) {
+                    child = spawn(cliPath, args, {
+                        cwd: workDir,
+                        stdio: ["ignore", "pipe", "pipe"],
+                        env,
+                        shell: true,
+                        windowsHide: true,
+                    });
+                }
+                else {
+                    child = spawn(cliPath, args, {
+                        cwd: workDir,
+                        stdio: ["ignore", "pipe", "pipe"],
+                        env,
+                        windowsHide: true,
+                    });
+                }
+            }
+            else {
+                child = spawn(cliPath, args, {
+                    cwd: workDir,
+                    stdio: ["ignore", "pipe", "pipe"],
+                    env,
+                });
+            }
+            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();
+            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) {
+                    const errorMsg = `Claude CLI exited with code ${exitCode}`;
+                    callbacks.onError(errorMsg);
+                    reject(new Error(errorMsg));
+                }
+                // 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();
+    }
+}

package/dist/feishu/message-sender.js

@@ -1,28 +1,65 @@
 import { getClient } from './client.js';
-import { messageCard } from '@larksuiteoapi/node-sdk';
 import { readFileSync } from 'node:fs';
 import { createLogger } from '../logger.js';
 import { splitLongContent } from '../shared/utils.js';
 import { MAX_FEISHU_MESSAGE_LENGTH } from '../constants.js';
 const log = createLogger('FeishuSender');
-const STATUS_ICONS = {
-    thinking: '🔵',
-    streaming: '🔵',
-    done: '🟢',
-    error: '🔴',
+const STATUS_CONFIG = {
+    thinking: { icon: '🔵', template: 'blue', title: '思考中' },
+    streaming: { icon: '🔄', template: 'blue', title: '执行中' },
+    done: { icon: '✅', template: 'green', title: '完成' },
+    error: { icon: '❌', template: 'red', title: '错误' },
 };
 const TOOL_DISPLAY_NAMES = {
-    claude: 'claude-code',
-    codex: 'codex',
-    cursor: 'cursor',
+    claude: 'Claude Code',
+    codex: 'Codex',
+    cursor: 'Cursor',
 };
 function getToolTitle(toolId, status) {
     const name = TOOL_DISPLAY_NAMES[toolId] ?? toolId;
-    if (status === 'thinking')
-        return `${name} - 思考中...`;
-    if (status === 'error')
-        return `${name} - 错误`;
-    return name;
+    const statusText = STATUS_CONFIG[status].title;
+    return status === 'done' ? name : `${name} - ${statusText}`;
+}
+/**
+ * Create Feishu interactive card with native lark_md support
+ * Feishu natively supports Markdown through the `lark_md` tag
+ */
+function createFeishuCard(title, content, status, note) {
+    const statusConfig = STATUS_CONFIG[status];
+    const elements = [];
+    // Main content - use native lark_md tag
+    elements.push({
+        tag: 'div',
+        text: {
+            tag: 'lark_md',
+            content: content || '_处理中..._',
+        },
+    });
+    // Add note separator and hint if provided
+    if (note) {
+        elements.push({ tag: 'hr' });
+        elements.push({
+            tag: 'div',
+            text: {
+                tag: 'lark_md',
+                content: `**💡 ${note}**`,
+            },
+        });
+    }
+    const card = {
+        config: {
+            wide_screen_mode: true,
+        },
+        header: {
+            template: statusConfig.template,
+            title: {
+                content: `${statusConfig.icon} ${title}`,
+                tag: 'plain_text',
+            },
+        },
+        elements,
+    };
+    return JSON.stringify(card);
 }
 async function getTenantAccessToken() {
     const client = getClient();
@@ -39,14 +76,9 @@ async function getTenantAccessToken() {
 }
 export async function sendThinkingMessage(chatId, replyToMessageId, toolId = 'claude') {
     const client = getClient();
-    // Use SDK's built-in card builder for simpler messages
-    const cardContent = messageCard.defaultCard({
-        title: `${STATUS_ICONS.thinking} ${getToolTitle(toolId, 'thinking')}`,
-        content: '正在思考...\n\n请稍候...',
-    });
+    const cardContent = createFeishuCard(getToolTitle(toolId, 'thinking'), '_正在思考，请稍候..._\n\n💭 **准备中**', 'thinking');
     try {
         log.info(`Sending thinking message to chat ${chatId}, replyTo: ${replyToMessageId}`);
-        // 注意：飞书 create 接口不支持 uuid 参数，传 uuid 会导致请求失败
         const resp = await client.im.message.create({
             data: {
                 receive_id: chatId,
@@ -68,17 +100,9 @@ export async function sendThinkingMessage(chatId, replyToMessageId, toolId = 'cl
 }
 export async function updateMessage(chatId, messageId, content, status, note, toolId = 'claude') {
     const client = getClient();
-    // Build content with note
-    let fullContent = content;
-    if (note) {
-        fullContent = `${content}\n\n─────────\n${note}`;
-    }
-    const icon = STATUS_ICONS[status];
-    const title = getToolTitle(toolId, status);
-    const cardContent = messageCard.defaultCard({
-        title: `${icon} ${title}`,
-        content: fullContent,
-    });
+    const icon = STATUS_CONFIG[status].icon;
+    const title = `${icon} ${getToolTitle(toolId, status)}`;
+    const cardContent = createFeishuCard(title, content, status, note);
     // Try to use patch API for in-place update (streaming)
     try {
         const resp = await client.im.message.patch({
@@ -132,10 +156,7 @@ export async function sendFinalMessages(chatId, messageId, fullContent, note, to
     const parts = splitLongContent(fullContent, MAX_FEISHU_MESSAGE_LENGTH);
     // If content fits in one message, try patch for smooth transition
     if (parts.length === 1) {
-        const cardContent = messageCard.defaultCard({
-            title: `${STATUS_ICONS.done} ${getToolTitle(toolId, 'done')}`,
-            content: fullContent,
-        });
+        const cardContent = createFeishuCard(getToolTitle(toolId, 'done'), fullContent, 'done');
         // Try to use patch API for in-place update
         try {
             const resp = await client.im.message.patch({
@@ -169,10 +190,8 @@ export async function sendFinalMessages(chatId, messageId, fullContent, note, to
     // Send new messages
     for (let i = 0; i < parts.length; i++) {
         try {
-            const cardContent = messageCard.defaultCard({
-                title: `${STATUS_ICONS.done} ${getToolTitle(toolId, 'done')}`,
-                content: i === 0 ? parts[0] : parts[i] + `\n\n(续 ${i + 1}/${parts.length})`,
-            });
+            const partContent = i === 0 ? parts[0] : `${parts[i]}\n\n_*(续 ${i + 1}/${parts.length})*_`;
+            const cardContent = createFeishuCard(getToolTitle(toolId, 'done'), partContent, 'done');
             await client.im.message.create({
                 data: {
                     receive_id: chatId,
@@ -189,11 +208,7 @@ export async function sendFinalMessages(chatId, messageId, fullContent, note, to
 }
 export async function sendTextReply(chatId, text) {
     const client = getClient();
-    // Use SDK's built-in card builder for simpler messages
-    const cardContent = messageCard.defaultCard({
-        title: 'open-im',
-        content: text,
-    });
+    const cardContent = createFeishuCard('📢 open-im', text, 'done');
     try {
         await client.im.message.create({
             data: {

package/dist/index.js

@@ -11,7 +11,7 @@ import { sendTextReply as sendTelegramTextReply } from "./telegram/message-sende
 import { initFeishu, stopFeishu } from "./feishu/client.js";
 import { setupFeishuHandlers } from "./feishu/event-handler.js";
 import { sendTextReply as sendFeishuTextReply } from "./feishu/message-sender.js";
-import { initAdapters } from "./adapters/registry.js";
+import { initAdapters, cleanupAdapters } from "./adapters/registry.js";
 import { SessionManager } from "./session/session-manager.js";
 import { loadActiveChats, getActiveChatId, flushActiveChats, } from "./shared/active-chats.js";
 import { initLogger, createLogger, closeLogger } from "./logger.js";
@@ -100,6 +100,7 @@ export async function main() {
         feishuHandle?.stop();
         stopFeishu();
         sessionManager.destroy();
+        cleanupAdapters();
         flushActiveChats();
         closeLogger();
         process.exit(0);

package/package.json

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