@wu529778790/open-im 0.1.0

package/dist/commands/handler.js

@@ -0,0 +1,122 @@
+import { resolveLatestPermission, getPendingCount } from '../hook/permission-server.js';
+import { TERMINAL_ONLY_COMMANDS } from '../constants.js';
+import { execFile } from 'node:child_process';
+export class CommandHandler {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    async dispatch(text, chatId, userId, platform, handleClaudeRequest) {
+        const t = text.trim();
+        if (platform === 'telegram' && t === '/start') {
+            await this.deps.sender.sendTextReply(chatId, '欢迎使用 open-im AI CLI 桥接！\n\n发送消息与 AI 交互，输入 /help 查看帮助。');
+            return true;
+        }
+        if (t === '/help')
+            return this.handleHelp(chatId, platform);
+        if (t === '/new')
+            return this.handleNew(chatId, userId);
+        if (t === '/pwd')
+            return this.handlePwd(chatId, userId);
+        if (t === '/status')
+            return this.handleStatus(chatId, userId);
+        if (t === '/allow' || t === '/y')
+            return this.handleAllow(chatId);
+        if (t === '/deny' || t === '/n')
+            return this.handleDeny(chatId);
+        if (t === '/cd' || t.startsWith('/cd ')) {
+            return this.handleCd(chatId, userId, t.slice(3).trim());
+        }
+        const cmd = t.split(/\s+/)[0];
+        if (TERMINAL_ONLY_COMMANDS.has(cmd)) {
+            await this.deps.sender.sendTextReply(chatId, `${cmd} 命令仅在终端可用。`);
+            return true;
+        }
+        return false;
+    }
+    async handleHelp(chatId, platform) {
+        const help = [
+            '📋 可用命令:',
+            '',
+            '/help - 显示帮助',
+            '/new - 开始新会话',
+            '/status - 显示状态',
+            '/cd <路径> - 切换工作目录',
+            '/pwd - 当前工作目录',
+            '/allow (/y) - 允许权限请求',
+            '/deny (/n) - 拒绝权限请求',
+        ].join('\n');
+        await this.deps.sender.sendTextReply(chatId, help);
+        return true;
+    }
+    async handleNew(chatId, userId) {
+        const ok = this.deps.sessionManager.newSession(userId);
+        await this.deps.sender.sendTextReply(chatId, ok ? '✅ 已开始新会话。' : '当前没有活动会话。');
+        return true;
+    }
+    async handlePwd(chatId, userId) {
+        const workDir = this.deps.sessionManager.getWorkDir(userId);
+        await this.deps.sender.sendTextReply(chatId, `当前工作目录: ${workDir}`);
+        return true;
+    }
+    async handleStatus(chatId, userId) {
+        const version = await this.getClaudeVersion();
+        const workDir = this.deps.sessionManager.getWorkDir(userId);
+        const convId = this.deps.sessionManager.getConvId(userId);
+        const sessionId = this.deps.sessionManager.getSessionIdForConv(userId, convId);
+        const record = this.deps.userCosts.get(userId);
+        const lines = [
+            '📊 状态:',
+            '',
+            `AI 工具: ${this.deps.config.aiCommand}`,
+            `版本: ${version}`,
+            `工作目录: ${workDir}`,
+            `会话: ${sessionId ?? '无'}`,
+            `费用: $${record?.totalCost.toFixed(4) ?? '0.0000'}`,
+        ];
+        await this.deps.sender.sendTextReply(chatId, lines.join('\n'));
+        return true;
+    }
+    async handleCd(chatId, userId, dir) {
+        if (!dir) {
+            await this.deps.sender.sendTextReply(chatId, `当前目录: ${this.deps.sessionManager.getWorkDir(userId)}\n使用 /cd <路径> 切换`);
+            return true;
+        }
+        try {
+            const resolved = await this.deps.sessionManager.setWorkDir(userId, dir);
+            await this.deps.sender.sendTextReply(chatId, `工作目录已切换到: ${resolved}\n会话已重置。`);
+        }
+        catch (err) {
+            await this.deps.sender.sendTextReply(chatId, err instanceof Error ? err.message : String(err));
+        }
+        return true;
+    }
+    async handleAllow(chatId) {
+        const reqId = resolveLatestPermission(chatId, 'allow');
+        if (reqId) {
+            const remaining = getPendingCount(chatId);
+            await this.deps.sender.sendTextReply(chatId, `✅ 权限已允许${remaining > 0 ? `（还有 ${remaining} 个待确认）` : ''}`);
+        }
+        else {
+            await this.deps.sender.sendTextReply(chatId, 'ℹ️ 没有待确认的权限请求');
+        }
+        return true;
+    }
+    async handleDeny(chatId) {
+        const reqId = resolveLatestPermission(chatId, 'deny');
+        if (reqId) {
+            await this.deps.sender.sendTextReply(chatId, '❌ 权限已拒绝');
+        }
+        else {
+            await this.deps.sender.sendTextReply(chatId, 'ℹ️ 没有待确认的权限请求');
+        }
+        return true;
+    }
+    getClaudeVersion() {
+        return new Promise((resolve) => {
+            execFile(this.deps.config.claudeCliPath, ['--version'], { timeout: 5000 }, (err, stdout) => {
+                resolve(err ? '未知' : (stdout?.toString().trim() || '未知'));
+            });
+        });
+    }
+}

