@wu529778790/open-im 0.1.0

package/.env.example

@@ -0,0 +1,16 @@
+# Telegram Bot Token (from @BotFather)
+TELEGRAM_BOT_TOKEN=
+
+# Allowed user IDs (comma-separated, empty = allow all in dev)
+ALLOWED_USER_IDS=
+
+# AI tool: claude | codex | cursor
+AI_COMMAND=claude
+
+# Claude CLI (when AI_COMMAND=claude)
+CLAUDE_CLI_PATH=claude
+CLAUDE_WORK_DIR=.
+CLAUDE_SKIP_PERMISSIONS=true
+CLAUDE_TIMEOUT_MS=600000
+CLAUDE_MODEL=
+ALLOWED_BASE_DIRS=

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 wu529778790
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,51 @@
+# open-im
+
+多平台 IM 桥接，支持多种 AI CLI 工具（Claude Code、Codex、Cursor 等）。
+
+## 功能
+
+- **多 AI 工具**：通过 `AI_COMMAND` 配置切换 Claude / Codex / Cursor
+- **流式输出**：节流更新，Telegram editMessage 实时展示
+- **会话管理**：每用户独立 session，`/new` 重置
+- **命令**：`/help` `/new` `/cd` `/pwd` `/status`
+
+## 快速开始
+
+### 快速开始
+
+```bash
+npm run build
+npm run dev   # 或 npm start
+```
+
+首次运行会进入交互式配置，按提示输入后自动启动服务。配置保存到 `~/.open-im/config.json`。
+
+## 配置
+
+| 变量 | 说明 |
+|------|------|
+| `TELEGRAM_BOT_TOKEN` | Telegram Bot Token |
+| `ALLOWED_USER_IDS` | 白名单用户 ID（逗号分隔，空=所有人） |
+| `AI_COMMAND` | `claude` \| `codex` \| `cursor`，默认 `claude` |
+| `CLAUDE_CLI_PATH` | Claude CLI 路径，默认 `claude` |
+| `CLAUDE_WORK_DIR` | 工作目录 |
+| `CLAUDE_SKIP_PERMISSIONS` | 跳过权限确认，默认 `true` |
+
+## 项目结构
+
+```
+src/
+├── adapters/          # ToolAdapter 抽象与实现
+│   ├── tool-adapter.interface.ts
+│   ├── claude-adapter.ts
+│   └── registry.ts
+├── claude/            # Claude CLI 运行与解析
+├── shared/            # ai-task、utils、types
+├── telegram/          # Telegram 事件与消息
+├── session/           # 会话管理
+└── commands/          # 命令分发
+```
+
+## License
+
+MIT

package/dist/access/access-control.d.ts

@@ -0,0 +1,5 @@
+export declare class AccessControl {
+    private allowedUserIds;
+    constructor(allowedUserIds: string[]);
+    isAllowed(userId: string): boolean;
+}

package/dist/access/access-control.js

@@ -0,0 +1,11 @@
+export class AccessControl {
+    allowedUserIds;
+    constructor(allowedUserIds) {
+        this.allowedUserIds = new Set(allowedUserIds);
+    }
+    isAllowed(userId) {
+        if (this.allowedUserIds.size === 0)
+            return true;
+        return this.allowedUserIds.has(userId);
+    }
+}

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

@@ -0,0 +1,7 @@
+import type { ToolAdapter, RunCallbacks, RunOptions, RunHandle } from './tool-adapter.interface.js';
+export declare class ClaudeAdapter implements ToolAdapter {
+    private cliPath;
+    readonly toolId = "claude";
+    constructor(cliPath: string);
+    run(prompt: string, sessionId: string | undefined, workDir: string, callbacks: RunCallbacks, options?: RunOptions): RunHandle;
+}

package/dist/adapters/claude-adapter.js

@@ -0,0 +1,17 @@
+import { runClaude } from '../claude/cli-runner.js';
+export class ClaudeAdapter {
+    cliPath;
+    toolId = 'claude';
+    constructor(cliPath) {
+        this.cliPath = cliPath;
+    }
+    run(prompt, sessionId, workDir, callbacks, options) {
+        return runClaude(this.cliPath, prompt, sessionId, workDir, callbacks, {
+            skipPermissions: options?.skipPermissions,
+            timeoutMs: options?.timeoutMs,
+            model: options?.model,
+            chatId: options?.chatId,
+            hookPort: options?.hookPort,
+        });
+    }
+}

