@nanhara/hara 0.70.0 → 0.95.2

package/dist/gateway/dingtalk.js

@@ -0,0 +1,209 @@
+// DingTalk (钉钉) adapter for `hara gateway` — connects to DingTalk's Stream Mode over Node's native global
+// WebSocket (zero new dep on Node ≥ 22) so the LOCAL daemon dials OUT (no public webhook endpoint needed, like
+// Feishu's long-connection). Creds from HARA_DINGTALK_CLIENT_ID / HARA_DINGTALK_CLIENT_SECRET (the app's
+// AppKey/AppSecret on open.dingtalk.com). Replies go to the per-message `sessionWebhook` the inbound payload
+// carries. Same ChatAdapter shape as Telegram/Discord/Feishu, so all the cross-platform gateway plumbing
+// (system context, stuck-guard, allowlist) works unchanged. v1 limitations: file send is not supported (DingTalk
+// bot replies via sessionWebhook only do text/markdown cards) and inbound images are noted but not downloaded.
+import { chunkText } from "./telegram.js";
+// Open a Stream connection here → response gives the WS endpoint + a ticket; then we dial endpoint?ticket=…
+const OPEN_CONNECTION = "https://api.dingtalk.com/v1.0/gateway/connections/open";
+const BOT_TOPIC = "/v1.0/im/bot/messages/get"; // the CALLBACK topic that carries a bot chat message
+const WSImpl = globalThis.WebSocket;
+const sleep = (ms, signal) => new Promise((r) => {
+    if (signal?.aborted)
+        return r();
+    const t = setTimeout(r, ms);
+    signal?.addEventListener?.("abort", () => { clearTimeout(t); r(); }, { once: true });
+});
+/** Parse a DingTalk bot message payload (the JSON.parse'd `data` field of a CALLBACK frame) → InboundMsg plus the
+ *  per-message sessionWebhook used to reply (pure). Accepts text (and picture, marked "[图片]"); null otherwise.
+ *  conversationId routes group/DM; senderStaffId is preferred for the allowlist (the org staff id), else senderId. */
+export function parseDingtalkMessage(msg) {
+    if (!msg)
+        return null;
+    const chatId = String(msg.conversationId || msg.senderId || "");
+    if (!chatId)
+        return null;
+    const userId = String(msg.senderStaffId || msg.senderId || "");
+    const userName = String(msg.senderNick || userId);
+    const sessionWebhook = typeof msg.sessionWebhook === "string" ? msg.sessionWebhook : null;
+    const type = String(msg.msgtype || "");
+    let text = "";
+    if (type === "text")
+        text = String(msg.text?.content ?? "").trim();
+    else if (type === "picture")
+        text = "[图片]"; // v1: inbound image not downloaded (downloadCode in content)
+    else if (type === "richText")
+        text = flattenRichText(msg.content?.richText).trim();
+    if (!text)
+        return null; // unsupported type (audio/file/etc.) or empty
+    return { msg: { chatId, userId, userName, text }, sessionWebhook };
+}
+/** Flatten a DingTalk richText message (an array of {text}/{type} runs) into plain text (pure). */
+function flattenRichText(runs) {
+    if (!Array.isArray(runs))
+        return "";
+    return runs.map((r) => (r && typeof r.text === "string" ? r.text : "")).join(" ").trim();
+}
+export function dingtalkAdapter(clientId, clientSecret) {
+    // chatId → the latest sessionWebhook seen for it (expires ~ a few hours; refreshed on each inbound message).
+    const webhooks = new Map();
+    return {
+        name: "dingtalk",
+        async send(chatId, text) {
+            const url = webhooks.get(String(chatId));
+            if (!url)
+                return; // no inbound seen yet → no webhook to reply through (replies must follow a message)
+            for (const part of chunkText(text || "(empty)")) {
+                await fetch(url, {
+                    method: "POST",
+                    headers: { "content-type": "application/json" },
+                    body: JSON.stringify({ msgtype: "text", text: { content: part } }),
+                }).catch(() => { });
+            }
+        },
+        // sendFile intentionally omitted: DingTalk bot replies (sessionWebhook) can't upload arbitrary files in v1.
+        // The gateway surfaces "(this platform can't send files yet)" when the agent queues a file.
+        async start(onMessage, signal) {
+            if (!WSImpl) {
+                console.error("hara gateway: DingTalk needs Node ≥ 22 (global WebSocket). Upgrade Node.");
+                return;
+            }
+            while (!signal.aborted) {
+                await connectOnce(clientId, clientSecret, webhooks, onMessage, signal);
+                if (!signal.aborted)
+                    await sleep(3000, signal); // reconnect backoff
+            }
+        },
+    };
+}
+/** One Stream connection: register → open the WS to the returned endpoint?ticket=…, then ACK every frame and
+ *  dispatch bot messages. Resolves on close/abort; the caller reconnects (fresh registration each time). */
+async function connectOnce(clientId, clientSecret, webhooks, onMessage, signal) {
+    let endpoint;
+    let ticket;
+    try {
+        const res = await fetch(OPEN_CONNECTION, {
+            method: "POST",
+            headers: { "content-type": "application/json", accept: "application/json" },
+            body: JSON.stringify({
+                clientId,
+                clientSecret,
+                subscriptions: [
+                    { type: "EVENT", topic: "*" },
+                    { type: "CALLBACK", topic: BOT_TOPIC },
+                ],
+                ua: "hara-cli/stream",
+                localIp: "127.0.0.1",
+            }),
+            signal,
+        });
+        if (!res.ok) {
+            console.error(`hara gateway: DingTalk connection register failed (HTTP ${res.status}) — check HARA_DINGTALK_CLIENT_ID/SECRET and that Stream mode is enabled.`);
+            return;
+        }
+        const j = (await res.json());
+        if (!j.endpoint || !j.ticket) {
+            console.error("hara gateway: DingTalk register returned no endpoint/ticket.");
+            return;
+        }
+        endpoint = j.endpoint;
+        ticket = j.ticket;
+    }
+    catch {
+        if (!signal.aborted)
+            console.error("hara gateway: DingTalk connection register error (network).");
+        return;
+    }
+    return new Promise((resolve) => {
+        const ws = new WSImpl(`${endpoint}?ticket=${encodeURIComponent(ticket)}`);
+        let hb = null;
+        const cleanup = () => {
+            if (hb)
+                clearInterval(hb);
+            signal.removeEventListener("abort", stop);
+        };
+        const stop = () => {
+            cleanup();
+            try {
+                ws.close();
+            }
+            catch {
+                /* already closing */
+            }
+            resolve();
+        };
+        signal.addEventListener("abort", stop, { once: true });
+        ws.addEventListener("open", () => {
+            // Application-level keepalive: a SYSTEM/ping frame keeps the connection registered between messages.
+            hb = setInterval(() => {
+                try {
+                    ws.send(JSON.stringify({ type: "SYSTEM", headers: { topic: "ping" }, data: "{}" }));
+                }
+                catch {
+                    /* socket gone — close handler resolves */
+                }
+            }, 30000);
+        });
+        ws.addEventListener("close", () => {
+            cleanup();
+            resolve();
+        });
+        ws.addEventListener("error", () => { });
+        ws.addEventListener("message", async (ev) => {
+            let frame;
+            try {
+                frame = JSON.parse(String(ev.data));
+            }
+            catch {
+                return;
+            }
+            const headers = frame?.headers ?? {};
+            const topic = String(headers.topic ?? "");
+            // ACK every frame with its messageId per the Stream ack protocol; reply data is a JSON-string `response`.
+            const ack = (response) => {
+                if (!headers.messageId)
+                    return;
+                try {
+                    ws.send(JSON.stringify({
+                        code: 200,
+                        headers: { messageId: headers.messageId, contentType: "application/json" },
+                        message: "OK",
+                        data: JSON.stringify({ response: response ?? {} }),
+                    }));
+                }
+                catch {
+                    /* socket gone */
+                }
+            };
+            if (frame?.type === "SYSTEM") {
+                if (topic === "disconnect") {
+                    stop(); // server asked us to drop → close and let the caller re-register
+                    return;
+                }
+                ack({}); // ping / connected / other system frames → just acknowledge
+                return;
+            }
+            if (topic === BOT_TOPIC) {
+                let payload;
+                try {
+                    payload = JSON.parse(String(frame.data ?? "{}")); // CALLBACK data is a JSON string
+                }
+                catch {
+                    ack({});
+                    return;
+                }
+                ack({}); // ack first (DingTalk expects a prompt ack; the actual reply goes via sessionWebhook)
+                const parsed = parseDingtalkMessage(payload);
+                if (parsed) {
+                    if (parsed.sessionWebhook)
+                        webhooks.set(String(parsed.msg.chatId), parsed.sessionWebhook);
+                    await onMessage(parsed.msg).catch(() => { });
+                }
+                return;
+            }
+            ack({}); // any other EVENT frame → acknowledge so DingTalk doesn't retry
+        });
+    });
+}