package/dist/config.d.ts

@@ -0,0 +1,20 @@
+import type { LogLevel } from './logger.js';
+export type Platform = 'feishu' | 'telegram';
+export type AiCommand = 'claude' | 'codex' | 'cursor';
+export interface Config {
+    enabledPlatforms: Platform[];
+    telegramBotToken: string;
+    allowedUserIds: string[];
+    aiCommand: AiCommand;
+    claudeCliPath: string;
+    claudeWorkDir: string;
+    allowedBaseDirs: string[];
+    claudeSkipPermissions: boolean;
+    claudeTimeoutMs: number;
+    claudeModel?: string;
+    logDir: string;
+    logLevel: LogLevel;
+}
+/** 检测是否需要交互式配置（无 token 且无环境变量） */
+export declare function needsSetup(): boolean;
+export declare function loadConfig(): Config;

package/dist/config.js

@@ -0,0 +1,88 @@
+try {
+    await import('dotenv/config');
+}
+catch {
+    /* dotenv optional */
+}
+import { readFileSync, accessSync, constants } from 'node:fs';
+import { execFileSync } from 'node:child_process';
+import { join, isAbsolute } from 'node:path';
+import { APP_HOME } from './constants.js';
+const CONFIG_PATH = join(APP_HOME, 'config.json');
+function loadFileConfig() {
+    try {
+        return JSON.parse(readFileSync(CONFIG_PATH, 'utf-8'));
+    }
+    catch {
+        return {};
+    }
+}
+/** 检测是否需要交互式配置（无 token 且无环境变量） */
+export function needsSetup() {
+    if (process.env.TELEGRAM_BOT_TOKEN)
+        return false;
+    const file = loadFileConfig();
+    return !file.telegramBotToken;
+}
+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'] : [];
+    if (enabledPlatforms.length === 0) {
+        throw new Error('至少需要配置 TELEGRAM_BOT_TOKEN');
+    }
+    const allowedUserIds = process.env.ALLOWED_USER_IDS !== undefined
+        ? parseCommaSeparated(process.env.ALLOWED_USER_IDS)
+        : file.allowedUserIds ?? [];
+    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();
+    const allowedBaseDirs = process.env.ALLOWED_BASE_DIRS !== undefined
+        ? parseCommaSeparated(process.env.ALLOWED_BASE_DIRS)
+        : file.allowedBaseDirs ?? [];
+    if (allowedBaseDirs.length === 0)
+        allowedBaseDirs.push(claudeWorkDir);
+    const claudeSkipPermissions = process.env.CLAUDE_SKIP_PERMISSIONS !== undefined
+        ? process.env.CLAUDE_SKIP_PERMISSIONS === 'true'
+        : file.claudeSkipPermissions ?? true;
+    const claudeTimeoutMs = process.env.CLAUDE_TIMEOUT_MS !== undefined
+        ? parseInt(process.env.CLAUDE_TIMEOUT_MS, 10) || 600000
+        : file.claudeTimeoutMs ?? 600000;
+    if (aiCommand === 'claude') {
+        if (isAbsolute(claudeCliPath) || claudeCliPath.includes('/')) {
+            try {
+                accessSync(claudeCliPath, constants.F_OK | constants.X_OK);
+            }
+            catch {
+                throw new Error(`Claude CLI 不可执行: ${claudeCliPath}`);
+            }
+        }
+        else {
+            try {
+                execFileSync('which', [claudeCliPath], { stdio: 'pipe' });
+            }
+            catch {
+                throw new Error(`Claude CLI 在 PATH 中未找到: ${claudeCliPath}`);
+            }
+        }
+    }
+    const logDir = process.env.LOG_DIR ?? file.logDir ?? join(APP_HOME, 'logs');
+    const logLevel = (process.env.LOG_LEVEL?.toUpperCase() ?? file.logLevel ?? 'INFO');
+    return {
+        enabledPlatforms,
+        telegramBotToken,
+        allowedUserIds,
+        aiCommand,
+        claudeCliPath,
+        claudeWorkDir,
+        allowedBaseDirs,
+        claudeSkipPermissions,
+        claudeTimeoutMs,
+        claudeModel: process.env.CLAUDE_MODEL ?? file.claudeModel,
+        logDir,
+        logLevel,
+    };
+}

