@wu529778790/open-im 0.4.0 → 1.0.0

package/dist/cli.js

@@ -1,78 +1,45 @@
 #!/usr/bin/env node
-import { main, needsSetup, runInteractiveSetup } from './index.js';
-import { loadConfig } from './config.js';
-import { spawn, execFileSync } from 'node:child_process';
-import { fileURLToPath } from 'node:url';
-import { dirname, join } from 'node:path';
-import { mkdir, writeFile, rm, readFile } from 'node:fs/promises';
-import { existsSync, readFileSync } from 'node:fs';
-import { platform, homedir } from 'node:os';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-// PID 文件路径
-const PID_DIR = join(homedir(), '.open-im');
-const PID_FILE = join(PID_DIR, 'daemon.pid');
-const STOP_FILE = join(PID_DIR, 'stop.flag');
-const CONFIG_FILE = join(PID_DIR, 'config.json');
-// 保存 PID 到文件
-async function savePid(pid) {
-    try {
-        await mkdir(PID_DIR, { recursive: true });
-        await writeFile(PID_FILE, String(pid), 'utf-8');
-    }
-    catch (err) {
-        console.error('无法保存 PID 文件:', err);
-    }
-}
-// 读取 PID 文件
-async function readPid() {
+import { spawn } from "node:child_process";
+import { readFileSync, writeFileSync, existsSync, unlinkSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { main, needsSetup, runInteractiveSetup } from "./index.js";
+import { loadConfig } from "./config.js";
+import { APP_HOME, SHUTDOWN_PORT } from "./constants.js";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PID_FILE = join(APP_HOME, "open-im.pid");
+const PORT_FILE = join(APP_HOME, "open-im.port");
+const INDEX_JS = join(__dirname, "index.js");
+function getPid() {
+    if (!existsSync(PID_FILE))
+        return null;
     try {
-        if (!existsSync(PID_FILE)) {
-            return null;
-        }
-        const content = await readFile(PID_FILE, 'utf-8');
-        return parseInt(content.trim(), 10);
+        const pid = parseInt(readFileSync(PID_FILE, "utf-8").trim(), 10);
+        return isNaN(pid) ? null : pid;
     }
     catch {
         return null;
     }
 }
-// 删除 PID 文件
-async function removePidFile() {
+function writePid(pid) {
     try {
-        if (existsSync(PID_FILE)) {
-            await rm(PID_FILE);
-        }
+        writeFileSync(PID_FILE, String(pid), "utf-8");
     }
-    catch {
-        // 忽略删除错误
+    catch (err) {
+        console.error("无法写入 PID 文件:", err);
     }
 }
-// 更新工作目录到配置文件
-async function updateWorkDir(workDir) {
+function removePid() {
     try {
-        await mkdir(PID_DIR, { recursive: true });
-        let config = {};
-        if (existsSync(CONFIG_FILE)) {
-            try {
-                config = JSON.parse(readFileSync(CONFIG_FILE, 'utf-8'));
-            }
-            catch {
-                // 忽略解析错误
-            }
-        }
-        // 更新工作目录
-        config.claudeWorkDir = workDir;
-        await writeFile(CONFIG_FILE, JSON.stringify(config, null, 2), 'utf-8');
+        if (existsSync(PID_FILE))
+            unlinkSync(PID_FILE);
     }
-    catch (err) {
-        console.error('无法保存工作目录配置:', err);
+    catch {
+        /* ignore */
     }
 }
-// 检查进程是否在运行
-async function isProcessRunning(pid) {
+function isRunning(pid) {
     try {
-        // 尝试发送信号 0（不杀死进程，只检查是否存在）
         process.kill(pid, 0);
         return true;
     }
@@ -80,160 +47,112 @@ async function isProcessRunning(pid) {
         return false;
     }
 }
-// 停止服务 - 创建停止标记文件，让服务优雅关闭
-async function stopService() {
-    const pid = await readPid();
-    if (!pid) {
-        console.log('未找到运行中的服务（PID 文件不存在）');
-        return;
-    }
-    const running = await isProcessRunning(pid);
-    if (!running) {
-        console.log(`服务未运行（进程 ${pid} 不存在）`);
-        await removePidFile();
+async function cmdStart() {
+    const pid = getPid();
+    if (pid && isRunning(pid)) {
+        console.log(`open-im 已在后台运行 (pid=${pid})`);
         return;
     }
-    try {
-        // 创建停止标记文件，服务会定期检查并优雅关闭
-        await mkdir(PID_DIR, { recursive: true });
-        await writeFile(STOP_FILE, Date.now().toString(), 'utf-8');
-        console.log('正在停止服务...');
-        // 等待进程退出（最多 10 秒）
-        const maxWait = 10000;
-        const interval = 200;
-        let waited = 0;
-        while (waited < maxWait) {
-            await new Promise(resolve => setTimeout(resolve, interval));
-            if (!(await isProcessRunning(pid))) {
-                await removePidFile();
-                console.log('服务已停止');
-                return;
-            }
-            waited += interval;
-        }
-        // 超时后强制终止
-        console.log('等待超时，强制终止服务...');
-        const isWindows = platform() === 'win32';
-        if (isWindows) {
-            execFileSync('taskkill', ['/F', '/PID', String(pid)], { stdio: 'ignore' });
-        }
-        else {
-            process.kill(pid, 'SIGKILL');
-        }
-        await removePidFile();
-        console.log('服务已强制停止');
-    }
-    catch (err) {
-        const errorMsg = err instanceof Error ? err.message : String(err);
-        console.error(`停止服务失败: ${errorMsg}`);
-        await removePidFile();
-    }
-}
-// 启动服务（后台）
-async function startService() {
-    // 首先检查是否需要配置
+    removePid();
+    // 在前台先完成配置校验与配置向导（与 dev 行为保持一致）
     if (needsSetup()) {
-        console.log('\n━━━ open-im 首次配置 ━━━\n');
-        console.log('检测到未配置，需要先完成配置才能启动服务\n');
+        console.log("\n━━━ open-im 首次配置 ━━━\n");
+        console.log("检测到尚未配置，将先进入配置向导...\n");
         const saved = await runInteractiveSetup();
         if (!saved) {
-            console.log('配置未完成，取消启动。');
+            console.log("配置未完成，已取消启动。");
             process.exit(1);
         }
-        console.log('');
+        console.log("");
     }
-    // 验证配置是否有效（避免有配置文件但缺少必要字段的情况）
+    // 校验配置是否有效（避免后台静默失败）
     try {
         loadConfig();
     }
     catch (err) {
-        console.error('配置无效或缺少必要字段:', err instanceof Error ? err.message : err);
-        console.log('\n请运行以下命令重新配置:\n  npx @wu529778790/open-im\n');
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error("配置无效或缺少必要字段:", msg);
+        console.log("\n请运行以下命令重新配置:\n  npx @wu529778790/open-im dev\n或:\n  npx @wu529778790/open-im init\n");
         process.exit(1);
     }
-    // 显示配置的工作目录（不自动更新，避免在不同目录重启时导致配置混乱）
-    const config = loadConfig();
-    console.log(`使用配置的工作目录: ${config.claudeWorkDir}`);
-    // 后台启动 - 跨平台方案
-    const distPath = join(__dirname, '..', 'dist', 'index.js');
-    // 使用 detached 模式创建独立进程
-    const child = spawn(process.execPath, [distPath], {
+    const child = spawn(process.execPath, [INDEX_JS], {
         detached: true,
-        stdio: ['ignore', 'ignore', 'ignore'],
-        windowsHide: true // Windows 上隐藏控制台窗口
+        stdio: "ignore",
+        cwd: process.cwd(),
+        env: process.env,
+        windowsHide: process.platform === "win32",
     });
-    // 保存 PID
-    await savePid(child.pid);
-    // 让子进程独立于父进程
     child.unref();
-    console.log(`服务已在后台启动 (PID: ${child.pid})`);
+    writePid(child.pid);
+    console.log(`open-im 已在后台启动 (pid=${child.pid})`);
 }
-const args = process.argv.slice(2);
-if (args[0] === 'init') {
-    // 手动触发配置
-    console.log('\n━━━ open-im 配置向导 ━━━\n');
-    const saved = await runInteractiveSetup();
-    if (!saved) {
-        console.log('配置未完成。');
-        process.exit(1);
+async function cmdStop() {
+    const pid = getPid();
+    if (!pid) {
+        console.log("open-im 未在后台运行");
+        return;
     }
-    console.log('\n✅ 配置完成！现在可以运行以下命令启动服务:\n  open-im start\n');
-}
-else if (args[0] === 'stop') {
-    stopService().catch((err) => {
-        console.error('停止服务时出错:', err);
-        process.exit(1);
-    });
-}
-else if (args[0] === 'restart') {
-    console.log('正在重启服务...\n');
-    await stopService().catch((err) => {
-        console.error('停止服务时出错:', err);
-    });
-    // 等待进程完全退出 AND Telegram API 释放连接（至少 3 秒）
-    // Telegram 需要时间释放 bot 实例，否则会出现 409 Conflict 错误
-    const pid = await readPid();
-    if (pid) {
-        // 持续检查直到进程真正退出（最多 15 秒）
-        const maxWait = 15000;
-        const checkInterval = 500;
-        let waited = 0;
-        while (waited < maxWait) {
-            if (!(await isProcessRunning(pid))) {
-                // 进程已退出，再等待 3 秒让 Telegram API 完全释放
-                const remainingWait = 3000;
-                console.log(`进程已退出，等待 ${remainingWait / 1000} 秒让 Telegram API 释放连接...`);
-                await new Promise(resolve => setTimeout(resolve, remainingWait));
-                break;
+    if (!isRunning(pid)) {
+        removePid();
+        console.log("open-im 进程已不存在");
+        return;
+    }
+    const port = existsSync(PORT_FILE)
+        ? parseInt(readFileSync(PORT_FILE, "utf-8").trim(), 10) || SHUTDOWN_PORT
+        : SHUTDOWN_PORT;
+    try {
+        const res = await fetch(`http://127.0.0.1:${port}/shutdown`, {
+            signal: AbortSignal.timeout(3000),
+        });
+        if (res.ok) {
+            for (let i = 0; i < 50; i++) {
+                await new Promise((r) => setTimeout(r, 100));
+                if (!isRunning(pid))
+                    break;
             }
-            await new Promise(resolve => setTimeout(resolve, checkInterval));
-            waited += checkInterval;
-        }
-        if (waited >= maxWait) {
-            console.log('警告: 进程退出超时，继续启动...');
         }
     }
-    console.log('\n正在重新启动服务...\n');
-    await startService();
+    catch {
+        /* HTTP 失败则用 SIGTERM 兜底 */
+        process.kill(pid, "SIGTERM");
+        await new Promise((r) => setTimeout(r, 500));
+    }
+    if (isRunning(pid)) {
+        process.kill(pid, "SIGKILL");
+    }
+    removePid();
+    try {
+        if (existsSync(PORT_FILE))
+            unlinkSync(PORT_FILE);
+    }
+    catch {
+        /* ignore */
+    }
+    console.log(`open-im 已停止 (pid=${pid})`);
 }
-else if (args[0] === 'start') {
-    await startService();
+const cmd = process.argv[2];
+if (cmd === "start") {
+    cmdStart().catch((err) => {
+        console.error(err);
+        process.exit(1);
+    });
 }
-else if (args[0] === 'run' || args.length === 0) {
-    // 前台运行（默认命令）
-    console.log('\n🚀 正在前台启动 open-im 服务...\n');
-    console.log('💡 提示：按 Ctrl+C 可随时停止服务\n');
-    main().catch((err) => {
+else if (cmd === "stop") {
+    cmdStop().catch((err) => {
         console.error(err);
         process.exit(1);
     });
 }
-else {
-    // 兼容旧版本，无参数时也运行
-    console.log('\n🚀 正在前台启动 open-im 服务...\n');
-    console.log('💡 提示：按 Ctrl+C 可随时停止服务\n');
+else if (cmd === "dev" || cmd === "run" || cmd === undefined) {
     main().catch((err) => {
         console.error(err);
         process.exit(1);
     });
 }
+else {
+    console.log(`用法: open-im [start|stop|dev]
+  start  - 后台运行
+  stop   - 停止后台进程
+  dev    - 前台运行（调试），Ctrl+C 停止`);
+    process.exit(cmd === "--help" || cmd === "-h" ? 0 : 1);
+}

package/dist/config.d.ts

@@ -3,8 +3,12 @@ export type Platform = 'feishu' | 'telegram';
 export type AiCommand = 'claude' | 'codex' | 'cursor';
 export interface Config {
     enabledPlatforms: Platform[];
-    telegramBotToken: string;
+    telegramBotToken?: string;
+    feishuAppId?: string;
+    feishuAppSecret?: string;
     allowedUserIds: string[];
+    telegramAllowedUserIds: string[];
+    feishuAllowedUserIds: string[];
     aiCommand: AiCommand;
     claudeCliPath: string;
     claudeWorkDir: string;
@@ -16,7 +20,13 @@ export interface Config {
     logLevel: LogLevel;
     platforms: {
         telegram?: {
+            enabled: boolean;
             proxy?: string;
+            allowedUserIds: string[];
+        };
+        feishu?: {
+            enabled: boolean;
+            allowedUserIds: string[];
         };
     };
 }

package/dist/config.js

@@ -19,24 +19,60 @@ function loadFileConfig() {
 }
 /** 检测是否需要交互式配置（无 token 且无环境变量） */
 export function needsSetup() {
+    // 环境变量已提供任一平台的凭证，则认为已配置
     if (process.env.TELEGRAM_BOT_TOKEN)
         return false;
+    if (process.env.FEISHU_APP_ID && process.env.FEISHU_APP_SECRET)
+        return false;
     const file = loadFileConfig();
-    return !file.telegramBotToken;
+    const tg = file.platforms?.telegram;
+    const fs = file.platforms?.feishu;
+    const hasTelegram = !!tg?.botToken;
+    const hasFeishu = !!(fs?.appId && fs?.appSecret);
+    return !hasTelegram && !hasFeishu;
 }
 function parseCommaSeparated(value) {
     return value.split(',').map((s) => s.trim()).filter(Boolean);
 }
 export function loadConfig() {
     const file = loadFileConfig();
-    const telegramBotToken = process.env.TELEGRAM_BOT_TOKEN ?? file.telegramBotToken ?? '';
-    const enabledPlatforms = telegramBotToken ? ['telegram'] : [];
+    const fileTelegram = file.platforms?.telegram;
+    const fileFeishu = file.platforms?.feishu;
+    // 1. 加载各平台凭证（env 优先，其次新结构，最后旧字段）
+    const telegramBotToken = process.env.TELEGRAM_BOT_TOKEN ??
+        fileTelegram?.botToken ??
+        file.telegramBotToken;
+    const feishuAppId = process.env.FEISHU_APP_ID ??
+        fileFeishu?.appId ??
+        file.feishuAppId;
+    const feishuAppSecret = process.env.FEISHU_APP_SECRET ??
+        fileFeishu?.appSecret ??
+        file.feishuAppSecret;
+    // 2. 计算启用平台
+    const enabledPlatforms = [];
+    const telegramEnabledFlag = fileTelegram?.enabled;
+    const feishuEnabledFlag = fileFeishu?.enabled;
+    const telegramEnabled = !!telegramBotToken && (telegramEnabledFlag !== false);
+    const feishuEnabled = !!(feishuAppId && feishuAppSecret) && (feishuEnabledFlag !== false);
+    if (telegramEnabled)
+        enabledPlatforms.push('telegram');
+    if (feishuEnabled)
+        enabledPlatforms.push('feishu');
     if (enabledPlatforms.length === 0) {
-        throw new Error('至少需要配置 TELEGRAM_BOT_TOKEN');
+        throw new Error('至少需要配置 Telegram 或 Feishu 其中一个平台（可以通过环境变量或 config.json）');
     }
+    // 3. 全局白名单（旧字段，向后兼容，主要用于作为 per-platform 的兜底）
     const allowedUserIds = process.env.ALLOWED_USER_IDS !== undefined
         ? parseCommaSeparated(process.env.ALLOWED_USER_IDS)
         : file.allowedUserIds ?? [];
+    // 4. 分平台白名单（新字段）
+    const telegramAllowedUserIds = process.env.TELEGRAM_ALLOWED_USER_IDS !== undefined
+        ? parseCommaSeparated(process.env.TELEGRAM_ALLOWED_USER_IDS)
+        : fileTelegram?.allowedUserIds ?? allowedUserIds;
+    const feishuAllowedUserIds = process.env.FEISHU_ALLOWED_USER_IDS !== undefined
+        ? parseCommaSeparated(process.env.FEISHU_ALLOWED_USER_IDS)
+        : fileFeishu?.allowedUserIds ?? allowedUserIds;
+    // 5. AI / 工作目录 / 安全配置
     const aiCommand = (process.env.AI_COMMAND ?? file.aiCommand ?? 'claude');
     const claudeCliPath = process.env.CLAUDE_CLI_PATH ?? file.claudeCliPath ?? 'claude';
     const claudeWorkDir = process.env.CLAUDE_WORK_DIR ?? file.claudeWorkDir ?? process.cwd();
@@ -51,6 +87,7 @@ export function loadConfig() {
     const claudeTimeoutMs = process.env.CLAUDE_TIMEOUT_MS !== undefined
         ? parseInt(process.env.CLAUDE_TIMEOUT_MS, 10) || 600000
         : file.claudeTimeoutMs ?? 600000;
+    // 6. 校验 Claude CLI
     if (aiCommand === 'claude') {
         if (isAbsolute(claudeCliPath) || claudeCliPath.includes('/') || claudeCliPath.includes('\\')) {
             try {
@@ -89,18 +126,39 @@ export function loadConfig() {
             }
         }
     }
+    // 7. 日志与平台配置
     const logDir = process.env.LOG_DIR ?? file.logDir ?? join(APP_HOME, 'logs');
     const logLevel = (process.env.LOG_LEVEL?.toUpperCase() ?? file.logLevel ?? 'INFO');
-    // Platform-specific proxy configuration
     const platforms = {
-        telegram: {
-            proxy: process.env.TELEGRAM_PROXY ?? file?.platforms?.telegram?.proxy,
-        },
+        telegram: telegramEnabled
+            ? {
+                enabled: true,
+                proxy: process.env.TELEGRAM_PROXY ?? file.platforms?.telegram?.proxy,
+                allowedUserIds: telegramAllowedUserIds,
+            }
+            : {
+                enabled: false,
+                proxy: process.env.TELEGRAM_PROXY ?? file.platforms?.telegram?.proxy,
+                allowedUserIds: telegramAllowedUserIds,
+            },
+        feishu: feishuEnabled
+            ? {
+                enabled: true,
+                allowedUserIds: feishuAllowedUserIds,
+            }
+            : {
+                enabled: false,
+                allowedUserIds: feishuAllowedUserIds,
+            },
     };
     return {
         enabledPlatforms,
-        telegramBotToken,
+        telegramBotToken: telegramBotToken ?? '',
+        feishuAppId: feishuAppId ?? '',
+        feishuAppSecret: feishuAppSecret ?? '',
         allowedUserIds,
+        telegramAllowedUserIds,
+        feishuAllowedUserIds,
         aiCommand,
         claudeCliPath,
         claudeWorkDir,

package/dist/constants.d.ts

@@ -1,7 +1,12 @@
 export declare const APP_HOME: string;
+/** 优雅关闭 HTTP 端口（stop 命令通过此端口触发 shutdown） */
+export declare const SHUTDOWN_PORT = 39281;
 export declare const IMAGE_DIR: string;
 export declare const READ_ONLY_TOOLS: string[];
 export declare const TERMINAL_ONLY_COMMANDS: Set<string>;
 export declare const DEDUP_TTL_MS: number;
 export declare const THROTTLE_MS = 200;
+/** Telegram 编辑消息节流：600ms，避免 API 限速且更流畅 */
+export declare const TELEGRAM_THROTTLE_MS = 600;
 export declare const MAX_TELEGRAM_MESSAGE_LENGTH = 4000;
+export declare const MAX_FEISHU_MESSAGE_LENGTH = 4000;

package/dist/constants.js

@@ -1,6 +1,8 @@
 import { join } from 'node:path';
 import { homedir, tmpdir } from 'node:os';
 export const APP_HOME = join(homedir(), '.open-im');
+/** 优雅关闭 HTTP 端口（stop 命令通过此端口触发 shutdown） */
+export const SHUTDOWN_PORT = 39281;
 export const IMAGE_DIR = join(tmpdir(), 'open-im-images');
 export const READ_ONLY_TOOLS = [
     'Read', 'Glob', 'Grep', 'WebFetch', 'WebSearch', 'Task', 'TodoRead',
@@ -12,4 +14,7 @@ export const TERMINAL_ONLY_COMMANDS = new Set([
 ]);
 export const DEDUP_TTL_MS = 5 * 60 * 1000;
 export const THROTTLE_MS = 200;
+/** Telegram 编辑消息节流：600ms，避免 API 限速且更流畅 */
+export const TELEGRAM_THROTTLE_MS = 600;
 export const MAX_TELEGRAM_MESSAGE_LENGTH = 4000;
+export const MAX_FEISHU_MESSAGE_LENGTH = 4000;

package/dist/feishu/client.d.ts

@@ -0,0 +1,5 @@
+import { Client } from '@larksuiteoapi/node-sdk';
+import type { Config } from '../config.js';
+export declare function getClient(): Client;
+export declare function initFeishu(config: Config, eventHandler: (data: unknown) => Promise<void>): Promise<void>;
+export declare function stopFeishu(): void;

package/dist/feishu/client.js

@@ -0,0 +1,69 @@
+import { Client, WSClient, EventDispatcher, LoggerLevel } from '@larksuiteoapi/node-sdk';
+import { createLogger } from '../logger.js';
+const log = createLogger('Feishu');
+let client = null;
+let wsClient = null;
+export function getClient() {
+    if (!client)
+        throw new Error('Feishu client not initialized');
+    return client;
+}
+export async function initFeishu(config, eventHandler) {
+    if (!config.feishuAppId || !config.feishuAppSecret) {
+        throw new Error('Feishu app_id and app_secret are required');
+    }
+    client = new Client({
+        appId: config.feishuAppId,
+        appSecret: config.feishuAppSecret,
+        loggerLevel: LoggerLevel.info,
+        disableTokenCache: false,
+    });
+    // Create event dispatcher for WebSocket events
+    const eventDispatcher = new EventDispatcher({});
+    // Register event handler for message received
+    // Note: register() takes an object with event type as key and handler as value
+    eventDispatcher.register({
+        'im.message.receive_v1': async (data) => {
+            log.info('[EVENT] Received Feishu message event');
+            log.info('[EVENT] Event data:', JSON.stringify(data).slice(0, 500));
+            try {
+                await eventHandler(data);
+                log.info('[EVENT] Event handler called successfully');
+            }
+            catch (err) {
+                log.error('[EVENT] Error calling event handler:', err);
+            }
+        },
+    });
+    // Register catch-all handler using wildcard
+    eventDispatcher.register({
+        '*': (data) => {
+            log.info('Received Feishu event (catch-all):', JSON.stringify(data).slice(0, 500));
+            // Don't call eventHandler for catch-all, let specific handlers handle it
+        },
+    });
+    // Start WebSocket connection for event receiving
+    wsClient = new WSClient({
+        appId: config.feishuAppId,
+        appSecret: config.feishuAppSecret,
+        loggerLevel: LoggerLevel.info,
+    });
+    try {
+        // WSClient.start() requires eventDispatcher parameter
+        await wsClient.start({ eventDispatcher });
+        log.info('Feishu WebSocket started');
+    }
+    catch (err) {
+        log.error('Failed to start Feishu WebSocket:', err);
+        throw err;
+    }
+    log.info('Feishu client initialized');
+}
+export function stopFeishu() {
+    if (wsClient) {
+        wsClient.close();
+        wsClient = null;
+        log.info('Feishu WebSocket closed');
+    }
+    client = null;
+}

package/dist/feishu/event-handler.d.ts

@@ -0,0 +1,8 @@
+import type { Config } from '../config.js';
+import type { SessionManager } from '../session/session-manager.js';
+export interface FeishuEventHandlerHandle {
+    stop: () => void;
+    getRunningTaskCount: () => number;
+    handleEvent: (data: unknown) => Promise<void>;
+}
+export declare function setupFeishuHandlers(config: Config, sessionManager: SessionManager): FeishuEventHandlerHandle;