oh-my-im 0.1.21 → 0.2.0

package/dist/dashboard-worker.js

@@ -6,9 +6,9 @@ import { spawn, spawnSync } from "node:child_process";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { startDashboard, isOpenCodeModelAllowed, isPiModelAllowed, } from "./dws-dashboard.js";
-import { getDwsAuthStatus, getCurrentDwsUser, startDwsDeviceLogin, getDwsDeviceLoginOutput, logoutDws, searchGroups, listGroupMembers, searchUsers, searchBots, } from "./dws-client.js";
-import { readVersion } from "./version.js";
+import { startDashboard, SESSION_MAX_AGE_SECONDS, } from "./dws-dashboard.js";
+import { getDwsAuthStatus, getCurrentDwsUser, startDwsDeviceLogin, getDwsDeviceLoginOutput, logoutDws, searchGroups, listGroupMembers, searchUsers, searchBots, } from "./dws/dws-client.js";
+import { readVersion } from "./core/version.js";
 const dataDir = join(homedir(), ".oh-my-im");
 const configFile = join(dataDir, "dws-dashboard.json");
 const serverFile = join(dataDir, "dws-dashboard-server.json");
@@ -20,7 +20,9 @@ const omiPath = join(workerDir, "omi.js");
 const processPaths = { "group-worker": join(workerDir, "group-worker.js"), bot: join(workerDir, "bot-worker.js") };
 const repliesDir = join(dataDir, "replies");
 const passwordFile = join(dataDir, "dashboard-password.json");
+const sessionsFile = join(dataDir, "dashboard-sessions.json");
 const scrypt = promisify(scryptCallback);