package/dist/gateway/discord.js

@@ -0,0 +1,164 @@
+// Discord adapter for `hara gateway` — connects to the Discord gateway over Node's native global WebSocket
+// (zero new dep on Node ≥ 22) for inbound, and the REST API for outbound. Token from HARA_DISCORD_TOKEN; allow
+// users via HARA_GATEWAY_ALLOWED (Discord user-id snowflakes). Same ChatAdapter shape as Telegram/WeChat, so all
+// the cross-platform gateway plumbing (send_file, in-chat system context, stuck-guard, image attach/describe)
+// works unchanged. NOTE: receiving message text needs the privileged "Message Content Intent" enabled for the
+// bot in the Discord developer portal.
+import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { join, basename } from "node:path";
+import { homedir } from "node:os";
+import { chunkText } from "./telegram.js";
+const REST = "https://discord.com/api/v10";
+const GATEWAY = "wss://gateway.discord.gg/?v=10&encoding=json";
+// GUILD_MESSAGES (1<<9) | DIRECT_MESSAGES (1<<12) | MESSAGE_CONTENT (1<<15, privileged)
+const INTENTS = (1 << 9) | (1 << 12) | (1 << 15);
+const WSImpl = globalThis.WebSocket;
+const sleep = (ms, signal) => new Promise((r) => {
+    if (signal?.aborted)
+        return r();
+    const t = setTimeout(r, ms);
+    signal?.addEventListener?.("abort", () => { clearTimeout(t); r(); }, { once: true });
+});
+const isImage = (name, mime) => (mime?.startsWith("image/") ?? false) || /\.(png|jpe?g|gif|webp)$/i.test(name);
+async function downloadDiscordAttachment(url, filename) {
+    try {
+        const r = await fetch(url);
+        if (!r.ok)
+            return null;
+        const dir = join(homedir(), ".hara", "discord", "media");
+        mkdirSync(dir, { recursive: true });
+        const path = join(dir, `dc_${Date.now()}_${basename(filename) || "file.bin"}`);
+        writeFileSync(path, Buffer.from(await r.arrayBuffer()));
+        return path;
+    }
+    catch {
+        return null;
+    }
+}
+/** Parse a Discord MESSAGE_CREATE payload → InboundMsg + its image attachment URLs (pure; download happens in
+ *  start()). null = ignore (own message / another bot / empty). */
+export function parseDiscordMessage(d, selfId) {
+    if (!d?.channel_id || !d?.author?.id)
+        return null;
+    if (d.author.id === selfId || d.author.bot)
+        return null; // ignore our own messages + other bots
+    const atts = Array.isArray(d.attachments) ? d.attachments : [];
+    const imageUrls = atts
+        .filter((a) => isImage(String(a?.filename ?? ""), a?.content_type))
+        .map((a) => ({ url: String(a.url), name: String(a.filename ?? "image") }));
+    const text = String(d.content ?? "");
+    if (!text && !imageUrls.length)
+        return null;
+    return {
+        msg: {
+            chatId: String(d.channel_id),
+            userId: String(d.author.id),
+            userName: d.author.global_name || d.author.username || String(d.author.id),
+            text: text || "[图片]",
+        },
+        imageUrls,
+    };
+}
+export function discordAdapter(token) {
+    const auth = { Authorization: `Bot ${token}` };
+    return {
+        name: "discord",
+        async send(chatId, text) {
+            for (const part of chunkText(text || "(empty)", 2000)) {
+                await fetch(`${REST}/channels/${chatId}/messages`, {
+                    method: "POST",
+                    headers: { ...auth, "content-type": "application/json" },
+                    body: JSON.stringify({ content: part }),
+                }).catch(() => { });
+            }
+        },
+        async sendFile(chatId, filePath) {
+            const form = new FormData();
+            form.append("payload_json", JSON.stringify({}));
+            form.append("files[0]", new Blob([readFileSync(filePath)]), basename(filePath));
+            await fetch(`${REST}/channels/${chatId}/messages`, { method: "POST", headers: auth, body: form }).catch(() => { });
+        },
+        async start(onMessage, signal) {
+            if (!WSImpl) {
+                console.error("hara gateway: Discord needs Node ≥ 22 (global WebSocket). Upgrade Node.");
+                return;
+            }
+            while (!signal.aborted) {
+                await connectOnce(token, onMessage, signal);
+                if (!signal.aborted)
+                    await sleep(3000, signal); // reconnect backoff
+            }
+        },
+    };
+}
+/** One gateway connection: HELLO→heartbeat, IDENTIFY, then dispatch MESSAGE_CREATE. Resolves on close/abort;
+ *  the caller reconnects. v1 keeps it simple — fresh IDENTIFY each time, no RESUME. */
+function connectOnce(token, onMessage, signal) {
+    return new Promise((resolve) => {
+        const ws = new WSImpl(GATEWAY);
+        let hb = null;
+        let seq = null;
+        let selfId = "";
+        const stop = () => {
+            if (hb)
+                clearInterval(hb);
+            signal.removeEventListener("abort", stop);
+            try {
+                ws.close();
+            }
+            catch {
+                /* already closing */
+            }
+            resolve();
+        };
+        signal.addEventListener("abort", stop, { once: true });
+        ws.addEventListener("close", () => {
+            if (hb)
+                clearInterval(hb);
+            signal.removeEventListener("abort", stop);
+            resolve();
+        });
+        ws.addEventListener("error", () => { });
+        ws.addEventListener("message", async (ev) => {
+            let p;
+            try {
+                p = JSON.parse(String(ev.data));
+            }
+            catch {
+                return;
+            }
+            if (typeof p.s === "number")
+                seq = p.s;
+            if (p.op === 10) {
+                const interval = p.d?.heartbeat_interval ?? 41250;
+                hb = setInterval(() => {
+                    try {
+                        ws.send(JSON.stringify({ op: 1, d: seq }));
+                    }
+                    catch {
+                        /* socket gone */
+                    }
+                }, interval);
+                ws.send(JSON.stringify({ op: 2, d: { token, intents: INTENTS, properties: { os: "linux", browser: "hara", device: "hara" } } }));
+            }
+            else if (p.op === 0) {
+                if (p.t === "READY")
+                    selfId = p.d?.user?.id ?? "";
+                else if (p.t === "MESSAGE_CREATE") {
+                    const parsed = parseDiscordMessage(p.d, selfId);
+                    if (parsed) {
+                        for (const im of parsed.imageUrls) {
+                            const path = await downloadDiscordAttachment(im.url, im.name);
+                            if (path)
+                                (parsed.msg.images ??= []).push(path);
+                        }
+                        await onMessage(parsed.msg).catch(() => { });
+                    }
+                }
+            }
+            else if (p.op === 7 || p.op === 9) {
+                stop(); // server asked to reconnect / invalid session → drop and let the caller reconnect
+            }
+        });
+    });
+}

