@wu529778790/open-im 0.1.0

package/dist/shared/utils.js

@@ -0,0 +1,72 @@
+const TOOL_EMOJIS = {
+    Read: '📖', Write: '✏️', Edit: '📝', Bash: '💻', Glob: '🔍', Grep: '🔎',
+    WebFetch: '🌐', WebSearch: '🔎', Task: '📋', TodoRead: '📌', TodoWrite: '✅',
+};
+function getToolEmoji(name) {
+    return TOOL_EMOJIS[name] ?? '🔧';
+}
+export function truncateText(text, maxLen) {
+    if (text.length <= maxLen)
+        return text;
+    const keepLen = maxLen - 20;
+    const tail = text.slice(text.length - keepLen);
+    const lineBreak = tail.indexOf('\n');
+    const clean = lineBreak > 0 && lineBreak < 200 ? tail.slice(lineBreak + 1) : tail;
+    return `...(前文已省略)...\n${clean}`;
+}
+export function splitLongContent(text, maxLen) {
+    if (text.length <= maxLen)
+        return [text];
+    const parts = [];
+    let start = 0;
+    while (start < text.length) {
+        let end = start + maxLen;
+        if (end >= text.length) {
+            parts.push(text.slice(start));
+            break;
+        }
+        const lastNewline = text.lastIndexOf('\n', end);
+        if (lastNewline > start)
+            end = lastNewline + 1;
+        parts.push(text.slice(start, end));
+        start = end;
+    }
+    return parts;
+}
+export function formatToolStats(toolStats, numTurns) {
+    const total = Object.values(toolStats).reduce((a, b) => a + b, 0);
+    if (total === 0)
+        return '';
+    const parts = Object.entries(toolStats)
+        .sort((a, b) => b[1] - a[1])
+        .map(([name, count]) => `${getToolEmoji(name)}${name}×${count}`)
+        .join(' ');
+    return `${numTurns > 0 ? numTurns + ' 轮 ' : ''}${total} 次工具（${parts}）`;
+}
+export function formatToolCallNotification(toolName, toolInput) {
+    const emoji = getToolEmoji(toolName);
+    if (!toolInput)
+        return `${emoji} ${toolName}`;
+    let detail = '';
+    if (toolName === 'Bash' && toolInput.command)
+        detail = ` → ${String(toolInput.command).slice(0, 60)}`;
+    if (toolName === 'Read' && toolInput.file_path)
+        detail = ` → ${toolInput.file_path}`;
+    if (toolName === 'Write' && toolInput.file_path)
+        detail = ` → ${toolInput.file_path}`;
+    return `${emoji} ${toolName}${detail}`;
+}
+export function trackCost(userCosts, userId, cost, durationMs) {
+    const r = userCosts.get(userId) ?? { totalCost: 0, totalDurationMs: 0, requestCount: 0 };
+    r.totalCost += cost;
+    r.totalDurationMs += durationMs;
+    r.requestCount += 1;
+    userCosts.set(userId, r);
+}
+export function getContextWarning(totalTurns) {
+    if (totalTurns >= 12)
+        return '⚠️ 上下文较长，建议 /new 开始新会话';
+    if (totalTurns >= 8)
+        return `💡 对话已 ${totalTurns} 轮，可用 /compact 压缩`;
+    return null;
+}

package/dist/telegram/client.d.ts

@@ -0,0 +1,6 @@
+import { Telegraf } from 'telegraf';
+import type { Config } from '../config.js';
+export declare function getBot(): Telegraf;
+export declare function getBotUsername(): string | undefined;
+export declare function initTelegram(config: Config, setupHandlers: (bot: Telegraf) => void): Promise<void>;
+export declare function stopTelegram(): void;

package/dist/telegram/client.js

@@ -0,0 +1,27 @@
+import { Telegraf } from 'telegraf';
+import { createLogger } from '../logger.js';
+const log = createLogger('Telegram');
+let bot;
+let botUsername;
+export function getBot() {
+    if (!bot)
+        throw new Error('Telegram bot not initialized');
+    return bot;
+}
+export function getBotUsername() {
+    return botUsername;
+}
+export async function initTelegram(config, setupHandlers) {
+    bot = new Telegraf(config.telegramBotToken);
+    setupHandlers(bot);
+    const me = (await bot.telegram.getMe());
+    botUsername = me.username;
+    bot.launch().catch((err) => {
+        log.error('Telegram polling error:', err);
+        process.exit(1);
+    });
+    log.info('Telegram bot launched');
+}
+export function stopTelegram() {
+    bot?.stop('SIGTERM');
+}

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

