@nanhara/hara 0.89.0 → 0.95.2

package/dist/gateway/tmux-routes.js

@@ -0,0 +1,135 @@
+// tmux reply routing — lets a chat reply (WeChat) be injected back into an already-running tmux session
+// (e.g. a Claude Code / codex / hara you started yourself), so "ping me on WeChat → I reply from outside →
+// that session continues" works WITHOUT the daemon owning the process. The asking session registers its tmux
+// pane (via the wechat-send `--ask` flow); the gateway daemon (sole WeChat receiver) injects the owner's reply
+// into the oldest live registered pane with `tmux send-keys`. Borrows the ccgram keystroke-injection pattern.
+//
+// Safety: the daemon only reaches this AFTER its allow-list gate (so only the owner can trigger it), and it
+// ONLY injects into panes that opted in by registering — never an arbitrary pane.
+import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import { join } from "node:path";
+import { homedir } from "node:os";
+function dir() {
+    return join(homedir(), ".hara", "gateway");
+}
+function storePath() {
+    return join(dir(), "tmux-routes.json");
+}
+function load() {
+    try {
+        const j = JSON.parse(readFileSync(storePath(), "utf8"));
+        return Array.isArray(j?.routes) ? j.routes : [];
+    }
+    catch {
+        return [];
+    }
+}
+function save(routes) {
+    mkdirSync(dir(), { recursive: true });
+    writeFileSync(storePath(), JSON.stringify({ routes }, null, 2));
+}
+/** Register (or refresh) a pane as awaiting a reply. De-dups by pane. mode "once" (default) = consumed after one
+ *  reply; "bind" = persistent (every reply injects until unbound). */
+export function registerTmuxRoute(pane, peer, cwd, mode = "once", now = Date.now()) {
+    const routes = load().filter((r) => r.pane !== pane);
+    routes.push({ pane, peer, cwd, ts: now, mode });
+    save(routes);
+}
+/** Remove a pane's route(s). Returns how many were removed. */
+export function unbindPane(pane) {
+    const before = load();
+    const after = before.filter((r) => r.pane !== pane);
+    save(after);
+    return before.length - after.length;
+}
+/** All current routes (for `hara remote status`). */
+export function listRoutes() {
+    return load();
+}
+/** Remove all persistent "bind" routes (the chat `/detach` command). Returns how many were removed. */
+export function unbindBinds() {
+    const before = load();
+    const after = before.filter((r) => r.mode === "bind" ? false : true);
+    save(after);
+    return before.length - after.length;
+}
+/** Pure: pick the OLDEST live registered pane (FIFO — the longest-waiting ask answers first); return it plus the
+ *  routes to keep. A "once" route is consumed after use; a "bind" route persists. Dead panes are always pruned. */
+export function pickRoute(routes, isAlive) {
+    const live = routes.filter((r) => isAlive(r.pane)).sort((a, b) => a.ts - b.ts);
+    const chosen = live[0] ?? null;
+    const remaining = chosen && chosen.mode !== "bind" ? live.filter((r) => r.pane !== chosen.pane) : live;
+    return { chosen, remaining };
+}
+/** Is this tmux pane still alive? Checks membership in `list-panes -a` (display-message -t is too lenient and
+ *  falls back to the active pane for a bogus target). false if tmux isn't running or the pane is gone. */
+export function paneAlive(pane) {
+    try {
+        const out = execFileSync("tmux", ["list-panes", "-a", "-F", "#{pane_id}"], { encoding: "utf8", timeout: 3000 });
+        return out.split("\n").map((s) => s.trim()).includes(pane);
+    }
+    catch {
+        return false;
+    }
+}
+/** Type `text` into a tmux pane as if the user typed it, then press Enter (submits the line / sends the turn). */
+export function injectTmux(pane, text) {
+    execFileSync("tmux", ["send-keys", "-t", pane, "-l", "--", text], { timeout: 3000 });
+    execFileSync("tmux", ["send-keys", "-t", pane, "Enter"], { timeout: 3000 });
+}
+/** Persistent ("bind") routes only — the panes whose OUTPUT we relay back to chat (two-way remote terminal). */
+export function boundRoutes() {
+    return load().filter((r) => r.mode === "bind");
+}
+/** Capture a tmux pane's visible text (plain, no ANSI). null if unavailable. */
+export function capturePane(pane) {
+    try {
+        return execFileSync("tmux", ["capture-pane", "-p", "-t", pane], { encoding: "utf8", timeout: 3000 });
+    }
+    catch {
+        return null;
+    }
+}
+/** Pure: the NEW output to relay, given what we last sent and the current pane capture. "" = nothing new.
+ *  Handles the common append case, anchors on the last sent line when the pane has scrolled, and falls back to
+ *  the tail when it can't re-anchor. */
+export function outputDelta(lastSent, current) {
+    if (current === lastSent)
+        return "";
+    if (!lastSent)
+        return current; // caller decides whether to baseline (skip) or send on first sight
+    if (current.startsWith(lastSent))
+        return current.slice(lastSent.length);
+    const lines = lastSent.split("\n").filter((l) => l.trim());
+    const anchor = lines[lines.length - 1];
+    if (anchor) {
+        const idx = current.lastIndexOf(anchor);
+        if (idx >= 0)
+            return current.slice(idx + anchor.length);
+    }
+    return current.split("\n").slice(-20).join("\n"); // scrolled past our anchor → send the tail
+}
+/** Pick (and consume per mode) the oldest live registered pane WITHOUT injecting — so the caller can capture the
+ *  pane before/after injecting and relay just the new output. Returns the pane id, or null if none pending. */
+export function pickPaneForReply() {
+    const { chosen, remaining } = pickRoute(load(), paneAlive);
+    save(remaining);
+    return chosen?.pane ?? null;
+}
+/** Daemon entrypoint: deliver an inbound reply to the oldest live registered pane. Returns the pane id injected
+ *  into, or null if there was no pending route (→ caller treats the message as a normal task). One-shot: the
+ *  chosen route is consumed and dead panes are pruned. */
+export function deliverToTmux(text) {
+    const { chosen, remaining } = pickRoute(load(), paneAlive);
+    save(remaining);
+    if (!chosen)
+        return null;
+    try {
+        injectTmux(chosen.pane, text);
+        return chosen.pane;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/gateway/wecom.js

@@ -0,0 +1,383 @@
+// WeCom (企业微信 / Enterprise WeChat) adapter for `hara gateway` — connects to WeCom's AI Bot WebSocket gateway
+// (wss://openws.work.weixin.qq.com) over Node's native global WebSocket (zero new dep on Node ≥ 22) so the LOCAL
+// daemon dials OUT: NO public webhook / callback endpoint is required, exactly like Discord/DingTalk/Feishu's
+// long-connection mode. Creds from HARA_WECOM_BOT_ID / HARA_WECOM_SECRET (the AI Bot's id + secret from the WeCom
+// admin console). Same ChatAdapter shape as Telegram/Discord, so all the cross-platform gateway plumbing (system
+// context, stuck-guard, allowlist, send_file, voice) works unchanged.
+//
+// Protocol (ported from the Hermes Python adapter): authenticate with an `aibot_subscribe` frame → receive
+// `aibot_msg_callback` events → reply with `aibot_send_msg` → upload media via the 3-step `aibot_upload_media_*`
+// chunked protocol → AES-256-CBC decrypt inbound media that carries an `aeskey`. Every request frame carries a
+// `headers.req_id` and the server echoes it back so request/response are correlated. v1 limitations are documented
+// at the bottom of this file (the public spec is thin — fields are best-effort and tolerant of shape drift).
+import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { join, basename, extname } from "node:path";
+import { homedir } from "node:os";
+import { randomUUID, createDecipheriv, createHash } from "node:crypto";
+import { chunkText } from "./telegram.js";
+const DEFAULT_WS_URL = "wss://openws.work.weixin.qq.com";
+const WSImpl = globalThis.WebSocket;
+// app-level command verbs on the AI Bot gateway (mirror the Hermes constants)
+const CMD_SUBSCRIBE = "aibot_subscribe";
+const CMD_CALLBACK = "aibot_msg_callback";
+const CMD_LEGACY_CALLBACK = "aibot_callback";
+const CMD_EVENT_CALLBACK = "aibot_event_callback";
+const CMD_SEND = "aibot_send_msg";
+const CMD_PING = "ping";
+const CMD_UPLOAD_INIT = "aibot_upload_media_init";
+const CMD_UPLOAD_CHUNK = "aibot_upload_media_chunk";
+const CMD_UPLOAD_FINISH = "aibot_upload_media_finish";
+const CALLBACK_CMDS = new Set([CMD_CALLBACK, CMD_LEGACY_CALLBACK]);
+const MAX_MESSAGE_LENGTH = 4000;
+const HEARTBEAT_MS = 30000;
+const REQUEST_TIMEOUT_MS = 15000;
+const UPLOAD_CHUNK_SIZE = 512 * 1024; // 512 KB chunks (WeCom upload protocol)
+const ABSOLUTE_MAX_BYTES = 20 * 1024 * 1024; // WeCom hard cap on any upload
+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 isImageName = (name) => /\.(png|jpe?g|gif|webp)$/i.test(name);
+/** Detect an image extension from magic bytes (pure) — used when WeCom doesn't give us a filename. */
+function imageExtFromBytes(data) {
+    if (data.length >= 8 && data[0] === 0x89 && data[1] === 0x50 && data[2] === 0x4e && data[3] === 0x47)
+        return ".png";
+    if (data.length >= 3 && data[0] === 0xff && data[1] === 0xd8 && data[2] === 0xff)
+        return ".jpg";
+    if (data.length >= 6 && data[0] === 0x47 && data[1] === 0x49 && data[2] === 0x46)
+        return ".gif";
+    if (data.length >= 12 && data.toString("ascii", 0, 4) === "RIFF" && data.toString("ascii", 8, 12) === "WEBP")
+        return ".webp";
+    return ".jpg";
+}
+/** AES-256-CBC decrypt WeCom-encrypted media (pure). The 32-byte key is the base64-decoded `aeskey`; the IV is the
+ *  first 16 bytes of that key; padding is PKCS#7 (validated leniently, like the Hermes reference). */
+export function decryptWecomMedia(ciphertext, aesKeyB64) {
+    const key = Buffer.from(aesKeyB64, "base64");
+    if (key.length !== 32)
+        throw new Error(`unexpected WeCom aes_key length: ${key.length} (expected 32)`);
+    const d = createDecipheriv("aes-256-cbc", key, key.subarray(0, 16));
+    d.setAutoPadding(false); // strip PKCS#7 ourselves so a non-conformant tail doesn't throw
+    const padded = Buffer.concat([d.update(ciphertext), d.final()]);
+    if (!padded.length)
+        return padded;
+    const pad = padded[padded.length - 1];
+    if (pad >= 1 && pad <= 32 && padded.length >= pad) {
+        let ok = true;
+        for (let i = padded.length - pad; i < padded.length; i++)
+            if (padded[i] !== pad)
+                ok = false;
+        if (ok)
+            return padded.subarray(0, padded.length - pad);
+    }
+    return padded;
+}
+/** Pull the plain text out of a WeCom callback body (pure). Handles `text`, `voice` (transcription), and `mixed`
+ *  (text + image runs) message types — joining all text runs with newlines. */
+function extractWecomText(body) {
+    const parts = [];
+    const msgtype = String(body?.msgtype ?? "").toLowerCase();
+    if (msgtype === "mixed") {
+        const items = Array.isArray(body?.mixed?.msg_item) ? body.mixed.msg_item : [];
+        for (const it of items) {
+            if (String(it?.msgtype ?? "").toLowerCase() === "text") {
+                const c = String(it?.text?.content ?? "").trim();
+                if (c)
+                    parts.push(c);
+            }
+        }
+    }
+    else {
+        const c = String(body?.text?.content ?? "").trim();
+        if (c)
+            parts.push(c);
+        if (msgtype === "voice") {
+            const v = String(body?.voice?.content ?? "").trim(); // voice transcription, when present
+            if (v)
+                parts.push(v);
+        }
+    }
+    return parts.join("\n").trim();
+}
+/** Collect downloadable media refs from a WeCom callback body (pure). Covers top-level `image`/`file` and the image
+ *  runs inside a `mixed` message. */
+function extractWecomMedia(body) {
+    const refs = [];
+    const pushMedia = (kind, m) => {
+        if (!m || typeof m !== "object")
+            return;
+        refs.push({
+            kind,
+            url: typeof m.url === "string" ? m.url : undefined,
+            base64: typeof m.base64 === "string" ? m.base64 : undefined,
+            aesKeyB64: typeof m.aeskey === "string" ? m.aeskey : undefined,
+            fileName: typeof m.filename === "string" ? m.filename : typeof m.name === "string" ? m.name : undefined,
+        });
+    };
+    const msgtype = String(body?.msgtype ?? "").toLowerCase();
+    if (msgtype === "mixed") {
+        const items = Array.isArray(body?.mixed?.msg_item) ? body.mixed.msg_item : [];
+        for (const it of items)
+            if (String(it?.msgtype ?? "").toLowerCase() === "image")
+                pushMedia("image", it.image);
+    }
+    else {
+        if (body?.image)
+            pushMedia("image", body.image);
+        if (msgtype === "file" && body?.file)
+            pushMedia("file", body.file);
+    }
+    return refs;
+}
+/** Parse a WeCom `aibot_msg_callback` payload → InboundMsg + its downloadable media refs (pure; the actual download
+ *  happens in start()). `selfBotId` filters out the bot's own echoes. null = ignore (own message / empty / no chat
+ *  id). chatId is the WeCom chatid (group) else the sender's userid (DM); userId/userName are the sender's userid.
+ *  Mirrors parseDiscordMessage. */
+export function parseWecomMessage(payload, selfBotId) {
+    const body = payload?.body;
+    if (!body || typeof body !== "object")
+        return null;
+    const sender = typeof body.from === "object" && body.from ? body.from : {};
+    const senderId = String(sender.userid ?? "").trim();
+    // ignore our own messages (the bot speaking) so we never loop on our replies
+    if (selfBotId && senderId && senderId === selfBotId)
+        return null;
+    if (selfBotId && String(body.bot_id ?? body.botid ?? "").trim() === selfBotId && !senderId)
+        return null;
+    const chatId = String(body.chatid ?? senderId).trim();
+    if (!chatId)
+        return null;
+    const text = extractWecomText(body);
+    const media = extractWecomMedia(body);
+    if (!text && !media.length)
+        return null; // unsupported type or empty
+    return {
+        msg: {
+            chatId,
+            userId: senderId || chatId,
+            userName: String(sender.name ?? sender.userid ?? senderId ?? chatId),
+            text: text || "[图片]",
+        },
+        media,
+    };
+}
+/** Download (and AES-decrypt if needed) a WeCom inbound media ref → a local path under ~/.hara/wecom/media. null on
+ *  failure. Inline base64 and remote (optionally encrypted) urls are both handled. */
+async function downloadWecomMedia(ref) {
+    try {
+        let data = null;
+        if (ref.base64) {
+            data = Buffer.from(ref.base64.split(",").pop().trim(), "base64");
+        }
+        else if (ref.url) {
+            const r = await fetch(ref.url);
+            if (!r.ok)
+                return null;
+            let buf = Buffer.from(await r.arrayBuffer());
+            if (buf.length > ABSOLUTE_MAX_BYTES)
+                return null;
+            if (ref.aesKeyB64)
+                buf = decryptWecomMedia(buf, ref.aesKeyB64);
+            data = buf;
+        }
+        if (!data || !data.length)
+            return null;
+        const dir = join(homedir(), ".hara", "wecom", "media");
+        mkdirSync(dir, { recursive: true });
+        let name = ref.fileName ? basename(ref.fileName) : "";
+        if (!name || (ref.kind === "image" && !extname(name)))
+            name = `image${imageExtFromBytes(data)}`;
+        const path = join(dir, `wc_${Date.now()}_${name || "file.bin"}`);
+        writeFileSync(path, data);
+        return path;
+    }
+    catch {
+        return null;
+    }
+}
+export function wecomAdapter(botId, secret, wsUrl = DEFAULT_WS_URL) {
+    // per-connection request/response correlation lives inside connectOnce; send/sendFile use the live socket handle
+    // it publishes through `conn`.
+    const conn = { send: null };
+    // Upload a local file to WeCom via the 3-step chunked protocol → its media_id. Throws on any step error.
+    async function uploadMedia(filePath, mediaType) {
+        if (!conn.send)
+            throw new Error("WeCom socket not connected");
+        const data = readFileSync(filePath);
+        if (data.length > ABSOLUTE_MAX_BYTES)
+            throw new Error(`file exceeds WeCom 20MB limit: ${data.length} bytes`);
+        const totalChunks = Math.max(1, Math.ceil(data.length / UPLOAD_CHUNK_SIZE));
+        const init = await conn.send(CMD_UPLOAD_INIT, {
+            type: mediaType,
+            filename: basename(filePath),
+            total_size: data.length,
+            total_chunks: totalChunks,
+            md5: createHash("md5").update(data).digest("hex"),
+        });
+        const uploadId = String(init?.body?.upload_id ?? "").trim();
+        if (!uploadId)
+            throw new Error(`media upload init returned no upload_id (${JSON.stringify(init?.errmsg ?? init)})`);
+        for (let i = 0, start = 0; start < data.length || i === 0; i++, start += UPLOAD_CHUNK_SIZE) {
+            const chunk = data.subarray(start, start + UPLOAD_CHUNK_SIZE);
+            await conn.send(CMD_UPLOAD_CHUNK, { upload_id: uploadId, chunk_index: i, base64_data: chunk.toString("base64") });
+            if (start + UPLOAD_CHUNK_SIZE >= data.length)
+                break;
+        }
+        const fin = await conn.send(CMD_UPLOAD_FINISH, { upload_id: uploadId });
+        const mediaId = String(fin?.body?.media_id ?? "").trim();
+        if (!mediaId)
+            throw new Error(`media upload finish returned no media_id (${JSON.stringify(fin?.errmsg ?? fin)})`);
+        return mediaId;
+    }
+    return {
+        name: "wecom",
+        async send(chatId, text) {
+            if (!conn.send)
+                return; // no live socket yet → nothing to reply through
+            for (const part of chunkText(text || "(empty)", MAX_MESSAGE_LENGTH)) {
+                await conn
+                    .send(CMD_SEND, { chatid: String(chatId), msgtype: "markdown", markdown: { content: part } })
+                    .catch(() => { });
+            }
+        },
+        async sendFile(chatId, filePath) {
+            if (!conn.send)
+                return;
+            const mediaType = isImageName(filePath) ? "image" : "file";
+            try {
+                const mediaId = await uploadMedia(filePath, mediaType);
+                await conn.send(CMD_SEND, { chatid: String(chatId), msgtype: mediaType, [mediaType]: { media_id: mediaId } });
+            }
+            catch {
+                /* upload/send failed — caller surfaces a generic failure; nothing else to do */
+            }
+        },
+        async start(onMessage, signal) {
+            if (!WSImpl) {
+                console.error("hara gateway: WeCom needs Node ≥ 22 (global WebSocket). Upgrade Node.");
+                return;
+            }
+            while (!signal.aborted) {
+                await connectOnce(botId, secret, wsUrl, conn, onMessage, signal);
+                if (!signal.aborted)
+                    await sleep(3000, signal); // reconnect backoff
+            }
+        },
+    };
+}
+/** One gateway connection: open WS → `aibot_subscribe` auth → correlate request/response by req_id, dispatch
+ *  `aibot_msg_callback` events, heartbeat with `ping`. Resolves on close/abort; the caller reconnects (fresh
+ *  subscribe each time — v1 keeps it simple, no resume). */
+function connectOnce(botId, secret, wsUrl, conn, onMessage, signal) {
+    return new Promise((resolve) => {
+        const ws = new WSImpl(wsUrl);
+        let hb = null;
+        const pending = new Map();
+        const seen = new Set(); // msgid dedup within this connection (network hiccups can re-deliver)
+        const sendRaw = (frame) => {
+            try {
+                ws.send(JSON.stringify(frame));
+            }
+            catch {
+                /* socket gone — close handler resolves */
+            }
+        };
+        // Send a request and await the frame whose headers.req_id matches; times out so callers never hang.
+        const request = (cmd, body) => new Promise((res) => {
+            const reqId = `${cmd}-${randomUUID()}`;
+            const timer = setTimeout(() => {
+                pending.delete(reqId);
+                res({ errcode: -1, errmsg: "timeout" });
+            }, REQUEST_TIMEOUT_MS);
+            pending.set(reqId, { resolve: res, timer });
+            sendRaw({ cmd, headers: { req_id: reqId }, body });
+        });
+        const cleanup = () => {
+            if (hb)
+                clearInterval(hb);
+            signal.removeEventListener("abort", stop);
+            for (const { resolve: r, timer } of pending.values()) {
+                clearTimeout(timer);
+                r({ errcode: -1, errmsg: "connection closed" });
+            }
+            pending.clear();
+            if (conn.send === request)
+                conn.send = null;
+        };
+        const stop = () => {
+            cleanup();
+            try {
+                ws.close();
+            }
+            catch {
+                /* already closing */
+            }
+            resolve();
+        };
+        signal.addEventListener("abort", stop, { once: true });
+        ws.addEventListener("open", () => {
+            // Authenticate, then publish this socket's request() so send/sendFile can use it; heartbeat keeps it alive.
+            sendRaw({ cmd: CMD_SUBSCRIBE, headers: { req_id: `subscribe-${randomUUID()}` }, body: { bot_id: botId, secret } });
+            conn.send = request;
+            hb = setInterval(() => sendRaw({ cmd: CMD_PING, headers: { req_id: `ping-${randomUUID()}` }, body: {} }), HEARTBEAT_MS);
+        });
+        ws.addEventListener("close", () => {
+            cleanup();
+            resolve();
+        });
+        ws.addEventListener("error", () => { });
+        ws.addEventListener("message", async (ev) => {
+            // Native WebSocket may hand us a string, an ArrayBuffer, or a Blob — normalize to text first.
+            let raw;
+            const d = ev?.data;
+            if (typeof d === "string")
+                raw = d;
+            else if (d instanceof ArrayBuffer)
+                raw = Buffer.from(d).toString("utf8");
+            else if (typeof d?.arrayBuffer === "function")
+                raw = Buffer.from(await d.arrayBuffer()).toString("utf8");
+            else
+                raw = String(d ?? "");
+            let p;
+            try {
+                p = JSON.parse(raw);
+            }
+            catch {
+                return;
+            }
+            const cmd = String(p?.cmd ?? "");
+            const reqId = String(p?.headers?.req_id ?? "");
+            // A correlated response to one of our requests (and not itself a callback) → resolve the waiter.
+            if (reqId && pending.has(reqId) && !CALLBACK_CMDS.has(cmd)) {
+                const waiter = pending.get(reqId);
+                clearTimeout(waiter.timer);
+                pending.delete(reqId);
+                waiter.resolve(p);
+                return;
+            }
+            if (cmd === CMD_PING || cmd === CMD_EVENT_CALLBACK)
+                return; // server ping / event ack → ignore
+            if (!CALLBACK_CMDS.has(cmd))
+                return; // pre-auth / unknown frame → ignore
+            const msgId = String(p?.body?.msgid ?? reqId ?? "");
+            if (msgId) {
+                if (seen.has(msgId))
+                    return; // duplicate delivery → drop
+                seen.add(msgId);
+                if (seen.size > 1000)
+                    seen.clear();
+            }
+            const parsed = parseWecomMessage(p, botId);
+            if (parsed) {
+                for (const ref of parsed.media) {
+                    const path = await downloadWecomMedia(ref);
+                    if (path)
+                        (parsed.msg.images ??= []).push(path);
+                }
+                await onMessage(parsed.msg).catch(() => { });
+            }
+        });
+    });
+}