@wu529778790/open-im 1.11.11 → 1.11.13-beta.0

package/README.md

@@ -77,6 +77,7 @@ open-im start
 | `/a` | 查看当前 AI 工具及可选列表 |
 | `/a <工具名>` | 切换当前平台的 AI 工具（claude/codex/codebuddy/opencode） |
 | `/cd <路径>` / `/pwd` | 切换/查看工作目录 |
+| `/restart` | 重启服务（需 `/restart confirm` 确认） |
 
 ### 快捷命令
 

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

@@ -3,10 +3,11 @@
  */
 import type { Config } from '../config.js';
 import type { SessionManager } from '../session/session-manager.js';
+import { type RequestRestartFn } from '../platform/create-event-context.js';
 export interface ClawBotEventHandlerHandle {
     stop: () => void;
     runningTasks: Map<string, import('../shared/ai-task.js').TaskRunState>;
     getRunningTaskCount: () => number;
     handleEvent: (chatId: string, msgId: string, content: string, imagePaths?: string[]) => Promise<void>;
 }
-export declare function setupClawbotHandlers(config: Config, sessionManager: SessionManager): ClawBotEventHandlerHandle;
+export declare function setupClawbotHandlers(config: Config, sessionManager: SessionManager, requestRestart: RequestRestartFn): ClawBotEventHandlerHandle;

package/dist/clawbot/event-handler.js

@@ -9,7 +9,7 @@ import { createPlatformEventContext } from '../platform/create-event-context.js'
 import { createPlatformAIRequestHandler } from '../platform/handle-ai-request.js';
 import { handleTextFlow } from '../platform/handle-text-flow.js';
 const log = createLogger('ClawBotHandler');