@@ -0,0 +1,8 @@
+import type { Telegraf } from 'telegraf';
+import type { Config } from '../config.js';
+import type { SessionManager } from '../session/session-manager.js';
+export interface TelegramEventHandlerHandle {
+    stop: () => void;
+    getRunningTaskCount: () => number;
+}
+export declare function setupTelegramHandlers(bot: Telegraf, config: Config, sessionManager: SessionManager): TelegramEventHandlerHandle;

package/dist/telegram/event-handler.js

@@ -0,0 +1,174 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { message } from 'telegraf/filters';
+import { AccessControl } from '../access/access-control.js';
+import { RequestQueue } from '../queue/request-queue.js';
+import { sendThinkingMessage, updateMessage, sendFinalMessages, sendTextReply, startTypingLoop, sendImageReply, } from './message-sender.js';
+import { registerPermissionSender, resolvePermissionById } from '../hook/permission-server.js';
+import { CommandHandler } from '../commands/handler.js';
+import { getAdapter } from '../adapters/registry.js';
+import { runAITask } from '../shared/ai-task.js';
+import { startTaskCleanup } from '../shared/task-cleanup.js';
+import { MessageDedup } from '../shared/message-dedup.js';
+import { THROTTLE_MS, IMAGE_DIR } from '../constants.js';
+import { setActiveChatId } from '../shared/active-chats.js';
+import { createLogger } from '../logger.js';
+const log = createLogger('TgHandler');
+async function downloadTelegramPhoto(bot, fileId) {
+    await mkdir(IMAGE_DIR, { recursive: true });
+    const fileLink = await bot.telegram.getFileLink(fileId);
+    const res = await fetch(fileLink.href, { signal: AbortSignal.timeout(30000) });
+    const buffer = Buffer.from(await res.arrayBuffer());
+    const safeId = fileId.replace(/[^a-zA-Z0-9_-]/g, '_');
+    const imagePath = join(IMAGE_DIR, `${Date.now()}-${safeId.slice(-8)}.jpg`);
+    await writeFile(imagePath, buffer);
+    return imagePath;
+}
+export function setupTelegramHandlers(bot, config, sessionManager) {
+    const accessControl = new AccessControl(config.allowedUserIds);
+    const requestQueue = new RequestQueue();
+    const userCosts = new Map();
+    const runningTasks = new Map();
+    const stopTaskCleanup = startTaskCleanup(runningTasks);
+    const dedup = new MessageDedup();
+    const commandHandler = new CommandHandler({
+        config,
+        sessionManager,
+        requestQueue,
+        sender: { sendTextReply },
+        userCosts,
+        getRunningTasksSize: () => runningTasks.size,
+    });
+    registerPermissionSender('telegram', {});
+    async function handleAIRequest(userId, chatId, prompt, workDir, convId, _threadCtx, replyToMessageId) {
+        const toolAdapter = getAdapter(config.aiCommand);
+        if (!toolAdapter) {
+            await sendTextReply(chatId, `未配置 AI 工具: ${config.aiCommand}`);
+            return;
+        }
+        const sessionId = convId ? sessionManager.getSessionIdForConv(userId, convId) : undefined;
+        log.info(`Running ${config.aiCommand} for user ${userId}, sessionId=${sessionId ?? 'new'}`);
+        const toolId = config.aiCommand;
+        let msgId;
+        try {
+            msgId = await sendThinkingMessage(chatId, replyToMessageId, toolId);
+        }
+        catch (err) {
+            log.error('Failed to send thinking message:', err);
+            return;
+        }
+        const stopTyping = startTypingLoop(chatId);
+        const taskKey = `${userId}:${msgId}`;
+        await runAITask({ config, sessionManager, userCosts }, { userId, chatId, workDir, sessionId, convId, platform: 'telegram', taskKey }, prompt, toolAdapter, {
+            throttleMs: THROTTLE_MS,
+            streamUpdate: (content, toolNote) => {
+                const note = toolNote ? '输出中...\n' + toolNote : '输出中...';
+                updateMessage(chatId, msgId, content, 'streaming', note, toolId).catch(() => { });
+            },
+            sendComplete: async (content, note) => {
+                await sendFinalMessages(chatId, msgId, content, note, toolId);
+            },
+            sendError: async (error) => {
+                await updateMessage(chatId, msgId, `错误：${error}`, 'error', '执行失败', toolId);
+            },
+            extraCleanup: () => {
+                stopTyping();
+                runningTasks.delete(taskKey);
+            },
+            onTaskReady: (state) => {
+                runningTasks.set(taskKey, state);
+            },
+            sendImage: (path) => sendImageReply(chatId, path),
+        });
+    }
+    bot.on('callback_query', async (ctx) => {
+        const query = ctx.callbackQuery;
+        if (!('data' in query))
+            return;
+        const userId = String(ctx.from?.id ?? '');
+        const data = query.data;
+        if (data.startsWith('stop_')) {
+            const messageId = data.replace('stop_', '');
+            const taskKey = `${userId}:${messageId}`;
+            const taskInfo = runningTasks.get(taskKey);
+            if (taskInfo) {
+                runningTasks.delete(taskKey);
+                taskInfo.settle();
+                taskInfo.handle.abort();
+                const chatId = String(ctx.chat?.id ?? '');
+                await updateMessage(chatId, messageId, taskInfo.latestContent || '已停止', 'error', '⏹️ 已停止', config.aiCommand);
+                await ctx.answerCbQuery('已停止执行');
+            }
+            else {
+                await ctx.answerCbQuery('任务已完成或不存在');
+            }
+        }
+        else if (data.startsWith('perm_allow_') || data.startsWith('perm_deny_')) {
+            const isAllow = data.startsWith('perm_allow_');
+            const requestId = data.replace(/^perm_(allow|deny)_/, '');
+            const decision = isAllow ? 'allow' : 'deny';
+            resolvePermissionById(requestId, decision);
+            await ctx.answerCbQuery(isAllow ? '✅ 已允许' : '❌ 已拒绝');
+        }
+    });
+    bot.on(message('text'), async (ctx) => {
+        const chatId = String(ctx.chat.id);
+        const userId = String(ctx.from.id);
+        const messageId = String(ctx.message.message_id);
+        let text = ctx.message.text.trim();
+        if (dedup.isDuplicate(`${chatId}:${messageId}`))
+            return;
+        if (!accessControl.isAllowed(userId)) {
+            await sendTextReply(chatId, '抱歉，您没有访问权限。\n您的 ID: ' + userId);
+            return;
+        }
+        setActiveChatId('telegram', chatId);
+        if (await commandHandler.dispatch(text, chatId, userId, 'telegram', handleAIRequest)) {
+            return;
+        }
+        const workDir = sessionManager.getWorkDir(userId);
+        const convId = sessionManager.getConvId(userId);
+        const enqueueResult = requestQueue.enqueue(userId, convId, text, async (prompt) => {
+            await handleAIRequest(userId, chatId, prompt, workDir, convId, undefined, messageId);
+        });
+        if (enqueueResult === 'rejected') {
+            await sendTextReply(chatId, '请求队列已满，请稍后再试。');
+        }
+        else if (enqueueResult === 'queued') {
+            await sendTextReply(chatId, '您的请求已排队等待。');
+        }
+    });
+    bot.on(message('photo'), async (ctx) => {
+        const chatId = String(ctx.chat.id);
+        const userId = String(ctx.from.id);
+        const caption = ctx.message.caption?.trim() || '';
+        if (dedup.isDuplicate(`${chatId}:${ctx.message.message_id}`))
+            return;
+        if (!accessControl.isAllowed(userId))
+            return;
+        setActiveChatId('telegram', chatId);
+        const photos = ctx.message.photo;
+        const largest = photos[photos.length - 1];
+        let imagePath;
+        try {
+            imagePath = await downloadTelegramPhoto(bot, largest.file_id);
+        }
+        catch (err) {
+            log.error('Failed to download photo:', err);
+            await sendTextReply(chatId, '图片下载失败。');
+            return;
+        }
+        const prompt = caption
+            ? `用户发送了一张图片（附言：${caption}），已保存到 ${imagePath}。请用 Read 工具查看并分析。`
+            : `用户发送了一张图片，已保存到 ${imagePath}。请用 Read 工具查看并分析。`;
+        const workDir = sessionManager.getWorkDir(userId);
+        const convId = sessionManager.getConvId(userId);
+        requestQueue.enqueue(userId, convId, prompt, async (p) => {
+            await handleAIRequest(userId, chatId, p, workDir, convId);
+        });
+    });
+    return {
+        stop: () => stopTaskCleanup(),
+        getRunningTaskCount: () => runningTasks.size,
+    };
+}