package/dist/adapters/registry.d.ts

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

package/dist/adapters/registry.js

@@ -0,0 +1,11 @@
+import { ClaudeAdapter } from './claude-adapter.js';
+const adapters = new Map();
+export function initAdapters(config) {
+    adapters.clear();
+    if (config.aiCommand === 'claude') {
+        adapters.set('claude', new ClaudeAdapter(config.claudeCliPath));
+    }
+}
+export function getAdapter(aiCommand) {
+    return adapters.get(aiCommand);
+}

package/dist/adapters/tool-adapter.interface.d.ts

@@ -0,0 +1,35 @@
+/**
+ * ToolAdapter 接口 - 多 AI CLI 统一抽象
+ */
+export interface ParsedResult {
+    success: boolean;
+    result: string;
+    accumulated: string;
+    cost: number;
+    durationMs: number;
+    model?: string;
+    numTurns: number;
+    toolStats: Record<string, number>;
+}
+export interface RunCallbacks {
+    onText: (accumulated: string) => void;
+    onThinking?: (accumulated: string) => void;
+    onToolUse?: (toolName: string, toolInput?: Record<string, unknown>) => void;
+    onComplete: (result: ParsedResult) => void;
+    onError: (error: string) => void;
+    onSessionId?: (sessionId: string) => void;
+}
+export interface RunOptions {
+    skipPermissions?: boolean;
+    timeoutMs?: number;
+    model?: string;
+    chatId?: string;
+    hookPort?: number;
+}
+export interface RunHandle {
+    abort: () => void;
+}
+export interface ToolAdapter {
+    readonly toolId: string;
+    run(prompt: string, sessionId: string | undefined, workDir: string, callbacks: RunCallbacks, options?: RunOptions): RunHandle;
+}

package/dist/adapters/tool-adapter.interface.js

@@ -0,0 +1,4 @@
+/**
+ * ToolAdapter 接口 - 多 AI CLI 统一抽象
+ */
+export {};

package/dist/claude/cli-runner.d.ts

@@ -0,0 +1,28 @@
+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 ClaudeRunOptions {
+    skipPermissions?: boolean;
+    timeoutMs?: number;
+    model?: string;
+    chatId?: string;
+    hookPort?: number;
+}
+export interface ClaudeRunHandle {
+    abort: () => void;
+}
+export declare function runClaude(cliPath: string, prompt: string, sessionId: string | undefined, workDir: string, callbacks: ClaudeRunCallbacks, options?: ClaudeRunOptions): ClaudeRunHandle;

package/dist/claude/cli-runner.js

