@seqyuan/annovibe 0.8.41 → 0.8.54

package/bin/annovibe-im-gateway.js

@@ -0,0 +1,675 @@
+#!/usr/bin/env node
+/**
+ * Annovibe IM Gateway — Standalone process that bridges WeCom bots to the
+ * Annovibe Next.js server.
+ *
+ * Usage: node bin/annovibe-im-gateway.js
+ *
+ * Reads project IM configs from localhost:PORT/api/im/projects,
+ * connects each enabled bot to WeCom WebSocket, and routes
+ * incoming messages through /api/im/turn (SSE streaming with delta push).
+ *
+ * Auto-started by annovibe supervisor; can also run standalone for debugging.
+ */
+"use strict";
+
+const fs = require("fs");
+const http = require("http");
+const https = require("https");
+const os = require("os");
+const path = require("path");
+const crypto = require("crypto");
+const WebSocket = require("ws");
+
+const REVISION_DIGITS = ["\u200b", "\u200c", "\u200d", "\u2060", "\ufeff"];
+const REVISION_SUFFIX_PATTERN = /[\u200b\u200c\u200d\u2060\ufeff]+$/u;
+
+// ── Cancel command vocabulary ───────────────────────────────────────
+
+const IM_CANCEL_COMMANDS = new Set([
+  "取消", "停止", "终止", "cancel", "stop", "abort",
+]);
+
+function normalizeImCancelText(text) {
+  return text.trim()
+    .replace(REVISION_SUFFIX_PATTERN, "")
+    .replace(/[\u200b\u200c\u200d\u2060\ufeff\u00ad\ufe00-\ufe0f]/g, "")
+    .trim().toLowerCase().replace(/\s+/g, "");
+}
+
+function isImCancelCommand(text) {
+  return IM_CANCEL_COMMANDS.has(normalizeImCancelText(text));
+}
+
+// ── Reply text cleanup ──────────────────────────────────────────────
+
+const SHOW_WIDGET_FENCE_RE = /```\s*show-widget[\s\S]*?```/gi;
+const SHOW_WIDGET_PARTIAL_RE = /```\s*show-widget[\s\S]*$/;
+
+function cleanImReplyText(text) {
+  let cleaned = String(text || "").replace(SHOW_WIDGET_FENCE_RE, "");
+  cleaned = cleaned.replace(SHOW_WIDGET_PARTIAL_RE, "");
+  cleaned = cleaned.replace(/\n{3,}/g, "\n\n").trim();
+  return cleaned;
+}
+
+// ── Config ──────────────────────────────────────────────────────────
+
+function envFirst(...names) {
+  for (const name of names) {
+    const value = process.env[name];
+    if (value !== undefined && value !== "") return value;
+  }
+  return undefined;
+}
+
+function getAgentDir() {
+  return envFirst("PI_AGENT_DIR") ?? path.join(os.homedir(), ".pi", "agent");
+}
+
+function readAnnovibeState() {
+  const statePath = path.join(getAgentDir(), "annovibe.json");
+  try {
+    return JSON.parse(fs.readFileSync(statePath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function getAnnovibePort() {
+  const state = readAnnovibeState();
+  if (state?.port) return String(state.port);
+  return envFirst("ANNOVIBE_PORT", "PORT") ?? "30141";
+}
+
+function getBaseUrl() {
+  return `http://127.0.0.1:${getAnnovibePort()}`;
+}
+
+function readGatewayToken() {
+  const statePath = path.join(getAgentDir(), "im", "gateway.json");
+  try {
+    const state = JSON.parse(fs.readFileSync(statePath, "utf8"));
+    return typeof state.token === "string" ? state.token.trim() : "";
+  } catch {
+    return "";
+  }
+}
+
+// ── HTTP helpers ────────────────────────────────────────────────────
+
+function getToken() {
+  return process.env.ANNOVIBE_GATEWAY_TOKEN?.trim() || readGatewayToken();
+}
+
+function requestJson(method, pathname, body) {
+  const url = new URL(pathname, getBaseUrl());
+  const payload = body === undefined ? undefined : JSON.stringify(body);
+  const lib = url.protocol === "https:" ? https : http;
+  const token = getToken();
+
+  return new Promise((resolve, reject) => {
+    const req = lib.request(
+      url,
+      {
+        method,
+        headers: {
+          ...(payload ? { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(payload) } : {}),
+          ...(token ? { Authorization: `Bearer ${token}` } : {}),
+        },
+      },
+      (res) => {
+        let data = "";
+        res.setEncoding("utf8");
+        res.on("data", (chunk) => { data += chunk; });
+        res.on("end", () => {
+          let parsed;
+          try { parsed = data ? JSON.parse(data) : {}; } catch (e) {
+            reject(new Error(`Invalid JSON: ${String(e)}`));
+            return;
+          }
+          if (res.statusCode >= 400) {
+            const msg = parsed.error || parsed.reply || `HTTP ${res.statusCode}`;
+            reject(new Error(formatImApiError(res.statusCode, msg)));
+            return;
+          }
+          resolve(parsed);
+        });
+      },
+    );
+    req.on("error", reject);
+    if (payload) req.write(payload);
+    req.end();
+  });
+}
+
+function formatImApiError(statusCode, message) {
+  if (statusCode === 401) {
+    return `${message}. Ensure annovibe is running in this Linux account and gateway token is synced (restart annovibe-im-gateway after saving IM settings).`;
+  }
+  if (statusCode === 403) {
+    return `${message}. annovibe-im-gateway must reach annovibe on localhost.`;
+  }
+  return message;
+}
+
+/**
+ * Consume SSE turn stream, yielding deltas and status changes to callbacks.
+ */
+function requestImTurnStream(body, callbacks) {
+  const url = new URL("/api/im/turn", getBaseUrl());
+  const payload = JSON.stringify(body);
+  const lib = url.protocol === "https:" ? https : http;
+  const token = getToken();
+
+  return new Promise((resolve, reject) => {
+    const req = lib.request(
+      url,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Content-Length": Buffer.byteLength(payload),
+          Accept: "text/event-stream",
+          ...(token ? { Authorization: `Bearer ${token}` } : {}),
+        },
+      },
+      (res) => {
+        if (res.statusCode >= 400) {
+          let data = "";
+          res.setEncoding("utf8");
+          res.on("data", (chunk) => { data += chunk; });
+          res.on("end", () => {
+            let parsed;
+            try { parsed = data ? JSON.parse(data) : {}; } catch { parsed = { error: data }; }
+            reject(new Error(parsed.error || parsed.reply || `HTTP ${res.statusCode}`));
+          });
+          return;
+        }
+
+        let buffer = "";
+        let doneEvent = null;
+
+        res.on("data", (chunk) => {
+          buffer += chunk;
+          const parts = buffer.split("\n\n");
+          buffer = parts.pop() || "";
+          for (const part of parts) {
+            for (const line of part.split("\n")) {
+              if (!line.startsWith("data: ")) continue;
+              try {
+                const event = JSON.parse(line.slice(6));
+                if (!event) continue;
+                if (event.type === "done") {
+                  doneEvent = event;
+                } else if (event.type === "delta" && callbacks.onDelta) {
+                  callbacks.onDelta(event.text);
+                } else if (event.type === "status" && callbacks.onStatus) {
+                  callbacks.onStatus(event.phase);
+                }
+              } catch { /* ignore malformed frames */ }
+            }
+          }
+        });
+
+        res.on("end", () => {
+          if (doneEvent) {
+            resolve(doneEvent);
+          } else {
+            resolve({ type: "done", ok: false, reply: "No response from agent" });
+          }
+        });
+
+        res.on("error", reject);
+      },
+    );
+    req.on("error", reject);
+    req.write(payload);
+    req.end();
+  });
+}
+
+// ── WeCom helpers ───────────────────────────────────────────────────
+
+function encodeRevision(revision) {
+  const base = REVISION_DIGITS.length;
+  let remaining = Math.max(1, revision);
+  let encoded = "";
+  while (remaining > 0) {
+    const digit = remaining % base;
+    encoded += REVISION_DIGITS[digit];
+    remaining = Math.floor(remaining / base);
+  }
+  return encoded;
+}
+
+function applyRevisionSuffix(text, revision) {
+  return text + encodeRevision(revision);
+}
+
+function stripRevisionSuffix(text) {
+  return text.replace(REVISION_SUFFIX_PATTERN, "");
+}
+
+function shouldAcceptGroupMessage(message, requireMention) {
+  if (!message.chatId) return true;  // DM, always accept
+  if (!requireMention) return true;  // group chat, mention not required
+  return message.mentionedBot;       // group chat, mention required
+}
+
+// ── WeCom WebSocket client ──────────────────────────────────────────
+
+class WeComWsClient {
+  constructor(options) {
+    this.options = options;
+    this.ws = null;
+    this.heartbeatTimer = null;
+    this.pendingAcks = new Map();
+    this.authenticated = createDeferred();
+  }
+
+  get isConnected() {
+    return this.ws?.readyState === WebSocket.OPEN;
+  }
+
+  async connect() {
+    if (this.isConnected) return;
+
+    await new Promise((resolve, reject) => {
+      const ws = new WebSocket(this.options.wsUrl || "wss://openws.work.weixin.qq.com");
+      this.ws = ws;
+      ws.once("open", () => resolve());
+      ws.once("error", (err) => reject(err));
+      ws.on("error", () => undefined);
+      ws.on("message", (raw) => { void this.handleFrame(String(raw)); });
+      ws.on("close", () => {
+        this.stopHeartbeat();
+        this.rejectPendingAcks(new Error("wecom websocket closed"));
+      });
+    });
+
+    await this.sendFrame({
+      cmd: "aibot_subscribe",
+      headers: { req_id: `aibot_subscribe_${Date.now()}` },
+      body: { bot_id: this.options.botId, secret: this.options.botSecret },
+    });
+  }
+
+  async waitAuthenticated(timeoutMs = 10000) {
+    const timer = setTimeout(() => {
+      this.authenticated.reject(new Error("wecom authentication timeout"));
+    }, timeoutMs);
+    try {
+      await this.authenticated.promise;
+      return true;
+    } catch { return false; }
+    finally { clearTimeout(timer); }
+  }
+
+  async replyStream(reqId, streamId, content, finish) {
+    await this.sendFrame({
+      cmd: "aibot_respond_msg",
+      headers: { req_id: reqId },
+      body: { msgtype: "stream", stream: { id: streamId, content, finish } },
+    });
+    if (!finish) return;
+    await new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.pendingAcks.delete(reqId);
+        reject(new Error(`wecom reply ack timeout for ${reqId}`));
+      }, 5000);
+      this.pendingAcks.set(reqId, { resolve, reject, timeout });
+    }).catch(() => undefined);
+  }
+
+  async disconnect() {
+    this.stopHeartbeat();
+    this.rejectPendingAcks(new Error("wecom websocket disconnected"));
+    if (!this.ws) return;
+    const ws = this.ws;
+    this.ws = null;
+    await new Promise((resolve) => {
+      ws.once("close", () => resolve());
+      ws.close();
+    });
+  }
+
+  async handleFrame(frameText) {
+    const frame = JSON.parse(frameText);
+    const reqId = frame.headers?.req_id?.trim();
+
+    if (reqId && this.pendingAcks.has(reqId)) {
+      const pending = this.pendingAcks.get(reqId);
+      if (pending) {
+        this.pendingAcks.delete(reqId);
+        clearTimeout(pending.timeout);
+        if ((frame.errcode ?? 0) !== 0) {
+          pending.reject(new Error(frame.errmsg || "wecom reply ack failed"));
+        } else {
+          pending.resolve();
+        }
+      }
+      return;
+    }
+
+    if (reqId?.startsWith("aibot_subscribe_")) {
+      if ((frame.errcode ?? 0) !== 0) {
+        this.authenticated.reject(new Error(frame.errmsg || "wecom authentication failed"));
+        return;
+      }
+      this.authenticated.resolve();
+      this.startHeartbeat();
+      return;
+    }
+
+    if (reqId?.startsWith("ping_")) return;
+
+    if (frame.cmd === "aibot_msg_callback" || frame.cmd === "aibot_event_callback") {
+      await this.options.onMessage(frame);
+    }
+  }
+
+  startHeartbeat() {
+    this.stopHeartbeat();
+    const intervalMs = this.options.heartbeatIntervalMs ?? 30000;
+    this.heartbeatTimer = setInterval(() => {
+      void this.sendFrame({
+        cmd: "ping",
+        headers: { req_id: `ping_${Date.now()}` },
+      }).catch(() => undefined);
+    }, intervalMs);
+  }
+
+  stopHeartbeat() {
+    if (!this.heartbeatTimer) return;
+    clearInterval(this.heartbeatTimer);
+    this.heartbeatTimer = null;
+  }
+
+  async sendFrame(frame) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      throw new Error("wecom websocket not connected");
+    }
+    this.ws.send(JSON.stringify(frame));
+  }
+
+  rejectPendingAcks(error) {
+    for (const [reqId, pending] of this.pendingAcks) {
+      this.pendingAcks.delete(reqId);
+      clearTimeout(pending.timeout);
+      pending.reject(error);
+    }
+  }
+}
+
+function createDeferred() {
+  let resolve, reject;
+  const promise = new Promise((res, rej) => { resolve = res; reject = rej; });
+  return { promise, resolve, reject };
+}
+
+// ── Inbound message extraction ──────────────────────────────────────
+
+function extractInboundMessage(frame) {
+  const reqId = frame.headers?.req_id?.trim();
+  const body = frame.body;
+  if (!reqId || !body || body.msgtype !== "text") return null;
+
+  const from = body.from;
+  const rawUserId = typeof from?.userid === "string" ? from.userid.trim() : "";
+  const textBody = body.text;
+  let content = typeof textBody?.content === "string" ? textBody.content.trim() : "";
+  if (!rawUserId || !content) return null;
+
+  const chatId = (typeof body.chat_id === "string" ? body.chat_id : null) ||
+    (typeof body.room_id === "string" ? body.room_id : null) || null;
+
+  let mentionedBot = false;
+  if (chatId) {
+    const mentions = content.match(/<@[^>]+>\s*/g);
+    if (mentions && mentions.length > 0) {
+      mentionedBot = true;
+      content = content.replace(/<@[^>]+>\s*/g, "").trim();
+    }
+    if (!content) return null;
+  }
+
+  return { reqId, userId: rawUserId, chatId, content, mentionedBot };
+}
+
+// ── Project bridge ──────────────────────────────────────────────────
+
+class ProjectWeComBridge {
+  constructor(project) {
+    this.project = project;
+    this.client = null;
+    this.stopped = false;
+    this.reconnectTimer = null;
+  }
+
+  async start() {
+    if (this.stopped) return;
+    const secret = this.project.botSecret;
+    if (!secret) {
+      console.error(`[im] missing bot secret for ${this.project.cwd}`);
+      this.scheduleReconnect(30000);
+      return;
+    }
+
+    this.client = new WeComWsClient({
+      botId: this.project.botId,
+      botSecret: secret,
+      onMessage: (frame) => this.handleFrame(frame),
+    });
+
+    try {
+      await this.client.connect();
+      const ok = await this.client.waitAuthenticated();
+      if (!ok) throw new Error("wecom authentication failed");
+      console.error(`[im] connected project ${this.project.cwd} bot ${this.project.botId}`);
+    } catch (error) {
+      console.error(`[im] connect failed for ${this.project.cwd}: ${String(error)}`);
+      await this.client?.disconnect().catch(() => undefined);
+      this.client = null;
+      this.scheduleReconnect(10000);
+    }
+  }
+
+  scheduleReconnect(delayMs) {
+    if (this.stopped || this.reconnectTimer) return;
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      void this.start();
+    }, delayMs);
+  }
+
+  async stop() {
+    this.stopped = true;
+    if (this.reconnectTimer) clearTimeout(this.reconnectTimer);
+    await this.client?.disconnect().catch(() => undefined);
+    this.client = null;
+  }
+
+  async handleFrame(frame) {
+    const message = extractInboundMessage(frame);
+    if (!message) return;
+
+    // Group message filtering — respect requireMentionInGroup config
+    if (!shouldAcceptGroupMessage(message, this.project.requireMentionInGroup)) return;
+
+    // ── Cancel command intercept ──
+    if (isImCancelCommand(message.content)) {
+      const reqId = message.reqId;
+      try {
+        const result = await requestJson("POST", "/api/im/cancel", {
+          cwd: this.project.cwd,
+          userId: message.userId,
+        });
+        const text = typeof result.reply === "string" && result.reply.trim()
+          ? result.reply.trim()
+          : (result.cancelled ? "已取消当前任务。" : "当前没有可取消的任务。");
+        if (this.client?.isConnected) {
+          const streamId = `${reqId}-cancel-${Date.now()}`;
+          await this.client.replyStream(reqId, streamId, text, true);
+        }
+      } catch (error) {
+        console.error(`[im] cancel failed for ${this.project.cwd} user ${message.userId}: ${String(error)}`);
+        if (this.client?.isConnected) {
+          const streamId = `${reqId}-cancel-${Date.now()}`;
+          await this.client.replyStream(reqId, streamId, `Error: ${String(error)}`, true);
+        }
+      }
+      return;
+    }
+
+    // ── Normal turn with streaming ──
+    const reqId = message.reqId;
+    const streamId = `${reqId}-stream`;
+    let revision = 0;
+    const startedAt = Date.now();
+    let refreshTimer = null;
+    let toolsRunning = false;
+    let lastText = "";
+
+    const pushText = async (text) => {
+      revision += 1;
+      if (this.client?.isConnected) {
+        await this.client.replyStream(reqId, streamId, applyRevisionSuffix(text, revision), false).catch(() => undefined);
+      }
+    };
+
+    const finishText = async (text) => {
+      revision += 1;
+      if (this.client?.isConnected) {
+        await this.client.replyStream(reqId, streamId, applyRevisionSuffix(text, revision), true).catch(() => undefined);
+      }
+    };
+
+    try {
+      // Start processing
+      await pushText("(working 1s)");
+
+      refreshTimer = setInterval(() => {
+        if (toolsRunning) {
+          const elapsed = Math.max(1, Math.floor((Date.now() - startedAt) / 1000));
+          void pushText(`(working ${elapsed}s)`).catch(() => undefined);
+        }
+      }, 5000);
+
+      const result = await requestImTurnStream(
+        { cwd: this.project.cwd, userId: message.userId, message: message.content, chatId: message.chatId },
+        {
+          onStatus(phase) {
+            toolsRunning = phase === "running_tools" || phase === "waiting_model";
+          },
+          onDelta(text) {
+            toolsRunning = false;
+            lastText = text;
+            // Schedule push — debounced by WeCom rate limits via replyStream
+            void pushText(text).catch(() => undefined);
+          },
+        },
+      );
+
+      if (refreshTimer) clearInterval(refreshTimer);
+
+      const rawReply = typeof result.reply === "string" && result.reply.trim()
+        ? result.reply.trim()
+        : "No reply from annovibe.";
+      const cleaned = cleanImReplyText(lastText || rawReply);
+      const finishTextStr = cleaned || "No reply from annovibe.";
+      await finishText(finishTextStr);
+    } catch (error) {
+      if (refreshTimer) clearInterval(refreshTimer);
+      await finishText(`Error: ${error.message}`);
+    }
+  }
+}
+
+class ImGateway {
+  constructor() {
+    this.bridges = new Map();
+    this.pollTimer = null;
+    this.stopped = false;
+  }
+
+  async start() {
+    console.error("[im] Annovibe IM Gateway starting...");
+
+    // Write gateway state
+    const imDir = path.join(getAgentDir(), "im");
+    try { fs.mkdirSync(imDir, { recursive: true }); } catch {}
+    const token = crypto.randomBytes(32).toString("hex");
+    fs.writeFileSync(
+      path.join(imDir, "gateway.json"),
+      JSON.stringify({
+        token,
+        startedAt: new Date().toISOString(),
+        pid: process.pid,
+      }, null, 2),
+    );
+
+    console.error(`[im] Gateway token: ${token.slice(0, 8)}...`);
+    console.error(`[im] Annovibe port: ${getAnnovibePort()}`);
+
+    // Start config poll
+    await this.refreshProjects();
+    this.pollTimer = setInterval(() => this.refreshProjects(), 30000);
+  }
+
+  async refreshProjects() {
+    if (this.stopped) return;
+    try {
+      const data = await requestJson("GET", "/api/im/projects");
+      const projects = data.projects || [];
+      const activeCwds = new Set();
+
+      for (const project of projects) {
+        if (!project.cwd || !project.botId) continue;
+        activeCwds.add(project.cwd);
+
+        const bridge = this.bridges.get(project.cwd);
+        if (bridge) {
+          bridge.project = project;
+        } else {
+          const newBridge = new ProjectWeComBridge(project);
+          this.bridges.set(project.cwd, newBridge);
+          void newBridge.start();
+        }
+      }
+
+      for (const [cwd, bridge] of this.bridges) {
+        if (activeCwds.has(cwd)) continue;
+        await bridge.stop();
+        this.bridges.delete(cwd);
+      }
+    } catch (error) {
+      console.error(`[im] Failed to poll projects: ${error.message}`);
+    }
+  }
+
+  async stop() {
+    this.stopped = true;
+    if (this.pollTimer) clearInterval(this.pollTimer);
+    for (const bridge of this.bridges.values()) {
+      await bridge.stop();
+    }
+    this.bridges.clear();
+
+    try {
+      const statePath = path.join(getAgentDir(), "im", "gateway.json");
+      fs.writeFileSync(statePath, JSON.stringify({ token: "" }, null, 2));
+    } catch {}
+  }
+}
+
+// ── Main ────────────────────────────────────────────────────────────
+
+const gateway = new ImGateway();
+
+process.on("SIGINT", () => { void gateway.stop().then(() => process.exit(0)); });
+process.on("SIGTERM", () => { void gateway.stop().then(() => process.exit(0)); });
+
+void gateway.start();
+
+setInterval(() => {}, 60000);