oh-my-im 0.1.21 → 0.2.0

package/dist/bot-app.js

@@ -1,22 +1,51 @@
 import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, isAbsolute, join, relative, resolve } from "node:path";
-import { loadConfig } from "./config.js";
+import { loadConfig } from "./core/config.js";
 import { agentLabel, agentSwitchMessage, listAgentSessions, 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";
+import { DingTalkBot, isSingleConversation } from "./dingtalk/dingtalk.js";
+import { createLogger } from "./core/logger.js";
+import { normalizeDingTalkMarkdown } from "./dingtalk/markdown.js";
+import { DingTalkAiCardClient } from "./dingtalk/dingtalk-ai-card.js";
+import { AiCardSession } from "./dingtalk/ai-card.js";
+import { parseAgentControlCommand } from "./core/monitor-command.js";
+import { appendConversationLog } from "./core/conversation-log.js";
 const PRIVATE_SESSIONS_FILE = join(homedir(), ".oh-my-im", "private-sessions.json");
+const PRIVATE_AGENTS_FILE = join(homedir(), ".oh-my-im", "private-agents.json");
 const privateSessionBindings = new Map();
+// Agent 与具体会话绑定：私聊 A 切了 Agent 不影响私聊 B，重启后也能各自记住。
+const privateAgentBindings = new Map();
 try {
     const stored = JSON.parse(readFileSync(PRIVATE_SESSIONS_FILE, "utf8"));
     Object.entries(stored).forEach(([key, value]) => { if (typeof value === "string" && value.trim())
         privateSessionBindings.set(key, value.trim()); });
 }
 catch { /* first run */ }
-function privateSessionKey(conversationId, agent) {
-    return `${agent}:${conversationId}`;
+try {
+    const stored = JSON.parse(readFileSync(PRIVATE_AGENTS_FILE, "utf8"));
+    Object.entries(stored).forEach(([key, value]) => {
+        if (value === "pi" || value === "codex" || value === "opencode")
+            privateAgentBindings.set(key, value);
+    });
+}
+catch { /* first run */ }
+function savePrivateAgents() {
+    mkdirSync(dirname(PRIVATE_AGENTS_FILE), { recursive: true });
+    const temporary = `${PRIVATE_AGENTS_FILE}.${process.pid}.tmp`;
+    writeFileSync(temporary, `${JSON.stringify(Object.fromEntries(privateAgentBindings), null, 2)}\n`, "utf8");
+    renameSync(temporary, PRIVATE_AGENTS_FILE);
+}
+function setPrivateAgent(conversationId, agent) {
+    if (privateAgentBindings.get(conversationId) === agent)
+        return;
+    privateAgentBindings.set(conversationId, agent);
+    savePrivateAgents();
+}
+function privateSessionKey(conversationId, agent, workDir) {
+    // The work directory is part of the key: a stored session created in a
+    // different directory must never be resumed, otherwise Pi/Codex/OpenCode
+    // fail with a project mismatch after the working directory changes.
+    return `${agent}:${conversationId}:${workDir}`;
 }
 function savePrivateSessions() {
     mkdirSync(dirname(PRIVATE_SESSIONS_FILE), { recursive: true });
@@ -25,18 +54,45 @@ function savePrivateSessions() {
     renameSync(temporary, PRIVATE_SESSIONS_FILE);
 }
 function clearPrivateSessionBindings(conversationId) {
-    privateSessionBindings.delete(privateSessionKey(conversationId, "pi"));
-    privateSessionBindings.delete(privateSessionKey(conversationId, "codex"));
-    privateSessionBindings.delete(privateSessionKey(conversationId, "opencode"));
-    savePrivateSessions();
+    let changed = false;
+    for (const agent of ["pi", "codex", "opencode"]) {
+        const prefix = `${agent}:${conversationId}:`;
+        for (const key of [...privateSessionBindings.keys()]) {
+            if (key.startsWith(prefix)) {
+                privateSessionBindings.delete(key);
+                changed = true;
+            }
+        }
+    }
+    if (changed)
+        savePrivateSessions();
 }
 const log = createLogger("Main");
-function safePathPart(value) {
-    return value.trim().replace(/[^\w.-]+/g, "_").slice(0, 120) || "unknown";
+function safeDirName(value, fallback) {
+    // Chinese display names are valid directory names; only strip characters
+    // that are illegal on the filesystem or could escape the parent directory.
+    const cleaned = value
+        .replace(/[\u0000-\u001f\u007f]/g, "")
+        .replace(/[\\/:*?"<>|]/g, "_")
+        .replace(/\s+/g, " ")
+        .replace(/^\.+/, "")
+        .trim()
+        .slice(0, 80)
+        .trim();
+    return cleaned || fallback;
 }
 function privateUserWorkDir(message) {
+    // An explicit AGENT_WORK_DIR override is used as-is (single shared dir).
+    const override = process.env.AGENT_WORK_DIR?.trim();
+    if (override) {
+        mkdirSync(override, { recursive: true });
+        return override;
+    }
+    // Otherwise each DingTalk user gets their own directory named after the
+    // sender display name, for example ~/.oh-my-im/users/杜振训.
     const userId = message.senderStaffId?.trim() || message.senderId.trim();
-    const dir = join(homedir(), ".oh-my-im", "users", safePathPart(userId), "workspace");
+    const displayName = safeDirName(message.senderNick ?? "", safeDirName(userId, "unknown"));
+    const dir = join(homedir(), ".oh-my-im", "users", displayName);
     mkdirSync(dir, { recursive: true });
     return dir;
 }
@@ -48,14 +104,30 @@ function pathInside(root, candidate) {
 }
 function getState(conversations, conversationId, defaultWorkDir) {
     const existing = conversations.get(conversationId);
-    if (existing)
+    if (existing) {
+        // The directory is derived from the sender display name, so a nickname
+        // change must take effect on the next message. Reset the bound sessions
+        // and selections so no Agent keeps running in (or resumes a session from)
+        // the previous directory.
+        if (existing.defaultWorkDir !== defaultWorkDir) {
+            existing.defaultWorkDir = defaultWorkDir;
+            existing.selectedSessions = {};
+            existing.visibleSessionLists = {};
+            existing.sessions = {};
+            // Drop persisted session bindings too; resuming a session created in the
+            // previous directory makes Pi/Codex/OpenCode fail with a project
+            // mismatch, so the next message must start a fresh session.
+            clearPrivateSessionBindings(conversationId);
+        }
         return existing;
+    }
     const created = {
         defaultWorkDir,
         sessions: {}, selectedSessions: {}, visibleSessionLists: {}, pendingMessages: [], pendingNoticeSent: false, busy: false,
+        selectedAgent: privateAgentBindings.get(conversationId),
     };
     ['codex', 'pi', 'opencode'].forEach((agent) => {
-        const sessionId = privateSessionBindings.get(privateSessionKey(conversationId, agent));
+        const sessionId = privateSessionBindings.get(privateSessionKey(conversationId, agent, defaultWorkDir));
         if (sessionId)
             created.sessions[agent] = sessionId;
     });
@@ -132,18 +204,14 @@ function formatSessionList(agent, cwd, sessions, selected, admin = false) {
         admin ? "返回目录：/admin-sessions" : `重新查看：/sessions ${agent}`,
     ].join("\n");
 }
-function formatStats(stats) {
-    const entries = Object.entries(stats);
-    if (entries.length === 0)
-        return "";
-    return entries.map(([name, count]) => `${name} x${count}`).join(", ");
-}
 function shortModelName(model) {
     const value = model?.trim() || "";
     return value.includes("/") ? value.slice(value.lastIndexOf("/") + 1) : value;
 }
 function buildCardContent(content, note) {
-    const safeContent = content.trim() || "[OMG] 正在分析...";
+    // DingTalk cards render a limited Markdown subset without table support, so
+    // convert tables to lists before they reach the card.
+    const safeContent = normalizeDingTalkMarkdown(content).trim() || "[OMG] 正在分析...";
     const safeNote = note?.trim();
     return safeNote ? `${safeContent}\n\n\n${safeNote}` : safeContent;
 }
@@ -289,6 +357,7 @@ async function handleCommand(bot, config, conversations, message, text, isSuperA
         state.sessions[agent] = selected.id;
         state.selectedSessions[agent] = { id: selected.id, cwd: selected.cwd };
         state.selectedAgent = agent;
+        setPrivateAgent(message.conversationId, agent);
         await bot.sendText(message.conversationId, [
             `已切换到 ${agentLabel(agent)} Session。`,
             `Session: ${selected.id}`,
@@ -383,6 +452,7 @@ async function handleCommand(bot, config, conversations, message, text, isSuperA
         state.sessions[agent] = selected.id;
         state.selectedSessions[agent] = { id: selected.id, cwd: selected.cwd };
         state.selectedAgent = agent;
+        setPrivateAgent(message.conversationId, agent);
         await bot.sendText(message.conversationId, [
             `已切换到管理员 ${agentLabel(agent)} Session。`,
             `Session: ${selected.id}`,
@@ -446,7 +516,8 @@ async function handleCommand(bot, config, conversations, message, text, isSuperA
         state.sessions = {};
         state.selectedSessions = {};
         state.visibleSessionLists = {};
-        state.selectedAgent = undefined;
+        // 只清空 session 与工作路径绑定，保留当前选中的 Agent，
+        // 否则下一条消息会退回默认 Agent（看起来像被自动切换了）。
         state.adminWorkDir = undefined;
         state.adminDirectories = undefined;
         await bot.sendText(message.conversationId, "已清空当前会话的 Agent session 和工作路径绑定。");
@@ -457,6 +528,8 @@ async function handleCommand(bot, config, conversations, message, text, isSuperA
 export async function runApp(configOverride, options = {}) {
     const config = configOverride ?? loadConfig();
     const bot = new DingTalkBot(config);
+    const aiCardClient = new DingTalkAiCardClient();
+    aiCardClient.setCredentials(config.dingtalkClientId, config.dingtalkClientSecret, config.dingtalkClientId);
     const conversations = new Map();
     // Stream callbacks can still be redelivered when an ACK is lost, and DWS /
     // history paths may surface the same content twice. Without message-level
@@ -546,6 +619,8 @@ export async function runApp(configOverride, options = {}) {
             if (control && typeof control === "object") {
                 const state = getState(conversations, message.conversationId, privateUserWorkDir(message));
                 state.selectedAgent = control.agent;
+                // 只绑定到当前会话：别的私聊/群聊不受影响，重启后这个会话仍记得。
+                setPrivateAgent(message.conversationId, control.agent);
                 await bot.sendText(message.conversationId, agentSwitchMessage(control.agent));
                 return;
             }
@@ -557,10 +632,11 @@ export async function runApp(configOverride, options = {}) {
         const selectedAgent = state.selectedAgent ?? options.getAgent?.() ?? config.agent;
         const currentConfig = {
             ...config,
+            // Session listing and command handling must run in the same isolated
+            // directory the Agent will execute in, for Codex, Pi and OpenCode alike.
+            codexWorkDir: state.defaultWorkDir,
             agent: selectedAgent,
-            agentModel: selectedAgent !== "codex"
-                ? options.getAgentModel?.(selectedAgent) ?? (config.agentModels[selectedAgent] || undefined)
-                : undefined,
+            agentModel: options.getAgentModel?.(selectedAgent) ?? (config.agentModels[selectedAgent] || undefined),
         };
         if (message.msgtype === "text" && await handleCommand(bot, currentConfig, conversations, message, text, isSuperAdminUser))
             return;
@@ -575,8 +651,13 @@ export async function runApp(configOverride, options = {}) {
             const steer = state.activeAgent === "pi" && state.busy && state.steer && state.steerTaskToken ? state.steer : undefined;
             if (steer && text) {
                 const steered = steer(text);
+                if (!steered) {
+                    // 引导失败时必须真的入队，否则“已排队等待处理”只是空话，消息会被丢掉。
+                    state.pendingMessages.push(message);
+                    state.pendingNoticeSent = true;
+                }
                 await bot.sendText(message.conversationId, steered
-                    ? "[灵感]已将这条消息作为引导发送给当前 Pi 任务。"
+                    ? "[灵感] 已将这条消息作为引导发送给当前 Pi 任务。"
                     : "当前 Pi 任务暂时无法接收引导，消息已排队等待处理。");
             }
             else if ((state.activeAgent === "codex" || state.activeAgent === "opencode") && text) {
@@ -602,13 +683,9 @@ export async function runApp(configOverride, options = {}) {
         state.activeFingerprint = messageFingerprint;
         const taskToken = `${message.conversationId}:${Date.now()}:${Math.random().toString(36).slice(2)}`;
         state.steerTaskToken = taskToken;
-        const modelName = selectedAgent !== "codex"
-            ? shortModelName(options.getAgentModel?.(selectedAgent) ?? config.agentModels[selectedAgent])
-            : "";
-        const label = `${agentLabel(selectedAgent)} Agent`;
-        const processingLabel = selectedAgent === "codex"
-            ? `${agentLabel(selectedAgent)} Agent`
-            : `${agentLabel(selectedAgent)} ${modelName || "默认模型"}`;
+        const modelName = shortModelName(options.getAgentModel?.(selectedAgent) ?? config.agentModels[selectedAgent]);
+        const label = agentLabel(selectedAgent);
+        const processingLabel = `${agentLabel(selectedAgent)} ${modelName || "默认模型"}`;
         const processingMessage = `[OMG] ${processingLabel} 正在分析...`;
         const taskStartedAt = Date.now();
         const formatElapsed = () => {
@@ -629,10 +706,45 @@ export async function runApp(configOverride, options = {}) {
         // The setting only controls the live processing title. Completion always
         // includes the elapsed time as a useful final result summary.
         const finishedTitle = (icon, state) => `${icon} ${title}${state} 总耗时 ${formatElapsed()}`;
-        const responseMode = options.getResponseMode?.() ?? "card";
-        const reply = responseMode === "card"
-            ? await bot.sendThinkingCard(message, processingMessage, processingTitle())
-            : { conversationId: message.conversationId, mode: "text" };
+        const requestedMode = options.getResponseMode?.() ?? "card";
+        const aiCardConfig = options.getAiCardConfig?.() ?? { templateId: "", contentKey: "content", streamIntervalMs: 500 };
+        let useAiCard = requestedMode === "aiCard" && Boolean(aiCardConfig.templateId) && aiCardClient.configured;
+        if (requestedMode === "aiCard" && !useAiCard) {
+            log.warn(`AI card unavailable (template=${aiCardConfig.templateId ? "set" : "empty"}, credentials=${aiCardClient.configured}); using standard card`);
+        }
+        const responseMode = requestedMode === "text" ? "text" : "card";
+        let aiCardSession;
+        let reply;
+        if (responseMode === "card") {
+            if (useAiCard) {
+                try {
+                    aiCardClient.setCredentials(config.dingtalkClientId, config.dingtalkClientSecret, message.robotCode || config.dingtalkClientId);
+                    const session = new AiCardSession({
+                        client: aiCardClient,
+                        templateId: aiCardConfig.templateId,
+                        contentKey: aiCardConfig.contentKey,
+                        log,
+                    });
+                    await session.openForSingle({
+                        userId: message.senderStaffId || message.senderId,
+                        title: `【${label}】${modelName || "默认模型"} 进行中...`,
+                    });
+                    aiCardSession = session;
+                    reply = { conversationId: message.conversationId, mode: "card", cardBizId: session.outTrackId };
+                }
+                catch (err) {
+                    log.warn(`AI card create failed; falling back to standard card: ${String(err)}`);
+                    useAiCard = false;
+                    reply = await bot.sendThinkingCard(message, processingMessage, processingTitle());
+                }
+            }
+            else {
+                reply = await bot.sendThinkingCard(message, processingMessage, processingTitle());
+            }
+        }
+        else {
+            reply = { conversationId: message.conversationId, mode: "text" };
+        }
         if (responseMode === "text")
             await bot.sendText(message.conversationId, processingMessage);
         let elapsedTimer;
@@ -640,14 +752,13 @@ export async function runApp(configOverride, options = {}) {
         const agent = selectedAgent;
         let prompt = "";
         try {
-            let latestStats = {};
             let streamedText = "";
             let toolStatus = "";
             let lastUpdateAt = 0;
             let pendingUpdate;
             let cardUpdatesStopped = false;
             let cardUpdateChain = Promise.resolve();
-            const getCardUpdateInterval = () => Math.max(0, options.getCardUpdateIntervalMs?.() ?? 3_000);
+            const getCardUpdateInterval = () => useAiCard ? Math.max(0, aiCardConfig.streamIntervalMs) : Math.max(0, options.getCardUpdateIntervalMs?.() ?? 3_000);
             const liveCardUpdates = responseMode === "card" && getCardUpdateInterval() > 0;
             const stopCardUpdates = () => {
                 cardUpdatesStopped = true;
@@ -677,6 +788,10 @@ export async function runApp(configOverride, options = {}) {
                     cardUpdateChain = cardUpdateChain.then(async () => {
                         if (cardUpdatesStopped)
                             return;
+                        if (aiCardSession) {
+                            await aiCardSession.push(content);
+                            return;
+                        }
                         await bot.updateReply(reply, title, content, { fallbackToText: false });
                     }).catch((err) => {
                         log.warn(`card update skipped: ${err instanceof Error ? err.message : String(err)}`);
@@ -695,7 +810,7 @@ export async function runApp(configOverride, options = {}) {
                     pendingUpdate.unref();
                 }
             };
-            if (liveCardUpdates) {
+            if (liveCardUpdates && !useAiCard) {
                 elapsedTimer = setInterval(() => {
                     if (!cardUpdatesStopped)
                         updateCard(processingTitle(), latestCardContent);
@@ -715,18 +830,20 @@ export async function runApp(configOverride, options = {}) {
                         state.steer = steer;
                 },
                 onText: (content) => {
-                    const stats = formatStats(latestStats);
                     streamedText = content;
-                    toolStatus = "";
-                    if (liveCardUpdates)
-                        updateCard(processingTitle(), buildCardContent(toolStatus ? `${streamedText}\n\n${toolStatus}` : (streamedText || content), stats ? `工具：${stats}` : undefined));
+                    if (liveCardUpdates && content.trim()) {
+                        toolStatus = "";
+                        updateCard(processingTitle(), buildCardContent(content));
+                    }
                 },
                 onToolUse: (toolName, stats) => {
-                    latestStats = stats;
-                    const statsText = formatStats(stats);
-                    toolStatus = `[OMG] 调用工具：${toolName} x${stats[toolName] ?? 1}`;
-                    if (liveCardUpdates)
-                        updateCard(processingTitle(), buildCardContent(streamedText ? `${streamedText}\n\n${toolStatus}` : toolStatus, statsText ? `工具：${statsText}` : undefined));
+                    const totalCalls = Object.values(stats).reduce((sum, count) => sum + (count || 0), 0);
+                    log.info(`tool=${toolName} total=${totalCalls}`);
+                    // AI 卡片在工具调用/等待期显示实时调用次数，出字后清除。
+                    if (!useAiCard || !liveCardUpdates)
+                        return;
+                    toolStatus = `[OMG] 正在调用工具（已 ${totalCalls} 次）…`;
+                    updateCard(processingTitle(), buildCardContent(streamedText ? `${streamedText}\n\n${toolStatus}` : toolStatus));
                 },
             });
             if (elapsedTimer) {
@@ -744,16 +861,32 @@ export async function runApp(configOverride, options = {}) {
             stopCardUpdatesForCurrentTask = undefined;
             state.sessions[agent] = result.sessionId ?? state.sessions[agent];
             if (state.sessions[agent]) {
-                privateSessionBindings.set(privateSessionKey(message.conversationId, agent), state.sessions[agent]);
+                privateSessionBindings.set(privateSessionKey(message.conversationId, agent, selectedSession?.cwd ?? state.defaultWorkDir), state.sessions[agent]);
                 savePrivateSessions();
             }
             const toolCount = Object.values(result.toolStats).reduce((total, count) => total + count, 0);
-            const note = `[夯爆了] ${modelName || "默认模型"} 1条消息 ${toolCount}次工具`;
-            const finalContent = buildCardContent(result.text, options.getShowProcessingDetails?.() === true ? note : undefined);
-            if (responseMode === "card")
-                await bot.updateReply(reply, finishedTitle("✅", "完成"), finalContent);
-            else
-                await bot.sendText(message.conversationId, result.text.trim() || "(无输出)");
+            const showDetails = options.getShowProcessingDetails?.() === true;
+            const note = `${modelName || "默认模型"} 1条消息,${toolCount}次工具`;
+            if (responseMode === "card" && aiCardSession) {
+                // AI 卡片：正文不带结束语，结束语走模板的 $end_text 变量。
+                const cardContent = buildCardContent(result.text);
+                const delivered = await aiCardSession.finish({
+                    content: cardContent,
+                    title: `【${label}】完成 总耗时 ${formatElapsed()}`,
+                    endText: showDetails ? note : undefined,
+                });
+                if (!delivered) {
+                    await bot.sendText(message.conversationId, `${normalizeDingTalkMarkdown(result.text).trim() || "(无输出)"}\n\n总耗时 ${formatElapsed()}`)
+                        .catch((sendErr) => log.warn(`AI card text fallback failed: ${String(sendErr)}`));
+                }
+            }
+            else if (responseMode === "card") {
+                // 非 AI 卡片在结束语前面加上「[夯爆了]」标记。
+                await bot.updateReply(reply, finishedTitle("✅", "完成"), buildCardContent(result.text, showDetails ? `[夯爆了] ${note}` : undefined));
+            }
+            else {
+                await bot.sendText(message.conversationId, normalizeDingTalkMarkdown(result.text).trim() || "(无输出)");
+            }
             await appendConversationLog({
                 id: `${message.conversationId}:${taskStartedAt}`,
                 createdAt: new Date().toISOString(),
@@ -780,10 +913,15 @@ export async function runApp(configOverride, options = {}) {
                 state.stopCardUpdates = undefined;
                 stopCardUpdatesForCurrentTask = undefined;
                 log.info(`${label} task paused by user`);
-                if (responseMode === "card")
+                if (responseMode === "card" && aiCardSession) {
+                    await aiCardSession.finish({ content: latestCardContent, title: `【${label}】处理暂停 总耗时 ${formatElapsed()}`, error: true });
+                }
+                else if (responseMode === "card") {
                     await bot.updateReply(reply, finishedTitle("🔴", "处理暂停"), latestCardContent);
-                else
+                }
+                else {
                     await bot.sendText(message.conversationId, "Agent 任务已暂停。");
+                }
                 await appendConversationLog({
                     id: `${message.conversationId}:${taskStartedAt}`,
                     createdAt: new Date().toISOString(), conversationType: "personal",
@@ -800,10 +938,15 @@ export async function runApp(configOverride, options = {}) {
                 stopCardUpdatesForCurrentTask = undefined;
                 log.error(`${label} execution failed`, err);
                 const errorMessage = err instanceof Error ? err.message : String(err);
-                if (responseMode === "card")
+                if (responseMode === "card" && aiCardSession) {
+                    await aiCardSession.finish({ content: `${label} 执行失败：${errorMessage}`, title: `【${label}】处理失败 总耗时 ${formatElapsed()}`, error: true });
+                }
+                else if (responseMode === "card") {
                     await bot.updateReply(reply, finishedTitle("❌", "处理失败"), `${label} 执行失败：${errorMessage}`);
-                else
+                }
+                else {
                     await bot.sendText(message.conversationId, `${label} 执行失败：${errorMessage}`);
+                }
                 await appendConversationLog({
                     id: `${message.conversationId}:${taskStartedAt}`,
                     createdAt: new Date().toISOString(),
@@ -859,6 +1002,16 @@ export async function runApp(configOverride, options = {}) {
     let privateChatConnected = false;
     let privateChatStarting = false;
     let privateChatGeneration = 0;
+    // 只在（启用状态, 连接状态）真的变化时写一次状态文件，避免看板读到过期值。
+    let lastReportedStatusKey;
+    const reportConnectionStatus = (connected) => {
+        const enabled = options.getPrivateChatEnabled?.() ?? true;
+        const key = `${enabled}|${connected}`;
+        if (key === lastReportedStatusKey)
+            return;
+        lastReportedStatusKey = key;
+        options.onConnectionStatus?.(connected);
+    };
     const privateChatTimer = setInterval(() => {
         const enabled = options.getPrivateChatEnabled?.() ?? true;
         if (!enabled) {
@@ -867,29 +1020,37 @@ export async function runApp(configOverride, options = {}) {
                 privateChatConnected = false;
                 privateChatStarting = false;
                 bot.stop();
-                options.onConnectionStatus?.(false);
+                reportConnectionStatus(false);
                 log.info("private chat stream stopped by configuration");
             }
             return;
         }
-        if (privateChatConnected || privateChatStarting)
+        if (privateChatConnected || privateChatStarting) {
+            // 流保持连接时，如果开关变了也要刷新状态，否则看板会一直显示未连接。
+            reportConnectionStatus(privateChatConnected);
             return;
+        }
         privateChatStarting = true;
         const generation = privateChatGeneration;
         log.info("private chat stream starting by configuration");
         void bot.start(handleMessage).then(() => {
             if (generation !== privateChatGeneration || options.getPrivateChatEnabled?.() === false) {
+                // 启动过程中开关又变了：停掉并复位状态。不复位 privateChatStarting
+                // 会让定时器以后每秒都提前 return，流永远不再重连。
+                privateChatStarting = false;
+                privateChatConnected = false;
                 bot.stop();
+                reportConnectionStatus(false);
                 return;
             }
             privateChatStarting = false;
             privateChatConnected = true;
-            options.onConnectionStatus?.(true);
+            reportConnectionStatus(true);
             log.info("private chat stream started by configuration");
         }).catch((err) => {
             privateChatStarting = false;
             privateChatConnected = false;
-            options.onConnectionStatus?.(false);
+            reportConnectionStatus(false);
             log.error("private chat stream restart failed", err);
         });
     }, 1_000);
@@ -904,7 +1065,9 @@ export async function runApp(configOverride, options = {}) {
         await bot.start(handleMessage);
         privateChatStarting = false;
         privateChatConnected = true;
-        options.onConnectionStatus?.(true);
     }
+    // 启动时无论开关状态都写一次状态文件（enabled 取实时配置、connected 取实际连接），
+    // 避免看板看到上一次进程遗留的旧值。
+    reportConnectionStatus(privateChatConnected);
     log.info(`ready workDir=${config.codexWorkDir} codex=${config.codexCliPath}`);
 }

package/dist/bot-worker.js

@@ -3,7 +3,7 @@ import { open, unlink } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { runApp } from "./bot-app.js";
-import { resolveAgentModel } from "./config.js";
+import { resolveAgentModel } from "./core/config.js";
 const stateDir = join(homedir(), ".oh-my-im");
 const dashboardConfigFile = join(stateDir, "dws-dashboard.json");
 const lockFile = join(stateDir, "omi-bot.lock");
@@ -62,11 +62,11 @@ function loadBotConfig() {
         codexCliPath: "codex",
         codexWorkDir: defaultWorkDir,
         agentModels: {
-            codex: "",
+            codex: resolveAgentModel("codex", credentials.agentModels, credentials.agent, credentials.agentModel) || "",
             pi: resolveAgentModel("pi", credentials.agentModels, credentials.agent, credentials.agentModel) || "",
             opencode: resolveAgentModel("opencode", credentials.agentModels, credentials.agent, credentials.agentModel) || "",
         },
-        agentModel: credentials.agent === "pi" || credentials.agent === "opencode"
+        agentModel: credentials.agent === "pi" || credentials.agent === "opencode" || credentials.agent === "codex"
             ? resolveAgentModel(credentials.agent, credentials.agentModels, credentials.agent, credentials.agentModel)
             : undefined,
         codexPermissionMode: "bypass",
@@ -98,6 +98,13 @@ function markBotStopped() {
 }
 const releaseLock = await acquireLock();
 process.once("exit", () => {
+    // 进程真正退出时才写“已停止”，否则会覆盖 runApp 初始化后写入的“已连接”。
+    try {
+        markBotStopped();
+    }
+    catch {
+        // status is diagnostic only
+    }
     try {
         unlinkSync(lockFile);
     }
@@ -130,8 +137,6 @@ try {
             }
         },
         getAgentModel: (agent) => {
-            if (agent === "codex")
-                return undefined;
             try {
                 const current = JSON.parse(readFileSync(dashboardConfigFile, "utf8"));
                 const model = resolveAgentModel(agent, current.agentModels, current.agent, current.agentModel);
@@ -145,12 +150,26 @@ try {
         getResponseMode: () => {
             try {
                 const current = JSON.parse(readFileSync(dashboardConfigFile, "utf8"));
-                return current.responseMode === "text" ? "text" : "card";
+                return current.responseMode === "text" ? "text" : current.responseMode === "aiCard" ? "aiCard" : "card";
             }
             catch {
                 return "card";
             }
         },
+        getAiCardConfig: () => {
+            // Live value so a template ID saved in the console applies to the next message.
+            try {
+                const current = JSON.parse(readFileSync(dashboardConfigFile, "utf8"));
+                return {
+                    templateId: typeof current.aiCardTemplateId === "string" ? current.aiCardTemplateId.trim() : "",
+                    contentKey: typeof current.aiCardContentKey === "string" && current.aiCardContentKey.trim() ? current.aiCardContentKey.trim() : "content",
+                    streamIntervalMs: Number.isFinite(current.aiCardStreamIntervalMs) ? Number(current.aiCardStreamIntervalMs) : 500,
+                };
+            }
+            catch {
+                return { templateId: "", contentKey: "content", streamIntervalMs: 500 };
+            }
+        },
         getShowProcessingDetails: () => {
             try {
                 const current = JSON.parse(readFileSync(dashboardConfigFile, "utf8"));
@@ -228,7 +247,10 @@ try {
         },
     });
 }
-finally {
+catch (err) {
+    // 只有初始化失败才在这里收尾；正常情况 runApp 返回后 Stream/定时器仍在运行，
+    // markBotStopped 交给 process exit 处理。
     markBotStopped();
     await releaseLock();
+    throw err;
 }

package/dist/{config.js → core/config.js}

@@ -1,6 +1,6 @@
 import { existsSync, readFileSync } from "node:fs";
 import { join, resolve } from "node:path";
-import { normalizeAgentModel } from "./dws-dashboard.js";
+import { normalizeAgentModel } from "../dws-dashboard.js";
 export function resolveAgentModel(agent, agentModels, activeAgent, legacyModel) {
     const configured = agentModels?.[agent]?.trim() || (activeAgent === agent ? legacyModel?.trim() : "") || "";
     return normalizeAgentModel(agent, configured) || undefined;
@@ -32,11 +32,11 @@ export function loadConfig() {
         codexCliPath: "codex",
         codexWorkDir: resolveWorkDir(),
         agentModels: {
-            codex: "",
+            codex: resolveAgentModel("codex", local.agentModels, local.agent, local.agentModel) || "",
             pi: resolveAgentModel("pi", local.agentModels, local.agent, local.agentModel) || "",
             opencode: resolveAgentModel("opencode", local.agentModels, local.agent, local.agentModel) || "",
         },
-        agentModel: local.agent === "pi" || local.agent === "opencode"
+        agentModel: local.agent === "pi" || local.agent === "opencode" || local.agent === "codex"
             ? resolveAgentModel(local.agent, local.agentModels, local.agent, local.agentModel)
             : undefined,
         codexPermissionMode: "bypass",

package/dist/{version.js → core/version.js}

@@ -7,7 +7,7 @@ import { fileURLToPath } from "node:url";
  * through here instead of parsing package.json on their own, and callers can
  * read it again after an in-place upgrade so they never report a stale value.
  */
-const packageFile = join(dirname(fileURLToPath(import.meta.url)), "..", "package.json");
+const packageFile = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "package.json");
 export function readVersion() {
     try {
         const parsed = JSON.parse(readFileSync(packageFile, "utf8"));