package/dist/gateway/feishu.js

@@ -0,0 +1,144 @@
+// Feishu/Lark adapter for `hara gateway` — uses the official @larksuiteoapi/node-sdk: a WSClient long-connection
+// for inbound events (no public webhook endpoint needed — fits hara's local daemon) and the REST Client for
+// outbound. Creds from HARA_FEISHU_APP_ID / HARA_FEISHU_APP_SECRET (+ HARA_FEISHU_DOMAIN=lark for larksuite.com).
+// Same ChatAdapter shape as the others, so all cross-platform gateway logic (send_file, system context,
+// stuck-guard, image attach/describe) works unchanged. v1 = p2p (DM) only; group support is a fast-follow.
+import lark from "@larksuiteoapi/node-sdk";
+import { createReadStream, createWriteStream, mkdirSync } from "node:fs";
+import { pipeline } from "node:stream/promises";
+import { join, basename } from "node:path";
+import { homedir } from "node:os";
+import { chunkText } from "./telegram.js";
+/** Normalize a Feishu message's parsed content by type → text + any media keys (pure; download done by caller). */
+export function parseFeishuContent(messageType, content) {
+    if (messageType === "text")
+        return { text: String(content?.text ?? "") };
+    if (messageType === "post")
+        return { text: flattenPost(content) };
+    if (messageType === "image")
+        return { text: "", imageKey: content?.image_key };
+    if (messageType === "file")
+        return { text: "", fileKey: content?.file_key, fileName: content?.file_name };
+    if (messageType === "audio")
+        return { text: "", fileKey: content?.file_key, fileName: "audio" };
+    return { text: "" };
+}
+/** Flatten a Feishu rich-text "post" message into plain text (best-effort over its [[{tag,text}]] runs). */
+export function flattenPost(content) {
+    const blocks = content?.content ?? content?.zh_cn?.content ?? content?.en_us?.content ?? [];
+    const out = [];
+    for (const line of Array.isArray(blocks) ? blocks : []) {
+        for (const seg of Array.isArray(line) ? line : []) {
+            if (seg?.tag === "text" && seg.text)
+                out.push(String(seg.text));
+            else if (seg?.tag === "a" && seg.text)
+                out.push(String(seg.text));
+        }
+    }
+    return out.join(" ").trim();
+}
+async function downloadFeishuResource(client, messageId, fileKey, type) {
+    try {
+        const resp = await client.im.messageResource.get({ path: { message_id: messageId, file_key: fileKey }, params: { type } });
+        const dir = join(homedir(), ".hara", "feishu", "media");
+        mkdirSync(dir, { recursive: true });
+        const path = join(dir, `fs_${Date.now()}_${fileKey.slice(-8)}.${type === "image" ? "jpg" : "bin"}`);
+        if (typeof resp?.writeFile === "function")
+            await resp.writeFile(path);
+        else if (typeof resp?.getReadableStream === "function")
+            await pipeline(resp.getReadableStream(), createWriteStream(path));
+        else
+            return null;
+        return path;
+    }
+    catch {
+        return null;
+    }
+}
+/** Build an InboundMsg from a Feishu im.message.receive_v1 event (downloads media). null = skip (not a DM / empty). */
+async function toInbound(client, data) {
+    const msg = data?.message;
+    if (!msg?.chat_id || msg.chat_type !== "p2p")
+        return null; // v1: direct messages only
+    const sender = data?.sender?.sender_id;
+    const userId = String(sender?.open_id || sender?.user_id || msg.chat_id);
+    let content = {};
+    try {
+        content = JSON.parse(msg.content ?? "{}");
+    }
+    catch {
+        /* malformed content → empty */
+    }
+    const parsed = parseFeishuContent(String(msg.message_type), content);
+    let text = parsed.text;
+    const images = [];
+    if (parsed.imageKey) {
+        const p = await downloadFeishuResource(client, msg.message_id, parsed.imageKey, "image");
+        if (p) {
+            images.push(p);
+            text = "[图片]";
+        }
+    }
+    else if (parsed.fileKey) {
+        const p = await downloadFeishuResource(client, msg.message_id, parsed.fileKey, "file");
+        const label = parsed.fileName === "audio" ? "语音" : `文件 ${parsed.fileName ?? ""}`.trim();
+        if (p)
+            text = `[${label}: ${p}]`;
+    }
+    text = text.trim();
+    if (!text && !images.length)
+        return null;
+    return { chatId: String(msg.chat_id), userId, userName: userId, text: text || "[图片]", images: images.length ? images : undefined };
+}
+export function feishuAdapter(appId, appSecret) {
+    const domain = process.env.HARA_FEISHU_DOMAIN === "lark" ? lark.Domain.Lark : lark.Domain.Feishu;
+    const client = new lark.Client({ appId, appSecret, domain });
+    const wsClient = new lark.WSClient({ appId, appSecret, domain });
+    const sendMsg = (chatId, msgType, content) => client.im.message
+        .create({ params: { receive_id_type: "chat_id" }, data: { receive_id: String(chatId), msg_type: msgType, content: JSON.stringify(content) } })
+        .catch(() => undefined);
+    return {
+        name: "feishu",
+        async send(chatId, text) {
+            for (const part of chunkText(text || "(empty)", 4000))
+                await sendMsg(chatId, "text", { text: part });
+        },
+        async sendFile(chatId, filePath) {
+            const name = basename(filePath);
+            const isImg = /\.(png|jpe?g|gif|webp)$/i.test(name);
+            try {
+                if (isImg) {
+                    const up = await client.im.image.create({ data: { image_type: "message", image: createReadStream(filePath) } });
+                    const key = up?.image_key ?? up?.data?.image_key;
+                    if (key)
+                        await sendMsg(chatId, "image", { image_key: key });
+                }
+                else {
+                    const up = await client.im.file.create({ data: { file_type: "stream", file_name: name, file: createReadStream(filePath) } });
+                    const key = up?.file_key ?? up?.data?.file_key;
+                    if (key)
+                        await sendMsg(chatId, "file", { file_key: key });
+                }
+            }
+            catch {
+                /* upload/send failed — surfaced upstream as "no file delivered" */
+            }
+        },
+        async start(onMessage, signal) {
+            const eventDispatcher = new lark.EventDispatcher({}).register({
+                "im.message.receive_v1": async (data) => {
+                    const m = await toInbound(client, data);
+                    if (m)
+                        await onMessage(m).catch(() => { });
+                },
+            });
+            wsClient.start({ eventDispatcher }); // runs its own background long-connection (auto-reconnect)
+            // keep the adapter alive until the gateway aborts (the WSClient manages the socket itself)
+            await new Promise((resolve) => {
+                if (signal.aborted)
+                    return resolve();
+                signal.addEventListener("abort", () => resolve(), { once: true });
+            });
+        },
+    };
+}