larkin 0.2.70

package/dist/feishu/host-channel-business.mjs

@@ -0,0 +1,157 @@
+import { decideWake, normalizeChannelMessage } from "./message-policy.mjs";
+import { normalizeCardAction } from "@larksuite/channel";
+function messageOf(error) { return error instanceof Error ? error.message : String(error); }
+export class HostChannelBusiness {
+    options;
+    log;
+    now;
+    constructor(options) {
+        this.options = options;
+        this.log = options.log ?? (() => { });
+        this.now = options.now ?? (() => new Date());
+    }
+    handlers(agent, channel) {
+        return {
+            message: (message) => {
+                try {
+                    const event = normalizeChannelMessage(message);
+                    this.options.state.updateStatus(agent, { inboundVerifiedAt: this.now().toISOString() });
+                    const senderIsBot = message.senderIsBot === true;
+                    const decision = decideWake({
+                        senderIsBot,
+                        mentionedBot: message.mentionedBot === true,
+                        mentionAll: message.mentionAll === true,
+                        isGroup: (message.chatType || "group") !== "p2p",
+                        mentionPolicy: senderIsBot ? "require" : this.options.mentionPolicy?.(agent.agentId, String(message.chatId || ""))
+                            || (Array.isArray(agent.noMentionChats) && agent.noMentionChats.includes(String(message.chatId || "")) ? "free" : "require"),
+                    });
+                    if (!decision.wake) {
+                        this.log(`${senderIsBot ? "bot 消息未点名@我" : "群消息未@bot"} → 只入箱不唤醒 agent=${agent.name} chat=${message.chatId}`);
+                    }
+                    void this.options.onMessage(agent, event, { wake: decision.wake });
+                }
+                catch (error) {
+                    this.log(`channel message 处理失败 agent=${agent.name}: ${messageOf(error)}`);
+                }
+            },
+            comment: async (event) => {
+                try {
+                    this.options.state.updateStatus(agent, {
+                        inboundVerifiedAt: this.now().toISOString(),
+                        documentCommentEventAt: this.now().toISOString(),
+                    });
+                    if (!channel || !this.options.onComment)
+                        return;
+                    await this.options.onComment(agent, event, channel);
+                }
+                catch (error) {
+                    this.log(`document comment 处理失败 agent=${agent.name}: ${messageOf(error)}`);
+                    this.options.state.recordStatusError(agent, `document comment: ${messageOf(error)}`);
+                }
+            },
+            cardAction: async (event) => {
+                if (!this.options.onCardAction)
+                    return { toast: { type: "error", content: "交互能力未启用，请重新运行 larkin setup 并重启 Larkin。" } };
+                return this.options.onCardAction(agent, event);
+            },
+            reconnecting: () => {
+                this.log(`ws 重连中… agent=${agent.name}`);
+                this.options.state.updateStatus(agent, { reconnectingAt: this.now().toISOString() });
+            },
+            reconnected: () => {
+                this.log(`ws 已恢复 agent=${agent.name}`);
+                const connectedAt = this.now().toISOString();
+                this.options.state.updateStatus(agent, { reconnectingAt: null, reconnectedAt: connectedAt, connectedAt });
+                if (channel && this.options.onReconnected) {
+                    void Promise.resolve(this.options.onReconnected(agent, channel)).catch((error) => {
+                        this.log(`document comment 恢复重放失败 agent=${agent.name}: ${messageOf(error)}`);
+                    });
+                }
+            },
+            error: () => {
+                this.log(`ws 错误 agent=${agent.name}`);
+                this.options.state.recordStatusError(agent, "channel ws 连接错误");
+            },
+        };
+    }
+    registerReadReceipts(agent, dispatcher) {
+        try {
+            dispatcher.register({
+                "im.message.message_read_v1": async (raw) => {
+                    try {
+                        const event = raw;
+                        const reader = event?.reader?.reader_id?.open_id || null;
+                        const readAt = event?.reader?.read_time || null;
+                        const ids = event?.message_id_list || [];
+                        this.options.state.recordReadReceipts(agent, reader, readAt, ids);
+                        this.log(`已读回执 agent=${agent.name} reader=${reader || "?"} msgs=${ids.length}`);
+                    }
+                    catch (error) {
+                        this.log(`已读回执处理失败 agent=${agent.name}: ${messageOf(error)}`);
+                    }
+                },
+            });
+        }
+        catch (error) {
+            this.log(`已读回执注册失败（不影响消息收发） agent=${agent.name}: ${messageOf(error)}`);
+        }
+    }
+    /**
+     * Replace the SDK's action-value TTL dedup handler after channel.connect().
+     * Durable callback event_id ownership lives in InteractionStateMachine, so
+     * retries receive the same response while later state-version clicks remain legal.
+     */
+    registerCardActions(agent, dispatcher) {
+        dispatcher.register({
+            "card.action.trigger": async (raw) => {
+                const event = normalizeCardAction(raw, { includeRaw: true });
+                if (!event)
+                    return { toast: { type: "error", content: "无法解析卡片操作，请刷新后重试。" } };
+                return this.handlers(agent).cardAction(event);
+            },
+        });
+    }
+    persistBotIdentity(agent, openId, name, via, avatarUrl = null) {
+        agent.botOpenId = openId;
+        agent.botName = name || agent.botName || null;
+        try {
+            let previous = {};
+            try {
+                previous = this.options.stateStore(agent).readJson("botIdentity", {}) || {};
+            }
+            catch { /* first run */ }
+            this.options.stateStore(agent).writeJson("botIdentity", {
+                open_id: openId,
+                name: name || previous.name || null,
+                avatar_url: avatarUrl || previous.avatar_url || null,
+                updated_at: this.now().toISOString(),
+            });
+        }
+        catch (error) {
+            this.log(`bot-identity 写入失败 agent=${agent.name}: ${messageOf(error)}`);
+        }
+        this.log(`bot 身份就绪(${via}) agent=${agent.name} bot=${name || "?"}(${openId})`);
+        this.options.state.updateStatus(agent, { connectedAt: this.now().toISOString(), connectedVia: via, reconnectingAt: null });
+    }
+    async connected(agent, channel, onFatal) {
+        const identity = channel.botIdentity || null;
+        if (!identity?.openId) {
+            this.log(`createLarkChannel 已连接但未取到 botIdentity agent=${agent.name}`);
+            onFatal?.(new Error("bot identity unavailable"));
+            return;
+        }
+        let avatarUrl = null;
+        let botName = identity.name || null;
+        try {
+            const info = await channel.rawClient?.request({ url: "/open-apis/bot/v3/info", method: "GET" });
+            if (info?.bot?.open_id === identity.openId) {
+                avatarUrl = info.bot.avatar_url || null;
+                botName = info.bot.app_name || botName;
+            }
+        }
+        catch (error) {
+            this.log(`bot 头像刷新失败（不影响连接） agent=${agent.name}: ${messageOf(error)}`);
+        }
+        this.persistBotIdentity(agent, identity.openId, botName, "channel", avatarUrl);
+    }
+}

