@nanhara/hara 0.70.0 → 0.89.0

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 });
+            });
+        },
+    };
+}

package/dist/gateway/matrix.js

@@ -0,0 +1,188 @@
+// Matrix adapter for `hara gateway` — client-server API with a /sync long-poll (built-in fetch, zero new dep;
+// no WebSocket). Mirrors the Telegram long-poll model and the Discord download-media/sendFile patterns. Creds
+// from HARA_MATRIX_HOMESERVER (e.g. https://matrix.org) + HARA_MATRIX_TOKEN (access token) + HARA_MATRIX_USER_ID
+// (the bot's own @user:server, for self-filtering). Same ChatAdapter shape as the others, so all cross-platform
+// gateway plumbing (send_file, system context, stuck-guard, image attach/describe) works unchanged.
+//
+// LIMITATION (v1): NO end-to-end encryption. Encrypted rooms (m.room.encrypted events) are skipped — only
+// plaintext rooms work. E2EE would need libolm + a crypto store (see hermes' matrix-nio adapter), which breaks
+// the zero-dep constraint. Invite this bot into UNENCRYPTED rooms only.
+import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { join, basename } from "node:path";
+import { homedir } from "node:os";
+import { chunkText } from "./telegram.js";
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+const isImage = (name, mime) => (mime?.startsWith("image/") ?? false) || /\.(png|jpe?g|gif|webp)$/i.test(name);
+const mimeFromExt = (name) => {
+    const ext = name.toLowerCase().split(".").pop() ?? "";
+    const map = {
+        png: "image/png", jpg: "image/jpeg", jpeg: "image/jpeg", gif: "image/gif", webp: "image/webp",
+        mp4: "video/mp4", mp3: "audio/mpeg", ogg: "audio/ogg", pdf: "application/pdf", txt: "text/plain",
+    };
+    return map[ext] ?? "application/octet-stream";
+};
+/** Parse `mxc://server/mediaId` → its two parts (pure). null if not an mxc URL. */
+export function parseMxc(mxc) {
+    if (typeof mxc !== "string" || !mxc.startsWith("mxc://"))
+        return null;
+    const rest = mxc.slice(6); // strip "mxc://"
+    const slash = rest.indexOf("/");
+    if (slash < 0)
+        return null;
+    const server = rest.slice(0, slash);
+    const mediaId = rest.slice(slash + 1);
+    if (!server || !mediaId)
+        return null;
+    return { server, mediaId };
+}
+/** Extract an InboundMsg from a single Matrix timeline event (pure). Accepts m.room.message of msgtype m.text
+ *  (and friends carrying a body) plus m.image (→ marker text + the mxc url to download in start()). Ignores our
+ *  own messages and encrypted events. Returns the InboundMsg + the image's mxc url (null if none). null = skip. */
+export function parseMatrixEvent(event, selfUserId) {
+    if (!event || event.type !== "m.room.message")
+        return null; // encrypted (m.room.encrypted) / state events → skip
+    const sender = typeof event.sender === "string" ? event.sender : "";
+    const roomId = typeof event.__roomId === "string" ? event.__roomId : ""; // injected by start() (events carry no room id)
+    if (!sender || !roomId)
+        return null;
+    if (sender === selfUserId)
+        return null; // ignore our own messages
+    const content = event.content ?? {};
+    const msgtype = typeof content.msgtype === "string" ? content.msgtype : "";
+    const body = typeof content.body === "string" ? content.body : "";
+    let imageMxc = null;
+    let text = body;
+    if (msgtype === "m.image") {
+        imageMxc = typeof content.url === "string" && content.url.startsWith("mxc://") ? content.url : null;
+        text = body || "[图片]";
+    }
+    else if (!body) {
+        return null; // text-less non-image (sticker/location/reaction-as-message/etc.)
+    }
+    return {
+        msg: {
+            chatId: roomId,
+            userId: sender,
+            userName: sender,
+            text: text || "[图片]",
+        },
+        imageMxc,
+    };
+}
+/** Download a Matrix mxc:// media to a local path under ~/.hara/matrix/media (resolves via /_matrix/media/v3/download). */
+async function downloadMatrixMedia(homeserver, token, mxc) {
+    const parts = parseMxc(mxc);
+    if (!parts)
+        return null;
+    try {
+        const url = `${homeserver}/_matrix/media/v3/download/${encodeURIComponent(parts.server)}/${encodeURIComponent(parts.mediaId)}`;
+        const r = await fetch(url, { headers: { Authorization: `Bearer ${token}` } });
+        if (!r.ok)
+            return null;
+        const dir = join(homedir(), ".hara", "matrix", "media");
+        mkdirSync(dir, { recursive: true });
+        const path = join(dir, `mx_${Date.now()}_${parts.mediaId.slice(-12)}`);
+        writeFileSync(path, Buffer.from(await r.arrayBuffer()));
+        return path;
+    }
+    catch {
+        return null;
+    }
+}
+export function matrixAdapter(homeserver, token, selfUserId) {
+    const base = homeserver.replace(/\/+$/, ""); // trim trailing slashes
+    const auth = { Authorization: `Bearer ${token}` };
+    let txnSeq = Date.now(); // monotonically increasing txn id base (survives clock-ish across a process run)
+    const nextTxn = () => `hara${++txnSeq}`;
+    return {
+        name: "matrix",
+        async send(chatId, text) {
+            for (const part of chunkText(text || "(empty)", 4000)) {
+                const txn = nextTxn();
+                await fetch(`${base}/_matrix/client/v3/rooms/${encodeURIComponent(String(chatId))}/send/m.room.message/${txn}`, {
+                    method: "PUT",
+                    headers: { ...auth, "content-type": "application/json" },
+                    body: JSON.stringify({ msgtype: "m.text", body: part }),
+                }).catch(() => { });
+            }
+        },
+        async sendFile(chatId, filePath) {
+            const name = basename(filePath);
+            const mime = mimeFromExt(name);
+            try {
+                // 1) upload bytes → content_uri (mxc://)
+                const up = await fetch(`${base}/_matrix/media/v3/upload?filename=${encodeURIComponent(name)}`, {
+                    method: "POST",
+                    headers: { ...auth, "content-type": mime },
+                    body: readFileSync(filePath),
+                });
+                if (!up.ok)
+                    return;
+                const j = (await up.json());
+                const mxc = j?.content_uri;
+                if (!mxc)
+                    return;
+                // 2) send a referencing m.room.message — m.image for images, m.file otherwise
+                const msgtype = isImage(name, mime) ? "m.image" : "m.file";
+                const txn = nextTxn();
+                await fetch(`${base}/_matrix/client/v3/rooms/${encodeURIComponent(String(chatId))}/send/m.room.message/${txn}`, {
+                    method: "PUT",
+                    headers: { ...auth, "content-type": "application/json" },
+                    body: JSON.stringify({ msgtype, body: name, filename: name, url: mxc, info: { mimetype: mime } }),
+                }).catch(() => { });
+            }
+            catch {
+                /* upload/send failed — surfaced upstream as "no file delivered" */
+            }
+        },
+        async start(onMessage, signal) {
+            // Prime the cursor: a since-less, timeout=0 sync skips backlog so we only see messages from now on.
+            let since = "";
+            try {
+                const r = await fetch(`${base}/_matrix/client/v3/sync?timeout=0`, { headers: auth, signal });
+                if (r.ok) {
+                    const j = (await r.json());
+                    if (typeof j.next_batch === "string")
+                        since = j.next_batch;
+                }
+            }
+            catch {
+                if (signal.aborted)
+                    return;
+            }
+            while (!signal.aborted) {
+                try {
+                    const q = `timeout=30000${since ? `&since=${encodeURIComponent(since)}` : ""}`;
+                    const res = await fetch(`${base}/_matrix/client/v3/sync?${q}`, { headers: auth, signal });
+                    if (!res.ok) {
+                        await sleep(2000);
+                        continue;
+                    }
+                    const j = (await res.json());
+                    if (typeof j.next_batch === "string")
+                        since = j.next_batch;
+                    const join = j.rooms?.join ?? {};
+                    for (const [roomId, room] of Object.entries(join)) {
+                        for (const event of room?.timeline?.events ?? []) {
+                            event.__roomId = roomId; // events carry no room id in /sync — inject it for the pure parser
+                            const parsed = parseMatrixEvent(event, selfUserId);
+                            if (!parsed)
+                                continue;
+                            if (parsed.imageMxc) {
+                                const path = await downloadMatrixMedia(base, token, parsed.imageMxc);
+                                if (path)
+                                    parsed.msg.images = [path];
+                            }
+                            await onMessage(parsed.msg).catch(() => { });
+                        }
+                    }
+                }
+                catch {
+                    if (signal.aborted)
+                        break;
+                    await sleep(2000); // network blip → back off + retry
+                }
+            }
+        },
+    };
+}