@nanhara/hara 0.89.0 → 0.98.0

package/dist/gateway/signal.js

@@ -0,0 +1,220 @@
+// Signal adapter for `hara gateway` — talks to a LOCAL signal-cli daemon running in HTTP/JSON-RPC mode
+// (built-in fetch, zero new dep; no WebSocket, no cloud API). The user installs signal-cli, registers/links the
+// bot's phone number, and runs `signal-cli -a <number> daemon --http localhost:8080`. Inbound is drained via the
+// JSON-RPC `receive` method on a long-poll loop (the robust zero-dep path — no SSE line-buffering quirks);
+// outbound + attachment fetch go through JSON-RPC `send`/`getAttachment`. Creds from HARA_SIGNAL_RPC_URL
+// (e.g. http://localhost:8080) + HARA_SIGNAL_NUMBER (the bot's registered phone, E.164). Same ChatAdapter shape
+// as the others, so all cross-platform gateway plumbing (send_file, system context, stuck-guard, image
+// attach/describe) works unchanged. Mirrors the Matrix long-poll model + the Discord download-media/sendFile
+// patterns, and the hermes signal.py protocol/redaction behavior.
+//
+// EXTERNAL DEPENDENCY: signal-cli is NOT bundled — it's a separate program the user installs and runs (it is the
+// only way to speak Signal's protocol; there is no official cloud API). The adapter just speaks HTTP/JSON-RPC to
+// the daemon the user has running. See setup notes at the bottom of this file.
+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));
+// E.164 phone numbers (+15551234567) anywhere in a string → +155****4567 (mirrors hermes' _redact_phone).
+const PHONE_RE = /\+[1-9]\d{6,14}/g;
+/** Redact phone numbers for logging. Keeps a 4/4 head+tail window; never logs the full E.164. (pure) */
+export function redactPhone(s) {
+    if (!s)
+        return "<none>";
+    return s.replace(PHONE_RE, (p) => (p.length <= 8 ? "****" : `${p.slice(0, 4)}****${p.slice(-4)}`));
+}
+const isImageExt = (ext) => /^\.(png|jpe?g|gif|webp)$/i.test(ext);
+/** Guess a file extension from an attachment's contentType / filename (signal-cli gives us both as hints). (pure) */
+export function attachmentExt(contentType, filename) {
+    const ct = (contentType ?? "").toLowerCase();
+    if (ct.startsWith("image/")) {
+        if (ct.includes("png"))
+            return ".png";
+        if (ct.includes("jpeg") || ct.includes("jpg"))
+            return ".jpg";
+        if (ct.includes("gif"))
+            return ".gif";
+        if (ct.includes("webp"))
+            return ".webp";
+    }
+    const fromName = (filename ?? "").toLowerCase().match(/\.(png|jpe?g|gif|webp|mp4|mp3|ogg|m4a|pdf|txt)$/);
+    if (fromName)
+        return fromName[0];
+    if (ct.startsWith("audio/"))
+        return ".ogg";
+    if (ct.startsWith("video/"))
+        return ".mp4";
+    return ".bin";
+}
+/** Sniff a file extension from magic bytes — fallback when signal-cli's base64 attachment lacks a contentType. (pure) */
+export function extFromBytes(data) {
+    if (data.length >= 4 && data[0] === 0x89 && data[1] === 0x50 && data[2] === 0x4e && data[3] === 0x47)
+        return ".png";
+    if (data.length >= 2 && data[0] === 0xff && data[1] === 0xd8)
+        return ".jpg";
+    if (data.length >= 4 && data[0] === 0x47 && data[1] === 0x49 && data[2] === 0x46 && data[3] === 0x38)
+        return ".gif";
+    if (data.length >= 12 && data[0] === 0x52 && data[1] === 0x49 && data[2] === 0x46 && data[3] === 0x46 && data[8] === 0x57 && data[9] === 0x45 && data[10] === 0x42 && data[11] === 0x50)
+        return ".webp";
+    return ".bin";
+}
+/** Parse one signal-cli envelope → InboundMsg + the image attachments to fetch (pure; the fetch/download happens in
+ *  start()). Mirrors hermes' _handle_envelope: unwraps the {envelope:{...}} shape, handles plain dataMessage + edits,
+ *  filters our own outbound + stories. Filtering of OUR OWN number is done here via `selfNumber`. Returns the msg +
+ *  the image attachment refs (only images — other media is ignored, like Telegram/Matrix). null = skip. */
+export function parseSignalMessage(raw, selfNumber) {
+    if (!raw || typeof raw !== "object")
+        return null;
+    const env = raw.envelope ?? raw; // signal-cli wraps payloads as { envelope: {...} }
+    // Stories / typing / receipts / sync echoes carry no inbound dataMessage → skip. Also skip our own outbound
+    // (syncMessage is the echo of what WE sent from another linked device — never treat it as user input).
+    if (env.syncMessage)
+        return null;
+    if (env.storyMessage)
+        return null;
+    if (env.typingMessage || env.receiptMessage)
+        return null;
+    const sender = env.sourceNumber || env.sourceUuid || env.source;
+    if (!sender)
+        return null;
+    if (selfNumber && (env.sourceNumber === selfNumber || env.source === selfNumber))
+        return null; // our own message
+    // editMessage carries its updated dataMessage nested inside (mirrors hermes).
+    const data = env.dataMessage ?? env.editMessage?.dataMessage;
+    if (!data || typeof data !== "object")
+        return null;
+    const group = data.groupInfo;
+    const groupId = group?.groupId;
+    const chatId = groupId ? `group:${groupId}` : String(sender);
+    const atts = Array.isArray(data.attachments) ? data.attachments : [];
+    const images = atts
+        .filter((a) => a?.id && (String(a.contentType ?? "").startsWith("image/") || isImageExt(attachmentExt(a?.contentType, a?.filename))))
+        .map((a) => ({ id: String(a.id), contentType: a?.contentType, filename: a?.filename }));
+    const text = typeof data.message === "string" ? data.message : "";
+    if (!text && images.length === 0)
+        return null; // no text + no image (reaction/sticker/other media) → skip
+    return {
+        msg: {
+            chatId,
+            userId: String(sender),
+            userName: env.sourceName || String(sender),
+            text: text || "[图片]",
+        },
+        images,
+    };
+}
+export function signalAdapter(rpcUrl, selfNumber) {
+    const base = rpcUrl.replace(/\/+$/, ""); // trim trailing slashes
+    let rpcSeq = 0;
+    /** One JSON-RPC 2.0 call to the signal-cli daemon. Returns `result` (any) or null on error. */
+    async function rpc(method, params, signal) {
+        const id = `${method}_${++rpcSeq}`;
+        try {
+            const res = await fetch(`${base}/api/v1/rpc`, {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                body: JSON.stringify({ jsonrpc: "2.0", method, params, id }),
+                signal,
+            });
+            if (!res.ok)
+                return null;
+            const j = (await res.json());
+            if (j.error) {
+                console.error(`hara gateway[signal]: RPC ${method} error:`, redactPhone(JSON.stringify(j.error)));
+                return null;
+            }
+            return j.result ?? null;
+        }
+        catch (e) {
+            if (signal?.aborted)
+                return null;
+            return null;
+        }
+    }
+    /** Recipient/group routing shared by send + sendFile (mirrors hermes). */
+    const target = (chatId) => {
+        const id = String(chatId);
+        return id.startsWith("group:") ? { groupId: id.slice(6) } : { recipient: [id] };
+    };
+    /** Fetch a signal-cli attachment by id (base64 over JSON-RPC) → a local path under ~/.hara/signal/media. */
+    async function downloadAttachment(ref) {
+        try {
+            const result = await rpc("getAttachment", { account: selfNumber, id: ref.id });
+            // signal-cli returns either a raw base64 string or { data: "base64..." }
+            const b64 = typeof result === "string" ? result : result && typeof result === "object" ? result.data : null;
+            if (!b64 || typeof b64 !== "string")
+                return null;
+            const bytes = Buffer.from(b64, "base64");
+            let ext = attachmentExt(ref.contentType, ref.filename);
+            if (ext === ".bin")
+                ext = extFromBytes(bytes); // last-resort magic-byte sniff
+            const dir = join(homedir(), ".hara", "signal", "media");
+            mkdirSync(dir, { recursive: true });
+            const path = join(dir, `sig_${Date.now()}_${ref.id.slice(-12)}${ext}`);
+            writeFileSync(path, bytes);
+            return path;
+        }
+        catch {
+            return null;
+        }
+    }
+    return {
+        name: "signal",
+        async send(chatId, text) {
+            for (const part of chunkText(text || "(empty)", 4000)) {
+                await rpc("send", { account: selfNumber, message: part, ...target(chatId) });
+            }
+        },
+        async sendFile(chatId, filePath) {
+            // Signal has no separate photo/document endpoints — everything is an `attachments` path on `send`.
+            // signal-cli reads the file off the local disk by path, so we just hand it the path (no upload step).
+            await rpc("send", { account: selfNumber, message: "", attachments: [filePath], ...target(chatId) }).catch(() => { });
+            // (readFileSync/basename imported for parity with the other adapters' file plumbing; signal-cli reads by path.)
+            void readFileSync;
+            void basename;
+        },
+        async start(onMessage, signal) {
+            console.error(`hara gateway[signal]: polling signal-cli daemon at ${base} as ${redactPhone(selfNumber)} (ensure \`signal-cli -a <number> daemon --http\` is running).`);
+            while (!signal.aborted) {
+                try {
+                    // JSON-RPC `receive` drains all envelopes queued since the last call. timeout is the long-poll seconds
+                    // the daemon will hold the request open waiting for new messages (server-side block → low-latency, low-spin).
+                    const result = await rpc("receive", { account: selfNumber, timeout: 30 }, signal);
+                    const envelopes = Array.isArray(result) ? result : result ? [result] : [];
+                    for (const raw of envelopes) {
+                        const parsed = parseSignalMessage(raw, selfNumber);
+                        if (!parsed)
+                            continue;
+                        for (const ref of parsed.images) {
+                            const path = await downloadAttachment(ref);
+                            if (path)
+                                (parsed.msg.images ??= []).push(path);
+                        }
+                        await onMessage(parsed.msg).catch(() => { });
+                    }
+                    if (envelopes.length === 0)
+                        await sleep(500); // daemon returned immediately (no long-poll support) → gentle spin
+                }
+                catch {
+                    if (signal.aborted)
+                        break;
+                    await sleep(2000); // daemon down / network blip → back off + retry (reconnect on drop)
+                }
+            }
+        },
+    };
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// signal-cli setup (the user does this once, OUTSIDE hara):
+//
+//   1. Install signal-cli           brew install signal-cli   (or download a release; needs a JRE)
+//   2. Register OR link the number  (a) register a NEW number:
+//                                       signal-cli -a +1555… register        # solve the captcha it prompts for
+//                                       signal-cli -a +1555… verify 123456    # the SMS code
+//                                   (b) OR link to an EXISTING phone as a secondary device:
+//                                       signal-cli link -n "hara"             # scan the QR from Signal app → Linked devices
+//   3. Run the HTTP/JSON-RPC daemon signal-cli -a +1555… daemon --http localhost:8080
+//   4. Point hara at it             HARA_SIGNAL_RPC_URL=http://localhost:8080  HARA_SIGNAL_NUMBER=+1555…
+//                                   hara gateway --platform signal
+// ─────────────────────────────────────────────────────────────────────────────

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