@wu529778790/open-im 1.11.8-beta.6 → 1.11.8-beta.7

package/dist/commands/handler.d.ts

@@ -23,6 +23,7 @@ export declare class CommandHandler {
     dispatch(text: string, chatId: string, userId: string, platform: Platform, handleClaudeRequest: ClaudeRequestHandler, 
     /** 若提供，本条消息的斜杠命令回复走此 sender（须与 handleTextFlow 的 sendTextReply 一致，如带 msgId）。 */
     senderOverride?: MessageSender): Promise<boolean>;
+    private handleAutopilotStatus;
     private handleHelp;
     private handlePlugins;
     private handleSessions;

package/dist/commands/handler.js

@@ -1,5 +1,6 @@
 import { resolvePlatformAiCommand } from '../config.js';
 import { escapePathForMarkdown } from '../shared/utils.js';
+import { getAutopilotPendingStatus } from '../shared/ai-task.js';
 import { TERMINAL_ONLY_COMMANDS } from '../constants.js';
 import { createLogger } from '../logger.js';
 import { ClaudeSDKAdapter } from '../adapters/claude-sdk-adapter.js';
@@ -103,6 +104,8 @@ export class CommandHandler {
                 return this.handlePwd(chatId, userId);
             if (t === '/status')
                 return this.handleStatus(chatId, userId, platform);
+            if (t === '/autopilot')
+                return this.handleAutopilotStatus(chatId, userId);
             // 快捷命令 — 直接发送预设 prompt 给 AI
             if (t === '/git commit')
                 return this.handleQuickCommand(chatId, userId, 'git commit -m "AI generated commit"', platform);
@@ -133,6 +136,36 @@ export class CommandHandler {
         }
         return runBody();
     }
+    async handleAutopilotStatus(chatId, userId) {
+        const ap = this.deps.config.autopilot;
+        const lines = [
+            '🤖 限流自动恢复 (Autopilot)',
+            '',
+            `状态: ${ap.enabled ? '✅ 已启用' : '❌ 已禁用'}`,
+            `最大重试: ${ap.maxRetries} 次`,
+            `默认等待: ${ap.defaultIntervalHours} 小时`,
+            `短延迟: ${ap.shortRetrySeconds} 秒`,
+            `恢复提示: "${ap.autoResumePrompt}"`,
+        ];
+        const pending = getAutopilotPendingStatus(userId);
+        if (pending) {
+            const remaining = Math.max(pending.retryAt.getTime() - Date.now(), 0);
+            const hours = Math.floor(remaining / 3600000);
+            const minutes = Math.floor((remaining % 3600000) / 60000);
+            lines.push('');
+            lines.push('⏳ 当前等待中:');
+            lines.push(`  类型: ${pending.type}`);
+            lines.push(`  恢复时间: ${pending.retryAt.toLocaleTimeString('zh-CN', { hour: '2-digit', minute: '2-digit' })}`);
+            lines.push(`  剩余: ${hours > 0 ? `${hours}小时` : ''}${minutes}分钟`);
+            lines.push(`  重试次数: ${pending.retryCount}/${ap.maxRetries}`);
+        }
+        else {
+            lines.push('');
+            lines.push('当前无等待中的限流恢复任务。');
+        }
+        await this.replySender().sendTextReply(chatId, lines.join('\n'));
+        return true;
+    }
     async handleHelp(chatId) {
         const help = [
             '📋 可用命令:',
@@ -151,6 +184,7 @@ export class CommandHandler {
             '/status - 显示状态',
             '/cd <路径> - 切换工作目录',
             '/pwd - 当前工作目录',
+            '/autopilot - 查看限流自动恢复状态',
             '',
             '⚡ 快捷命令:',
             '/git commit - 提交代码',

package/dist/config/types.d.ts

@@ -53,6 +53,17 @@ export interface Config {
         /** 可选 Bearer，与采集端一致 */
         token?: string;
     };
+    /**
+     * 限流自动恢复（Autopilot）。
+     * 当 AI 工具遇到限流错误时，自动等待并在恢复后重试。
+     */
+    autopilot: {
+        enabled: boolean;
+        maxRetries: number;
+        defaultIntervalHours: number;
+        shortRetrySeconds: number;
+        autoResumePrompt: string;
+    };
     platforms: {
         telegram?: {
             enabled: boolean;
@@ -176,6 +187,14 @@ export interface FileToolClaude {
     proxy?: string;
     /** Claude API 配置（优先级：环境变量 > tools.claude.env > ~/.claude/settings.json） */
     env?: Record<string, string>;
+    /** 限流自动恢复配置 */
+    autopilot?: {
+        enabled?: boolean;
+        maxRetries?: number;
+        defaultIntervalHours?: number;
+        shortRetrySeconds?: number;
+        autoResumePrompt?: string;
+    };
 }
 export interface FileToolCodex {
     cliPath?: string;

package/dist/config-web.js

@@ -503,6 +503,13 @@ function createProbeConfig(values) {
         logDir: "",
         logLevel: "INFO",
         telemetry: { enabled: true },
+        autopilot: {
+            enabled: true,
+            maxRetries: 5,
+            defaultIntervalHours: 5,
+            shortRetrySeconds: 60,
+            autoResumePrompt: "继续",
+        },
         codebuddyCliPath: "codebuddy",
         opencodeCliPath: "opencode",
         platforms: {},

package/dist/config.js

@@ -8,7 +8,7 @@ import { accessSync, constants } from 'node:fs';
 import { execFileSync } from 'node:child_process';
 import { join, isAbsolute } from 'node:path';
 import { createLogger } from './logger.js';
-import { APP_HOME, } from './constants.js';
+import { APP_HOME, AUTOPILOT_ENABLED_DEFAULT, AUTOPILOT_MAX_RETRIES, AUTOPILOT_DEFAULT_INTERVAL_HOURS, AUTOPILOT_SHORT_RETRY_SECONDS, AUTOPILOT_DEFAULT_PROMPT, } from './constants.js';
 const log = createLogger('config');
 import { isAiCommand, AI_TOOL_BY_ID } from './adapters/tool-registry.js';
 /**
@@ -200,6 +200,24 @@ export function loadConfig() {
     const tc = file.tools?.claude ?? {};
     const tcod = file.tools?.codex ?? {};
     const tcb = file.tools?.codebuddy ?? {};
+    // Autopilot（限流自动恢复）配置
+    const autopilotFile = tc.autopilot ?? {};
+    const autopilot = {
+        enabled: process.env.OPEN_IM_AUTOPILOT !== 'false'
+            && (autopilotFile.enabled ?? AUTOPILOT_ENABLED_DEFAULT),
+        maxRetries: (() => {
+            const envVal = process.env.OPEN_IM_AUTOPILOT_MAX_RETRIES;
+            if (envVal !== undefined && envVal !== '') {
+                const n = Number.parseInt(envVal, 10);
+                if (Number.isFinite(n) && n >= 0)
+                    return n;
+            }
+            return autopilotFile.maxRetries ?? AUTOPILOT_MAX_RETRIES;
+        })(),
+        defaultIntervalHours: autopilotFile.defaultIntervalHours ?? AUTOPILOT_DEFAULT_INTERVAL_HOURS,
+        shortRetrySeconds: autopilotFile.shortRetrySeconds ?? AUTOPILOT_SHORT_RETRY_SECONDS,
+        autoResumePrompt: autopilotFile.autoResumePrompt ?? AUTOPILOT_DEFAULT_PROMPT,
+    };
     const claudeProxy = process.env.CLAUDE_PROXY ?? tc.proxy;
     const codexProxy = process.env.CODEX_PROXY ?? tcod.proxy;
     // Windows 下若 CLI 路径仍是默认名,尝试在 npm 全局目录定位 .cmd。
@@ -532,6 +550,7 @@ export function loadConfig() {
         telemetry: {
             enabled: telemetryEnabled,
         },
+        autopilot,
         platforms,
     };
 }

package/dist/constants.d.ts

@@ -71,5 +71,15 @@ export declare const MAX_WORKBUDDY_MESSAGE_LENGTH = 2000;
 export declare const MAX_CLAWBOT_MESSAGE_LENGTH = 2000;
 /** ClawBot 长轮询间隔 */
 export declare const CLAWBOT_POLL_INTERVAL_MS = 3000;
+/** Autopilot 默认开启 */
+export declare const AUTOPILOT_ENABLED_DEFAULT = true;
+/** 最大连续自动重试次数 */
+export declare const AUTOPILOT_MAX_RETRIES = 5;
+/** 无法从错误消息提取重置时间时的默认等待小时数 */
+export declare const AUTOPILOT_DEFAULT_INTERVAL_HOURS = 5;
+/** 529/临时限流的短延迟秒数 */
+export declare const AUTOPILOT_SHORT_RETRY_SECONDS = 60;
+/** 自动恢复时发送的提示词 */
+export declare const AUTOPILOT_DEFAULT_PROMPT = "\u7EE7\u7EED";
 export declare const DEFAULT_OPEN_IM_COAUTHOR_ADDR = "529778790@qq.com";
 export declare const TERMINAL_ONLY_COMMANDS: Set<string>;

package/dist/constants.js

@@ -90,6 +90,17 @@ export const MAX_CLAWBOT_MESSAGE_LENGTH = 2000;
 // ─── 轮询间隔 ───
 /** ClawBot 长轮询间隔 */
 export const CLAWBOT_POLL_INTERVAL_MS = 3000;
+// ─── Autopilot（限流自动恢复） ───
+/** Autopilot 默认开启 */
+export const AUTOPILOT_ENABLED_DEFAULT = true;
+/** 最大连续自动重试次数 */
+export const AUTOPILOT_MAX_RETRIES = 5;
+/** 无法从错误消息提取重置时间时的默认等待小时数 */
+export const AUTOPILOT_DEFAULT_INTERVAL_HOURS = 5;
+/** 529/临时限流的短延迟秒数 */
+export const AUTOPILOT_SHORT_RETRY_SECONDS = 60;
+/** 自动恢复时发送的提示词 */
+export const AUTOPILOT_DEFAULT_PROMPT = "继续";
 // ─── Git 共同作者 ───
 export const DEFAULT_OPEN_IM_COAUTHOR_ADDR = "529778790@qq.com";
 // ─── 终端独占命令 ───

package/dist/platform/handle-ai-request.js

@@ -133,7 +133,24 @@ export function createPlatformAIRequestHandler(deps) {
         };
         // 7. Run AI task
         try {
-            await runAITask({ config, sessionManager }, {
+            await runAITask({
+                config,
+                sessionManager,
+                autopilot: {
+                    onAutoPilotContinue: (continuePrompt) => {
+                        log.info(`[${platform}] Autopilot: re-enqueuing "${continuePrompt}" for user ${userId}`);
+                        handleAIRequest({
+                            userId,
+                            chatId,
+                            prompt: continuePrompt,
+                            workDir,
+                            convId,
+                        }).catch((err) => {
+                            log.error(`[${platform}] Autopilot re-enqueue failed:`, err);
+                        });
+                    },
+                },
+            }, {
                 userId,
                 chatId,
                 workDir,

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

@@ -4,9 +4,24 @@
 import type { Config } from '../config.js';
 import type { SessionManager } from '../session/session-manager.js';
 import type { ToolAdapter } from '../adapters/tool-adapter.interface.js';
+/** 查询指定用户的 autopilot 等待状态（供 /autopilot 命令使用）。 */
+export declare function getAutopilotPendingStatus(userId: string): {
+    retryAt: Date;
+    type: string;
+    retryCount: number;
+} | undefined;
+/** 清除指定用户的 autopilot 状态（测试用）。 */
+export declare function clearAutopilotState(userId: string): void;
 export interface TaskDeps {
     config: Config;
     sessionManager: SessionManager;
+    /**
+     * Autopilot 回调：限流恢复后调用，将 autoResumePrompt 作为新消息
+     * 通过平台的请求队列重新入队。如果不提供，autopilot 不执行恢复动作。
+     */
+    autopilot?: {
+        onAutoPilotContinue: (prompt: string) => void;
+    };
 }
 export interface TaskContext {
     userId: string;

package/dist/shared/ai-task.js

@@ -6,8 +6,99 @@ import { captureError } from './sentry.js';
 import { formatToolStats, formatToolCallNotification, getContextWarning, getAIToolDisplayName, toReplyPlainText, } from './utils.js';
 import { createLogger } from '../logger.js';
 const log = createLogger('AITask');
+/** 每用户连续 autopilot 重试计数。成功完成或遇到非限流错误时清零。 */
+const autopilotRetryCount = new Map();
+/** 当前等待中的 autopilot 定时器（用于 /autopilot 状态查询）。 */
+const pendingAutopilotTimers = new Map();
+/** 查询指定用户的 autopilot 等待状态（供 /autopilot 命令使用）。 */
+export function getAutopilotPendingStatus(userId) {
+    return pendingAutopilotTimers.get(userId);
+}
+/** 清除指定用户的 autopilot 状态（测试用）。 */
+export function clearAutopilotState(userId) {
+    autopilotRetryCount.delete(userId);
+    pendingAutopilotTimers.delete(userId);
+}
+/**
+ * 判断错误是否为限流类错误（用于决定是否保留 session）。
+ * 覆盖所有已知的限流模式：429/529/session limit/overloaded/temporary throttle。
+ */
 function isUsageLimitError(error) {
-    return /usage limit/i.test(error) || /try again at\s+\d{1,2}:\d{2}\s*(AM|PM)/i.test(error);
+    return /usage\s*limit/i.test(error)
+        || /try\s+again\s+at\s+\d{1,2}:\d{2}/i.test(error)
+        || /rate\s*limit/i.test(error)
+        || /\b429\b/.test(error)
+        || /\b529\b/.test(error)
+        || /overloaded/i.test(error)
+        || /temporarily\s+limiting/i.test(error)
+        || /session\s+limit/i.test(error)
+        || /you['\u2019]ve\s+hit\s+your/i.test(error);
+}
+/**
+ * 从错误消息中提取限流详情。仅在 isUsageLimitError() 返回 true 后调用。
+ */
+function classifyRateLimit(error, config) {
+    const now = Date.now();
+    const shortMs = config.autopilot.shortRetrySeconds * 1000;
+    const defaultMs = config.autopilot.defaultIntervalHours * 3600 * 1000;
+    // Session quota / usage limit（最常见，等待时间最长）
+    if (/session\s*limit|usage\s*limit|opus\s*limit|you['\u2019]ve\s+hit\s+your/i.test(error)) {
+        const timeMatch = error.match(/try\s+again\s+at\s+(\d{1,2}):(\d{2})\s*(AM|PM)?/i);
+        if (timeMatch) {
+            let hours = parseInt(timeMatch[1], 10);
+            const minutes = parseInt(timeMatch[2], 10);
+            const ampm = timeMatch[3]?.toUpperCase();
+            if (ampm === 'PM' && hours < 12)
+                hours += 12;
+            if (ampm === 'AM' && hours === 12)
+                hours = 0;
+            const retryAt = new Date();
+            retryAt.setHours(hours, minutes, 0, 0);
+            if (retryAt.getTime() <= now)
+                retryAt.setDate(retryAt.getDate() + 1);
+            return { detected: true, type: 'session_limit', retryAt, isLongWait: true };
+        }
+        return { detected: true, type: 'session_limit', retryAt: new Date(now + defaultMs), isLongWait: true };
+    }
+    // 529 overloaded / temporarily limiting（短延迟）
+    if (/\b529\b|overloaded|temporarily\s+limiting/i.test(error)) {
+        return {
+            detected: true,
+            type: /overloaded/i.test(error) ? 'overloaded' : 'temporary',
+            retryAt: new Date(now + shortMs),
+            isLongWait: false,
+        };
+    }
+    // 429 rate limit（使用默认周期）
+    if (/\b429\b|rate\s*limit/i.test(error)) {
+        return { detected: true, type: 'api_rate_limit', retryAt: new Date(now + defaultMs), isLongWait: true };
+    }
+    return { detected: false, type: null, retryAt: null, isLongWait: false };
+}
+function rateLimitTypeLabel(type) {
+    switch (type) {
+        case 'session_limit': return '会话额度限制';
+        case 'api_rate_limit': return 'API 速率限制';
+        case 'overloaded': return '服务器过载';
+        case 'temporary': return '临时限流';
+        default: return '限流';
+    }
+}
+function formatTimeHHMM(date) {
+    return `${date.getHours().toString().padStart(2, '0')}:${date.getMinutes().toString().padStart(2, '0')}`;
+}
+function formatDuration(ms) {
+    if (ms <= 0)
+        return '即将';
+    const totalSec = Math.ceil(ms / 1000);
+    const hours = Math.floor(totalSec / 3600);
+    const minutes = Math.floor((totalSec % 3600) / 60);
+    const seconds = totalSec % 60;
+    if (hours > 0)
+        return `${hours}小时${minutes > 0 ? `${minutes}分钟` : ''}`;
+    if (minutes > 0)
+        return `${minutes}分钟${seconds > 0 ? `${seconds}秒` : ''}`;
+    return `${seconds}秒`;
 }
 /**
  * 将 AI/CLI 错误文本归类为一个稳定的 errorType 字符串，用于遥测聚合。
@@ -211,6 +302,8 @@ export function runAITask(deps, ctx, prompt, toolAdapter, platformAdapter) {
                     if (settled)
                         return;
                     settled = true;
+                    // 成功完成 → 清除 autopilot 重试计数
+                    autopilotRetryCount.delete(ctx.userId);
                     if (pendingUpdate) {
                         clearTimeout(pendingUpdate);
                         pendingUpdate = null;
@@ -263,6 +356,83 @@ export function runAITask(deps, ctx, prompt, toolAdapter, platformAdapter) {
                     }
                     settled = true;
                     log.error(`Task error for user ${ctx.userId}: ${error}`);
+                    // ── Autopilot 拦截 ──
+                    const apConfig = config.autopilot;
+                    const currentRetries = autopilotRetryCount.get(ctx.userId) ?? 0;
+                    if (apConfig?.enabled &&
+                        deps.autopilot &&
+                        isUsageLimitError(error) &&
+                        currentRetries < apConfig.maxRetries) {
+                        const rateInfo = classifyRateLimit(error, config);
+                        if (rateInfo.detected && rateInfo.retryAt) {
+                            const retryCount = currentRetries + 1;
+                            autopilotRetryCount.set(ctx.userId, retryCount);
+                            // 记录等待状态
+                            pendingAutopilotTimers.set(ctx.userId, {
+                                retryAt: rateInfo.retryAt,
+                                type: rateInfo.type,
+                                retryCount,
+                            });
+                            // 通知用户
+                            const typeLabel = rateLimitTypeLabel(rateInfo.type);
+                            const timeStr = formatTimeHHMM(rateInfo.retryAt);
+                            const remaining = formatDuration(rateInfo.retryAt.getTime() - Date.now());
+                            const statusMsg = `⏳ 检测到${typeLabel}，将在 ${timeStr}（${remaining}后）自动恢复 (${retryCount}/${apConfig.maxRetries})`;
+                            log.info(`[Autopilot] ${statusMsg} for user ${ctx.userId}`);
+                            try {
+                                await platformAdapter.sendError(hadSessionInvalid
+                                    ? '当前 Claude 会话已失效，已自动执行 /new 重置会话，请重新发送刚才的问题。'
+                                    : `${error}\n\n${statusMsg}`);
+                            }
+                            catch (err) {
+                                log.error('Failed to send autopilot status:', err);
+                            }
+                            cleanup();
+                            resolve();
+                            // 异步等待 → 恢复（不阻塞 Promise 解决）
+                            const retryAt = rateInfo.retryAt;
+                            const delayMs = Math.max(retryAt.getTime() - Date.now(), 0);
+                            log.info(`[Autopilot] Scheduling retry in ${delayMs}ms for user ${ctx.userId}`);
+                            // 分段定时器（setTimeout 最大 ~24.8 天）
+                            const MAX_SEGMENT = 2_147_483_647; // 2^31 - 1
+                            const scheduleRetry = (remaining) => {
+                                if (remaining <= 0) {
+                                    // 定时器到期 → 清除状态 → 发送恢复消息
+                                    pendingAutopilotTimers.delete(ctx.userId);
+                                    log.info(`[Autopilot] Timer fired for user ${ctx.userId}, sending "${apConfig.autoResumePrompt}"`);
+                                    try {
+                                        platformAdapter.streamUpdate('', `🔄 限额已恢复，正在自动重试... (${retryCount})`);
+                                    }
+                                    catch {
+                                        /* ignore */
+                                    }
+                                    deps.autopilot.onAutoPilotContinue(apConfig.autoResumePrompt);
+                                    return;
+                                }
+                                const segment = Math.min(remaining, MAX_SEGMENT);
+                                const timer = setTimeout(() => scheduleRetry(remaining - segment), segment);
+                                if (typeof timer === 'object' && 'unref' in timer)
+                                    timer.unref();
+                                // 如果任务被 abort（/new、cancelUser），取消待执行的定时器
+                                if (ctx.signal) {
+                                    if (ctx.signal.aborted) {
+                                        clearTimeout(timer);
+                                        pendingAutopilotTimers.delete(ctx.userId);
+                                        return;
+                                    }
+                                    ctx.signal.addEventListener('abort', () => {
+                                        clearTimeout(timer);
+                                        pendingAutopilotTimers.delete(ctx.userId);
+                                        log.info(`[Autopilot] Timer cancelled by abort for user ${ctx.userId}`);
+                                    }, { once: true });
+                                }
+                            };
+                            scheduleRetry(delayMs);
+                            return;
+                        }
+                    }
+                    // ── 非限流错误或 autopilot 未启用/耗尽重试 ──
+                    autopilotRetryCount.delete(ctx.userId);
                     if (isUsageLimitError(error)) {
                         // Usage limit errors: keep session for all tools (user can retry later)
                         log.warn(`Keeping ${aiCommand} session for user ${ctx.userId} after usage limit error`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wu529778790/open-im",
-  "version": "1.11.8-beta.6",
+  "version": "1.11.8-beta.7",
   "description": "Your AI coding assistant, in every chat app. Multi-platform IM bridge for Claude Code, Codex, and CodeBuddy.",
   "type": "module",
   "main": "dist/index.js",