+const SESSION_TTL_MS = SESSION_MAX_AGE_SECONDS * 1000;
 const sessions = new Map();
 const DEFAULT_PASSWORD = "5552123";
 async function passwordHash(password, salt = randomBytes(16).toString("hex")) {
@@ -47,6 +49,29 @@ async function savePassword(record) {
 function cookieValue(request) {
     return request.headers.cookie?.split(";").map((part) => part.trim()).find((part) => part.startsWith("omi_session="))?.slice("omi_session=".length);
 }
+// 登录会话持久化到磁盘，重启看板不会把已登录的设备踢下线（有效期 60 天）。
+async function loadSessions() {
+    try {
+        const stored = JSON.parse(await readFile(sessionsFile, "utf8"));
+        const now = Date.now();
+        Object.entries(stored).forEach(([token, expires]) => {
+            if (typeof expires === "number" && expires > now)
+                sessions.set(token, expires);
+        });
+    }
+    catch { /* first run */ }
+}
+async function saveSessions() {
+    const now = Date.now();
+    for (const [token, expires] of sessions)
+        if (expires <= now)
+            sessions.delete(token);
+    await mkdir(dataDir, { recursive: true });
+    const temporary = `${sessionsFile}.${process.pid}.tmp`;
+    await writeFile(temporary, `${JSON.stringify(Object.fromEntries(sessions))}\n`, { encoding: "utf8", mode: 0o600 });
+    await chmod(temporary, 0o600);
+    await rename(temporary, sessionsFile);
+}
 const defaultConfig = () => ({
     privateChatEnabled: false,
     responseMode: "card",
@@ -60,7 +85,7 @@ const defaultConfig = () => ({
     targets: [], botAllowedUserIds: [], botAllowedUserNames: {},
     botSuperAdminUserIds: [], botSuperAdminUserNames: {}, robotSenderOpenDingTalkId: "",
     commandKeywords: { pause: [], monitorOpen: [], monitorStop: [], switchPi: [], switchCodex: [], switchOpencode: [] },
-    groupPromptSuffix: "", replyFormat: "markdown", robotName: "AI Agent",
+    groupPromptSuffix: "", aiCardTemplateId: "", aiCardContentKey: "content", aiCardStreamIntervalMs: 500, robotName: "AI Agent",
     clientId: "", clientSecret: "", agentModels: { codex: "", pi: "", opencode: "" }, agent: "pi",
 });
 async function loadConfig() {
@@ -73,7 +98,7 @@ async function loadConfig() {
         return {
             ...defaultConfig(),
             ...migrated,
-            agentModels: { ...defaultConfig().agentModels, ...(migrated.agentModels ?? {}), codex: "" },
+            agentModels: { ...defaultConfig().agentModels, ...(migrated.agentModels ?? {}) },
             commandKeywords: { ...defaultConfig().commandKeywords, ...(migrated.commandKeywords ?? {}) },
         };
     }
@@ -309,13 +334,37 @@ function externalCliEnv() {
     }
     return env;
 }
+async function listCodexModels() {
+    // Codex CLI 没有列模型的命令，但会在 config.toml 的 model_catalog_json 里
+    // 指定模型目录（含内置目录）；读出其中的 slug 作为可选模型。
+    const home = process.env.CODEX_HOME?.trim() || join(homedir(), ".codex");
+    let catalogPath = join(home, "models.json");
+    try {
+        const toml = await readFile(join(home, "config.toml"), "utf8");
+        const match = toml.match(/^\s*model_catalog_json\s*=\s*["']([^"']+)["']/m);
+        if (match?.[1])
+            catalogPath = match[1];
+    }
+    catch { /* fall back to the default catalog path */ }
+    try {
+        const parsed = JSON.parse(await readFile(catalogPath, "utf8"));
+        const slugs = (parsed.models ?? [])
+            .filter((model) => model.visibility !== "hide")
+            .map((model) => (typeof model.slug === "string" ? model.slug.trim() : ""))
+            .filter(Boolean);
+        return [...new Set(slugs)];
+    }
+    catch {
+        return [];
+    }
+}
 async function listAgentModels(agent) {
-    const command = agent === "pi" ? "pi" : agent === "opencode" ? "opencode" : "codex";
+    if (agent === "codex")
+        return { models: await listCodexModels() };
+    const command = agent === "pi" ? "pi" : "opencode";
     const args = agent === "opencode" ? ["models"] : ["--list-models"];
     const result = spawnSync(command, args, { encoding: "utf8", timeout: 20_000, env: agent === "opencode" ? externalCliEnv() : process.env });
     if (result.error || result.status !== 0) {
-        if (agent === "codex")
-            return { models: ["默认模型（不指定）"] };
         throw new Error(result.stderr?.trim() || result.error?.message || `${command} 模型列表查询失败`);
     }
     const lines = String(result.stdout || "").split(/\r?\n/).map((line) => line.trim());
@@ -326,7 +375,7 @@ async function listAgentModels(agent) {
         })
         : lines.filter((line) => line && !/^[-= ]+$/.test(line) && !/^available models/i.test(line));
     if (agent === "pi")
-        return { models: [...new Set(models.filter(isPiModelAllowed))] };
+        return { models: [...new Set(models)] };
     if (agent !== "opencode")
         return { models: [...new Set(models)] };
     let defaultModel;
@@ -343,16 +392,25 @@ async function listAgentModels(agent) {
         }
         catch { /* model list remains usable if debug output changes */ }
     }
-    const filteredModels = models.filter((model) => isOpenCodeModelAllowed(model));
-    if (defaultModel && !isOpenCodeModelAllowed(defaultModel))
-        defaultModel = undefined;
-    return { models: [...new Set(defaultModel ? [defaultModel, ...filteredModels] : filteredModels)], defaultModel };
+    // 不做白名单过滤，OpenCode CLI 能列出什么就展示什么。
+    return { models: [...new Set(defaultModel ? [defaultModel, ...models] : models)], defaultModel };
 }
 async function botStatus() {
     const config = await loadConfig();
     try {
         const value = JSON.parse(await readFile(botStatusFile, "utf8"));
-        return { enabled: config.privateChatEnabled === true, connected: config.privateChatEnabled === true && value.connected !== false, updatedAt: value.updatedAt };
+        // 状态文件可能是上次进程遗留的：进程已经不在时不能报“已连接”。
+        const alive = typeof value.pid === "number" && value.pid > 0 && (() => {
+            try {
+                process.kill(value.pid, 0);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        })();
+        const enabled = config.privateChatEnabled === true;
+        return { enabled, connected: enabled && alive && value.connected !== false, updatedAt: value.updatedAt };
     }
     catch {
         return { enabled: config.privateChatEnabled !== false, connected: false };
@@ -385,6 +443,7 @@ async function main() {
     }, 1_000);
     replyReloadTimer.unref();
     const password = await loadPassword();
+    await loadSessions();
     // Password-free access only for genuinely local use. A reverse proxy or
     // tunnel (nginx/frp) on this machine also connects from 127.0.0.1, so the
     // socket alone cannot separate local use from proxied external traffic.
@@ -406,20 +465,21 @@ async function main() {
         isAuthenticated: (request) => { if (isLoopbackRequest(request))
             return true; const token = cookieValue(request); const expires = token ? sessions.get(token) : undefined; return Boolean(expires && expires > Date.now()); },
         login: async (candidate) => { const derived = await passwordHash(candidate, password.salt); const matches = derived.hash.length === password.hash.length && timingSafeEqual(Buffer.from(derived.hash, "hex"), Buffer.from(password.hash, "hex")); if (!matches)
-            return null; const token = randomBytes(32).toString("base64url"); sessions.set(token, Date.now() + 8 * 60 * 60 * 1000); return token; },
-        logout: (request) => { const token = cookieValue(request); if (token)
-            sessions.delete(token); },
+            return null; const token = randomBytes(32).toString("base64url"); sessions.set(token, Date.now() + SESSION_TTL_MS); void saveSessions(); return token; },
+        logout: (request) => { const token = cookieValue(request); if (token) {
+            sessions.delete(token);
+            void saveSessions();
+        } },
         changePassword: async (request, current, next) => { if (!auth.isAuthenticated(request))
             return "未登录"; if (next.length < 8 || next.length > 200)
             return "新密码长度需为 8-200 位"; const currentHash = await passwordHash(current, password.salt); if (currentHash.hash.length !== password.hash.length || !timingSafeEqual(Buffer.from(currentHash.hash, "hex"), Buffer.from(password.hash, "hex")))
-            return "当前密码错误"; const record = await passwordHash(next); await savePassword(record); password.salt = record.salt; password.hash = record.hash; sessions.clear(); return null; },
+            return "当前密码错误"; const record = await passwordHash(next); await savePassword(record); password.salt = record.salt; password.hash = record.hash; sessions.clear(); void saveSessions(); return null; },
     };
     startDashboard(serverConfig.port, {
         getConfig: () => config,
         updateConfig: async (next) => {
-            const normalized = { ...next, agentModels: { ...next.agentModels, codex: "" } };
-            await saveConfig(normalized);
-            config = normalized;
+            await saveConfig(next);
+            config = next;
         },
         getStatus: () => ({ ...runtime }),
         // Replies are persisted by group-worker/bot. The dashboard remains usable

package/dist/dingtalk/ai-card.js

@@ -0,0 +1,99 @@
+import { randomUUID } from "node:crypto";
+/**
+ * 一张 AI 卡片的完整生命周期封装：投放 → 流式推送（含打字机补帧）→ 收尾
+ * （finalize + $end_text + $title），并内置接口失败时的降级。
+ *
+ * 与底层 {@link DingTalkAiCardClient} 分开：客户端只管钉钉 API 协议，本类
+ * 只管「一张卡片」的业务流程，让私聊（bot-app）和群聊（group-worker）
+ * 共用同一套逻辑，后续要改 AI 卡片行为只需要动这一个文件。
+ */
+export class AiCardSession {
+    outTrackId;
+    client;
+    templateId;
+    contentKey;
+    log;
+    constructor(options) {
+        this.client = options.client;
+        this.templateId = options.templateId;
+        this.contentKey = options.contentKey;
+        this.log = options.log;
+        this.outTrackId = options.outTrackId ?? randomUUID();
+    }
+    /** 投放一张群聊卡片。 */
+    async openForGroup(params) {
+        await this.client.createForGroup({
+            outTrackId: this.outTrackId,
+            templateId: this.templateId,
+            contentKey: this.contentKey,
+            openConversationId: params.openConversationId,
+            title: params.title,
+        });
+    }
+    /** 投放一张机器人单聊卡片。 */
+    async openForSingle(params) {
+        await this.client.createForSingle({
+            outTrackId: this.outTrackId,
+            templateId: this.templateId,
+            contentKey: this.contentKey,
+            userId: params.userId,
+            title: params.title,
+        });
+    }
+    /** 中间帧：逐帧补推增量，尽量呈现打字机效果；失败只记日志，不影响主流程。 */
+    async push(content) {
+        await this.client
+            .typeOutRemaining({ outTrackId: this.outTrackId, contentKey: this.contentKey, content, maxFrames: 5, maxDurationMs: 400 })
+            .catch((err) => this.log.warn(`AI card stream skipped: ${String(err)}`));
+    }
+    /** 用 isError 关闭一张残留的卡片（例如进程重启后卡片停在「输入中」）。 */
+    async closeStale() {
+        await this.client
+            .stream({ outTrackId: this.outTrackId, contentKey: this.contentKey, content: "", isError: true })
+            .catch((err) => this.log.warn(`stale AI card finalize skipped: ${String(err)}`));
+    }
+    /**
+     * 收尾：finalize 正文 + 写 $end_text + 改 $title。
+     * @returns 正文是否成功写入卡片；false 表示调用方应改用文本兜底。
+     */
+    async finish(options) {
+        const isError = options.error === true;
+        let contentDelivered = true;
+        try {
+            if (!isError) {
+                await this.client
+                    .typeOutRemaining({ outTrackId: this.outTrackId, contentKey: this.contentKey, content: options.content })
+                    .catch((err) => this.log.warn(`AI card type-out skipped: ${String(err)}`));
+            }
+            // 必须在 finalize 之前写入 $end_text：卡片进入「完成」状态那一刻就会渲染，
+            // 之后再改变量部分模板不会重新渲染。
+            if (!isError && options.endText) {
+                await this.client
+                    .setEndText({ outTrackId: this.outTrackId, text: options.endText })
+                    .catch((err) => this.log.warn(`AI card end_text update skipped: ${String(err)}`));
+            }
+            await this.client.stream({
+                outTrackId: this.outTrackId,
+                contentKey: this.contentKey,
+                content: options.content,
+                isFinalize: !isError,
+                isError,
+            });
+        }
+        catch (err) {
+            // 流式接口失败时用实例更新接口兜底写正文，避免卡片停留在空白/输入中。
+            this.log.warn(`AI card finalize failed: ${String(err)}`);
+            contentDelivered = await this.client
+                .updateCardData({ outTrackId: this.outTrackId, data: { [this.contentKey]: options.content } })
+                .then(() => true)
+                .catch((updateErr) => {
+                this.log.warn(`AI card content fallback skipped: ${String(updateErr)}`);
+                return false;
+            });
+        }
+        await this.client
+            .updateTitle({ outTrackId: this.outTrackId, title: options.title })
+            .catch((err) => this.log.warn(`AI card title update skipped: ${String(err)}`));
+        return contentDelivered;
+    }
+}

package/dist/dingtalk/dingtalk-ai-card.js

@@ -0,0 +1,210 @@
+import { randomUUID } from "node:crypto";
+import { createLogger } from "../core/logger.js";
+const log = createLogger("DingTalkAiCard");
+const apiBase = "https://api.dingtalk.com";
+// 模板里用于展示结束语的变量名。
+const END_TEXT_KEY = "end_text";
+/** 5xx 与网络错误可重试；4xx 业务错误不重试。 */
+function isRetryableCardError(err) {
+    const message = err instanceof Error ? err.message : String(err);
+    const status = /API failed:\s*(\d{3})/.exec(message)?.[1];
+    if (status)
+        return Number(status) >= 500;
+    return true;
+}
+/**
+ * 钉钉 AI 卡片（流式卡片）客户端。
+ *
+ * 与内置的 StandardCard 不同，AI 卡片需要在卡片平台手工创建模板（消息卡片 +
+ * 场景「AI 卡片」，并在 Markdown 组件上开启流式开关、绑定一个变量名）。流程：
+ *   1. POST /v1.0/card/instances/createAndDeliver  投放卡片，进入「处理中」状态
+ *   2. PUT  /v1.0/card/streaming                   反复推送全量 markdown，进入「输入中」
+ *   3. 最后一帧 isFinalize=true（完成）或 isError=true（失败）
+ *
+ * 依赖权限：Card.Instance.Write（投放）+ Card.Streaming.Write（流式更新）。
+ */
+export class DingTalkAiCardClient {
+    accessToken;
+    accessTokenExpiresAt = 0;
+    clientId = "";
+    clientSecret = "";
+    robotCode = "";
+    // Last streamed content length per card, used to type out content that the
+    // agent produced in one burst instead of as incremental deltas.
+    streamedLengths = new Map();
+    setCredentials(clientId, clientSecret, robotCode) {
+        const nextClientId = clientId.trim();
+        const nextClientSecret = clientSecret.trim();
+        const nextRobotCode = (robotCode ?? clientId).trim();
+        if (this.clientId === nextClientId && this.clientSecret === nextClientSecret && this.robotCode === nextRobotCode)
+            return;
+        this.clientId = nextClientId;
+        this.clientSecret = nextClientSecret;
+        this.robotCode = nextRobotCode;
+        this.accessToken = undefined;
+        this.accessTokenExpiresAt = 0;
+    }
+    get configured() {
+        return Boolean(this.clientId && this.clientSecret && this.robotCode);
+    }
+    get robotCodeValue() {
+        return this.robotCode;
+    }
+    /** 投放一张群聊 AI 卡片。outTrackId 由调用方生成，后续流式更新必须复用。 */
+    async createForGroup(params) {
+        await this.createAndDeliver({
+            cardTemplateId: params.templateId,
+            outTrackId: params.outTrackId,
+            cardData: { cardParamMap: { [params.contentKey]: "", [END_TEXT_KEY]: "", ...(params.title ? { title: params.title } : {}) } },
+            openSpaceId: `dtv1.card//IM_GROUP.${params.openConversationId}`,
+            imGroupOpenSpaceModel: { supportForward: true },
+            imGroupOpenDeliverModel: { robotCode: this.robotCode },
+            userIdType: 1,
+        });
+        log.info(`ai card delivered group=${params.openConversationId} outTrackId=${params.outTrackId}`);
+    }
+    /** 投放一张机器人单聊 AI 卡片。 */
+    async createForSingle(params) {
+        await this.createAndDeliver({
+            cardTemplateId: params.templateId,
+            outTrackId: params.outTrackId,
+            cardData: { cardParamMap: { [params.contentKey]: "", [END_TEXT_KEY]: "", ...(params.title ? { title: params.title } : {}) } },
+            openSpaceId: `dtv1.card//IM_ROBOT.${params.userId}`,
+            imRobotOpenSpaceModel: { supportForward: false },
+            imRobotOpenDeliverModel: { spaceType: "IM_ROBOT", robotCode: this.robotCode },
+            userIdType: 1,
+        });
+        log.info(`ai card delivered single user=${params.userId} outTrackId=${params.outTrackId}`);
+    }
+    /**
+     * 流式更新。markdown 场景必须使用全量内容且 isFull=true；最后一帧传
+     * isFinalize=true，异常传 isError=true。
+     */
+    async stream(params) {
+        log.info(`ai card stream outTrackId=${params.outTrackId} len=${params.content.length}${params.isFinalize ? " FINALIZE" : ""}${params.isError ? " ERROR" : ""}`);
+        // guid 在重试时保持不变，保证服务端幂等；钉钉流式接口偶发返回 500，
+        // 尤其首帧与 finalize 帧，重试可以显著降低卡片空白/卡在输入中的概率。
+        await this.callWithRetry("PUT", "/v1.0/card/streaming", {
+            outTrackId: params.outTrackId,
+            guid: randomUUID(),
+            key: params.contentKey,
+            content: params.content,
+            isFull: true,
+            isFinalize: params.isFinalize === true,
+            isError: params.isError === true,
+        });
+        this.streamedLengths.set(params.outTrackId, params.content.length);
+        if (params.isFinalize || params.isError)
+            this.streamedLengths.delete(params.outTrackId);
+    }
+    /**
+     * 若最终内容比已经流式推送过的内容更长（模型一次性吐出整段），按几帧逐步
+     * 补推剩余内容，保证卡片仍然呈现“打字机”效果；已经逐字流过的则几乎不做额外请求。
+     */
+    async typeOutRemaining(params) {
+        const already = this.streamedLengths.get(params.outTrackId) ?? 0;
+        if (params.content.length <= already + 1)
+            return;
+        const remaining = params.content.length - already;
+        const frames = Math.max(1, Math.min(params.maxFrames ?? 8, remaining));
+        const step = Math.max(1, Math.ceil(remaining / frames));
+        const delayMs = Math.max(0, Math.floor((params.maxDurationMs ?? 1_200) / frames));
+        for (let end = already + step; end < params.content.length; end += step) {
+            await this.stream({ outTrackId: params.outTrackId, contentKey: params.contentKey, content: params.content.slice(0, end) });
+            if (delayMs > 0)
+                await new Promise((resolve) => setTimeout(resolve, delayMs));
+        }
+    }
+    /**
+     * 按 key 更新卡片变量（不覆盖其它变量）。用于完成后把标题改成
+     * 「【Pi】完成 总耗时 15s」这类状态文案。
+     */
+    async updateTitle(params) {
+        await this.updateCardData({ outTrackId: params.outTrackId, data: { title: params.title } });
+        log.info(`ai card title updated outTrackId=${params.outTrackId} title=${params.title}`);
+    }
+    /**
+     * 完成后把「模型 x条消息 y次工具」这类结束语写到模板的 $end_text，
+     * 不再拼接到正文里。
+     */
+    async setEndText(params) {
+        await this.updateCardData({ outTrackId: params.outTrackId, data: { [END_TEXT_KEY]: params.text } });
+        log.info(`ai card end_text updated outTrackId=${params.outTrackId} len=${params.text.length}`);
+    }
+    /** 按 key 更新一个或多个卡片变量，其它变量保持不变。 */
+    async updateCardData(params) {
+        await this.callWithRetry("PUT", "/v1.0/card/instances", {
+            outTrackId: params.outTrackId,
+            cardData: { cardParamMap: params.data },
+            cardUpdateOptions: { updateCardDataByKey: true },
+            userIdType: 1,
+        });
+    }
+    async createAndDeliver(body) {
+        await this.call("POST", "/v1.0/card/instances/createAndDeliver", body);
+    }
+    /** 对 5xx / 网络错误做指数退避重试；4xx 业务错误不重试。 */
+    async callWithRetry(method, path, body, attempts = 3) {
+        let lastError;
+        for (let attempt = 0; attempt < attempts; attempt += 1) {
+            try {
+                return await this.call(method, path, body);
+            }
+            catch (err) {
+                lastError = err;
+                if (attempt === attempts - 1 || !isRetryableCardError(err))
+                    throw err;
+                const delayMs = 250 * 2 ** attempt;
+                log.warn(`ai card API retry ${attempt + 1}/${attempts - 1} in ${delayMs}ms: ${err instanceof Error ? err.message : String(err)}`);
+                await new Promise((resolve) => setTimeout(resolve, delayMs));
+            }
+        }
+        throw lastError;
+    }
+    async call(method, path, body) {
+        const accessToken = await this.getAccessToken();
+        const response = await fetch(`${apiBase}${path}`, {
+            method,
+            headers: {
+                "content-type": "application/json",
+                "x-acs-dingtalk-access-token": accessToken,
+            },
+            body: JSON.stringify(body),
+            signal: AbortSignal.timeout(30_000),
+        });
+        const text = await response.text();
+        if (!response.ok)
+            throw new Error(`DingTalk AI card API failed: ${response.status} ${text.slice(0, 1_000)}`);
+        if (!text)
+            return {};
+        const result = JSON.parse(text);
+        const code = result.errcode ?? result.errorCode ?? result.code;
+        if ((typeof code === "number" && code !== 0) ||
+            (typeof code === "string" && code && code !== "0" && code.toLowerCase() !== "ok") ||
+            result.success === false) {
+            throw new Error(`DingTalk AI card business error: ${text.slice(0, 1_000)}`);
+        }
+        return result;
+    }
+    async getAccessToken() {
+        if (this.accessToken && Date.now() < this.accessTokenExpiresAt)
+            return this.accessToken;
+        if (!this.clientId || !this.clientSecret)
+            throw new Error("DingTalk app credentials are missing");
+        const response = await fetch(`${apiBase}/v1.0/oauth2/accessToken`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ appKey: this.clientId, appSecret: this.clientSecret }),
+            signal: AbortSignal.timeout(30_000),
+        });
+        const text = await response.text();
+        if (!response.ok)
+            throw new Error(`DingTalk token API failed: ${response.status}`);
+        const result = JSON.parse(text);
+        if (!result.accessToken)
+            throw new Error("DingTalk token API returned no accessToken");
+        this.accessToken = result.accessToken;
+        this.accessTokenExpiresAt = Date.now() + Math.max((result.expireIn ?? 7200) - 120, 60) * 1_000;
+        return result.accessToken;
+    }
+}

package/dist/{dingtalk-card.js → dingtalk/dingtalk-card.js}

@@ -1,4 +1,4 @@
-import { createLogger } from "./logger.js";
+import { createLogger } from "../core/logger.js";
 const log = createLogger("DingTalkCard");
 const apiBase = "https://api.dingtalk.com";
 function buildCardData(title, content) {

package/dist/{dingtalk.js → dingtalk/dingtalk.js}

@@ -1,7 +1,7 @@
 import { mkdir, writeFile } from "node:fs/promises";
 import { basename, extname, join, resolve } from "node:path";
 import { DWClient, TOPIC_ROBOT } from "dingtalk-stream";
-import { createLogger } from "./logger.js";
+import { createLogger } from "../core/logger.js";
 const log = createLogger("DingTalk");
 function safePreview(value, limit = 160) {
     const text = typeof value === "string" ? value : JSON.stringify(value) ?? String(value);

package/dist/dingtalk/markdown.js

@@ -0,0 +1,112 @@
+/**
+ * DingTalk 的互动卡片与机器人消息使用钉钉自有的 Markdown 渲染器，它只支持
+ * 标题、加粗、列表、链接、引用和分割线等有限语法，**不支持 GitHub 风格的表格**。
+ * 因此 Agent 输出的 `| a | b |` 表格会被原样显示成一堆竖线，在手机端尤其难读。
+ *
+ * 这里把表格块转换成移动端/桌面端都好读的紧凑结构：行内用第一列序号 +
+ * 名称类列做强标题，其余字段用 ` ｜ ` 拼成一行；字段过多或过长时才退化成列表。
+ *
+ *   | 排名 | 次数 | UID | 昵称 | 收礼主播 |
+ *   |---|---|---|---|---|
+ *   | 1 | 3 | 778339247 | 不语 | Dh·幽月 |
+ *
+ * 变成：
+ *
+ *   **1. 不语**
+ *   次数：3 ｜ UID：778339247 ｜ 收礼主播：Dh·幽月
+ */
+const INDEX_HEADER = /^(#|序号|编号|排名|名次|排位|no\.?|index|id|rank)$/i;
+const NAME_HEADER = /^(昵称|名称|名字|用户|用户名|用户昵称|主播|收礼主播|送礼用户|送礼人|项目|项目名|活动|活动名|name|user|nick|nickname|title)$/i;
+// 表格分隔行：支持 - / – / — 三种横线，以及可选的居中对齐冒号。
+const SEPARATOR_CELL = /^:?[-\u2013\u2014]{1,}:?$/;
+function splitRow(line) {
+    let text = line.trim();
+    if (text.startsWith("|"))
+        text = text.slice(1);
+    if (text.endsWith("|"))
+        text = text.slice(0, -1);
+    return text.split("|").map((cell) => cell.trim());
+}
+function isSeparatorRow(line) {
+    const cells = splitRow(line);
+    return cells.length > 0 && cells.every((cell) => SEPARATOR_CELL.test(cell));
+}
+function looksLikeTableRow(line) {
+    return line.includes("|") && line.trim().length > 0;
+}
+function renderTable(header, rows) {
+    // 序号列：优先识别常见的排序列，否则回退到第一列。
+    const indexColumn = header.findIndex((cell, column) => Boolean(cell) && INDEX_HEADER.test(cell));
+    // 标题列：优先用名称类列（昵称/项目等），否则用第一个非序号列。
+    let titleColumn = header.findIndex((cell, column) => column !== indexColumn && Boolean(cell) && NAME_HEADER.test(cell));
+    if (titleColumn < 0)
+        titleColumn = header.findIndex((cell, column) => column !== indexColumn && Boolean(cell));
+    if (titleColumn < 0)
+        titleColumn = indexColumn >= 0 ? indexColumn : 0;
+    const blocks = rows.map((row) => {
+        const title = (row[titleColumn] ?? "").trim() || "(空)";
+        const indexValue = indexColumn >= 0 ? (row[indexColumn] ?? "").trim() : "";
+        const prefix = indexColumn >= 0 && indexColumn !== titleColumn && indexValue ? `${indexValue}. ` : "";
+        const lines = [`**${prefix}${title}**`];
+        const fields = [];
+        header.forEach((name, column) => {
+            if (column === indexColumn || column === titleColumn)
+                return;
+            const value = (row[column] ?? "").trim();
+            if (!value)
+                return;
+            fields.push(`${name || `列${column + 1}`}：${value}`);
+        });
+        if (fields.length > 0) {
+            const joined = fields.join(" ｜ ");
+            // 字段少且不长时并成一行，卡片更紧凑；否则退回列表便于逐条阅读。
+            if (fields.length <= 4 && joined.length <= 60)
+                lines.push(joined);
+            else
+                lines.push(...fields.map((field) => `- ${field}`));
+        }
+        return lines.join("\n");
+    });
+    return blocks.join("\n\n");
+}
+/**
+ * 把内容中的 Markdown 表格转成钉钉可读的列表，其它内容保持不变。
+ * 代码块（``` 或 ~~~）内的竖线不会被处理。
+ */
+export function normalizeDingTalkMarkdown(content) {
+    const lines = content.replace(/\r\n?/g, "\n").split("\n");
+    const output = [];
+    let inFence = false;
+    let cursor = 0;
+    while (cursor < lines.length) {
+        const line = lines[cursor];
+        if (/^\s*(```|~~~)/.test(line)) {
+            inFence = !inFence;
+            output.push(line);
+            cursor += 1;
+            continue;
+        }
+        // 表头行 + 分隔行才算一个表格，且列数要一致，避免误伤正文中的单个竖线
+        // 或紧跟在横线下方的普通文本。
+        if (!inFence && looksLikeTableRow(line) && cursor + 1 < lines.length && isSeparatorRow(lines[cursor + 1])) {
+            const header = splitRow(line);
+            const separator = splitRow(lines[cursor + 1]);
+            if (separator.length !== header.length) {
+                output.push(line);
+                cursor += 1;
+                continue;
+            }
+            const rows = [];
+            cursor += 2;
+            while (cursor < lines.length && looksLikeTableRow(lines[cursor]) && !isSeparatorRow(lines[cursor])) {
+                rows.push(splitRow(lines[cursor]));
+                cursor += 1;
+            }
+            output.push(renderTable(header, rows));
+            continue;
+        }
+        output.push(line);
+        cursor += 1;
+    }
+    return output.join("\n");
+}

package/dist/{dws-client.js → dws/dws-client.js}

@@ -177,6 +177,20 @@ export async function listGroupMembers(groupId) {
         return senderId && senderName ? [{ senderId, senderName, role: user.role }] : [];
     });
 }
+/**
+ * 机器人成员与真人成员使用同一套 openDingtalkId，可用于判断群消息是否由
+ * 群内机器人（AI）发出。返回的 senderId 与事件里的 sender_open_dingtalk_id 可直接比较。
+ */
+export async function listGroupBotMembers(groupId) {
+    const result = await runDwsJson([
+        "chat", "+chat-members-list", "--conversation-id", groupId, "--member-types", "bot",
+    ]);
+    return (result.bots ?? []).flatMap((bot) => {
+        const senderId = (bot.openDingtalkId || bot.openDingTalkId)?.trim();
+        const senderName = bot.name?.trim();
+        return senderId && senderName ? [{ senderId, senderName }] : [];
+    });
+}
 export async function listConversations() {
     const result = await runDwsJson([
         "chat", "+chat-list", "--types", "group", "--page-size", "20",

package/dist/{dws-history.js → dws/dws-history.js}

@@ -2,7 +2,7 @@ import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { getCurrentDwsUser, searchRecentGroupMessages } from "./dws-client.js";
-import { createLogger } from "./logger.js";
+import { createLogger } from "../core/logger.js";
 const log = createLogger("personal_history");
 const DEFAULT_INTERVAL_SECONDS = 15;
 const DEFAULT_LOOKBACK_MINUTES = 10;