oh-my-im 0.1.2 → 0.1.4

package/README.md

@@ -1,6 +1,6 @@
 # oh-my-im
 
-独立版钉钉机器人到 Codex CLI 桥接程序。
+独立版钉钉机器人到 Codex CLI / Pi Agent 桥接程序。
 
 ## 使用
 
@@ -11,6 +11,6 @@ npm link
 omi
 ```
 
-首次运行会在 `~/.oh-my-im` 创建本地配置；在管理页填写钉钉应用凭证、钉钉规则和机器人单聊授权人员即可。`omi` 的状态、日志和全部运行配置都固定保存在此目录，因此可在任意目录执行 `omi status`、`omi stop` 或 `omi update`。
+首次运行会在 `~/.oh-my-im` 创建本地配置；在管理页填写钉钉应用凭证、钉钉规则和机器人单聊授权人员，并选择 **Codex CLI** 或 **Pi Agent（Pi 默认模型）**。使用 Pi 前请确保本机 `pi` 命令已安装并完成 `/login`；可用 `PI_CLI_PATH` 覆盖命令路径。`omi` 的状态、日志和全部运行配置都固定保存在此目录，因此可在任意目录执行 `omi status`、`omi stop` 或 `omi update`。
 
 详见 [docs/development.md](docs/development.md)。

package/dist/{codex.js → agents/codex-agent.js}

@@ -1,6 +1,7 @@
 import { spawn } from "node:child_process";
 import { createInterface } from "node:readline";
-import { createLogger } from "./logger.js";
+import { createLogger } from "../logger.js";
+import { createAgentEnv } from "./process-utils.js";
 const log = createLogger("Codex");
 function parseJsonLine(line) {
     try {
@@ -55,15 +56,7 @@ export function runCodex(prompt, sessionId, config, callbacks = {}) {
     return new Promise((resolve, reject) => {
         const start = Date.now();
         const args = buildArgs(prompt, config.codexWorkDir, sessionId, config);
-        const env = { ...process.env };
-        if (config.codexProxy) {
-            env.HTTP_PROXY = config.codexProxy;
-            env.HTTPS_PROXY = config.codexProxy;
-            env.http_proxy = config.codexProxy;
-            env.https_proxy = config.codexProxy;
-            env.ALL_PROXY = config.codexProxy;
-            env.all_proxy = config.codexProxy;
-        }
+        const env = createAgentEnv(config.codexProxy);
         log.info(`spawn ${config.codexCliPath} ${args.join(" ")}`);
         const child = spawn(config.codexCliPath, args, {
             cwd: config.codexWorkDir,
@@ -84,6 +77,17 @@ export function runCodex(prompt, sessionId, config, callbacks = {}) {
             reject(new Error(`Codex CLI timeout after ${Math.round(config.cliTimeoutMs / 1000)}s`));
         }, config.cliTimeoutMs);
         timeout.unref();
+        callbacks.onAbortReady?.(() => {
+            if (!completed) {
+                child.kill("SIGTERM");
+                // Some child processes do not exit on SIGTERM. Ensure a user pause
+                // actually stops the current Codex task.
+                setTimeout(() => {
+                    if (!completed)
+                        child.kill("SIGKILL");
+                }, 1_000).unref();
+            }
+        });
         child.stdin.write(prompt);
         child.stdin.end();
         child.stderr.on("data", (chunk) => {

package/dist/agents/index.js

@@ -0,0 +1,20 @@
+import { runCodex } from "./codex-agent.js";
+import { runPi } from "./pi-agent.js";
+export function agentLabel(agent) {
+    return agent === "pi" ? "Pi" : "Codex";
+}
+export function agentSwitchMessage(agent) {
+    const label = agentLabel(agent);
+    const source = agent === "pi"
+        ? "Pi Agent（使用本机 Pi CLI）"
+        : "Codex Agent（使用本机 Codex CLI）";
+    return [
+        `当前已切换到 ${label}。\n`,
+        "使用方法：直接发送问题或任务即可；发送已配置的暂停指令可暂停当前任务，发送 Agent 切换指令可再次切换。",
+    ].join("\n");
+}
+export function runAgent(agent, prompt, sessionId, config, callbacks = {}) {
+    return agent === "pi"
+        ? runPi(prompt, sessionId, config, callbacks)
+        : runCodex(prompt, sessionId, config, callbacks);
+}

package/dist/agents/pi-agent.js

@@ -0,0 +1,148 @@
+import { spawn } from "node:child_process";
+import { createLogger } from "../logger.js";
+import { asObject, attachJsonlReader, createAgentEnv } from "./process-utils.js";
+const log = createLogger("Pi");
+function extractAssistantText(message) {
+    const value = asObject(message);
+    if (!value || value.role !== "assistant" || !Array.isArray(value.content))
+        return undefined;
+    const text = value.content.flatMap((part) => {
+        const item = asObject(part);
+        return item?.type === "text" && typeof item.text === "string" ? [item.text] : [];
+    }).join("\n");
+    return text || undefined;
+}
+export function runPi(prompt, sessionId, config, callbacks = {}) {
+    return new Promise((resolve, reject) => {
+        const start = Date.now();
+        const args = ["--mode", "rpc", "--approve"];
+        if (sessionId)
+            args.push("--session", sessionId);
+        const env = createAgentEnv(config.codexProxy);
+        const cliPath = config.piCliPath || "pi";
+        log.info(`spawn ${cliPath} ${args.join(" ")}`);
+        const child = spawn(cliPath, args, {
+            cwd: config.codexWorkDir,
+            env,
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        let completed = false;
+        let accumulated = "";
+        let authoritativeText = "";
+        let nextSessionId = sessionId;
+        let stderr = "";
+        const toolStats = {};
+        const seenToolCalls = new Set();
+        const finish = () => {
+            if (completed)
+                return;
+            completed = true;
+            clearTimeout(timeout);
+            child.kill("SIGTERM");
+            resolve({
+                sessionId: nextSessionId,
+                text: (authoritativeText || accumulated).trim() || "(无输出)",
+                toolStats,
+                durationMs: Date.now() - start,
+            });
+        };
+        const fail = (message) => {
+            if (completed)
+                return;
+            completed = true;
+            clearTimeout(timeout);
+            child.kill("SIGTERM");
+            reject(new Error(message));
+        };
+        const timeout = setTimeout(() => {
+            log.warn(`timeout after ${config.cliTimeoutMs}ms`);
+            fail(`Pi Agent timeout after ${Math.round(config.cliTimeoutMs / 1000)}s`);
+        }, config.cliTimeoutMs);
+        timeout.unref();
+        callbacks.onAbortReady?.(() => {
+            if (!completed) {
+                child.stdin.write(`${JSON.stringify({ type: "abort" })}\n`);
+                setTimeout(() => child.kill("SIGTERM"), 1000).unref();
+            }
+        });
+        callbacks.onSteerReady?.((message) => {
+            if (completed || child.stdin.destroyed || !child.stdin.writable)
+                return false;
+            try {
+                child.stdin.write(`${JSON.stringify({ type: "steer", message })}\n`);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        });
+        child.stderr.on("data", (chunk) => {
+            const text = chunk.toString();
+            stderr += text;
+            for (const line of text.split(/\r?\n/).map((item) => item.trim()).filter(Boolean)) {
+                log.debug(`stderr: ${line.slice(0, 1_000)}`);
+            }
+        });
+        attachJsonlReader(child.stdout, (line) => {
+            let event;
+            try {
+                event = JSON.parse(line);
+            }
+            catch {
+                log.warn(`ignored non-JSON Pi output: ${line.slice(0, 240)}`);
+                return;
+            }
+            if (event.type === "response" && event.success === false) {
+                fail(typeof event.error === "string" ? event.error : "Pi Agent command failed");
+                return;
+            }
+            if (event.type === "response" && event.command === "get_state" && event.success === true) {
+                const data = asObject(event.data);
+                if (typeof data?.sessionId === "string" && data.sessionId)
+                    nextSessionId = data.sessionId;
+                child.stdin.write(`${JSON.stringify({ id: "prompt", type: "prompt", message: prompt })}\n`);
+                return;
+            }
+            if (event.type === "message_update") {
+                const update = asObject(event.assistantMessageEvent);
+                if (update?.type === "text_delta" && typeof update.delta === "string") {
+                    accumulated += update.delta;
+                    callbacks.onText?.(accumulated);
+                }
+                return;
+            }
+            if (event.type === "tool_execution_start") {
+                const name = typeof event.toolName === "string" ? event.toolName : "tool";
+                const callId = typeof event.toolCallId === "string" ? event.toolCallId : `${name}:${seenToolCalls.size}`;
+                if (!seenToolCalls.has(callId)) {
+                    seenToolCalls.add(callId);
+                    toolStats[name] = (toolStats[name] ?? 0) + 1;
+                    callbacks.onToolUse?.(name, { ...toolStats });
+                }
+                return;
+            }
+            if (event.type === "message_end") {
+                const text = extractAssistantText(event.message);
+                if (text)
+                    authoritativeText = text;
+                return;
+            }
+            if (event.type === "agent_settled")
+                finish();
+        });
+        child.on("error", (err) => {
+            log.error("spawn error", err);
+            fail(err.message);
+        });
+        child.on("close", (code) => {
+            if (completed)
+                return;
+            if (code && code !== 0) {
+                fail(stderr.trim() || `Pi Agent exited with code ${code}`);
+                return;
+            }
+            finish();
+        });
+        child.stdin.write(`${JSON.stringify({ id: "state", type: "get_state" })}\n`);
+    });
+}

package/dist/agents/process-utils.js

@@ -0,0 +1,40 @@
+import { StringDecoder } from "node:string_decoder";
+export function asObject(value) {
+    return value && typeof value === "object" ? value : undefined;
+}
+export function createAgentEnv(proxy) {
+    const env = { ...process.env };
+    if (!proxy)
+        return env;
+    env.HTTP_PROXY = proxy;
+    env.HTTPS_PROXY = proxy;
+    env.http_proxy = proxy;
+    env.https_proxy = proxy;
+    env.ALL_PROXY = proxy;
+    env.all_proxy = proxy;
+    return env;
+}
+/** Read strict LF-delimited JSONL without treating Unicode separators as records. */
+export function attachJsonlReader(stream, onLine) {
+    const decoder = new StringDecoder("utf8");
+    let buffer = "";
+    stream.on("data", (chunk) => {
+        buffer += typeof chunk === "string" ? chunk : decoder.write(chunk);
+        while (true) {
+            const index = buffer.indexOf("\n");
+            if (index < 0)
+                break;
+            let line = buffer.slice(0, index);
+            buffer = buffer.slice(index + 1);
+            if (line.endsWith("\r"))
+                line = line.slice(0, -1);
+            if (line)
+                onLine(line);
+        }
+    });
+    stream.on("end", () => {
+        buffer += decoder.end();
+        if (buffer)
+            onLine(buffer.endsWith("\r") ? buffer.slice(0, -1) : buffer);
+    });
+}

package/dist/bot-app.js

@@ -0,0 +1,349 @@
+import { loadConfig } from "./config.js";
+import { agentLabel, agentSwitchMessage, runAgent } from "./agents/index.js";
+import { DingTalkBot, isSingleConversation } from "./dingtalk.js";
+import { createLogger } from "./logger.js";
+import { parseAgentControlCommand } from "./monitor-command.js";
+import { appendConversationLog } from "./conversation-log.js";
+const log = createLogger("Main");
+function getState(conversations, conversationId) {
+    const existing = conversations.get(conversationId);
+    if (existing)
+        return existing;
+    const created = { sessions: {}, busy: false };
+    conversations.set(conversationId, created);
+    return created;
+}
+function isAllowed(message, allowedUserIds) {
+    // Single-chat authorization is deny-by-default. Only users explicitly added
+    // in the dashboard may use the bot; an empty list allows nobody.
+    if (allowedUserIds.length === 0)
+        return false;
+    // DingTalk may provide both a staffId and an open userId. The dashboard
+    // stores the openDingTalkId returned by dws, so accept either identifier.
+    const senderIds = [message.senderStaffId, message.senderId]
+        .filter((id) => Boolean(id?.trim()))
+        .map((id) => id.trim());
+    return senderIds.some((id) => allowedUserIds.includes(id));
+}
+function formatStats(stats) {
+    const entries = Object.entries(stats);
+    if (entries.length === 0)
+        return "";
+    return entries.map(([name, count]) => `${name} x${count}`).join(", ");
+}
+function buildCardContent(content, note) {
+    const safeContent = content.trim() || "Codex 正在处理...";
+    const safeNote = note?.trim();
+    return safeNote ? `${safeContent}\n\n---\n${safeNote}` : safeContent;
+}
+function describeAttachment(attachment) {
+    const parts = [
+        `类型: ${attachment.type}`,
+        `路径: ${attachment.path}`,
+    ];
+    if (attachment.fileName)
+        parts.push(`文件名: ${attachment.fileName}`);
+    if (attachment.contentType)
+        parts.push(`Content-Type: ${attachment.contentType}`);
+    if (attachment.size)
+        parts.push(`大小: ${attachment.size} bytes`);
+    if (attachment.duration)
+        parts.push(`时长: ${attachment.duration}ms`);
+    if (attachment.recognition)
+        parts.push(`语音识别: ${attachment.recognition}`);
+    return parts.join("\n");
+}
+async function buildCodexPrompt(bot, message) {
+    if (message.msgtype === "text")
+        return message.text.trim();
+    const downloaded = await bot.downloadAttachments(message);
+    const attachmentText = downloaded.map(describeAttachment).join("\n\n");
+    const recognizedText = message.attachments
+        .map((item) => item.recognition)
+        .filter((item) => Boolean(item))
+        .join("\n");
+    const text = [message.text, recognizedText].filter(Boolean).join("\n").trim();
+    if (message.msgtype === "audio" || message.msgtype === "voice") {
+        if (text) {
+            return [
+                "用户发送了一段语音，钉钉识别文本如下：",
+                text,
+                attachmentText ? `\n语音文件信息：\n${attachmentText}` : "",
+                "\n请根据语音识别文本回复用户。如果需要，也可以参考本地语音文件路径。",
+            ].filter(Boolean).join("\n");
+        }
+        return [
+            "用户发送了一段语音，但钉钉消息里没有提供语音识别文本。",
+            attachmentText ? `语音文件已下载：\n${attachmentText}` : "语音文件未能下载。",
+            "请尝试根据本地文件分析；如果当前环境不支持音频识别，请明确告诉用户需要文字或可识别语音。",
+        ].join("\n\n");
+    }
+    if (message.msgtype === "picture" || message.msgtype === "image") {
+        return [
+            "用户发送了图片。",
+            attachmentText ? `图片已下载到本地：\n${attachmentText}` : "图片未能下载。",
+            text ? `随图文字：\n${text}` : "",
+            "请分析图片内容并回复用户。",
+        ].filter(Boolean).join("\n\n");
+    }
+    if (message.msgtype === "richText") {
+        return [
+            "用户发送了富文本消息。",
+            text ? `文本内容：\n${text}` : "",
+            attachmentText ? `附件信息：\n${attachmentText}` : "",
+            "请根据以上内容回复用户。",
+        ].filter(Boolean).join("\n\n");
+    }
+    if (downloaded.length > 0) {
+        return [
+            `用户发送了 ${message.msgtype} 消息。`,
+            `附件已下载到本地：\n${attachmentText}`,
+            text ? `附带文本：\n${text}` : "",
+            "请根据附件内容回复用户；如果当前 Codex 环境无法直接读取该类型文件，请说明已收到文件及本地路径。",
+        ].filter(Boolean).join("\n\n");
+    }
+    throw new Error(`暂不支持 ${message.msgtype} 消息：钉钉没有提供可处理的文本或附件下载信息。`);
+}
+async function handleCommand(bot, config, conversations, message, text) {
+    const state = getState(conversations, message.conversationId);
+    if (text === "/help") {
+        await bot.sendText(message.conversationId, [
+            "oh-my-im commands:",
+            "/help - 查看帮助",
+            "/status - 查看运行状态",
+            "/new - 清空当前会话的 Codex/Pi session",
+        ].join("\n"));
+        return true;
+    }
+    if (text === "/status") {
+        await bot.sendText(message.conversationId, [
+            "oh-my-im status:",
+            `Agent: ${agentLabel(config.agent)}`,
+            `Codex CLI: ${config.codexCliPath}`,
+            `Pi CLI: ${config.piCliPath ?? "pi"}`,
+            `WorkDir: ${config.codexWorkDir}`,
+            `Current session: ${state.sessions[config.agent] ?? "new"}`,
+            `Known conversations: ${conversations.size}`,
+        ].join("\n"));
+        return true;
+    }
+    if (text === "/new") {
+        state.sessions = {};
+        await bot.sendText(message.conversationId, "已清空当前会话的 Agent session。");
+        return true;
+    }
+    return false;
+}
+export async function runApp(configOverride, options = {}) {
+    const config = configOverride ?? loadConfig();
+    const bot = new DingTalkBot(config);
+    const conversations = new Map();
+    async function handleMessage(message) {
+        log.info(`received message conversation=${message.conversationId} conversationType=${message.conversationType ?? "<none>"} msgtype=${message.msgtype} senderNick=${message.senderNick ?? "<none>"} senderId=${message.senderId} senderStaffId=${message.senderStaffId ?? "<none>"} text=${JSON.stringify(message.text.slice(0, 500))} textLen=${message.text.length} attachmentCount=${message.attachments.length}`);
+        if (options.singleChatOnly && !isSingleConversation(message.conversationType)) {
+            log.debug(`ignored non-single conversation=${message.conversationId} type=${message.conversationType ?? "unknown"}`);
+            return;
+        }
+        const allowedUserIds = options.getAllowedUserIds?.() ?? config.allowedUserIds;
+        const allowed = isAllowed(message, allowedUserIds);
+        log.info(`permission check conversation=${message.conversationId} senderNick=${message.senderNick ?? "<none>"} senderId=${message.senderId} senderStaffId=${message.senderStaffId ?? "<none>"} allowedCount=${allowedUserIds.length} allowed=[${allowedUserIds.join(",")}] result=${allowed ? "ALLOW" : "DENY"}`);
+        if (!allowed) {
+            const receivedIds = [message.senderStaffId, message.senderId].filter(Boolean).join(", ");
+            await bot.sendText(message.conversationId, `抱歉，您没有访问权限。\n收到的 ID: ${receivedIds}`);
+            return;
+        }
+        const text = message.text.trim();
+        if (!text && message.attachments.length === 0 && message.msgtype !== "richText")
+            return;
+        if (message.msgtype === "text" || message.msgtype === "richText") {
+            const keywords = options.getCommandKeywords?.();
+            const control = keywords ? parseAgentControlCommand(text, keywords) : undefined;
+            if (control === "pause") {
+                const state = getState(conversations, message.conversationId);
+                if (!state.busy || !state.abort) {
+                    await bot.sendText(message.conversationId, "当前没有正在处理的 Agent 任务。");
+                    return;
+                }
+                state.paused = true;
+                state.abort();
+                return;
+            }
+            if (control && typeof control === "object") {
+                await options.setAgent?.(control.agent);
+                await bot.sendText(message.conversationId, agentSwitchMessage(control.agent));
+                return;
+            }
+        }
+        if (message.msgtype === "text" && text.startsWith("/")) {
+            log.info(`command=${text} conversation=${message.conversationId}`);
+        }
+        const selectedAgent = options.getAgent?.() ?? config.agent;
+        const currentConfig = selectedAgent === config.agent ? config : { ...config, agent: selectedAgent };
+        if (message.msgtype === "text" && await handleCommand(bot, currentConfig, conversations, message, text))
+            return;
+        const state = getState(conversations, message.conversationId);
+        if (state.busy) {
+            if (state.activeAgent === "pi" && state.steer && text) {
+                const steered = state.steer(text);
+                await bot.sendText(message.conversationId, steered
+                    ? "已将这条消息作为引导发送给当前 Pi 任务。"
+                    : "当前 Pi 任务暂时无法接收引导，消息已排队等待处理。");
+            }
+            else {
+                await bot.sendText(message.conversationId, "当前 Agent 不支持运行中引导，请等待任务结束，或先发送暂停指令。");
+            }
+            return;
+        }
+        state.busy = true;
+        state.paused = false;
+        state.activeAgent = selectedAgent;
+        const label = agentLabel(selectedAgent);
+        const taskStartedAt = Date.now();
+        const formatElapsed = () => {
+            const totalSeconds = Math.max(0, Math.floor((Date.now() - taskStartedAt) / 1000));
+            const minutes = Math.floor(totalSeconds / 60);
+            const seconds = totalSeconds % 60;
+            return minutes > 0 ? `${minutes}分${seconds}秒` : `${seconds}秒`;
+        };
+        const title = `【${label}】`;
+        const processingTitle = () => `🔵 ${title}处理中... (${formatElapsed()})`;
+        const reply = await bot.sendThinkingCard(message, `${label} 正在处理...`, processingTitle());
+        let elapsedTimer;
+        let latestCardContent = `${label} 正在处理...`;
+        const agent = selectedAgent;
+        let prompt = "";
+        try {
+            let latestStats = {};
+            let lastUpdateAt = 0;
+            const cardUpdateInterval = selectedAgent === "pi" ? 1_000 : 500;
+            let pendingUpdate;
+            const updateCard = (title, content, force = false) => {
+                latestCardContent = content;
+                if (reply.mode !== "card")
+                    return;
+                const now = Date.now();
+                const run = () => {
+                    lastUpdateAt = Date.now();
+                    pendingUpdate = undefined;
+                    bot.updateReply(reply, title, content, { fallbackToText: false }).catch((err) => {
+                        log.warn(`card update skipped: ${err instanceof Error ? err.message : String(err)}`);
+                    });
+                };
+                if (force || now - lastUpdateAt >= cardUpdateInterval) {
+                    if (pendingUpdate) {
+                        clearTimeout(pendingUpdate);
+                        pendingUpdate = undefined;
+                    }
+                    run();
+                    return;
+                }
+                if (!pendingUpdate) {
+                    pendingUpdate = setTimeout(run, cardUpdateInterval - (now - lastUpdateAt));
+                    pendingUpdate.unref();
+                }
+            };
+            elapsedTimer = setInterval(() => {
+                updateCard(processingTitle(), latestCardContent);
+            }, 1_000);
+            elapsedTimer.unref();
+            prompt = await buildCodexPrompt(bot, message);
+            const result = await runAgent(agent, prompt, state.sessions[agent], config, {
+                onAbortReady: (abort) => { state.abort = abort; },
+                onSteerReady: (steer) => { state.steer = steer; },
+                onText: (content) => {
+                    const stats = formatStats(latestStats);
+                    updateCard(processingTitle(), buildCardContent(content, stats ? `工具：${stats}` : undefined));
+                },
+                onToolUse: (_toolName, stats) => {
+                    latestStats = stats;
+                    const statsText = formatStats(stats);
+                    updateCard(processingTitle(), buildCardContent(`${label} 正在处理...`, statsText ? `工具：${statsText}` : undefined));
+                },
+            });
+            if (elapsedTimer) {
+                clearInterval(elapsedTimer);
+                elapsedTimer = undefined;
+            }
+            if (state.paused)
+                throw new Error("Agent task paused by user");
+            if (pendingUpdate) {
+                clearTimeout(pendingUpdate);
+            }
+            state.sessions[agent] = result.sessionId ?? state.sessions[agent];
+            const stats = formatStats(result.toolStats);
+            const note = [`Agent ${label}`, `耗时 ${(result.durationMs / 1000).toFixed(1)}s`, stats].filter(Boolean).join(" | ");
+            await bot.updateReply(reply, `✅ ${title}完成 总耗时 ${formatElapsed()}`, buildCardContent(result.text, note));
+            await appendConversationLog({
+                id: `${message.conversationId}:${taskStartedAt}`,
+                createdAt: new Date().toISOString(),
+                conversationType: "personal",
+                conversationName: message.senderNick || message.senderId,
+                groupId: message.conversationId,
+                groupName: message.senderNick || message.senderId,
+                status: "completed",
+                agent,
+                question: prompt,
+                senderNames: [message.senderNick || message.senderId],
+                senderDetails: [{ senderName: message.senderNick || message.senderId, senderId: message.senderStaffId || message.senderId, content: prompt }],
+                content: result.text,
+                messageCount: 1,
+            }, [{ senderName: message.senderNick || message.senderId, senderId: message.senderStaffId || message.senderId, content: prompt }]);
+        }
+        catch (err) {
+            if (elapsedTimer) {
+                clearInterval(elapsedTimer);
+                elapsedTimer = undefined;
+            }
+            if (state.paused) {
+                log.info(`${label} task paused by user`);
+                await bot.updateReply(reply, `🔴 ${title}处理暂停 总耗时 ${formatElapsed()}`, latestCardContent);
+                await appendConversationLog({
+                    id: `${message.conversationId}:${taskStartedAt}`,
+                    createdAt: new Date().toISOString(), conversationType: "personal",
+                    conversationName: message.senderNick || message.senderId, groupId: message.conversationId,
+                    groupName: message.senderNick || message.senderId, status: "failed", agent,
+                    question: prompt, senderNames: [message.senderNick || message.senderId],
+                    senderDetails: [{ senderName: message.senderNick || message.senderId, senderId: message.senderStaffId || message.senderId, content: prompt }],
+                    content: latestCardContent, messageCount: 1,
+                }, [{ senderName: message.senderNick || message.senderId, senderId: message.senderStaffId || message.senderId, content: prompt }]);
+            }
+            else {
+                log.error(`${label} execution failed`, err);
+                const errorMessage = err instanceof Error ? err.message : String(err);
+                await bot.updateReply(reply, `❌ ${title}处理失败 总耗时 ${formatElapsed()}`, `${label} 执行失败：${errorMessage}`);
+                await appendConversationLog({
+                    id: `${message.conversationId}:${taskStartedAt}`,
+                    createdAt: new Date().toISOString(),
+                    conversationType: "personal",
+                    conversationName: message.senderNick || message.senderId,
+                    groupId: message.conversationId,
+                    groupName: message.senderNick || message.senderId,
+                    status: "failed",
+                    agent,
+                    question: prompt,
+                    senderNames: [message.senderNick || message.senderId],
+                    senderDetails: [{ senderName: message.senderNick || message.senderId, senderId: message.senderStaffId || message.senderId, content: prompt }],
+                    content: errorMessage,
+                    messageCount: 1,
+                }, [{ senderName: message.senderNick || message.senderId, senderId: message.senderStaffId || message.senderId, content: prompt }]);
+            }
+        }
+        finally {
+            state.busy = false;
+            state.abort = undefined;
+            state.steer = undefined;
+            state.activeAgent = undefined;
+            state.paused = false;
+        }
+    }
+    process.once("SIGINT", () => {
+        bot.stop();
+        process.exit(0);
+    });
+    process.once("SIGTERM", () => {
+        bot.stop();
+        process.exit(0);
+    });
+    await bot.start(handleMessage);
+    log.info(`ready workDir=${config.codexWorkDir} codex=${config.codexCliPath}`);
+}