@greatlhd/ailo-desktop 1.0.0

package/dist/desktop_state_store.js

@@ -0,0 +1,57 @@
+const DEFAULT_OBSERVATION_TTL_MS = 60_000;
+const MAX_OBSERVATIONS = 20;
+export class DesktopStateStore {
+    observationTtlMs;
+    observations = new Map();
+    lastObservationId = null;
+    lastAction = null;
+    lastVerdict = null;
+    constructor(observationTtlMs = DEFAULT_OBSERVATION_TTL_MS) {
+        this.observationTtlMs = observationTtlMs;
+    }
+    saveObservation(observation) {
+        this.pruneExpired();
+        this.observations.set(observation.id, observation);
+        this.lastObservationId = observation.id;
+        while (this.observations.size > MAX_OBSERVATIONS) {
+            const oldestKey = this.observations.keys().next().value;
+            if (!oldestKey)
+                break;
+            this.observations.delete(oldestKey);
+        }
+    }
+    getObservation(id) {
+        this.pruneExpired();
+        return this.observations.get(id) ?? null;
+    }
+    getLatestObservation() {
+        this.pruneExpired();
+        if (!this.lastObservationId)
+            return null;
+        return this.observations.get(this.lastObservationId) ?? null;
+    }
+    isExpired(observation) {
+        return Date.now() - observation.timestamp > this.observationTtlMs;
+    }
+    setLastAction(action) {
+        this.lastAction = action;
+    }
+    getLastAction() {
+        return this.lastAction;
+    }
+    setLastVerdict(verdict) {
+        this.lastVerdict = verdict;
+    }
+    getLastVerdict() {
+        return this.lastVerdict;
+    }
+    pruneExpired() {
+        for (const [id, observation] of this.observations) {
+            if (this.isExpired(observation))
+                this.observations.delete(id);
+        }
+        if (this.lastObservationId && !this.observations.has(this.lastObservationId)) {
+            this.lastObservationId = null;
+        }
+    }
+}

package/dist/desktop_types.js

@@ -0,0 +1 @@
+export {};

package/dist/desktop_verifier.js