package/dist/constants.d.ts

@@ -0,0 +1,7 @@
+export declare const APP_HOME: string;
+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;
+export declare const MAX_TELEGRAM_MESSAGE_LENGTH = 4000;

package/dist/constants.js

@@ -0,0 +1,15 @@
+import { join } from 'node:path';
+import { homedir, tmpdir } from 'node:os';
+export const APP_HOME = join(homedir(), '.open-im');
+export const IMAGE_DIR = join(tmpdir(), 'open-im-images');
+export const READ_ONLY_TOOLS = [
+    'Read', 'Glob', 'Grep', 'WebFetch', 'WebSearch', 'Task', 'TodoRead',
+];
+export const TERMINAL_ONLY_COMMANDS = new Set([
+    '/context', '/rewind', '/resume', '/copy', '/export', '/config',
+    '/init', '/memory', '/permissions', '/theme', '/vim', '/statusline',
+    '/terminal-setup', '/debug', '/tasks', '/mcp', '/teleport', '/add-dir',
+]);
+export const DEDUP_TTL_MS = 5 * 60 * 1000;
+export const THROTTLE_MS = 200;
+export const MAX_TELEGRAM_MESSAGE_LENGTH = 4000;

package/dist/hook/permission-server.d.ts

@@ -0,0 +1,4 @@
+export declare function resolveLatestPermission(_chatId: string, _decision: 'allow' | 'deny'): string | null;
+export declare function getPendingCount(_chatId: string): number;
+export declare function resolvePermissionById(_requestId: string, _decision: 'allow' | 'deny'): boolean;
+export declare function registerPermissionSender(_platform: string, _sender: unknown): void;

package/dist/hook/permission-server.js