package/dist/telegram/message-sender.d.ts

@@ -0,0 +1,7 @@
+export type MessageStatus = 'thinking' | 'streaming' | 'done' | 'error';
+export declare function sendThinkingMessage(chatId: string, replyToMessageId?: string, toolId?: string): Promise<string>;
+export declare function updateMessage(chatId: string, messageId: string, content: string, status: MessageStatus, note?: string, toolId?: string): Promise<void>;
+export declare function sendFinalMessages(chatId: string, messageId: string, fullContent: string, note: string, toolId?: string): Promise<void>;
+export declare function sendTextReply(chatId: string, text: string): Promise<void>;
+export declare function sendImageReply(chatId: string, imagePath: string): Promise<void>;
+export declare function startTypingLoop(chatId: string): () => void;

package/dist/telegram/message-sender.js

@@ -0,0 +1,102 @@
+import { getBot } from './client.js';
+import { createReadStream } from 'node:fs';
+import { createLogger } from '../logger.js';
+import { splitLongContent, truncateText } from '../shared/utils.js';
+import { MAX_TELEGRAM_MESSAGE_LENGTH } from '../constants.js';
+const log = createLogger('TgSender');
+const STATUS_ICONS = {
+    thinking: '🔵',
+    streaming: '🔵',
+    done: '🟢',
+    error: '🔴',
+};
+const TOOL_DISPLAY_NAMES = {
+    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;
+}
+function formatMessage(content, status, note, toolId = 'claude') {
+    const icon = STATUS_ICONS[status];
+    const title = getToolTitle(toolId, status);
+    const text = truncateText(content, MAX_TELEGRAM_MESSAGE_LENGTH);
+    let out = `${icon} ${title}\n\n${text}`;
+    if (note)
+        out += `\n\n─────────\n${note}`;
+    return out;
+}
+function buildStopKeyboard(messageId) {
+    return {
+        inline_keyboard: [[{ text: '⏹️ 停止', callback_data: `stop_${messageId}` }]],
+    };
+}
+export async function sendThinkingMessage(chatId, replyToMessageId, toolId = 'claude') {
+    const bot = getBot();
+    const extra = {};
+    if (replyToMessageId) {
+        extra.reply_parameters = {
+            message_id: Number(replyToMessageId),
+        };
+    }
+    const msg = await bot.telegram.sendMessage(Number(chatId), formatMessage('正在思考...', 'thinking', '请稍候', toolId), { ...extra, parse_mode: 'Markdown' });
+    await bot.telegram.editMessageText(Number(chatId), msg.message_id, undefined, formatMessage('正在思考...', 'thinking', '请稍候', toolId), { reply_markup: buildStopKeyboard(msg.message_id), parse_mode: 'Markdown' });
+    return String(msg.message_id);
+}
+export async function updateMessage(chatId, messageId, content, status, note, toolId = 'claude') {
+    const bot = getBot();
+    const opts = {};
+    if (status === 'thinking' || status === 'streaming') {
+        opts.reply_markup = buildStopKeyboard(Number(messageId));
+    }
+    try {
+        await bot.telegram.editMessageText(Number(chatId), Number(messageId), undefined, formatMessage(content, status, note, toolId), { ...opts, parse_mode: 'Markdown' });
+    }
+    catch (err) {
+        if (err && typeof err === 'object' && 'message' in err && String(err.message).includes('not modified')) {
+            /* ignore */
+        }
+        else {
+            log.error('Failed to update message:', err);
+        }
+    }
+}
+export async function sendFinalMessages(chatId, messageId, fullContent, note, toolId = 'claude') {
+    const parts = splitLongContent(fullContent, MAX_TELEGRAM_MESSAGE_LENGTH);
+    await updateMessage(chatId, messageId, parts[0], 'done', note, toolId);
+    const bot = getBot();
+    for (let i = 1; i < parts.length; i++) {
+        try {
+            await bot.telegram.sendMessage(Number(chatId), formatMessage(parts[i], 'done', `(续 ${i + 1}/${parts.length}) ${note}`, toolId), { parse_mode: 'Markdown' });
+        }
+        catch (err) {
+            log.error('Failed to send continuation:', err);
+        }
+    }
+}
+export async function sendTextReply(chatId, text) {
+    const bot = getBot();
+    try {
+        await bot.telegram.sendMessage(Number(chatId), text, { parse_mode: 'Markdown' });
+    }
+    catch (err) {
+        log.error('Failed to send text:', err);
+    }
+}
+export async function sendImageReply(chatId, imagePath) {
+    const bot = getBot();
+    await bot.telegram.sendPhoto(Number(chatId), { source: createReadStream(imagePath) });
+}
+export function startTypingLoop(chatId) {
+    const bot = getBot();
+    const interval = setInterval(() => {
+        bot.telegram.sendChatAction(Number(chatId), 'typing').catch(() => { });
+    }, 4000);
+    return () => clearInterval(interval);
+}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@wu529778790/open-im",
+  "version": "0.1.0",
+  "description": "Multi-platform IM bridge for AI CLI tools (Claude, Codex, Cursor)",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "open-im": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    ".env.example"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/index.ts",
+    "start": "node dist/index.js",
+    "setup": "node dist/index.js --setup-only",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "telegram",
+    "feishu",
+    "claude",
+    "claude-code",
+    "bot",
+    "bridge"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/wu529778790/open-im.git"
+  },
+  "homepage": "https://github.com/wu529778790/open-im#readme",
+  "bugs": {
+    "url": "https://github.com/wu529778790/open-im/issues"
+  },
+  "dependencies": {
+    "prompts": "^2.4.2",
+    "telegraf": "^4.16.3"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "@types/prompts": "^2.4.9",
+    "dotenv": "^16.0.0",
+    "tsx": "^4.0.0",
+    "typescript": "^5.0.0"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}