@@ -0,0 +1,40 @@
+import { readFileSync } from "fs";
+import { PNG } from "pngjs";
+import pixelmatch from "pixelmatch";
+function imagesDiffer(beforePath, afterPath) {
+    const before = PNG.sync.read(readFileSync(beforePath));
+    const after = PNG.sync.read(readFileSync(afterPath));
+    if (before.width !== after.width || before.height !== after.height)
+        return true;
+    const diff = new PNG({ width: before.width, height: before.height });
+    // pixelmatch is exported as CJS export =, use .default in ESM context
+    const pm = pixelmatch.default ?? pixelmatch;
+    const numDiffPixels = pm(before.data, after.data, diff.data, before.width, before.height, { threshold: 0.1 });
+    // 少于 0.5% 像素变化视为无变化（防误报）
+    const totalPixels = before.width * before.height;
+    return numDiffPixels / totalPixels > 0.005;
+}
+export function verifyDesktopAction(args) {
+    const { beforeObservation, afterObservation, actionResult } = args;
+    if (!actionResult.accepted) {
+        return { status: "failure", reason: actionResult.error ?? "动作被拒绝执行" };
+    }
+    if (!actionResult.executed) {
+        return { status: "failure", reason: actionResult.error ?? "动作未执行" };
+    }
+    if (!beforeObservation || !afterObservation) {
+        return { status: "uncertain", reason: "缺少动作前后 observation，无法完成验证" };
+    }
+    try {
+        if (imagesDiffer(beforeObservation.image.path, afterObservation.image.path)) {
+            return { status: "success", reason: "动作后界面发生变化" };
+        }
+        return { status: "uncertain", reason: "动作后未观察到明显界面变化" };
+    }
+    catch (error) {
+        return {
+            status: "uncertain",
+            reason: `无法比较动作前后截图: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}

package/dist/dingtalk-handler.js

@@ -0,0 +1,173 @@
+import { textPart, } from "@lmcl/ailo-endpoint-sdk";
+import { STALE_MESSAGE_THRESHOLD_MS, } from "./dingtalk-types.js";
+import { createChannelLogger } from "./utils.js";
+export class DingTalkHandler {
+    config;
+    ctx = null;
+    client = null;
+    constructor(config) {
+        this.config = config;
+    }
+    get storage() {
+        return this.ctx?.storage ?? null;
+    }
+    _log = createChannelLogger("dingtalk", () => this.ctx);
+    static WEBHOOK_STORE_KEY = "session_webhooks";
+    async saveWebhook(sessionKey, webhook, expiresAt) {
+        if (!this.storage)
+            return;
+        try {
+            const raw = await this.storage.getData(DingTalkHandler.WEBHOOK_STORE_KEY);
+            const store = raw ? JSON.parse(raw) : {};
+            const now = Date.now();
+            for (const [k, v] of Object.entries(store)) {
+                if (v.exp < now)
+                    delete store[k];
+            }
+            store[sessionKey] = { url: webhook, exp: expiresAt };
+            await this.storage.setData(DingTalkHandler.WEBHOOK_STORE_KEY, JSON.stringify(store));
+        }
+        catch (err) {
+            this._log("warn", "保存 webhook 失败", { err: String(err) });
+        }
+    }
+    async getWebhook(sessionKey) {
+        if (!this.storage)
+            return null;
+        try {
+            const raw = await this.storage.getData(DingTalkHandler.WEBHOOK_STORE_KEY);
+            if (!raw)
+                return null;
+            const store = JSON.parse(raw);
+            const entry = store[sessionKey];
+            if (!entry)
+                return null;
+            if (entry.exp < Date.now())
+                return null;
+            return entry.url;
+        }
+        catch {
+            return null;
+        }
+    }
+    sessionKeyFromMessage(msg) {
+        if (msg.conversationType === "2" && msg.conversationId) {
+            return `grp:${msg.conversationId.slice(-16)}`;
+        }
+        return `p2p:${msg.senderStaffId || msg.senderNick}`;
+    }
+    acceptMessage(msg) {
+        if (!this.ctx)
+            return;
+        this.ctx.accept(msg).catch((err) => this._log("error", "accept failed", { err: String(err) }));
+    }
+    buildAcceptMessage(opts) {
+        const { chatId, text, chatType, senderId = "", senderName = "", chatName } = opts;
+        const isPrivate = chatType === "私聊";
+        const tags = [
+            { kind: "channel", value: "dingtalk", groupWith: true },
+            { kind: "conv_type", value: chatType, groupWith: false },
+            { kind: "chat_id", value: chatId, groupWith: true, passToTool: true },
+        ];
+        if (!isPrivate && chatName) {
+            tags.push({ kind: "group", value: chatName, groupWith: false });
+        }
+        if (senderName) {
+            tags.push({ kind: "participant", value: senderName, groupWith: false });
+        }
+        if (senderId) {
+            tags.push({ kind: "sender_id", value: senderId, groupWith: false, passToTool: true });
+        }
+        const content = [];
+        if (text)
+            content.push(textPart(text));
+        return { content, contextTags: tags };
+    }
+    async start(ctx) {
+        this.ctx = ctx;
+        const { DWClient, TOPIC_ROBOT, EventAck } = await import("dingtalk-stream");
+        const client = new DWClient({
+            clientId: this.config.clientId,
+            clientSecret: this.config.clientSecret,
+        });
+        this.client = client;
+        const onBotMessage = async (event) => {
+            try {
+                const msg = JSON.parse(event.data);
+                const text = (msg.text?.content ?? "").trim();
+                const isGroup = msg.conversationType === "2";
+                const chatType = isGroup ? "群聊" : "私聊";
+                const sessionKey = this.sessionKeyFromMessage(msg);
+                const chatId = sessionKey;
+                if (msg.createAt && Date.now() - msg.createAt > STALE_MESSAGE_THRESHOLD_MS) {
+                    this._log("info", `dropped stale message ${msg.msgId}`, {
+                        create_time: msg.createAt,
+                        age_min: Math.round((Date.now() - msg.createAt) / 60000),
+                    });
+                    return { status: EventAck.SUCCESS, message: "stale" };
+                }
+                if (msg.sessionWebhook) {
+                    await this.saveWebhook(sessionKey, msg.sessionWebhook, msg.sessionWebhookExpiredTime);
+                }
+                this._log("debug", `received ${msg.msgtype} ${chatType} from ${msg.senderNick}`, {
+                    conversationId: msg.conversationId,
+                    text_len: text.length,
+                });
+                if (!text) {
+                    this._log("debug", `skipped empty message ${msg.msgId}`);
+                    return { status: EventAck.SUCCESS, message: "empty" };
+                }
+                this.acceptMessage(this.buildAcceptMessage({
+                    chatId,
+                    text,
+                    chatType,
+                    senderId: msg.senderStaffId,
+                    senderName: msg.senderNick,
+                    chatName: isGroup ? (msg.conversationTitle || undefined) : undefined,
+                }));
+            }
+            catch (err) {
+                this._log("error", "处理钉钉消息失败", { err: String(err) });
+            }
+            return { status: EventAck.SUCCESS, message: "OK" };
+        };
+        client.registerCallbackListener(TOPIC_ROBOT, onBotMessage).connect();
+        this._log("info", "钉钉 Stream 连接已建立");
+        ctx.reportHealth("connected");
+    }
+    async sendText(chatId, text) {
+        if (!text?.trim())
+            return;
+        const webhook = await this.getWebhook(chatId);
+        if (!webhook) {
+            this._log("warn", `无法发送消息到 ${chatId}：sessionWebhook 不存在或已过期`);
+            throw new Error(`sessionWebhook 不存在或已过期 (chatId=${chatId})`);
+        }
+        const isMarkdown = /[#*`\[\]|]/.test(text);
+        const body = isMarkdown
+            ? { msgtype: "markdown", markdown: { title: "回复", text } }
+            : { msgtype: "text", text: { content: text } };
+        const res = await fetch(webhook, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(body),
+        });
+        if (!res.ok) {
+            const detail = await res.text().catch(() => "");
+            this._log("error", `发送消息失败: HTTP ${res.status}`, { detail });
+            throw new Error(`钉钉发送失败: HTTP ${res.status}`);
+        }
+        this._log("debug", `消息已发送到 ${chatId}`);
+    }
+    async stop() {
+        if (this.client) {
+            try {
+                if (typeof this.client.disconnect === "function")
+                    this.client.disconnect();
+            }
+            catch { /* best-effort */ }
+            this.client = null;
+        }
+        this.ctx = null;
+    }
+}

package/dist/dingtalk-types.js

@@ -0,0 +1 @@
+export const STALE_MESSAGE_THRESHOLD_MS = 5 * 60 * 1000;