@@ -0,0 +1,12 @@
+export function resolveLatestPermission(_chatId, _decision) {
+    return null;
+}
+export function getPendingCount(_chatId) {
+    return 0;
+}
+export function resolvePermissionById(_requestId, _decision) {
+    return false;
+}
+export function registerPermissionSender(_platform, _sender) {
+    /* stub */
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export declare function main(): Promise<void>;

package/dist/index.js

@@ -0,0 +1,76 @@
+import { loadConfig, needsSetup } from './config.js';
+import { runInteractiveSetup } from './setup.js';
+import { initTelegram, stopTelegram } from './telegram/client.js';
+import { setupTelegramHandlers } from './telegram/event-handler.js';
+import { sendTextReply } from './telegram/message-sender.js';
+import { initAdapters } 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';
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+const { version: APP_VERSION } = require('../package.json');
+const log = createLogger('Main');
+async function sendLifecycleNotification(platform, message) {
+    const chatId = getActiveChatId('telegram');
+    if (!chatId)
+        return;
+    try {
+        await sendTextReply(chatId, message);
+    }
+    catch (err) {
+        log.debug('Failed to send lifecycle notification:', err);
+    }
+}
+export async function main() {
+    if (needsSetup()) {
+        const saved = await runInteractiveSetup();
+        if (!saved)
+            process.exit(1);
+    }
+    const config = loadConfig();
+    initLogger(config.logDir, config.logLevel);
+    loadActiveChats();
+    initAdapters(config);
+    log.info('Starting open-im bridge...');
+    log.info(`AI 工具: ${config.aiCommand}`);
+    log.info(`工作目录: ${config.claudeWorkDir}`);
+    const sessionManager = new SessionManager(config.claudeWorkDir, config.allowedBaseDirs);
+    let telegramHandle = null;
+    if (config.enabledPlatforms.includes('telegram')) {
+        await initTelegram(config, (bot) => {
+            telegramHandle = setupTelegramHandlers(bot, config, sessionManager);
+        });
+    }
+    log.info('Service is running. Press Ctrl+C to stop.');
+    const startupMsg = [
+        `🟢 open-im v${APP_VERSION} 服务已启动`,
+        '',
+        `AI 工具: ${config.aiCommand}`,
+        `工作目录: ${config.claudeWorkDir}`,
+    ].join('\n');
+    await sendLifecycleNotification('telegram', startupMsg).catch(() => { });
+    const startedAt = Date.now();
+    const shutdown = async () => {
+        log.info('Shutting down...');
+        const uptimeSec = Math.floor((Date.now() - startedAt) / 1000);
+        const m = Math.floor(uptimeSec / 60);
+        await sendLifecycleNotification('telegram', `🔴 open-im 服务正在关闭...\n运行时长: ${m}分钟`).catch(() => { });
+        telegramHandle?.stop();
+        stopTelegram();
+        sessionManager.destroy();
+        flushActiveChats();
+        closeLogger();
+        process.exit(0);
+    };
+    process.on('SIGINT', () => shutdown().catch(() => process.exit(1)));
+    process.on('SIGTERM', () => shutdown().catch(() => process.exit(1)));
+}
+const isEntry = process.argv[1]?.replace(/\\/g, '/').endsWith('/index.js') || process.argv[1]?.replace(/\\/g, '/').endsWith('/index.ts');
+if (isEntry) {
+    main().catch((err) => {
+        console.error('Fatal error:', err);
+        closeLogger();
+        process.exit(1);
+    });
+}

package/dist/logger.d.ts

@@ -0,0 +1,16 @@
+declare const LOG_LEVELS: {
+    readonly DEBUG: 0;
+    readonly INFO: 1;
+    readonly WARN: 2;
+    readonly ERROR: 3;
+};
+export type LogLevel = keyof typeof LOG_LEVELS;
+export declare function initLogger(dir?: string, level?: LogLevel): void;
+export declare function createLogger(tag: string): {
+    info: (msg: string, ...args: unknown[]) => void;
+    warn: (msg: string, ...args: unknown[]) => void;
+    error: (msg: string, ...args: unknown[]) => void;
+    debug: (msg: string, ...args: unknown[]) => void;
+};
+export declare function closeLogger(): void;
+export {};

package/dist/logger.js

@@ -0,0 +1,65 @@
+import { createWriteStream, mkdirSync, existsSync, readdirSync, statSync, unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+import { sanitize } from './sanitize.js';
+import { APP_HOME } from './constants.js';
+const DEFAULT_LOG_DIR = join(APP_HOME, 'logs');
+const MAX_LOG_FILES = 10;
+const LOG_LEVELS = { DEBUG: 0, INFO: 1, WARN: 2, ERROR: 3 };
+let logDir = DEFAULT_LOG_DIR;
+let minLevel = LOG_LEVELS.DEBUG;
+let logStream;
+function pad(n) {
+    return String(n).padStart(2, '0');
+}
+function getLogFileName() {
+    const d = new Date();
+    return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}.log`;
+}
+function rotateOldLogs() {
+    try {
+        const files = readdirSync(logDir)
+            .filter((f) => f.endsWith('.log'))
+            .map((f) => ({ name: f, time: statSync(join(logDir, f)).mtimeMs }))
+            .sort((a, b) => b.time - a.time);
+        for (let i = MAX_LOG_FILES; i < files.length; i++) {
+            unlinkSync(join(logDir, files[i].name));
+        }
+    }
+    catch {
+        /* ignore */
+    }
+}
+export function initLogger(dir, level) {
+    if (dir)
+        logDir = dir;
+    if (level)
+        minLevel = LOG_LEVELS[level] ?? LOG_LEVELS.DEBUG;
+    if (!existsSync(logDir))
+        mkdirSync(logDir, { recursive: true });
+    rotateOldLogs();
+    logStream = createWriteStream(join(logDir, getLogFileName()), { flags: 'a' });
+}
+function write(level, tag, msg, ...args) {
+    if (LOG_LEVELS[level] < minLevel)
+        return;
+    const d = new Date();
+    const ts = `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
+    const extra = args.length > 0 ? ' ' + args.map((a) => (a instanceof Error ? a.message : String(a))).join(' ') : '';
+    const line = sanitize(`${ts} [${level}] [${tag}] ${msg}${extra}\n`);
+    if (level === 'ERROR')
+        process.stderr.write(line);
+    else
+        process.stdout.write(line);
+    logStream?.write(line);
+}
+export function createLogger(tag) {
+    return {
+        info: (msg, ...args) => write('INFO', tag, msg, ...args),
+        warn: (msg, ...args) => write('WARN', tag, msg, ...args),
+        error: (msg, ...args) => write('ERROR', tag, msg, ...args),
+        debug: (msg, ...args) => write('DEBUG', tag, msg, ...args),
+    };
+}
+export function closeLogger() {
+    logStream?.end();
+}

package/dist/queue/request-queue.d.ts

@@ -0,0 +1,6 @@
+export type EnqueueResult = 'running' | 'queued' | 'rejected';
+export declare class RequestQueue {
+    private queues;
+    enqueue(userId: string, convId: string, prompt: string, execute: (prompt: string) => Promise<void>): EnqueueResult;
+    private run;
+}

package/dist/queue/request-queue.js

@@ -0,0 +1,43 @@
+import { createLogger } from '../logger.js';
+const log = createLogger('Queue');
+const MAX_QUEUE_SIZE = 3;
+export class RequestQueue {
+    queues = new Map();
+    enqueue(userId, convId, prompt, execute) {
+        const key = `${userId}:${convId}`;
+        let q = this.queues.get(key);
+        if (!q) {
+            q = { running: false, tasks: [] };
+            this.queues.set(key, q);
+        }
+        if (q.running && q.tasks.length >= MAX_QUEUE_SIZE)
+            return 'rejected';
+        if (q.running) {
+            q.tasks.push({ prompt, execute, enqueuedAt: Date.now() });
+            log.info(`Queued task for ${key}`);
+            return 'queued';
+        }
+        q.running = true;
+        this.run(key, prompt, execute);
+        return 'running';
+    }
+    async run(key, prompt, execute) {
+        try {
+            await execute(prompt);
+        }
+        catch (err) {
+            log.error(`Error executing task for ${key}:`, err);
+        }
+        const q = this.queues.get(key);
+        if (!q)
+            return;
+        const next = q.tasks.shift();
+        if (next) {
+            setImmediate(() => this.run(key, next.prompt, next.execute));
+        }
+        else {
+            q.running = false;
+            this.queues.delete(key);
+        }
+    }
+}

package/dist/sanitize.d.ts

@@ -0,0 +1 @@
+export declare function sanitize(text: string): string;

package/dist/sanitize.js

@@ -0,0 +1,11 @@
+const PATTERNS = [
+    [/\b(sk|pk|bot)[-_][a-zA-Z0-9_-]{8,}/gi, (m) => (m.match(/^[a-zA-Z]+/)?.[0] || m.slice(0, 2)) + '_****'],
+    [/\b(AIza|AKIA)[a-zA-Z0-9]{12,}/g, (m) => m.slice(0, 4) + '****'],
+];
+export function sanitize(text) {
+    let result = text;
+    for (const [re, replacer] of PATTERNS) {
+        result = result.replace(re, replacer);
+    }
+    return result;
+}

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

@@ -0,0 +1,26 @@
+export declare class SessionManager {
+    private sessions;
+    private convSessionMap;
+    private defaultWorkDir;
+    private allowedBaseDirs;
+    private saveTimer;
+    constructor(defaultWorkDir: string, allowedBaseDirs: string[]);
+    getSessionIdForConv(userId: string, convId: string): string | undefined;
+    setSessionIdForConv(userId: string, convId: string, sessionId: string): void;
+    getSessionIdForThread(_userId: string, _threadId: string): string | undefined;
+    setSessionIdForThread(userId: string, threadId: string, sessionId: string): void;
+    getWorkDir(userId: string): string;
+    getConvId(userId: string): string;
+    setWorkDir(userId: string, workDir: string): Promise<string>;
+    newSession(userId: string): boolean;
+    addTurns(userId: string, turns: number): number;
+    addTurnsForThread(userId: string, threadId: string, turns: number): number;
+    getModel(userId: string, threadId?: string): string | undefined;
+    setModel(userId: string, model: string | undefined, threadId?: string): void;
+    private resolveAndValidate;
+    private load;
+    private save;
+    private flushSync;
+    destroy(): void;
+    private doFlush;
+}