@@ -0,0 +1,166 @@
+import { spawn } from 'node:child_process';
+import { createInterface } from 'node:readline';
+import { parseStreamLine, extractTextDelta, extractThinkingDelta, extractResult } from './stream-parser.js';
+import { isStreamInit, isContentBlockStart, isContentBlockDelta, isContentBlockStop } from './types.js';
+import { createLogger } from '../logger.js';
+const log = createLogger('CliRunner');
+export function runClaude(cliPath, prompt, sessionId, workDir, callbacks, options) {
+    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);
+    const env = {};
+    for (const [k, v] of Object.entries(process.env)) {
+        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);
+    const child = spawn(cliPath, args, { cwd: workDir, stdio: ['ignore', 'pipe', 'pipe'], env });
+    log.debug(`Claude CLI spawned: pid=${child.pid}, cwd=${workDir}, session=${sessionId ?? 'new'}`);
+    let accumulated = '';
+    let accumulatedThinking = '';
+    let completed = false;
+    let model = '';
+    const toolStats = {};
+    const pendingToolInputs = new Map();
+    const MAX_TIMEOUT = 2_147_483_647;
+    const timeoutMs = options?.timeoutMs && options.timeoutMs > 0 ? Math.min(options.timeoutMs, MAX_TIMEOUT) : 0;
+    let timeoutHandle = null;
+    if (timeoutMs > 0) {
+        timeoutHandle = setTimeout(() => {
+            if (!completed && !child.killed) {
+                completed = true;
+                log.warn(`Claude CLI timeout after ${timeoutMs}ms, killing pid=${child.pid}`);
+                child.kill('SIGTERM');
+                callbacks.onError(`执行超时（${timeoutMs}ms），已终止进程`);
+            }
+        }, timeoutMs);
+    }
+    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);
+        }
+        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) {
+            completed = true;
+            if (timeoutHandle)
+                clearTimeout(timeoutHandle);
+            const fullResult = {
+                ...result,
+                accumulated,
+                model,
+                toolStats,
+            };
+            if (!accumulated && fullResult.result)
+                accumulated = fullResult.result;
+            callbacks.onComplete(fullResult);
+        }
+    });
+    let exitCode = null;
+    let rlClosed = false;
+    let childClosed = false;
+    const finalize = () => {
+        if (!rlClosed || !childClosed)
+            return;
+        if (timeoutHandle)
+            clearTimeout(timeoutHandle);
+        if (!completed) {
+            if (exitCode !== null && exitCode !== 0) {
+                callbacks.onError(`Claude CLI exited with code ${exitCode}`);
+            }
+            else {
+                callbacks.onComplete({
+                    success: true,
+                    result: accumulated,
+                    accumulated,
+                    cost: 0,
+                    durationMs: 0,
+                    model,
+                    numTurns: 0,
+                    toolStats,
+                });
+            }
+        }
+    };
+    child.on('close', (code) => {
+        exitCode = code;
+        childClosed = true;
+        finalize();
+    });
+    rl.on('close', () => {
+        rlClosed = true;
+        finalize();
+    });
+    child.on('error', (err) => {
+        log.error(`Claude CLI error: ${err.message}`);
+        if (timeoutHandle)
+            clearTimeout(timeoutHandle);
+        if (!completed) {
+            completed = true;
+            callbacks.onError(`Failed to start Claude CLI: ${err.message}`);
+        }
+        childClosed = true;
+        finalize();
+    });
+    return {
+        abort: () => {
+            if (timeoutHandle)
+                clearTimeout(timeoutHandle);
+            rl.close();
+            if (!child.killed)
+                child.kill('SIGTERM');
+        },
+    };
+}

package/dist/claude/stream-parser.d.ts

@@ -0,0 +1,17 @@
+import type { StreamEvent } from './types.js';
+export declare function parseStreamLine(line: string): StreamEvent | null;
+export declare function extractTextDelta(event: StreamEvent): {
+    text: string;
+} | null;
+export declare function extractThinkingDelta(event: StreamEvent): {
+    text: string;
+} | null;
+export declare function extractResult(event: StreamEvent): {
+    success: boolean;
+    result: string;
+    accumulated: string;
+    cost: number;
+    durationMs: number;
+    numTurns: number;
+    toolStats: Record<string, number>;
+} | null;

package/dist/claude/stream-parser.js

@@ -0,0 +1,50 @@
+export function parseStreamLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return null;
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (typeof parsed === 'object' && parsed !== null && 'type' in parsed) {
+            return parsed;
+        }
+    }
+    catch {
+        /* ignore */
+    }
+    return null;
+}
+export function extractTextDelta(event) {
+    const e = event;
+    if (e.type === 'stream_event' &&
+        e.event?.type === 'content_block_delta' &&
+        e.event.delta?.type === 'text_delta' &&
+        e.event.delta.text) {
+        return { text: e.event.delta.text };
+    }
+    return null;
+}
+export function extractThinkingDelta(event) {
+    const e = event;
+    if (e.type === 'stream_event' &&
+        e.event?.type === 'content_block_delta' &&
+        e.event.delta?.type === 'thinking_delta' &&
+        e.event.delta.thinking) {
+        return { text: e.event.delta.thinking };
+    }
+    return null;
+}
+export function extractResult(event) {
+    if (event.type === 'result' && 'subtype' in event) {
+        const e = event;
+        return {
+            success: e.subtype === 'success',
+            result: e.result,
+            accumulated: '',
+            cost: e.total_cost_usd ?? 0,
+            durationMs: e.duration_ms ?? 0,
+            numTurns: e.num_turns ?? 0,
+            toolStats: {},
+        };
+    }
+    return null;
+}