package/dist/feishu/host-processing-eye.cjs

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProcessingEyeOrchestrator = void 0;
+const node_child_process_1 = require("node:child_process");
+const agent_lark_cli_workspace_js_1 = require("../app/agent-lark-cli-workspace.cjs");
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error || "?");
+}
+class ProcessingEyeOrchestrator {
+    options;
+    pending = new Map();
+    state = new Map();
+    execFile;
+    log;
+    recordError;
+    setTimer;
+    clearTimer;
+    constructor(options = {}) {
+        this.options = options;
+        this.execFile = options.execFile ?? node_child_process_1.execFile;
+        this.log = options.log ?? (() => { });
+        this.recordError = options.recordStatusError ?? (() => { });
+        this.setTimer = options.setTimer ?? setTimeout;
+        this.clearTimer = options.clearTimer ?? clearTimeout;
+    }
+    larkApi(agent, method, apiPath, data, callback) {
+        const args = ["api", method, apiPath];
+        if (data)
+            args.push("--data", JSON.stringify(data));
+        const selected = this.options.cliForAgent?.(agent) ?? (() => {
+            const managed = (0, agent_lark_cli_workspace_js_1.managedOfficialLarkCli)(agent, this.options.envForAgent?.(agent) ?? process.env);
+            return { command: managed.command.command, argsPrefix: managed.command.argsPrefix, env: managed.env };
+        })();
+        this.execFile(selected.command, [...selected.argsPrefix, ...args], { encoding: "utf8", timeout: 10_000,
+            env: selected.env }, (error, stdout, stderr) => {
+            let result = null;
+            try {
+                result = JSON.parse(String(stdout));
+            }
+            catch { /* non-JSON */ }
+            if (error && !result) {
+                const killed = "killed" in error && Boolean(error.killed);
+                // 不回显命令行：execFile 的 message 以整条命令开头，会占满 recentErrors 的 200 字符截断额度，
+                // 把真正可诊断的 exit 码和 stderr 挤出去（2026-07-17 三次偶发失败均因此无法定位）。
+                const code = error.code;
+                const head = String(stderr || "").trim().slice(0, 160) || String(stdout || "").trim().slice(0, 120);
+                const detail = (killed ? "超时(10s)被杀" : `exit=${code ?? "?"}`) + (head ? ` | ${head}` : "");
+                const endpoint = apiPath.split("/").slice(-2).join("/");
+                this.log(`larkApi ${method} ${endpoint} 失败 agent=${agent.name}: ${detail}`);
+                const processingReaction = /\/reactions(?:\/[^/]+)?$/.test(apiPath);
+                if (!processingReaction)
+                    this.recordError(agent, `larkApi ${method} ${endpoint}: ${detail}`);
+            }
+            callback?.(error, result);
+        });
+    }
+    save(agent) {
+        try {
+            this.options.writePending?.(agent, this.pending.get(agent.agentId) || []);
+        }
+        catch { /* best effort */ }
+    }
+    getState(agent) {
+        const existing = this.state.get(agent.agentId);
+        if (existing)
+            return existing;
+        const created = { sawActive: false, fallbackTimer: null, completionTimer: null, gen: 0 };
+        this.state.set(agent.agentId, created);
+        return created;
+    }
+    cancelCompletion(state) {
+        if (!state.completionTimer)
+            return;
+        this.clearTimer(state.completionTimer);
+        state.completionTimer = null;
+    }
+    restoreAndClear(agent) {
+        let leftovers = [];
+        try {
+            leftovers = this.options.readPending?.(agent) || [];
+        }
+        catch {
+            return;
+        }
+        if (!leftovers.length)
+            return;
+        this.pending.set(agent.agentId, leftovers);
+        this.clear(agent, "启动清扫遗留");
+    }
+    add(agent, msgId) {
+        if (!agent.feishuProfile || !msgId || !msgId.startsWith("om_")) {
+            this.log(`👀 跳过 agent=${agent.name} msg=${msgId || "?"} profile=${agent.feishuProfile || "缺"}（不满足点表情条件）`);
+            return;
+        }
+        this.log(`👀 点上尝试 agent=${agent.name} msg=${msgId}`);
+        const state = this.getState(agent);
+        state.gen += 1;
+        // A successful delivery may emit turn-start before the Feishu POST is
+        // attempted, and a new inbound message may arrive during idle grace. The
+        // add itself therefore establishes an active generation instead of
+        // erasing activity already observed for that turn.
+        state.sawActive = true;
+        this.cancelCompletion(state);
+        if (state.fallbackTimer)
+            this.clearTimer(state.fallbackTimer);
+        const generation = state.gen;
+        let fallbackTimer;
+        fallbackTimer = this.setTimer(() => {
+            const current = this.state.get(agent.agentId);
+            if (current?.gen !== generation || current.fallbackTimer !== fallbackTimer)
+                return;
+            this.clear(agent, "15分钟兜底");
+        }, 15 * 60 * 1000);
+        state.fallbackTimer = fallbackTimer;
+        this.larkApi(agent, "POST", `/open-apis/im/v1/messages/${msgId}/reactions`, { reaction_type: { emoji_type: "OnIt" } }, (error, result) => {
+            const reactionId = result?.data?.reaction_id;
+            if (!reactionId) {
+                this.log(`👀 点上失败 msg=${msgId}: ${result ? JSON.stringify(result.error || result).slice(0, 120) : errorMessage(error)}`);
+                return;
+            }
+            if ((this.state.get(agent.agentId)?.gen ?? 0) !== generation) {
+                this.log(`👀 迟到回执自删 agent=${agent.name} msg=${msgId}（点上生效前执行已结束）`);
+                this.larkApi(agent, "DELETE", `/open-apis/im/v1/messages/${msgId}/reactions/${reactionId}`, null, () => { });
+                return;
+            }
+            const list = this.pending.get(agent.agentId) || [];
+            list.push({ msgId, reactionId });
+            this.pending.set(agent.agentId, list);
+            this.save(agent);
+        });
+    }
+    clear(agent, reason) {
+        const state = this.state.get(agent.agentId);
+        if (state) {
+            state.gen += 1;
+            state.sawActive = false;
+            if (state.fallbackTimer) {
+                this.clearTimer(state.fallbackTimer);
+                state.fallbackTimer = null;
+            }
+            this.cancelCompletion(state);
+        }
+        const list = this.pending.get(agent.agentId) || [];
+        if (!list.length) {
+            this.log(`👀 清除(无待摘) agent=${agent.name} 原因=${reason || "?"}`);
+            return;
+        }
+        this.pending.set(agent.agentId, []);
+        this.save(agent);
+        for (const { msgId, reactionId } of list) {
+            this.larkApi(agent, "DELETE", `/open-apis/im/v1/messages/${msgId}/reactions/${reactionId}`, null, (error, result) => {
+                if (error || result?.ok === false) {
+                    this.log(`👀 摘除失败 msg=${msgId}: ${result ? JSON.stringify(result.error || {}).slice(0, 120) : errorMessage(error)}`);
+                }
+            });
+        }
+        this.log(`👀 已摘 agent=${agent.name} n=${list.length} 原因=${reason || "?"}`);
+    }
+    observeActivity(agent, activity) {
+        const state = this.getState(agent);
+        if (activity === "error" || activity === "offline") {
+            this.clear(agent, `activity:${activity}`);
+            return;
+        }
+        if (activity === "idle") {
+            if (!state.sawActive || state.completionTimer)
+                return;
+            const generation = state.gen;
+            let completionTimer;
+            completionTimer = this.setTimer(() => {
+                const current = this.state.get(agent.agentId);
+                if (current?.gen !== generation || current.completionTimer !== completionTimer)
+                    return;
+                this.clear(agent, "activity:idle(执行结束缓冲完成)");
+            }, 1_000);
+            state.completionTimer = completionTimer;
+            return;
+        }
+        // Runtime adapters may add new intermediate activity types. Anything other
+        // than an explicit terminal state means the turn is still active.
+        state.sawActive = true;
+        this.cancelCompletion(state);
+    }
+}
+exports.ProcessingEyeOrchestrator = ProcessingEyeOrchestrator;

