@wu529778790/open-im 0.1.0

package/dist/session/session-manager.js

@@ -0,0 +1,207 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
+import { realpath } from 'node:fs/promises';
+import { randomBytes } from 'node:crypto';
+import { dirname, join, resolve } from 'node:path';
+import { createLogger } from '../logger.js';
+import { APP_HOME } from '../constants.js';
+const log = createLogger('Session');
+const SESSIONS_FILE = join(APP_HOME, 'data', 'sessions.json');
+export class SessionManager {
+    sessions = new Map();
+    convSessionMap = new Map();
+    defaultWorkDir;
+    allowedBaseDirs;
+    saveTimer = null;
+    constructor(defaultWorkDir, allowedBaseDirs) {
+        this.defaultWorkDir = defaultWorkDir;
+        this.allowedBaseDirs = allowedBaseDirs;
+        this.load();
+    }
+    getSessionIdForConv(userId, convId) {
+        const s = this.sessions.get(userId);
+        if (s?.activeConvId === convId)
+            return s.sessionId;
+        return this.convSessionMap.get(`${userId}:${convId}`);
+    }
+    setSessionIdForConv(userId, convId, sessionId) {
+        const s = this.sessions.get(userId);
+        if (s?.activeConvId === convId) {
+            s.sessionId = sessionId;
+            this.save();
+        }
+        else {
+            this.convSessionMap.set(`${userId}:${convId}`, sessionId);
+        }
+    }
+    getSessionIdForThread(_userId, _threadId) {
+        return undefined;
+    }
+    setSessionIdForThread(userId, threadId, sessionId) {
+        const s = this.sessions.get(userId);
+        if (s && !s.threads)
+            s.threads = {};
+        const t = s?.threads?.[threadId];
+        if (t) {
+            t.sessionId = sessionId;
+            this.save();
+        }
+    }
+    getWorkDir(userId) {
+        return this.sessions.get(userId)?.workDir ?? this.defaultWorkDir;
+    }
+    getConvId(userId) {
+        const s = this.sessions.get(userId);
+        if (s) {
+            if (!s.activeConvId) {
+                s.activeConvId = randomBytes(4).toString('hex');
+                this.save();
+            }
+            return s.activeConvId;
+        }
+        const convId = randomBytes(4).toString('hex');
+        this.sessions.set(userId, { workDir: this.defaultWorkDir, activeConvId: convId });
+        this.save();
+        return convId;
+    }
+    async setWorkDir(userId, workDir) {
+        const currentDir = this.getWorkDir(userId);
+        const realPath = await this.resolveAndValidate(currentDir, workDir);
+        const s = this.sessions.get(userId);
+        if (s) {
+            if (s.activeConvId && s.sessionId) {
+                this.convSessionMap.set(`${userId}:${s.activeConvId}`, s.sessionId);
+            }
+            s.workDir = realPath;
+            s.sessionId = undefined;
+            s.activeConvId = randomBytes(4).toString('hex');
+        }
+        else {
+            this.sessions.set(userId, {
+                workDir: realPath,
+                activeConvId: randomBytes(4).toString('hex'),
+            });
+        }
+        this.flushSync();
+        log.info(`WorkDir changed for user ${userId}: ${realPath}`);
+        return realPath;
+    }
+    newSession(userId) {
+        const s = this.sessions.get(userId);
+        if (s) {
+            if (s.activeConvId && s.sessionId) {
+                this.convSessionMap.set(`${userId}:${s.activeConvId}`, s.sessionId);
+            }
+            s.sessionId = undefined;
+            s.activeConvId = randomBytes(4).toString('hex');
+            s.totalTurns = 0;
+            this.flushSync();
+            return true;
+        }
+        return false;
+    }
+    addTurns(userId, turns) {
+        const s = this.sessions.get(userId);
+        if (!s)
+            return 0;
+        s.totalTurns = (s.totalTurns ?? 0) + turns;
+        this.save();
+        return s.totalTurns;
+    }
+    addTurnsForThread(userId, threadId, turns) {
+        const s = this.sessions.get(userId);
+        const t = s?.threads?.[threadId];
+        if (!t)
+            return 0;
+        t.totalTurns = (t.totalTurns ?? 0) + turns;
+        this.save();
+        return t.totalTurns;
+    }
+    getModel(userId, threadId) {
+        const s = this.sessions.get(userId);
+        if (threadId) {
+            const t = s?.threads?.[threadId];
+            if (t?.claudeModel)
+                return t.claudeModel;
+        }
+        return s?.claudeModel;
+    }
+    setModel(userId, model, threadId) {
+        const s = this.sessions.get(userId);
+        if (threadId) {
+            const t = s?.threads?.[threadId];
+            if (t) {
+                t.claudeModel = model;
+                this.save();
+                return;
+            }
+        }
+        if (s)
+            s.claudeModel = model;
+        else
+            this.sessions.set(userId, { workDir: this.defaultWorkDir, activeConvId: randomBytes(4).toString('hex'), claudeModel: model });
+        this.save();
+    }
+    async resolveAndValidate(baseDir, targetDir) {
+        const resolved = resolve(baseDir, targetDir);
+        if (!existsSync(resolved))
+            throw new Error(`目录不存在: ${resolved}`);
+        const realPath = await realpath(resolved);
+        const allowed = this.allowedBaseDirs.some((base) => realPath === base || realPath.startsWith(base + '/'));
+        if (!allowed)
+            throw new Error(`目录不在允许范围内: ${realPath}`);
+        return realPath;
+    }
+    load() {
+        try {
+            if (existsSync(SESSIONS_FILE)) {
+                const data = JSON.parse(readFileSync(SESSIONS_FILE, 'utf-8'));
+                for (const [k, v] of Object.entries(data)) {
+                    if (v && typeof v.workDir === 'string') {
+                        if (!v.activeConvId)
+                            v.activeConvId = randomBytes(4).toString('hex');
+                        this.sessions.set(k, v);
+                    }
+                }
+            }
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    save() {
+        if (this.saveTimer)
+            return;
+        this.saveTimer = setTimeout(() => {
+            this.saveTimer = null;
+            this.doFlush();
+        }, 500);
+    }
+    flushSync() {
+        if (this.saveTimer) {
+            clearTimeout(this.saveTimer);
+            this.saveTimer = null;
+        }
+        this.doFlush();
+    }
+    destroy() {
+        if (this.saveTimer) {
+            clearTimeout(this.saveTimer);
+            this.saveTimer = null;
+        }
+        this.doFlush();
+    }
+    doFlush() {
+        try {
+            const dir = dirname(SESSIONS_FILE);
+            if (!existsSync(dir))
+                mkdirSync(dir, { recursive: true });
+            const obj = {};
+            for (const [k, v] of this.sessions)
+                obj[k] = v;
+            writeFileSync(SESSIONS_FILE, JSON.stringify(obj, null, 2), 'utf-8');
+        }
+        catch (err) {
+            log.error('Failed to save sessions:', err);
+        }
+    }
+}

package/dist/setup.d.ts

@@ -0,0 +1,5 @@
+/**
+ * 首次运行时的交互式配置引导
+ * 使用 prompts 库，兼容 tsx watch、IDE 终端等环境
+ */
+export declare function runInteractiveSetup(): Promise<boolean>;

package/dist/setup.js

@@ -0,0 +1,97 @@
+/**
+ * 首次运行时的交互式配置引导
+ * 使用 prompts 库，兼容 tsx watch、IDE 终端等环境
+ */
+import prompts from 'prompts';
+import { mkdirSync, writeFileSync, existsSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { APP_HOME } from './constants.js';
+function printManualInstructions(configPath) {
+    console.log('\n━━━ open-im 首次配置 ━━━\n');
+    console.log('当前环境不支持交互输入，请手动创建配置文件：');
+    console.log('');
+    console.log('  1. 创建目录:', dirname(configPath));
+    console.log('  2. 创建文件:', configPath);
+    console.log('  3. 填入以下内容（替换为你的 Token 和用户 ID）：');
+    console.log('');
+    console.log(`{
+  "telegramBotToken": "你的Bot Token",
+  "allowedUserIds": ["你的Telegram用户ID"],
+  "claudeWorkDir": "${process.cwd().replace(/\\/g, '/')}",
+  "claudeSkipPermissions": true,
+  "aiCommand": "claude"
+}`);
+    console.log('');
+    console.log('或设置环境变量: TELEGRAM_BOT_TOKEN=xxx 后再运行');
+    console.log('');
+}
+export async function runInteractiveSetup() {
+    const configPath = join(APP_HOME, 'config.json');
+    const forceManual = process.argv.includes('--manual') || process.argv.includes('-m');
+    if (forceManual || !process.stdin.isTTY) {
+        printManualInstructions(configPath);
+        return false;
+    }
+    console.log('\n━━━ open-im 首次配置 ━━━\n');
+    console.log('配置将保存到:', configPath);
+    console.log('');
+    const onCancel = () => {
+        console.log('\n已取消配置。');
+        process.exit(0);
+    };
+    const response = await prompts([
+        {
+            type: 'text',
+            name: 'telegramBotToken',
+            message: 'Telegram Bot Token（必填，从 @BotFather 获取）',
+            validate: (v) => (v.trim() ? true : 'Token 不能为空'),
+        },
+        {
+            type: 'text',
+            name: 'allowedUserIds',
+            message: '白名单用户 ID（可选，逗号分隔，留空=所有人可访问）',
+            initial: '',
+        },
+        {
+            type: 'select',
+            name: 'aiCommand',
+            message: 'AI 工具（↑↓ 选择）',
+            choices: [
+                { title: 'claude-code', value: 'claude' },
+                { title: 'codex', value: 'codex' },
+                { title: 'cursor', value: 'cursor' },
+            ],
+            initial: 0,
+        },
+        {
+            type: 'text',
+            name: 'workDir',
+            message: '工作目录',
+            initial: process.cwd(),
+        },
+    ], { onCancel });
+    if (!response.telegramBotToken) {
+        console.log('\n未输入 Token，取消配置。');
+        return false;
+    }
+    const config = {
+        telegramBotToken: response.telegramBotToken.trim(),
+        allowedUserIds: response.allowedUserIds
+            ? response.allowedUserIds
+                .split(',')
+                .map((s) => s.trim())
+                .filter(Boolean)
+            : [],
+        claudeWorkDir: (response.workDir || process.cwd()).trim(),
+        claudeSkipPermissions: true,
+        aiCommand: response.aiCommand ?? 'claude',
+    };
+    const dir = dirname(configPath);
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf-8');
+    console.log('\n✅ 配置已保存到', configPath);
+    console.log('');
+    return true;
+}

package/dist/shared/active-chats.d.ts

@@ -0,0 +1,4 @@
+export declare function loadActiveChats(): void;
+export declare function getActiveChatId(platform: 'feishu' | 'telegram'): string | undefined;
+export declare function setActiveChatId(platform: 'feishu' | 'telegram', chatId: string): void;
+export declare function flushActiveChats(): void;

package/dist/shared/active-chats.js

@@ -0,0 +1,55 @@
+import { readFileSync, existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { writeFile, mkdir } from 'node:fs/promises';
+import { join, dirname } from 'node:path';
+import { APP_HOME } from '../constants.js';
+const ACTIVE_CHATS_FILE = join(APP_HOME, 'data', 'active-chats.json');
+let data = {};
+let saveTimer = null;
+function scheduleSave() {
+    if (saveTimer)
+        clearTimeout(saveTimer);
+    saveTimer = setTimeout(async () => {
+        saveTimer = null;
+        try {
+            await mkdir(dirname(ACTIVE_CHATS_FILE), { recursive: true });
+            await writeFile(ACTIVE_CHATS_FILE, JSON.stringify(data, null, 2), 'utf-8');
+        }
+        catch {
+            /* ignore */
+        }
+    }, 500);
+}
+export function loadActiveChats() {
+    try {
+        if (existsSync(ACTIVE_CHATS_FILE)) {
+            data = JSON.parse(readFileSync(ACTIVE_CHATS_FILE, 'utf-8'));
+        }
+    }
+    catch {
+        data = {};
+    }
+}
+export function getActiveChatId(platform) {
+    return data[platform];
+}
+export function setActiveChatId(platform, chatId) {
+    if (data[platform] === chatId)
+        return;
+    data[platform] = chatId;
+    scheduleSave();
+}
+export function flushActiveChats() {
+    if (saveTimer) {
+        clearTimeout(saveTimer);
+        saveTimer = null;
+    }
+    try {
+        const dir = dirname(ACTIVE_CHATS_FILE);
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        writeFileSync(ACTIVE_CHATS_FILE, JSON.stringify(data, null, 2), 'utf-8');
+    }
+    catch {
+        /* ignore */
+    }
+}

package/dist/shared/ai-task.d.ts

@@ -0,0 +1,42 @@
+/**
+ * 共享 AI 任务执行层 - 支持多 ToolAdapter
+ */
+import type { Config } from '../config.js';
+import type { SessionManager } from '../session/session-manager.js';
+import type { ToolAdapter } from '../adapters/tool-adapter.interface.js';
+import type { CostRecord } from './types.js';
+export interface TaskDeps {
+    config: Config;
+    sessionManager: SessionManager;
+    userCosts: Map<string, CostRecord>;
+}
+export interface TaskContext {
+    userId: string;
+    chatId: string;
+    workDir: string;
+    sessionId: string | undefined;
+    convId?: string;
+    threadId?: string;
+    platform: string;
+    taskKey: string;
+}
+export interface TaskAdapter {
+    streamUpdate(content: string, toolNote?: string): void;
+    sendComplete(content: string, note: string, thinkingText?: string): Promise<void>;
+    sendError(error: string): Promise<void>;
+    onThinkingToText?(content: string): void;
+    extraCleanup?(): void;
+    throttleMs: number;
+    onTaskReady(state: TaskRunState): void;
+    onFirstContent?(): void;
+    sendImage?(imagePath: string): Promise<void>;
+}
+export interface TaskRunState {
+    handle: {
+        abort: () => void;
+    };
+    latestContent: string;
+    settle: () => void;
+    startedAt: number;
+}
+export declare function runAITask(deps: TaskDeps, ctx: TaskContext, prompt: string, toolAdapter: ToolAdapter, platformAdapter: TaskAdapter): Promise<void>;

package/dist/shared/ai-task.js

@@ -0,0 +1,167 @@
+/**
+ * 共享 AI 任务执行层 - 支持多 ToolAdapter
+ */
+import { formatToolStats, formatToolCallNotification, trackCost, getContextWarning, } from './utils.js';
+import { createLogger } from '../logger.js';
+const log = createLogger('AITask');
+function buildCompletionNote(result, sessionManager, ctx) {
+    const toolInfo = formatToolStats(result.toolStats, result.numTurns);
+    const parts = [];
+    if (result.cost > 0) {
+        parts.push(`耗时 ${(result.durationMs / 1000).toFixed(1)}s`);
+        parts.push(`费用 $${result.cost.toFixed(4)}`);
+    }
+    else {
+        parts.push('完成');
+    }
+    if (toolInfo)
+        parts.push(toolInfo);
+    if (result.model)
+        parts.push(result.model);
+    const totalTurns = ctx.threadId
+        ? sessionManager.addTurnsForThread(ctx.userId, ctx.threadId, result.numTurns)
+        : sessionManager.addTurns(ctx.userId, result.numTurns);
+    const ctxWarning = getContextWarning(totalTurns);
+    if (ctxWarning)
+        parts.push(ctxWarning);
+    return parts.join(' | ');
+}
+export function runAITask(deps, ctx, prompt, toolAdapter, platformAdapter) {
+    const { config, sessionManager, userCosts } = deps;
+    return new Promise((resolve) => {
+        let lastUpdateTime = 0;
+        let pendingUpdate = null;
+        let settled = false;
+        let firstContentLogged = false;
+        let wasThinking = false;
+        let thinkingText = '';
+        const toolLines = [];
+        const startTime = Date.now();
+        const cleanup = () => {
+            if (pendingUpdate) {
+                clearTimeout(pendingUpdate);
+                pendingUpdate = null;
+            }
+            platformAdapter.extraCleanup?.();
+        };
+        const settle = () => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            resolve();
+        };
+        let taskState;
+        const throttledUpdate = (content) => {
+            taskState.latestContent = content;
+            const now = Date.now();
+            const elapsed = now - lastUpdateTime;
+            if (elapsed >= platformAdapter.throttleMs) {
+                lastUpdateTime = now;
+                if (pendingUpdate) {
+                    clearTimeout(pendingUpdate);
+                    pendingUpdate = null;
+                }
+                const toolNote = toolLines.length > 0 ? toolLines.slice(-3).join('\n') : undefined;
+                platformAdapter.streamUpdate(content, toolNote);
+            }
+            else if (!pendingUpdate) {
+                pendingUpdate = setTimeout(() => {
+                    pendingUpdate = null;
+                    lastUpdateTime = Date.now();
+                    const toolNote = toolLines.length > 0 ? toolLines.slice(-3).join('\n') : undefined;
+                    platformAdapter.streamUpdate(taskState.latestContent, toolNote);
+                }, platformAdapter.throttleMs - elapsed);
+            }
+        };
+        const handle = toolAdapter.run(prompt, ctx.sessionId, ctx.workDir, {
+            onSessionId: (id) => {
+                if (ctx.threadId)
+                    sessionManager.setSessionIdForThread(ctx.userId, ctx.threadId, id);
+                else if (ctx.convId)
+                    sessionManager.setSessionIdForConv(ctx.userId, ctx.convId, id);
+            },
+            onThinking: (t) => {
+                if (!firstContentLogged) {
+                    firstContentLogged = true;
+                    platformAdapter.onFirstContent?.();
+                }
+                wasThinking = true;
+                thinkingText = t;
+                throttledUpdate(`💭 **思考中...**\n\n${t}`);
+            },
+            onText: (accumulated) => {
+                if (!firstContentLogged) {
+                    firstContentLogged = true;
+                    platformAdapter.onFirstContent?.();
+                }
+                if (wasThinking && platformAdapter.onThinkingToText) {
+                    wasThinking = false;
+                    if (pendingUpdate) {
+                        clearTimeout(pendingUpdate);
+                        pendingUpdate = null;
+                    }
+                    lastUpdateTime = Date.now();
+                    taskState.latestContent = accumulated;
+                    platformAdapter.onThinkingToText(accumulated);
+                    return;
+                }
+                wasThinking = false;
+                throttledUpdate(accumulated);
+            },
+            onToolUse: (toolName, toolInput) => {
+                const notification = formatToolCallNotification(toolName, toolInput);
+                toolLines.push(notification);
+                if (toolLines.length > 5)
+                    toolLines.shift();
+                throttledUpdate(taskState.latestContent);
+            },
+            onComplete: async (result) => {
+                if (settled)
+                    return;
+                settled = true;
+                if (pendingUpdate) {
+                    clearTimeout(pendingUpdate);
+                    pendingUpdate = null;
+                }
+                const note = buildCompletionNote(result, sessionManager, ctx);
+                log.info(`Task completed for user ${ctx.userId}: cost=$${result.cost.toFixed(4)}`);
+                trackCost(userCosts, ctx.userId, result.cost, result.durationMs);
+                const finalContent = result.accumulated || result.result || '(无输出)';
+                try {
+                    await platformAdapter.sendComplete(finalContent, note, thinkingText || undefined);
+                }
+                catch (err) {
+                    log.error('Failed to send complete:', err);
+                }
+                cleanup();
+                resolve();
+            },
+            onError: async (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                if (pendingUpdate) {
+                    clearTimeout(pendingUpdate);
+                    pendingUpdate = null;
+                }
+                log.error(`Task error for user ${ctx.userId}: ${error}`);
+                try {
+                    await platformAdapter.sendError(error);
+                }
+                catch (err) {
+                    log.error('Failed to send error:', err);
+                }
+                cleanup();
+                resolve();
+            },
+        }, {
+            skipPermissions: config.claudeSkipPermissions,
+            timeoutMs: config.claudeTimeoutMs,
+            model: sessionManager.getModel(ctx.userId, ctx.threadId) ?? config.claudeModel,
+            chatId: ctx.chatId,
+        });
+        taskState = { handle, latestContent: '', settle, startedAt: Date.now() };
+        platformAdapter.onTaskReady(taskState);
+    });
+}

package/dist/shared/message-dedup.d.ts

@@ -0,0 +1,4 @@
+export declare class MessageDedup {
+    private processedMessages;
+    isDuplicate(messageId: string): boolean;
+}

package/dist/shared/message-dedup.js

@@ -0,0 +1,25 @@
+import { DEDUP_TTL_MS } from '../constants.js';
+const MAX_DEDUP_SIZE = 1000;
+export class MessageDedup {
+    processedMessages = new Map();
+    isDuplicate(messageId) {
+        const now = Date.now();
+        if (this.processedMessages.has(messageId))
+            return true;
+        this.processedMessages.set(messageId, now);
+        for (const [id, ts] of this.processedMessages) {
+            if (now - ts > DEDUP_TTL_MS)
+                this.processedMessages.delete(id);
+            else
+                break;
+        }
+        while (this.processedMessages.size > MAX_DEDUP_SIZE) {
+            const k = this.processedMessages.keys().next().value;
+            if (k !== undefined)
+                this.processedMessages.delete(k);
+            else
+                break;
+        }
+        return false;
+    }
+}

package/dist/shared/task-cleanup.d.ts

@@ -0,0 +1,2 @@
+import type { TaskRunState } from './ai-task.js';
+export declare function startTaskCleanup(runningTasks: Map<string, TaskRunState>): () => void;

package/dist/shared/task-cleanup.js

@@ -0,0 +1,19 @@
+import { createLogger } from '../logger.js';
+const log = createLogger('TaskCleanup');
+const TASK_TIMEOUT_MS = 30 * 60 * 1000;
+const INTERVAL_MS = 10 * 60 * 1000;
+export function startTaskCleanup(runningTasks) {
+    const timer = setInterval(() => {
+        const now = Date.now();
+        for (const [key, task] of runningTasks) {
+            if (now - task.startedAt > TASK_TIMEOUT_MS) {
+                log.warn(`Auto-cleaning timeout task: ${key}`);
+                task.settle();
+                task.handle.abort();
+                runningTasks.delete(key);
+            }
+        }
+    }, INTERVAL_MS);
+    timer.unref();
+    return () => clearInterval(timer);
+}

package/dist/shared/types.d.ts

@@ -0,0 +1,9 @@
+export interface ThreadContext {
+    rootMessageId: string;
+    threadId: string;
+}
+export interface CostRecord {
+    totalCost: number;
+    totalDurationMs: number;
+    requestCount: number;
+}

package/dist/shared/types.js

@@ -0,0 +1 @@
+export {};

package/dist/shared/utils.d.ts

@@ -0,0 +1,7 @@
+import type { CostRecord } from './types.js';
+export declare function truncateText(text: string, maxLen: number): string;
+export declare function splitLongContent(text: string, maxLen: number): string[];
+export declare function formatToolStats(toolStats: Record<string, number>, numTurns: number): string;
+export declare function formatToolCallNotification(toolName: string, toolInput?: Record<string, unknown>): string;
+export declare function trackCost(userCosts: Map<string, CostRecord>, userId: string, cost: number, durationMs: number): void;
+export declare function getContextWarning(totalTurns: number): string | null;