package/dist/claude/types.d.ts

@@ -0,0 +1,54 @@
+export interface StreamInit {
+    type: 'system';
+    subtype: 'init';
+    session_id: string;
+    model: string;
+}
+export interface StreamContentBlockDelta {
+    type: 'stream_event';
+    event: {
+        type: 'content_block_delta';
+        index: number;
+        delta: {
+            type: string;
+            text?: string;
+            thinking?: string;
+            partial_json?: string;
+        };
+    };
+}
+export interface StreamContentBlockStop {
+    type: 'stream_event';
+    event: {
+        type: 'content_block_stop';
+        index: number;
+    };
+}
+export interface StreamContentBlockStart {
+    type: 'stream_event';
+    event: {
+        type: 'content_block_start';
+        index: number;
+        content_block: {
+            type: string;
+            name?: string;
+        };
+    };
+}
+export interface StreamResult {
+    type: 'result';
+    subtype: 'success' | 'error';
+    result: string;
+    total_cost_usd: number;
+    duration_ms: number;
+    num_turns: number;
+}
+export type StreamEvent = StreamInit | StreamContentBlockDelta | StreamContentBlockStart | StreamContentBlockStop | StreamResult | {
+    type: string;
+    [key: string]: unknown;
+};
+export declare function isStreamInit(e: StreamEvent): e is StreamInit;
+export declare function isContentBlockDelta(e: StreamEvent): e is StreamContentBlockDelta;
+export declare function isContentBlockStart(e: StreamEvent): e is StreamContentBlockStart;
+export declare function isContentBlockStop(e: StreamEvent): e is StreamContentBlockStop;
+export declare function isStreamResult(e: StreamEvent): e is StreamResult;

package/dist/claude/types.js

@@ -0,0 +1,21 @@
+export function isStreamInit(e) {
+    return e.type === 'system' && 'subtype' in e && e.subtype === 'init';
+}
+export function isContentBlockDelta(e) {
+    return (e.type === 'stream_event' &&
+        typeof e.event === 'object' &&
+        e.event.type === 'content_block_delta');
+}
+export function isContentBlockStart(e) {
+    return (e.type === 'stream_event' &&
+        typeof e.event === 'object' &&
+        e.event.type === 'content_block_start');
+}
+export function isContentBlockStop(e) {
+    return (e.type === 'stream_event' &&
+        typeof e.event === 'object' &&
+        e.event.type === 'content_block_stop');
+}
+export function isStreamResult(e) {
+    return e.type === 'result' && 'subtype' in e;
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+import { main } from './index.js';
+main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/dist/commands/handler.d.ts

@@ -0,0 +1,30 @@
+import type { Config } from '../config.js';
+import type { SessionManager } from '../session/session-manager.js';
+import type { RequestQueue } from '../queue/request-queue.js';
+import type { ThreadContext, CostRecord } from '../shared/types.js';
+export type { ThreadContext, CostRecord };
+export interface MessageSender {
+    sendTextReply(chatId: string, text: string, threadCtx?: ThreadContext): Promise<void>;
+}
+export interface CommandHandlerDeps {
+    config: Config;
+    sessionManager: SessionManager;
+    requestQueue: RequestQueue;
+    sender: MessageSender;
+    userCosts: Map<string, CostRecord>;
+    getRunningTasksSize: () => number;
+}
+export type ClaudeRequestHandler = (userId: string, chatId: string, prompt: string, workDir: string, convId?: string, threadCtx?: ThreadContext, replyToMessageId?: string) => Promise<void>;
+export declare class CommandHandler {
+    private deps;
+    constructor(deps: CommandHandlerDeps);
+    dispatch(text: string, chatId: string, userId: string, platform: 'feishu' | 'telegram', handleClaudeRequest: ClaudeRequestHandler): Promise<boolean>;
+    private handleHelp;
+    private handleNew;
+    private handlePwd;
+    private handleStatus;
+    private handleCd;
+    private handleAllow;
+    private handleDeny;
+    private getClaudeVersion;
+}