package/dist/feishu/host-processing-eye.mjs

@@ -0,0 +1,181 @@
+import { execFile as nodeExecFile } from "node:child_process";
+import { managedOfficialLarkCli } from "../app/agent-lark-cli-workspace.mjs";
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error || "?");
+}
+export class ProcessingEyeOrchestrator {
+    options;
+    pending = new Map();
+    state = new Map();
+    execFile;
+    log;
+    recordError;
+    setTimer;
+    clearTimer;
+    constructor(options = {}) {
+        this.options = options;
+        this.execFile = options.execFile ?? nodeExecFile;
+        this.log = options.log ?? (() => { });
+        this.recordError = options.recordStatusError ?? (() => { });
+        this.setTimer = options.setTimer ?? setTimeout;
+        this.clearTimer = options.clearTimer ?? clearTimeout;
+    }
+    larkApi(agent, method, apiPath, data, callback) {
+        const args = ["api", method, apiPath];
+        if (data)
+            args.push("--data", JSON.stringify(data));
+        const selected = this.options.cliForAgent?.(agent) ?? (() => {
+            const managed = managedOfficialLarkCli(agent, this.options.envForAgent?.(agent) ?? process.env);
+            return { command: managed.command.command, argsPrefix: managed.command.argsPrefix, env: managed.env };
+        })();
+        this.execFile(selected.command, [...selected.argsPrefix, ...args], { encoding: "utf8", timeout: 10_000,
+            env: selected.env }, (error, stdout, stderr) => {
+            let result = null;
+            try {
+                result = JSON.parse(String(stdout));
+            }
+            catch { /* non-JSON */ }
+            if (error && !result) {
+                const killed = "killed" in error && Boolean(error.killed);
+                // 不回显命令行：execFile 的 message 以整条命令开头，会占满 recentErrors 的 200 字符截断额度，
+                // 把真正可诊断的 exit 码和 stderr 挤出去（2026-07-17 三次偶发失败均因此无法定位）。
+                const code = error.code;
+                const head = String(stderr || "").trim().slice(0, 160) || String(stdout || "").trim().slice(0, 120);
+                const detail = (killed ? "超时(10s)被杀" : `exit=${code ?? "?"}`) + (head ? ` | ${head}` : "");
+                const endpoint = apiPath.split("/").slice(-2).join("/");
+                this.log(`larkApi ${method} ${endpoint} 失败 agent=${agent.name}: ${detail}`);
+                const processingReaction = /\/reactions(?:\/[^/]+)?$/.test(apiPath);
+                if (!processingReaction)
+                    this.recordError(agent, `larkApi ${method} ${endpoint}: ${detail}`);
+            }
+            callback?.(error, result);
+        });
+    }
+    save(agent) {
+        try {
+            this.options.writePending?.(agent, this.pending.get(agent.agentId) || []);
+        }
+        catch { /* best effort */ }
+    }
+    getState(agent) {
+        const existing = this.state.get(agent.agentId);
+        if (existing)
+            return existing;
+        const created = { sawActive: false, fallbackTimer: null, completionTimer: null, gen: 0 };
+        this.state.set(agent.agentId, created);
+        return created;
+    }
+    cancelCompletion(state) {
+        if (!state.completionTimer)
+            return;
+        this.clearTimer(state.completionTimer);
+        state.completionTimer = null;
+    }
+    restoreAndClear(agent) {
+        let leftovers = [];
+        try {
+            leftovers = this.options.readPending?.(agent) || [];
+        }
+        catch {
+            return;
+        }
+        if (!leftovers.length)
+            return;
+        this.pending.set(agent.agentId, leftovers);
+        this.clear(agent, "启动清扫遗留");
+    }
+    add(agent, msgId) {
+        if (!agent.feishuProfile || !msgId || !msgId.startsWith("om_")) {
+            this.log(`👀 跳过 agent=${agent.name} msg=${msgId || "?"} profile=${agent.feishuProfile || "缺"}（不满足点表情条件）`);
+            return;
+        }
+        this.log(`👀 点上尝试 agent=${agent.name} msg=${msgId}`);
+        const state = this.getState(agent);
+        state.gen += 1;
+        // A successful delivery may emit turn-start before the Feishu POST is
+        // attempted, and a new inbound message may arrive during idle grace. The
+        // add itself therefore establishes an active generation instead of
+        // erasing activity already observed for that turn.
+        state.sawActive = true;
+        this.cancelCompletion(state);
+        if (state.fallbackTimer)
+            this.clearTimer(state.fallbackTimer);
+        const generation = state.gen;
+        let fallbackTimer;
+        fallbackTimer = this.setTimer(() => {
+            const current = this.state.get(agent.agentId);
+            if (current?.gen !== generation || current.fallbackTimer !== fallbackTimer)
+                return;
+            this.clear(agent, "15分钟兜底");
+        }, 15 * 60 * 1000);
+        state.fallbackTimer = fallbackTimer;
+        this.larkApi(agent, "POST", `/open-apis/im/v1/messages/${msgId}/reactions`, { reaction_type: { emoji_type: "OnIt" } }, (error, result) => {
+            const reactionId = result?.data?.reaction_id;
+            if (!reactionId) {
+                this.log(`👀 点上失败 msg=${msgId}: ${result ? JSON.stringify(result.error || result).slice(0, 120) : errorMessage(error)}`);
+                return;
+            }
+            if ((this.state.get(agent.agentId)?.gen ?? 0) !== generation) {
+                this.log(`👀 迟到回执自删 agent=${agent.name} msg=${msgId}（点上生效前执行已结束）`);
+                this.larkApi(agent, "DELETE", `/open-apis/im/v1/messages/${msgId}/reactions/${reactionId}`, null, () => { });
+                return;
+            }
+            const list = this.pending.get(agent.agentId) || [];
+            list.push({ msgId, reactionId });
+            this.pending.set(agent.agentId, list);
+            this.save(agent);
+        });
+    }
+    clear(agent, reason) {
+        const state = this.state.get(agent.agentId);
+        if (state) {
+            state.gen += 1;
+            state.sawActive = false;
+            if (state.fallbackTimer) {
+                this.clearTimer(state.fallbackTimer);
+                state.fallbackTimer = null;
+            }
+            this.cancelCompletion(state);
+        }
+        const list = this.pending.get(agent.agentId) || [];
+        if (!list.length) {
+            this.log(`👀 清除(无待摘) agent=${agent.name} 原因=${reason || "?"}`);
+            return;
+        }
+        this.pending.set(agent.agentId, []);
+        this.save(agent);
+        for (const { msgId, reactionId } of list) {
+            this.larkApi(agent, "DELETE", `/open-apis/im/v1/messages/${msgId}/reactions/${reactionId}`, null, (error, result) => {
+                if (error || result?.ok === false) {
+                    this.log(`👀 摘除失败 msg=${msgId}: ${result ? JSON.stringify(result.error || {}).slice(0, 120) : errorMessage(error)}`);
+                }
+            });
+        }
+        this.log(`👀 已摘 agent=${agent.name} n=${list.length} 原因=${reason || "?"}`);
+    }
+    observeActivity(agent, activity) {
+        const state = this.getState(agent);
+        if (activity === "error" || activity === "offline") {
+            this.clear(agent, `activity:${activity}`);
+            return;
+        }
+        if (activity === "idle") {
+            if (!state.sawActive || state.completionTimer)
+                return;
+            const generation = state.gen;
+            let completionTimer;
+            completionTimer = this.setTimer(() => {
+                const current = this.state.get(agent.agentId);
+                if (current?.gen !== generation || current.completionTimer !== completionTimer)
+                    return;
+                this.clear(agent, "activity:idle(执行结束缓冲完成)");
+            }, 1_000);
+            state.completionTimer = completionTimer;
+            return;
+        }
+        // Runtime adapters may add new intermediate activity types. Anything other
+        // than an explicit terminal state means the turn is still active.
+        state.sawActive = true;
+        this.cancelCompletion(state);
+    }
+}