@wu529778790/open-im 1.6.2 → 1.6.3-beta.2

package/dist/dingtalk/event-handler.js

@@ -1,3 +1,4 @@
+import { resolvePlatformAiCommand } from '../config.js';
 import { AccessControl } from '../access/access-control.js';
 import { RequestQueue } from '../queue/request-queue.js';
 import { configureDingTalkMessageSender, sendThinkingMessage, updateMessage, sendFinalMessages, sendErrorMessage, sendTextReply, sendImageReply, startTypingLoop, sendPermissionCard, sendModeCard, sendDirectorySelection, } from './message-sender.js';
@@ -175,16 +176,17 @@ export function setupDingTalkHandlers(config, sessionManager) {
     }
     async function handleAIRequest(userId, chatId, prompt, workDir, convId, _threadCtx, replyToMessageId, dingtalkTarget) {
         log.info(`[AI_REQUEST] userId=${userId}, chatId=${chatId}, promptLength=${prompt.length}`);
-        const toolAdapter = getAdapter(config.aiCommand);
+        const aiCommand = resolvePlatformAiCommand(config, 'dingtalk');
+        const toolAdapter = getAdapter(aiCommand);
         if (!toolAdapter) {
-            await sendTextReply(chatId, `AI tool is not configured: ${config.aiCommand}`);
+            await sendTextReply(chatId, `AI tool is not configured: ${aiCommand}`);
             return;
         }
         const sessionId = convId
-            ? sessionManager.getSessionIdForConv(userId, convId, config.aiCommand)
+            ? sessionManager.getSessionIdForConv(userId, convId, aiCommand)
             : undefined;
-        log.info(`[AI_REQUEST] Running ${config.aiCommand} for user ${userId}, sessionId=${sessionId ?? 'new'}`);
-        const toolId = config.aiCommand;
+        log.info(`[AI_REQUEST] Running ${aiCommand} for user ${userId}, sessionId=${sessionId ?? 'new'}`);
+        const toolId = aiCommand;
         const msgId = await sendThinkingMessage(chatId, replyToMessageId, toolId, dingtalkTarget);
         const stopTyping = startTypingLoop(chatId);
         const taskKey = `${userId}:${msgId}`;

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

@@ -1,4 +1,4 @@
-import type { Config } from '../config.js';
+import { type Config } from '../config.js';
 import type { SessionManager } from '../session/session-manager.js';
 export interface FeishuEventHandlerHandle {
     stop: () => void;

package/dist/feishu/event-handler.js

@@ -1,3 +1,4 @@
+import { resolvePlatformAiCommand } from '../config.js';
 import { AccessControl } from '../access/access-control.js';
 import { RequestQueue } from '../queue/request-queue.js';
 import { sendTextReply, sendTextReplyByOpenId, startTypingLoop, sendImageReply, createFeishuButtonCard, sendModeCard, createFeishuModeCardReadOnly, delayUpdateCard, sendThinkingCard, streamContentUpdate, sendFinalCards, sendErrorCard, } from './message-sender.js';
@@ -91,16 +92,17 @@ export function setupFeishuHandlers(config, sessionManager) {
     async function handleAIRequest(userId, chatId, prompt, workDir, convId, _threadCtx, replyToMessageId) {
         log.info(`[AI_REQUEST] userId=${userId}, chatId=${chatId}, promptLength=${prompt.length}`);
         log.info(`[AI_REQUEST] Full prompt: "${prompt}"`);
-        const toolAdapter = getAdapter(config.aiCommand);
+        const aiCommand = resolvePlatformAiCommand(config, 'feishu');
+        const toolAdapter = getAdapter(aiCommand);
         if (!toolAdapter) {
-            log.error(`[handleAIRequest] No adapter found for: ${config.aiCommand}`);
-            await sendTextReply(chatId, `未配置 AI 工具: ${config.aiCommand}`);
+            log.error(`[handleAIRequest] No adapter found for: ${aiCommand}`);
+            await sendTextReply(chatId, `未配置 AI 工具: ${aiCommand}`);
             return;
         }
         log.info(`[handleAIRequest] Adapter found, getting session...`);
-        const sessionId = convId ? sessionManager.getSessionIdForConv(userId, convId, config.aiCommand) : undefined;
-        log.info(`[handleAIRequest] Running ${config.aiCommand} for user ${userId}, sessionId=${sessionId ?? 'new'}`);
-        const toolId = config.aiCommand;
+        const sessionId = convId ? sessionManager.getSessionIdForConv(userId, convId, aiCommand) : undefined;
+        log.info(`[handleAIRequest] Running ${aiCommand} for user ${userId}, sessionId=${sessionId ?? 'new'}`);
+        const toolId = aiCommand;
         // 使用 CardKit 打字机效果（80ms 节流，约 12 次/秒，比 patch 5 QPS 更流畅）
         let cardHandle;
         try {

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

@@ -9,6 +9,7 @@ interface MessageSender {
     sendTextReply(chatId: string, text: string): Promise<void>;
     sendPermissionCard?(chatId: string, requestId: string, toolName: string, toolInput: string): Promise<void>;
 }
+export declare function resolvePermissionChatId(data: Record<string, unknown>): string | undefined;
 /**
  * Start the permission HTTP server
  */

package/dist/hook/permission-server.js

@@ -11,6 +11,15 @@ import { getPlatformByChatId } from '../shared/chat-user-map.js';
 const log = createLogger('PermissionServer');
 const PERMISSION_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes default timeout
 const DEFAULT_PORT = 35801;
+export function resolvePermissionChatId(data) {
+    if (typeof data.chatId === 'string' && data.chatId.trim()) {
+        return data.chatId;
+    }
+    if (typeof data.chat_id === 'string' && data.chat_id.trim()) {
+        return data.chat_id;
+    }
+    return undefined;
+}
 // Global state
 let server = null;
 let serverPort = DEFAULT_PORT;
@@ -153,19 +162,16 @@ function handlePermissionRequest(req, res) {
             const requestId = String(data.requestId ?? '');
             const toolName = String(data.toolName ?? '');
             const toolInput = data.toolInput;
-            const chatId = (typeof data.chatId === 'string' ? data.chatId : null) ??
-                (typeof data.chat_id === 'string' ? data.chat_id : null) ??
-                process.env.CC_IM_CHAT_ID ??
-                undefined;
+            const chatId = resolvePermissionChatId(data);
             if (!requestId || !toolName) {
                 res.writeHead(400, { 'Content-Type': 'application/json' });
                 res.end(JSON.stringify({ error: 'Missing required fields' }));
                 return;
             }
             if (!chatId) {
-                log.warn('No chatId, auto-allowing permission');
-                res.writeHead(200, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ allowed: true }));
+                log.warn(`Permission request ${requestId} missing chatId`);
+                res.writeHead(400, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Missing chatId' }));
                 return;
             }
             if (process.env.CC_SKIP_PERMISSIONS === 'true') {

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

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

package/dist/hook/permission-server.test.js

@@ -0,0 +1,12 @@
+import { describe, expect, it } from "vitest";
+import { resolvePermissionChatId } from "./permission-server.js";
+describe("resolvePermissionChatId", () => {
+    it("prefers explicit chatId fields from the request payload", () => {
+        expect(resolvePermissionChatId({ chatId: "chat-1" })).toBe("chat-1");
+        expect(resolvePermissionChatId({ chat_id: "chat-2" })).toBe("chat-2");
+    });
+    it("does not fall back to process-global state", () => {
+        process.env.CC_IM_CHAT_ID = "leaked-chat";
+        expect(resolvePermissionChatId({})).toBeUndefined();
+    });
+});

package/dist/index.js

@@ -1,7 +1,7 @@
 import { createServer } from "node:http";
 import { writeFileSync, existsSync, mkdirSync, unlinkSync } from "node:fs";
 import { dirname, join } from "node:path";
-import { loadConfig, needsSetup } from "./config.js";
+import { getConfiguredAiCommands, loadConfig, needsSetup, resolvePlatformAiCommand } from "./config.js";
 import { runInteractiveSetup, runClaudeApiSetup } from "./setup.js";
 import { runWebConfigFlow } from "./config-web.js";
 // 导出供 cli.ts 使用
@@ -77,7 +77,7 @@ async function sendLifecycleNotification(platform, message) {
     }
     await Promise.all(sendPromises);
 }
-function buildStartupMessage(platform, appVersion, aiCommand, defaultWorkDir, successfulPlatforms, sessionManager) {
+function buildStartupMessage(platform, appVersion, aiCommand, defaultWorkDir, sessionManager) {
     let sessionDir;
     // Telegram 私聊、企业微信当前实现里，活跃 chatId 可直接对应到 session userId。
     if (platform === "telegram" || platform === "wework") {
@@ -86,13 +86,12 @@ function buildStartupMessage(platform, appVersion, aiCommand, defaultWorkDir, su
             sessionDir = sessionManager.getWorkDir(activeChatId);
         }
     }
-    const platformList = successfulPlatforms.map((item) => `\`${item}\``).join("、");
     const lines = [
         `**服务已启动**`,
         "",
         `- 版本: \`open-im v${appVersion}\``,
-        `- AI 工具: \`${aiCommand}\``,
-        `- 成功启动平台: ${platformList}`,
+        `- 当前渠道: \`${platform}\``,
+        `- 当前渠道 CLI: \`${aiCommand}\``,
     ];
     if (sessionDir) {
         lines.push(`- 会话目录: ${escapePathForMarkdown(sessionDir)}`);
@@ -151,15 +150,13 @@ export async function main() {
     const actualPort = startPermissionServer(config.hookPort);
     log.info(`Permission server listening on port ${actualPort}`);
     log.info("Starting open-im bridge...");
-    log.info(`AI 工具: ${config.aiCommand}`);
+    log.info(`AI 工具: ${getConfiguredAiCommands(config).join(", ")}`);
     log.info(`默认会话目录: ${config.claudeWorkDir}`);
     log.info(`启用平台: ${config.enabledPlatforms.join(", ")}`);
     const sessionManager = new SessionManager(config.claudeWorkDir);
     // CLI 工具（Cursor/Codex）的 session 是进程级别的，服务重启后一定无效。
     // 启动时仅清除 CLI 工具自己的 sessionId，保留 Claude 的持久上下文。
-    if (config.aiCommand !== 'claude') {
-        sessionManager.clearAllCliSessionIds();
-    }
+    sessionManager.clearAllCliSessionIds();
     let telegramHandle = null;
     let feishuHandle = null;
     let qqHandle = null;
@@ -237,7 +234,7 @@ export async function main() {
     log.info(`Successfully initialized platforms: ${successfulPlatforms.join(", ")}`);
     // Send notification only to successfully initialized platforms
     for (const platform of successfulPlatforms) {
-        const startupMsg = buildStartupMessage(platform, APP_VERSION, config.aiCommand, config.claudeWorkDir, successfulPlatforms, sessionManager);
+        const startupMsg = buildStartupMessage(platform, APP_VERSION, resolvePlatformAiCommand(config, platform), config.claudeWorkDir, sessionManager);
         await sendLifecycleNotification(platform, startupMsg).catch((err) => {
             log.warn(`Failed to send startup notification to ${platform}:`, err);
         });

package/dist/manager.js

@@ -1,9 +1,10 @@
 import { startWebConfigServer } from "./config-web.js";
 import { removeManagerPid, removeManagerReady, writeManagerReady } from "./manager-control.js";
-import { startBackgroundService, stopBackgroundService } from "./service-control.js";
+import { startBackgroundService, stopBackgroundService, waitForBackgroundServiceReady } from "./service-control.js";
 async function main() {
     const web = await startWebConfigServer({ mode: "start", cwd: process.cwd(), persistent: true });
     startBackgroundService(process.cwd());
+    await waitForBackgroundServiceReady();
     writeManagerReady();
     const shutdown = async () => {
         await web.close().catch((err) => console.warn("[manager] Failed to close web server:", err));

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

@@ -1,4 +1,4 @@
-import type { Config } from "../config.js";
+import { type Config } from "../config.js";
 import type { SessionManager } from "../session/session-manager.js";
 import type { QQMessageEvent } from "./types.js";
 export interface QQEventHandlerHandle {

package/dist/qq/event-handler.js

@@ -1,3 +1,4 @@
+import { resolvePlatformAiCommand } from "../config.js";
 import { AccessControl } from "../access/access-control.js";
 import { RequestQueue } from "../queue/request-queue.js";
 import { sendThinkingMessage, updateMessage, sendFinalMessages, sendErrorMessage, sendTextReply, sendImageReply, sendModeKeyboard, sendDirectorySelection, startTypingLoop, } from "./message-sender.js";
@@ -135,15 +136,16 @@ export function setupQQHandlers(config, sessionManager) {
         });
     }
     async function handleAIRequest(userId, chatId, prompt, workDir, convId, _threadCtx, replyToMessageId) {
-        const toolAdapter = getAdapter(config.aiCommand);
+        const aiCommand = resolvePlatformAiCommand(config, "qq");
+        const toolAdapter = getAdapter(aiCommand);
         if (!toolAdapter) {
-            await sendTextReply(chatId, `AI tool is not configured: ${config.aiCommand}`);
+            await sendTextReply(chatId, `AI tool is not configured: ${aiCommand}`);
             return;
         }
         const sessionId = convId
-            ? sessionManager.getSessionIdForConv(userId, convId, config.aiCommand)
+            ? sessionManager.getSessionIdForConv(userId, convId, aiCommand)
             : undefined;
-        const toolId = config.aiCommand;
+        const toolId = aiCommand;
         const msgId = await sendThinkingMessage(chatId, replyToMessageId, toolId);
         const stopTyping = startTypingLoop();
         const taskKey = `${userId}:${msgId}`;

package/dist/qq/event-handler.test.js

@@ -46,6 +46,13 @@ describe("QQ event handler", () => {
             aiCommand: "codex",
             qqAllowedUserIds: ["user-1"],
             defaultPermissionMode: "ask",
+            platforms: {
+                qq: {
+                    enabled: true,
+                    aiCommand: "codex",
+                    allowedUserIds: ["user-1"],
+                },
+            },
         };
         const sessionManager = {
             getWorkDir: vi.fn(() => "D:\\coding\\open-im"),

package/dist/service-control.d.ts

@@ -9,6 +9,7 @@ export declare function getServiceStatus(): {
 export declare function startBackgroundService(cwd: string): {
     pid: number;
 };
+export declare function waitForBackgroundServiceReady(timeoutMs?: number, pollIntervalMs?: number): Promise<void>;
 export declare function stopBackgroundService(): Promise<{
     pid: number | null;
     stopped: boolean;

package/dist/service-control.js

@@ -6,6 +6,15 @@ import { APP_HOME, SHUTDOWN_PORT } from "./constants.js";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const PID_FILE = join(APP_HOME, "open-im-worker.pid");
 const PORT_FILE = join(APP_HOME, "open-im.port");
+function removePortFile() {
+    try {
+        if (existsSync(PORT_FILE))
+            unlinkSync(PORT_FILE);
+    }
+    catch {
+        /* ignore */
+    }
+}
 function getServiceEntry() {
     const extension = extname(fileURLToPath(import.meta.url));
     if (extension === ".ts") {
@@ -64,6 +73,7 @@ export function getServiceStatus() {
         return { running: false, pid: null };
     if (!isRunning(pid)) {
         removePid();
+        removePortFile();
         return { running: false, pid: null };
     }
     return { running: true, pid };
@@ -74,6 +84,7 @@ export function startBackgroundService(cwd) {
         return { pid: current.pid };
     }
     removePid();
+    removePortFile();
     const entry = getServiceEntry();
     const child = spawn(entry.command, entry.args, {
         detached: true,
@@ -89,6 +100,20 @@ export function startBackgroundService(cwd) {
     writePid(child.pid);
     return { pid: child.pid };
 }
+export async function waitForBackgroundServiceReady(timeoutMs = 8000, pollIntervalMs = 100) {
+    const startedAt = Date.now();
+    while (Date.now() - startedAt < timeoutMs) {
+        const status = getServiceStatus();
+        if (!status.running || !status.pid) {
+            throw new Error("Background service exited before becoming ready.");
+        }
+        if (existsSync(PORT_FILE)) {
+            return;
+        }
+        await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+    }
+    throw new Error("Background service did not become ready in time.");
+}
 export async function stopBackgroundService() {
     const pid = getPid();
     if (!pid)
@@ -120,12 +145,6 @@ export async function stopBackgroundService() {
         process.kill(pid, "SIGKILL");
     }
     removePid();
-    try {
-        if (existsSync(PORT_FILE))
-            unlinkSync(PORT_FILE);
-    }
-    catch {
-        /* ignore */
-    }
+    removePortFile();
     return { pid, stopped: true };
 }

package/dist/service-control.test.d.ts

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

package/dist/service-control.test.js

@@ -0,0 +1,36 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+const { execFileSyncMock, existsSyncMock, readFileSyncMock, unlinkSyncMock, writeFileSyncMock, spawnMock } = vi.hoisted(() => ({
+    execFileSyncMock: vi.fn(),
+    existsSyncMock: vi.fn(),
+    readFileSyncMock: vi.fn(),
+    unlinkSyncMock: vi.fn(),
+    writeFileSyncMock: vi.fn(),
+    spawnMock: vi.fn(),
+}));
+vi.mock("node:child_process", () => ({
+    execFileSync: execFileSyncMock,
+    spawn: spawnMock,
+}));
+vi.mock("node:fs", () => ({
+    existsSync: existsSyncMock,
+    readFileSync: readFileSyncMock,
+    unlinkSync: unlinkSyncMock,
+    writeFileSync: writeFileSyncMock,
+}));
+import { waitForBackgroundServiceReady } from "./service-control.js";
+describe("waitForBackgroundServiceReady", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        execFileSyncMock.mockReturnValue(Buffer.from("node.exe 123 Console 1 10,000 K"));
+    });
+    it("returns once the worker pid is running and the port file appears", async () => {
+        existsSyncMock.mockImplementation((target) => target.includes("worker.pid") || target.includes("open-im.port"));
+        readFileSyncMock.mockImplementation((target) => (target.includes("worker.pid") ? "123" : "39281"));
+        await expect(waitForBackgroundServiceReady(20, 0)).resolves.toBeUndefined();
+    });
+    it("fails if the worker never becomes ready", async () => {
+        existsSyncMock.mockImplementation((target) => target.includes("worker.pid"));
+        readFileSyncMock.mockReturnValue("123");
+        await expect(waitForBackgroundServiceReady(10, 0)).rejects.toThrow("Background service did not become ready in time.");
+    });
+});

package/dist/shared/ai-task.js

@@ -5,6 +5,9 @@ import { getPermissionMode } from '../permission-mode/session-mode.js';
 import { formatToolStats, formatToolCallNotification, getContextWarning, getAIToolDisplayName, } from './utils.js';
 import { createLogger } from '../logger.js';
 const log = createLogger('AITask');
+function isUsageLimitError(error) {
+    return /usage limit/i.test(error) || /try again at\s+\d{1,2}:\d{2}\s*(AM|PM)/i.test(error);
+}
 function buildCompletionNote(result, sessionManager, ctx, mode) {
     const toolInfo = formatToolStats(result.toolStats, result.numTurns);
     const parts = [];
@@ -34,6 +37,8 @@ export function runAITask(deps, ctx, prompt, toolAdapter, platformAdapter) {
         let firstContentLogged = false;
         let wasThinking = false;
         let thinkingText = '';
+        let currentSessionId = ctx.sessionId;
+        let activeHandle = null;
         const toolLines = [];
         const minDelta = platformAdapter.minContentDeltaChars ?? 0;
         const cleanup = () => {
@@ -79,7 +84,6 @@ export function runAITask(deps, ctx, prompt, toolAdapter, platformAdapter) {
             }
         };
         const mode = getPermissionMode(ctx.userId, config.defaultPermissionMode);
-        process.env.CC_IM_CHAT_ID = ctx.chatId;
         let skipPermissions;
         let permissionMode;
         if (mode === 'plan') {
@@ -99,115 +103,135 @@ export function runAITask(deps, ctx, prompt, toolAdapter, platformAdapter) {
         const timeoutMs = config.aiCommand === 'codex'
             ? config.codexTimeoutMs
             : config.claudeTimeoutMs;
-        const handle = toolAdapter.run(prompt, ctx.sessionId, ctx.workDir, {
-            onSessionId: (id) => {
-                if (ctx.threadId)
-                    sessionManager.setSessionIdForThread(ctx.userId, ctx.threadId, config.aiCommand, id);
-                else if (ctx.convId)
-                    sessionManager.setSessionIdForConv(ctx.userId, ctx.convId, config.aiCommand, id);
-            },
-            onSessionInvalid: () => {
-                if (ctx.convId)
-                    sessionManager.clearSessionForConv(ctx.userId, ctx.convId, config.aiCommand);
-            },
-            onThinking: (t) => {
-                if (!firstContentLogged) {
-                    firstContentLogged = true;
-                    platformAdapter.onFirstContent?.();
-                }
-                wasThinking = true;
-                thinkingText = t;
-                throttledUpdate(`💭 **${getAIToolDisplayName(config.aiCommand)} 思考中...**\n\n${t}`);
-            },
-            onText: (accumulated) => {
-                if (!firstContentLogged) {
-                    firstContentLogged = true;
-                    platformAdapter.onFirstContent?.();
-                }
-                if (wasThinking && platformAdapter.onThinkingToText) {
+        const startRun = () => {
+            activeHandle = toolAdapter.run(prompt, currentSessionId, ctx.workDir, {
+                onSessionId: (id) => {
+                    currentSessionId = id;
+                    if (ctx.threadId)
+                        sessionManager.setSessionIdForThread(ctx.userId, ctx.threadId, config.aiCommand, id);
+                    else if (ctx.convId)
+                        sessionManager.setSessionIdForConv(ctx.userId, ctx.convId, config.aiCommand, id);
+                },
+                onSessionInvalid: () => {
+                    if (ctx.convId)
+                        sessionManager.clearSessionForConv(ctx.userId, ctx.convId, config.aiCommand);
+                },
+                onThinking: (t) => {
+                    if (!firstContentLogged) {
+                        firstContentLogged = true;
+                        platformAdapter.onFirstContent?.();
+                    }
+                    wasThinking = true;
+                    thinkingText = t;
+                    throttledUpdate(`💭 **${getAIToolDisplayName(config.aiCommand)} 思考中...**\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, true);
+                },
+                onComplete: async (result) => {
+                    if (settled)
+                        return;
+                    settled = true;
                     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, true);
-            },
-            onComplete: async (result) => {
-                if (settled)
-                    return;
-                settled = true;
-                if (pendingUpdate) {
-                    clearTimeout(pendingUpdate);
-                    pendingUpdate = null;
-                }
-                const note = buildCompletionNote(result, sessionManager, ctx, mode);
-                const output = result.accumulated ||
-                    result.result ||
-                    taskState.latestContent ||
-                    '(无输出)';
-                if (!result.accumulated && !result.result && taskState.latestContent) {
-                    log.warn(`Empty AI output from adapter but had streamed content (${taskState.latestContent.length} chars), using latestContent. platform=${ctx.platform}, taskKey=${ctx.taskKey}`);
-                }
-                else if (!output || output === '(无输出)') {
-                    log.warn(`Empty AI output for user ${ctx.userId}, platform=${ctx.platform}, taskKey=${ctx.taskKey}`);
-                }
-                try {
-                    await platformAdapter.sendComplete(output, 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}`);
-                if (config.aiCommand !== 'claude') {
-                    if (ctx.convId)
-                        sessionManager.clearSessionForConv(ctx.userId, ctx.convId, config.aiCommand);
-                    else
-                        sessionManager.clearActiveToolSession(ctx.userId, config.aiCommand);
-                    log.info(`Session reset for user ${ctx.userId} due to ${config.aiCommand} task error`);
-                }
-                try {
-                    await platformAdapter.sendError(error);
-                }
-                catch (err) {
-                    log.error('Failed to send error:', err);
-                }
-                cleanup();
-                resolve();
+                    const note = buildCompletionNote(result, sessionManager, ctx, mode);
+                    const output = result.accumulated ||
+                        result.result ||
+                        taskState.latestContent ||
+                        '(无输出)';
+                    if (!result.accumulated && !result.result && taskState.latestContent) {
+                        log.warn(`Empty AI output from adapter but had streamed content (${taskState.latestContent.length} chars), using latestContent. platform=${ctx.platform}, taskKey=${ctx.taskKey}`);
+                    }
+                    else if (!output || output === '(无输出)') {
+                        log.warn(`Empty AI output for user ${ctx.userId}, platform=${ctx.platform}, taskKey=${ctx.taskKey}`);
+                    }
+                    try {
+                        await platformAdapter.sendComplete(output, note, thinkingText || undefined);
+                    }
+                    catch (err) {
+                        log.error('Failed to send complete:', err);
+                    }
+                    cleanup();
+                    resolve();
+                },
+                onError: async (error) => {
+                    if (settled)
+                        return;
+                    if (pendingUpdate) {
+                        clearTimeout(pendingUpdate);
+                        pendingUpdate = null;
+                    }
+                    settled = true;
+                    log.error(`Task error for user ${ctx.userId}: ${error}`);
+                    if (config.aiCommand !== 'claude' && !isUsageLimitError(error)) {
+                        if (ctx.convId)
+                            sessionManager.clearSessionForConv(ctx.userId, ctx.convId, config.aiCommand);
+                        else
+                            sessionManager.clearActiveToolSession(ctx.userId, config.aiCommand);
+                        log.info(`Session reset for user ${ctx.userId} due to ${config.aiCommand} task error`);
+                    }
+                    else if (config.aiCommand === 'codex' && isUsageLimitError(error)) {
+                        log.info(`Keeping codex session for user ${ctx.userId} after usage limit error`);
+                    }
+                    try {
+                        await platformAdapter.sendError(error);
+                    }
+                    catch (err) {
+                        log.error('Failed to send error:', err);
+                    }
+                    cleanup();
+                    resolve();
+                },
+            }, {
+                skipPermissions,
+                permissionMode,
+                timeoutMs,
+                model: sessionManager.getModel(ctx.userId, ctx.threadId) ?? config.claudeModel,
+                chatId: ctx.chatId,
+                ...(config.useSdkMode ? {} : { hookPort: config.hookPort }),
+                ...(config.aiCommand === 'codex' && config.codexProxy ? { proxy: config.codexProxy } : {}),
+            });
+            return activeHandle;
+        };
+        taskState = {
+            handle: {
+                abort: () => {
+                    activeHandle?.abort();
+                    cleanup();
+                    settle();
+                },
             },
-        }, {
-            skipPermissions,
-            permissionMode,
-            timeoutMs,
-            model: sessionManager.getModel(ctx.userId, ctx.threadId) ?? config.claudeModel,
-            chatId: ctx.chatId,
-            ...(config.useSdkMode ? {} : { hookPort: config.hookPort }),
-            ...(config.aiCommand === 'codex' && config.codexProxy ? { proxy: config.codexProxy } : {}),
-        });
-        taskState = { handle, latestContent: '', settle, startedAt: Date.now(), toolId: config.aiCommand };
+            latestContent: '',
+            settle,
+            startedAt: Date.now(),
+            toolId: config.aiCommand,
+        };
+        startRun();
         platformAdapter.onTaskReady(taskState);
     });
 }

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

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