-export function setupClawbotHandlers(config, sessionManager) {
+export function setupClawbotHandlers(config, sessionManager, requestRestart) {
     const ctx = createPlatformEventContext({
         platform: 'clawbot',
         allowedUserIds: config.clawbotAllowedUserIds,
@@ -20,6 +20,7 @@ export function setupClawbotHandlers(config, sessionManager) {
                 await sendTextReply(chatId, text);
             },
         },
+        requestRestart,
     });
     const stopTaskCleanup = startTaskCleanup(ctx.runningTasks);
     const platformSender = {

package/dist/commands/handler.d.ts

@@ -13,6 +13,8 @@ export interface CommandHandlerDeps {
     requestQueue: RequestQueue;
     sender: MessageSender;
     getRunningTasksSize: () => number;
+    /** 触发 worker 重启（写重启标志 + 优雅关闭）。供 /restart 调用。 */
+    requestRestart: (reason: string) => Promise<void>;
 }
 export type ClaudeRequestHandler = (userId: string, chatId: string, prompt: string, workDir: string, convId?: string, threadCtx?: ThreadContext, replyToMessageId?: string) => Promise<void>;
 export declare function normalizeSlashCommandForDispatch(text: string): string;
@@ -23,6 +25,11 @@ export declare class CommandHandler {
     dispatch(text: string, chatId: string, userId: string, platform: Platform, handleClaudeRequest: ClaudeRequestHandler, 
     /** 若提供，本条消息的斜杠命令回复走此 sender（须与 handleTextFlow 的 sendTextReply 一致，如带 msgId）。 */
     senderOverride?: MessageSender): Promise<boolean>;
+    /**
+     * 重启 worker（IM 桥）：写重启标志文件 + 优雅关闭，由 manager 监督重生。
+     * 需二次确认（/restart confirm）以避免误触中断所有用户的进行中任务。
+     */
+    private handleRestart;
     private handleAutopilotStatus;
     private handleHelp;
     private handlePlugins;

package/dist/commands/handler.js

@@ -108,6 +108,11 @@ export class CommandHandler {
                 return this.handleSwitchAi(chatId, t.slice(2).trim(), platform);
             if (t === '/autopilot')
                 return this.handleAutopilotStatus(chatId, userId);
+            // 重启 worker（需 /restart confirm 二次确认，避免误触中断所有任务）
+            if (t === '/restart')
+                return this.handleRestart(chatId, userId, false);
+            if (t === '/restart confirm')
+                return this.handleRestart(chatId, userId, true);
             // 快捷命令 — 直接发送预设 prompt 给 AI
             if (t === '/git commit')
                 return this.handleQuickCommand(chatId, userId, 'git commit -m "AI generated commit"', platform);
@@ -138,6 +143,34 @@ export class CommandHandler {
         }
         return runBody();
     }
+    /**
+     * 重启 worker（IM 桥）：写重启标志文件 + 优雅关闭，由 manager 监督重生。
+     * 需二次确认（/restart confirm）以避免误触中断所有用户的进行中任务。
+     */
+    async handleRestart(chatId, userId, confirmed) {
+        if (!confirmed) {
+            const running = this.deps.getRunningTasksSize();
+            const taskLine = running > 0
+                ? `⚠️ 当前有 ${running} 个进行中的任务，重启将全部中断。`
+                : '当前无进行中的任务。';
+            await this.replySender().sendTextReply(chatId, [
+                '🔄 重启服务',
+                '',
+                taskLine,
+                '重启会短暂断开 IM 连接（数秒后自动恢复），Web 面板保持在线。',
+                '',
+                '确认请发送：/restart confirm',
+            ].join('\n'));
+            return true;
+        }
+        // 必须先回复用户，否则 requestRestart 触发的关闭流程会让进程退出、回复发不出去。
+        await this.replySender().sendTextReply(chatId, '🔄 正在重启服务，IM 连接将短暂断开，稍后自动恢复…');
+        // 不 await：关闭流程会结束当前进程；await 反而可能因连接断开而抛错。
+        this.deps.requestRestart(`/restart by user ${userId}`).catch((err) => {
+            log.error('requestRestart failed:', err);
+        });
+        return true;
+    }
     async handleAutopilotStatus(chatId, userId) {
         const ap = this.deps.config.autopilot;
         const lines = [
@@ -188,6 +221,7 @@ export class CommandHandler {
             '/cd <路径> - 切换工作目录',
             '/pwd - 当前工作目录',
             '/autopilot - 查看限流自动恢复状态',
+            '/restart - 重启服务（需 /restart confirm 确认）',
             '',
             '⚡ 快捷命令:',
             '/git commit - 提交代码',

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

@@ -1,10 +1,11 @@
 import type { DWClientDownStream } from 'dingtalk-stream';
 import { type Config } from '../config.js';
 import type { SessionManager } from '../session/session-manager.js';
+import { type RequestRestartFn } from '../platform/create-event-context.js';
 export interface DingTalkEventHandlerHandle {
     stop: () => void;
     runningTasks: Map<string, import('../shared/ai-task.js').TaskRunState>;
     getRunningTaskCount: () => number;
     handleEvent: (data: DWClientDownStream) => Promise<void>;
 }
-export declare function setupDingTalkHandlers(config: Config, sessionManager: SessionManager): DingTalkEventHandlerHandle;
+export declare function setupDingTalkHandlers(config: Config, sessionManager: SessionManager, requestRestart: RequestRestartFn): DingTalkEventHandlerHandle;

package/dist/dingtalk/event-handler.js

@@ -142,7 +142,7 @@ async function buildMediaPrompt(message, kind, robotCodeFallback) {
         metadata: sanitized,
     });
 }
-export function setupDingTalkHandlers(config, sessionManager) {
+export function setupDingTalkHandlers(config, sessionManager, requestRestart) {
     configureDingTalkMessageSender({
         cardTemplateId: config.dingtalkCardTemplateId,
         robotCodeFallback: config.dingtalkClientId,
@@ -162,6 +162,7 @@ export function setupDingTalkHandlers(config, sessionManager) {
         config,
         sessionManager,
         sender: { sendTextReply, sendDirectorySelection },
+        requestRestart,
     });
     const { accessControl, requestQueue, runningTasks } = ctx;
     // DingTalk-specific sender callbacks for the factory

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

@@ -1,9 +1,10 @@
 import { type Config } from '../config.js';
 import type { SessionManager } from '../session/session-manager.js';
+import { type RequestRestartFn } from '../platform/create-event-context.js';
 export interface FeishuEventHandlerHandle {
     stop: () => void;
     runningTasks: Map<string, import('../shared/ai-task.js').TaskRunState>;
     getRunningTaskCount: () => number;
     handleEvent: (data: unknown) => Promise<void | Record<string, unknown>>;
 }
-export declare function setupFeishuHandlers(config: Config, sessionManager: SessionManager): FeishuEventHandlerHandle;
+export declare function setupFeishuHandlers(config: Config, sessionManager: SessionManager, requestRestart: RequestRestartFn): FeishuEventHandlerHandle;

package/dist/feishu/event-handler.js

@@ -26,7 +26,7 @@ async function downloadFeishuMessageResource(client, messageId, fileKey, type, o
     await response.writeFile(targetPath);
     return targetPath;
 }
-export function setupFeishuHandlers(config, sessionManager) {
+export function setupFeishuHandlers(config, sessionManager, requestRestart) {
     // Create shared platform event context
     const ctx = createPlatformEventContext({
         platform: 'feishu',
@@ -34,6 +34,7 @@ export function setupFeishuHandlers(config, sessionManager) {
         config,
         sessionManager,
         sender: { sendTextReply },
+        requestRestart,
     });
     // Feishu-specific streaming state for error recovery
     let consecutiveStreamErrors = 0;

package/dist/index.js

@@ -5,6 +5,7 @@ import { dirname, join } from "node:path";
 import { getConfiguredAiCommands, loadConfig, needsSetup, resolvePlatformAiCommand } from "./config.js";
 import { runInteractiveSetup, runClaudeApiSetup } from "./setup.js";
 import { runWebConfigFlow } from "./config-web.js";
+import { markRestartRequest } from "./service-control.js";
 // 导出供 cli.ts 使用
 export { needsSetup, runInteractiveSetup };
 import { initTelegram, stopTelegram } from "./telegram/client.js";
@@ -45,17 +46,17 @@ const { version: APP_VERSION } = require("../package.json");
 const log = createLogger("Main");
 const PLATFORM_MODULES = {
     telegram: {
-        init: (config, sessionManager) => new Promise((resolve, reject) => {
+        init: (config, sessionManager, requestRestart) => new Promise((resolve, reject) => {
             initTelegram(config, (bot) => {
-                resolve(setupTelegramHandlers(bot, config, sessionManager));
+                resolve(setupTelegramHandlers(bot, config, sessionManager, requestRestart));
             }).catch(reject);
         }),
         stop: () => stopTelegram(),
         sendNotification: (chatId, msg) => sendTelegramTextReply(chatId, msg),
     },
     feishu: {
-        init: async (config, sessionManager) => {
-            const handle = setupFeishuHandlers(config, sessionManager);
+        init: async (config, sessionManager, requestRestart) => {
+            const handle = setupFeishuHandlers(config, sessionManager, requestRestart);
             await initFeishu(config, handle.handleEvent);
             return handle;
         },
@@ -64,8 +65,8 @@ const PLATFORM_MODULES = {
         formatError: (err) => formatFeishuInitError(err),
     },
     qq: {
-        init: async (config, sessionManager) => {
-            const handle = setupQQHandlers(config, sessionManager);
+        init: async (config, sessionManager, requestRestart) => {
+            const handle = setupQQHandlers(config, sessionManager, requestRestart);
             await initQQ(config, handle.handleEvent);
             return handle;
         },
@@ -73,8 +74,8 @@ const PLATFORM_MODULES = {
         sendNotification: (chatId, msg) => sendQQTextReply(chatId, msg),
     },
     wework: {
-        init: async (config, sessionManager) => {
-            const handle = setupWeWorkHandlers(config, sessionManager);
+        init: async (config, sessionManager, requestRestart) => {
+            const handle = setupWeWorkHandlers(config, sessionManager, requestRestart);
             await initWeWork(config, handle.handleEvent);
             return handle;
         },
@@ -82,8 +83,8 @@ const PLATFORM_MODULES = {
         sendNotification: (chatId, msg) => sendWeWorkTextReply(chatId, msg),
     },
     dingtalk: {
-        init: async (config, sessionManager) => {
-            const handle = setupDingTalkHandlers(config, sessionManager);
+        init: async (config, sessionManager, requestRestart) => {
+            const handle = setupDingTalkHandlers(config, sessionManager, requestRestart);
             await initDingTalk(config, handle.handleEvent);
             return handle;
         },
@@ -92,8 +93,8 @@ const PLATFORM_MODULES = {
         // No sendNotification — DingTalk doesn't support proactive messaging
     },
     workbuddy: {
-        init: async (config, sessionManager) => {
-            const handle = setupWorkBuddyHandlers(config, sessionManager);
+        init: async (config, sessionManager, requestRestart) => {
+            const handle = setupWorkBuddyHandlers(config, sessionManager, requestRestart);
             await initWorkBuddy(config, handle.handleEvent);
             return handle;
         },
@@ -101,12 +102,12 @@ const PLATFORM_MODULES = {
         sendNotification: (chatId, msg) => sendWorkBuddyTextReply(null, chatId, msg, randomUUID()),
     },
     clawbot: {
-        init: async (config, sessionManager) => {
+        init: async (config, sessionManager, requestRestart) => {
             const pc = config.platforms.clawbot;
             if (pc?.apiUrl && pc?.apiToken) {
                 initClawBotSender(pc.apiUrl, pc.apiToken);
             }
-            const handle = setupClawbotHandlers(config, sessionManager);
+            const handle = setupClawbotHandlers(config, sessionManager, requestRestart);
             await initClawbot(config, handle.handleEvent);
             return handle;
         },
@@ -310,6 +311,13 @@ export async function main() {
     // Track active platform handles and successfully initialized platforms
     const activeHandles = new Map();
     const successfulPlatforms = [];
+    // restart 触发 worker 重启：写重启标志 + 走优雅关闭（shutdown 见下方，运行时调用时已定义）。
+    // init 时把引用传给各平台，实际调用发生在用户触发 /restart 之后。
+    const restart = async (reason) => {
+        markRestartRequest(reason);
+        log.info(`Restart requested: ${reason}`);
+        await shutdown();
+    };
     for (const platform of config.enabledPlatforms) {
         const mod = PLATFORM_MODULES[platform];
         if (!mod) {
@@ -317,7 +325,7 @@ export async function main() {
             continue;
         }
         try {
-            const handle = await mod.init(config, sessionManager);
+            const handle = await mod.init(config, sessionManager, restart);
             activeHandles.set(platform, handle);
             successfulPlatforms.push(platform);
         }

package/dist/manager.js

@@ -1,6 +1,6 @@
 import { startWebConfigServer } from "./config-web.js";
 import { removeManagerPid, removeManagerReady, writeManagerReady } from "./manager-control.js";
-import { startBackgroundService, stopBackgroundService, waitForBackgroundServiceReady } from "./service-control.js";
+import { startBackgroundService, stopBackgroundService, waitForBackgroundServiceReady, hasRestartRequested, clearRestartRequest, } from "./service-control.js";
 import { createLogger } from "./logger.js";
 import { loadFileConfig } from "./config.js";
 const log = createLogger("Manager");
@@ -8,10 +8,51 @@ async function main() {
     const file = loadFileConfig();
     const workDir = file.tools?.claude?.workDir ?? process.cwd();
     const web = await startWebConfigServer({ mode: "start", cwd: workDir, persistent: true });
-    startBackgroundService(workDir);
+    // manager 是否正在主动关闭。置位后 worker 的 exit 回调不再重生，避免 stop 触发误拉起。
+    const state = { managerStopping: false };
+    /**
+     * 监督 worker 子进程：退出时若 worker 在退出前置写了重启请求标志文件（/restart），
+     * 则重新 spawn 一个 worker 并继续监督；否则不自动拉起（保持原"崩溃不重启"行为，
+     * 但已为此 supervisor 预留扩展点）。
+     *
+     * 用具名函数递归挂监听，避免回调嵌套；每个 child 只挂一次。
+     */
+    function supervise(child) {
+        if (!child)
+            return;
+        child.on("exit", (code, signal) => {
+            // manager 主动 stop：stopBackgroundService 会让 worker 退出，此时不应重生。
+            if (state.managerStopping) {
+                log.info(`Worker exited during manager shutdown (code=${code}, signal=${signal}).`);
+                return;
+            }
+            if (hasRestartRequested()) {
+                clearRestartRequest();
+                log.info("Restart requested, respawning worker...");
+                try {
+                    const next = startBackgroundService(workDir);
+                    supervise(next.child);
+                    waitForBackgroundServiceReady().catch((err) => {
+                        log.error("Respawned worker failed to become ready:", err);
+                    });
+                }
+                catch (err) {
+                    log.error("Failed to respawn worker:", err);
+                }
+            }
+            else {
+                // 非 restart 的退出：不自动拉起（保持现状），仅记录。
+                log.warn(`Worker exited (code=${code}, signal=${signal}), not respawning.`);
+            }
+        });
+    }
+    // 首次启动 worker 并监督：worker 退出时，若存在重启请求则重生，否则视为崩溃/正常退出。
+    const initial = startBackgroundService(workDir);
+    supervise(initial.child);
     await waitForBackgroundServiceReady();
     writeManagerReady();
     const shutdown = async () => {
+        state.managerStopping = true;
         await web.close().catch((err) => log.warn("Failed to close web server:", err));
         await stopBackgroundService().catch((err) => log.warn("Failed to stop background service:", err));
         removeManagerReady();

package/dist/platform/create-event-context.d.ts

@@ -12,12 +12,16 @@ import { AccessControl } from '../access/access-control.js';
 import { RequestQueue } from '../queue/request-queue.js';
 import { CommandHandler, type MessageSender } from '../commands/handler.js';
 import type { TaskRunState } from '../shared/ai-task.js';
+/** 触发 worker 重启（写重启标志 + 优雅关闭）。由 worker 注入，命令处理器调用。 */
+export type RequestRestartFn = (reason: string) => Promise<void>;
 export interface CreateEventContextDeps {
     platform: Platform;
     allowedUserIds: string[];
     config: Config;
     sessionManager: SessionManager;
     sender: MessageSender;
+    /** 触发 /restart 的回调。 */
+    requestRestart: RequestRestartFn;
 }
 export interface PlatformEventContext {
     accessControl: AccessControl;

package/dist/platform/create-event-context.js

@@ -10,7 +10,7 @@ import { AccessControl } from '../access/access-control.js';
 import { RequestQueue } from '../queue/request-queue.js';
 import { CommandHandler } from '../commands/handler.js';
 export function createPlatformEventContext(deps) {
-    const { allowedUserIds, config, sessionManager, sender } = deps;
+    const { allowedUserIds, config, sessionManager, sender, requestRestart } = deps;
     const accessControl = new AccessControl(allowedUserIds);
     const requestQueue = new RequestQueue();
     const runningTasks = new Map();
@@ -20,6 +20,7 @@ export function createPlatformEventContext(deps) {
         requestQueue,
         sender,
         getRunningTasksSize: () => runningTasks.size,
+        requestRestart,
     });
     return {
         accessControl,

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

@@ -1,10 +1,11 @@
 import { type Config } from "../config.js";
 import type { SessionManager } from "../session/session-manager.js";
 import type { QQMessageEvent } from "./types.js";
+import { type RequestRestartFn } from "../platform/create-event-context.js";
 export interface QQEventHandlerHandle {
     stop: () => void;
     runningTasks: Map<string, import('../shared/ai-task.js').TaskRunState>;
     getRunningTaskCount: () => number;
     handleEvent: (event: QQMessageEvent) => Promise<void>;
 }
-export declare function setupQQHandlers(config: Config, sessionManager: SessionManager): QQEventHandlerHandle;
+export declare function setupQQHandlers(config: Config, sessionManager: SessionManager, requestRestart: RequestRestartFn): QQEventHandlerHandle;

package/dist/qq/event-handler.js

@@ -110,7 +110,7 @@ async function buildAttachmentPrompt(event) {
         guidance: "If direct attachment fetch is not available, explain the limitation and ask the user for a text summary or a resend via Telegram/Feishu/WeWork.",
     });
 }
-export function setupQQHandlers(config, sessionManager) {
+export function setupQQHandlers(config, sessionManager, requestRestart) {
     // Use shared platform event context factory
     const platformContext = createPlatformEventContext({
         platform: "qq",
@@ -118,6 +118,7 @@ export function setupQQHandlers(config, sessionManager) {
         config,
         sessionManager,
         sender: { sendTextReply, sendDirectorySelection },
+        requestRestart,
     });
     const { accessControl, requestQueue, runningTasks } = platformContext;
     const recentEventIds = new Map();

package/dist/service-control.d.ts

@@ -1,3 +1,10 @@
+import { type ChildProcess } from "node:child_process";
+/** 写入重启请求标志。reason 与时间戳一并记录，便于日志追溯。供 worker 的 /restart 调用。 */
+export declare function markRestartRequest(reason: string): void;
+/** 是否存在待处理的重启请求。供 manager 的 worker exit 监听判断是否重生。 */
+export declare function hasRestartRequested(): boolean;
+/** 清除重启请求标志。manager 重生 worker 前调用，避免重复触发。 */
+export declare function clearRestartRequest(): void;
 export declare function getPid(): number | null;
 export declare function writePid(pid: number): void;
 export declare function removePid(): void;
@@ -6,8 +13,15 @@ export declare function getServiceStatus(): {
     running: boolean;
     pid: number | null;
 };
+/**
+ * Spawn the background service (worker).
+ * Returns the child handle so the manager can supervise it.
+ * If a worker is already running, returns its pid with a null child (manager supervision
+ * already has a child from the initial spawn; web UI callers only need the pid).
+ */
 export declare function startBackgroundService(cwd: string): {
     pid: number;
+    child: ChildProcess | null;
 };
 export declare function waitForBackgroundServiceReady(timeoutMs?: number, pollIntervalMs?: number): Promise<void>;
 export declare function stopBackgroundService(): Promise<{

package/dist/service-control.js

@@ -7,6 +7,8 @@ import { resolveNodeExecutable } from "./node-exec.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");
+/** 重启请求标志文件：worker 优雅退出前置于此文件，manager 的 exit 监听据此判断是否重生 worker。 */
+const RESTART_REQUESTED_FILE = join(APP_HOME, "open-im.restart-requested");
 function removePortFile() {
     try {
         if (existsSync(PORT_FILE))
@@ -16,6 +18,33 @@ function removePortFile() {
         /* ignore */
     }
 }
+// ─── 重启请求标志文件（worker ↔ manager 协作） ───
+/** 写入重启请求标志。reason 与时间戳一并记录，便于日志追溯。供 worker 的 /restart 调用。 */
+export function markRestartRequest(reason) {
+    try {
+        const dir = dirname(RESTART_REQUESTED_FILE);
+        if (!existsSync(dir))
+            return; // APP_HOME 通常已存在；防御性
+        writeFileSync(RESTART_REQUESTED_FILE, JSON.stringify({ reason, at: new Date().toISOString() }, null, 2), "utf-8");
+    }
+    catch {
+        /* 写失败则 manager 不会重生，退化为普通关闭 */
+    }
+}
+/** 是否存在待处理的重启请求。供 manager 的 worker exit 监听判断是否重生。 */
+export function hasRestartRequested() {
+    return existsSync(RESTART_REQUESTED_FILE);
+}
+/** 清除重启请求标志。manager 重生 worker 前调用，避免重复触发。 */
+export function clearRestartRequest() {
+    try {
+        if (existsSync(RESTART_REQUESTED_FILE))
+            unlinkSync(RESTART_REQUESTED_FILE);
+    }
+    catch {
+        /* ignore */
+    }
+}
 function getServiceEntry() {
     const node = resolveNodeExecutable();
     const extension = extname(fileURLToPath(import.meta.url));
@@ -80,10 +109,16 @@ export function getServiceStatus() {
     }
     return { running: true, pid };
 }
+/**
+ * Spawn the background service (worker).
+ * Returns the child handle so the manager can supervise it.
+ * If a worker is already running, returns its pid with a null child (manager supervision
+ * already has a child from the initial spawn; web UI callers only need the pid).
+ */
 export function startBackgroundService(cwd) {
     const current = getServiceStatus();
     if (current.running && current.pid) {
-        return { pid: current.pid };
+        return { pid: current.pid, child: null };
     }
     removePid();
     removePortFile();
@@ -104,7 +139,7 @@ export function startBackgroundService(cwd) {
         throw new Error("Failed to start background service.");
     }
     writePid(child.pid);
-    return { pid: child.pid };
+    return { pid: child.pid, child };
 }
 export async function waitForBackgroundServiceReady(timeoutMs = SERVICE_READY_TIMEOUT_MS, pollIntervalMs = 100) {
     const startedAt = Date.now();

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

@@ -1,9 +1,10 @@
 import type { Telegraf } from "telegraf";
 import { type Config } from "../config.js";
 import type { SessionManager } from "../session/session-manager.js";
+import { type RequestRestartFn } from "../platform/create-event-context.js";
 export interface TelegramEventHandlerHandle {
     stop: () => void;
     runningTasks: Map<string, import('../shared/ai-task.js').TaskRunState>;
     getRunningTaskCount: () => number;
 }
-export declare function setupTelegramHandlers(bot: Telegraf, config: Config, sessionManager: SessionManager): TelegramEventHandlerHandle;
+export declare function setupTelegramHandlers(bot: Telegraf, config: Config, sessionManager: SessionManager, requestRestart: RequestRestartFn): TelegramEventHandlerHandle;

package/dist/telegram/event-handler.js

@@ -59,7 +59,7 @@ async function downloadTelegramFile(bot, fileId, basenameHint, fallbackExtension
         fallbackExtension,
     });
 }
-export function setupTelegramHandlers(bot, config, sessionManager) {
+export function setupTelegramHandlers(bot, config, sessionManager, requestRestart) {
     // Create shared platform event context
     const platformCtx = createPlatformEventContext({
         platform: 'telegram',
@@ -67,6 +67,7 @@ export function setupTelegramHandlers(bot, config, sessionManager) {
         config,
         sessionManager,
         sender: { sendTextReply, sendDirectorySelection },
+        requestRestart,
     });
     const { accessControl, requestQueue, runningTasks } = platformCtx;
     // Telegram-specific sender callbacks for the factory

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

@@ -4,6 +4,7 @@
 import type { Config } from '../config.js';
 import type { SessionManager } from '../session/session-manager.js';
 import type { WeWorkCallbackMessage } from './types.js';
+import { type RequestRestartFn } from '../platform/create-event-context.js';
 type MediaKind = 'image' | 'file' | 'voice' | 'video';
 export interface WeWorkEventHandlerHandle {
     stop: () => void;
@@ -12,5 +13,5 @@ export interface WeWorkEventHandlerHandle {
     handleEvent: (data: WeWorkCallbackMessage) => Promise<void>;
 }
 export declare function buildMediaPrompt(data: WeWorkCallbackMessage, kind: MediaKind): Promise<string | null>;
-export declare function setupWeWorkHandlers(config: Config, sessionManager: SessionManager): WeWorkEventHandlerHandle;
+export declare function setupWeWorkHandlers(config: Config, sessionManager: SessionManager, requestRestart: RequestRestartFn): WeWorkEventHandlerHandle;
 export {};

package/dist/wework/event-handler.js

@@ -156,7 +156,7 @@ export async function buildMediaPrompt(data, kind) {
         guidance: 'If the media content is not directly accessible, explain that clearly and ask the user for a text summary, transcript, or a resend via a channel with native media support.',
     });
 }
-export function setupWeWorkHandlers(config, sessionManager) {
+export function setupWeWorkHandlers(config, sessionManager, requestRestart) {
     // Mutable ref that captures the req_id of the message currently being handled.
     // WeWork requires req_id to reply; CommandHandler doesn't carry it, so we inject
     // it via a closure. WeWork delivers messages sequentially over WebSocket, so
@@ -168,6 +168,7 @@ export function setupWeWorkHandlers(config, sessionManager) {
         allowedUserIds: config.weworkAllowedUserIds,
         config,
         sessionManager,
+        requestRestart,
         sender: {
             sendTextReply: (chatId, text) => sendTextReply(chatId, text, senderCtx.reqId),
             sendDirectorySelection: (chatId, currentDir, userId) => sendDirectorySelection(chatId, currentDir, userId, senderCtx.reqId),

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

@@ -3,10 +3,11 @@
  */
 import type { Config } from '../config.js';
 import type { SessionManager } from '../session/session-manager.js';
+import { type RequestRestartFn } from '../platform/create-event-context.js';
 export interface WorkBuddyEventHandlerHandle {
     stop: () => void;
     runningTasks: Map<string, import('../shared/ai-task.js').TaskRunState>;
     getRunningTaskCount: () => number;
     handleEvent: (chatId: string, msgId: string, content: string) => Promise<void>;
 }
-export declare function setupWorkBuddyHandlers(config: Config, sessionManager: SessionManager): WorkBuddyEventHandlerHandle;
+export declare function setupWorkBuddyHandlers(config: Config, sessionManager: SessionManager, requestRestart: RequestRestartFn): WorkBuddyEventHandlerHandle;

package/dist/workbuddy/event-handler.js

@@ -9,7 +9,7 @@ import { createPlatformEventContext } from '../platform/create-event-context.js'
 import { createPlatformAIRequestHandler } from '../platform/handle-ai-request.js';
 import { handleTextFlow } from '../platform/handle-text-flow.js';
 const log = createLogger('WorkBuddyHandler');
-export function setupWorkBuddyHandlers(config, sessionManager) {
+export function setupWorkBuddyHandlers(config, sessionManager, requestRestart) {
     // Create shared platform event context
     const ctx = createPlatformEventContext({
         platform: 'workbuddy',
@@ -21,6 +21,7 @@ export function setupWorkBuddyHandlers(config, sessionManager) {
                 await sendTextReply(null, chatId, text, '');
             },
         },
+        requestRestart,
     });
     // Start task cleanup
     const stopTaskCleanup = startTaskCleanup(ctx.runningTasks);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wu529778790/open-im",
-  "version": "1.11.11",
+  "version": "1.11.13-beta.0",
   "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",