@paean-ai/wechat-mcp 0.1.0

package/dist/daemon/server.js

@@ -0,0 +1,565 @@
+#!/usr/bin/env node
+
+// src/daemon/server.ts
+import http from "http";
+
+// src/constants.ts
+import path from "path";
+import os from "os";
+var CHANNEL_VERSION = "0.1.0";
+var MSG_TYPE_USER = 1;
+var MSG_TYPE_BOT = 2;
+var MSG_STATE_FINISH = 2;
+var MSG_ITEM_TEXT = 1;
+var MSG_ITEM_VOICE = 3;
+var LONG_POLL_TIMEOUT_MS = 35e3;
+var SEND_TIMEOUT_MS = 15e3;
+var MAX_CONSECUTIVE_FAILURES = 3;
+var BACKOFF_DELAY_MS = 3e4;
+var RETRY_DELAY_MS = 2e3;
+var DAEMON_LONG_POLL_MS = 3e4;
+var DAEMON_HOST = "127.0.0.1";
+var CONFIG_DIR = path.join(os.homedir(), ".wechat-mcp");
+var CREDENTIALS_FILE = path.join(CONFIG_DIR, "credentials.json");
+var SYNC_BUF_FILE = path.join(CONFIG_DIR, "sync_buf.txt");
+var CONTACTS_FILE = path.join(CONFIG_DIR, "contacts.json");
+var DAEMON_PID_FILE = path.join(CONFIG_DIR, "daemon.pid");
+var DAEMON_INFO_FILE = path.join(CONFIG_DIR, "daemon.json");
+var MAX_WECHAT_MSG_LENGTH = 2048;
+var MESSAGE_QUEUE_MAX_PER_AGENT = 200;
+
+// src/credentials.ts
+import fs from "fs";
+function ensureDir() {
+  fs.mkdirSync(CONFIG_DIR, { recursive: true });
+}
+function loadCredentials() {
+  try {
+    if (!fs.existsSync(CREDENTIALS_FILE)) return null;
+    return JSON.parse(fs.readFileSync(CREDENTIALS_FILE, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function loadSyncBuf() {
+  try {
+    if (fs.existsSync(SYNC_BUF_FILE)) {
+      return fs.readFileSync(SYNC_BUF_FILE, "utf-8");
+    }
+  } catch {
+  }
+  return "";
+}
+function saveSyncBuf(buf) {
+  try {
+    ensureDir();
+    fs.writeFileSync(SYNC_BUF_FILE, buf, "utf-8");
+  } catch {
+  }
+}
+function loadContacts() {
+  try {
+    if (!fs.existsSync(CONTACTS_FILE)) return [];
+    return JSON.parse(fs.readFileSync(CONTACTS_FILE, "utf-8"));
+  } catch {
+    return [];
+  }
+}
+function saveContact(userId, contextToken) {
+  const contacts = loadContacts();
+  const displayName = userId.split("@")[0] || userId;
+  const idx = contacts.findIndex((c) => c.userId === userId);
+  const entry = {
+    userId,
+    contextToken,
+    lastSeen: (/* @__PURE__ */ new Date()).toISOString(),
+    displayName
+  };
+  if (idx >= 0) contacts[idx] = entry;
+  else contacts.push(entry);
+  try {
+    ensureDir();
+    fs.writeFileSync(CONTACTS_FILE, JSON.stringify(contacts, null, 2), "utf-8");
+  } catch {
+  }
+}
+function getContactToken(userId) {
+  const contacts = loadContacts();
+  const match = contacts.find(
+    (c) => c.userId === userId || c.displayName === userId
+  );
+  return match?.contextToken ?? null;
+}
+function saveDaemonInfo(info) {
+  ensureDir();
+  fs.writeFileSync(DAEMON_INFO_FILE, JSON.stringify(info, null, 2), "utf-8");
+}
+function removeDaemonInfo() {
+  for (const file of [DAEMON_INFO_FILE, DAEMON_PID_FILE]) {
+    try {
+      if (fs.existsSync(file)) fs.unlinkSync(file);
+    } catch {
+    }
+  }
+}
+function saveDaemonPid(pid) {
+  ensureDir();
+  fs.writeFileSync(DAEMON_PID_FILE, String(pid), "utf-8");
+}
+
+// src/wechat-api.ts
+import crypto from "crypto";
+function randomWechatUin() {
+  const uint32 = crypto.randomBytes(4).readUInt32BE(0);
+  return Buffer.from(String(uint32), "utf-8").toString("base64");
+}
+function buildHeaders(token, body) {
+  const headers = {
+    "Content-Type": "application/json",
+    AuthorizationType: "ilink_bot_token",
+    "X-WECHAT-UIN": randomWechatUin()
+  };
+  if (body) {
+    headers["Content-Length"] = String(Buffer.byteLength(body, "utf-8"));
+  }
+  if (token?.trim()) {
+    headers.Authorization = `Bearer ${token.trim()}`;
+  }
+  return headers;
+}
+function normalizeBaseUrl(baseUrl) {
+  return baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+}
+async function apiFetch(baseUrl, endpoint, body, token, timeoutMs = 15e3) {
+  const url = new URL(endpoint, normalizeBaseUrl(baseUrl)).toString();
+  const headers = buildHeaders(token, body);
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const res = await fetch(url, {
+      method: "POST",
+      headers,
+      body,
+      signal: controller.signal
+    });
+    clearTimeout(timer);
+    const text = await res.text();
+    if (!res.ok) throw new Error(`HTTP ${res.status}: ${text}`);
+    return text;
+  } catch (err) {
+    clearTimeout(timer);
+    throw err;
+  }
+}
+async function getUpdates(baseUrl, token, getUpdatesBuf) {
+  try {
+    const raw = await apiFetch(
+      baseUrl,
+      "ilink/bot/getupdates",
+      JSON.stringify({
+        get_updates_buf: getUpdatesBuf,
+        base_info: { channel_version: CHANNEL_VERSION }
+      }),
+      token,
+      LONG_POLL_TIMEOUT_MS
+    );
+    return JSON.parse(raw);
+  } catch (err) {
+    if (err instanceof Error && err.name === "AbortError") {
+      return { ret: 0, msgs: [], get_updates_buf: getUpdatesBuf };
+    }
+    throw err;
+  }
+}
+function generateClientId() {
+  return `wechat-mcp:${Date.now()}-${crypto.randomBytes(4).toString("hex")}`;
+}
+async function sendTextMessage(baseUrl, token, to, text, contextToken) {
+  const clientId = generateClientId();
+  await apiFetch(
+    baseUrl,
+    "ilink/bot/sendmessage",
+    JSON.stringify({
+      msg: {
+        from_user_id: "",
+        to_user_id: to,
+        client_id: clientId,
+        message_type: MSG_TYPE_BOT,
+        message_state: MSG_STATE_FINISH,
+        item_list: [{ type: MSG_ITEM_TEXT, text_item: { text } }],
+        context_token: contextToken
+      },
+      base_info: { channel_version: CHANNEL_VERSION }
+    }),
+    token,
+    SEND_TIMEOUT_MS
+  );
+  return clientId;
+}
+function extractTextFromMessage(msg) {
+  if (!msg.item_list?.length) return "";
+  for (const item of msg.item_list) {
+    if (item.type === MSG_ITEM_TEXT && item.text_item?.text) {
+      const text = item.text_item.text;
+      const ref = item.ref_msg;
+      if (!ref) return text;
+      const parts = [];
+      if (ref.title) parts.push(ref.title);
+      if (!parts.length) return text;
+      return `[Quote: ${parts.join(" | ")}]
+${text}`;
+    }
+    if (item.type === MSG_ITEM_VOICE && item.voice_item?.text) {
+      return item.voice_item.text;
+    }
+  }
+  return "";
+}
+
+// src/daemon/store.ts
+var DaemonStore = class {
+  agents = /* @__PURE__ */ new Map();
+  defaultAgentId = null;
+  startedAt = Date.now();
+  registerAgent(agentId, name) {
+    const existing = this.agents.get(agentId);
+    if (existing) return existing.registration;
+    const registration = {
+      agentId,
+      name: name || agentId,
+      registeredAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.agents.set(agentId, {
+      registration,
+      messages: [],
+      waiters: []
+    });
+    if (!this.defaultAgentId) {
+      this.defaultAgentId = agentId;
+    }
+    return registration;
+  }
+  unregisterAgent(agentId) {
+    const state = this.agents.get(agentId);
+    if (!state) return false;
+    for (const w of state.waiters) {
+      clearTimeout(w.timer);
+      w.resolve([]);
+    }
+    this.agents.delete(agentId);
+    if (this.defaultAgentId === agentId) {
+      const first = this.agents.keys().next();
+      this.defaultAgentId = first.done ? null : first.value;
+    }
+    return true;
+  }
+  getAgents() {
+    return Array.from(this.agents.values()).map((s) => s.registration);
+  }
+  getDefaultAgentId() {
+    return this.defaultAgentId;
+  }
+  hasAgent(agentId) {
+    return this.agents.has(agentId);
+  }
+  getUptime() {
+    return Date.now() - this.startedAt;
+  }
+  /**
+   * Push a message to a specific agent's queue.
+   * If an agent has a waiting long-poll, resolve it immediately.
+   */
+  pushMessage(agentId, message) {
+    const state = this.agents.get(agentId);
+    if (!state) return false;
+    if (state.waiters.length > 0) {
+      const waiter = state.waiters.shift();
+      clearTimeout(waiter.timer);
+      waiter.resolve([message]);
+      return true;
+    }
+    state.messages.push(message);
+    if (state.messages.length > MESSAGE_QUEUE_MAX_PER_AGENT) {
+      state.messages.shift();
+    }
+    return true;
+  }
+  /**
+   * Drain all queued messages for an agent, or wait up to timeoutMs
+   * for new ones to arrive.
+   */
+  async pollMessages(agentId, timeoutMs) {
+    const state = this.agents.get(agentId);
+    if (!state) return [];
+    if (state.messages.length > 0) {
+      const msgs = state.messages.splice(0);
+      return msgs;
+    }
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        const idx = state.waiters.findIndex((w) => w.resolve === resolve);
+        if (idx >= 0) state.waiters.splice(idx, 1);
+        resolve([]);
+      }, timeoutMs);
+      state.waiters.push({ resolve, timer });
+    });
+  }
+};
+
+// src/daemon/router.ts
+import crypto2 from "crypto";
+function parseMention(text) {
+  const trimmed = text.trimStart();
+  const match = trimmed.match(/^@(\S+)\s*([\s\S]*)$/);
+  if (!match) {
+    return { agent: null, rest: text };
+  }
+  return { agent: match[1].toLowerCase(), rest: match[2] || "" };
+}
+function routeMessage(store2, senderId, text, contextToken) {
+  const { agent, rest } = parseMention(text);
+  let targetAgent = null;
+  let strippedText = text;
+  if (agent && store2.hasAgent(agent)) {
+    targetAgent = agent;
+    strippedText = rest || text;
+  } else {
+    targetAgent = store2.getDefaultAgentId();
+    strippedText = text;
+  }
+  if (!targetAgent) return null;
+  const message = {
+    id: crypto2.randomBytes(8).toString("hex"),
+    senderId,
+    senderName: senderId.split("@")[0] || senderId,
+    text: strippedText,
+    rawText: text,
+    contextToken,
+    targetAgent,
+    timestamp: Date.now()
+  };
+  store2.pushMessage(targetAgent, message);
+  return message;
+}
+
+// src/daemon/server.ts
+var store = new DaemonStore();
+var activeAccount = null;
+var wechatConnected = false;
+function log(msg) {
+  process.stderr.write(`[wechat-mcp:daemon] ${msg}
+`);
+}
+async function readBody(req) {
+  const chunks = [];
+  for await (const chunk of req) {
+    chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+  }
+  return Buffer.concat(chunks).toString("utf-8");
+}
+function json(res, status, data) {
+  const body = JSON.stringify(data);
+  res.writeHead(status, {
+    "Content-Type": "application/json",
+    "Content-Length": Buffer.byteLength(body)
+  });
+  res.end(body);
+}
+async function handleRequest(req, res) {
+  const url = new URL(req.url || "/", `http://${DAEMON_HOST}`);
+  const method = req.method?.toUpperCase() || "GET";
+  const path2 = url.pathname;
+  try {
+    if (method === "GET" && path2 === "/health") {
+      json(res, 200, { ok: true, pid: process.pid });
+      return;
+    }
+    if (method === "GET" && path2 === "/status") {
+      const status = {
+        running: true,
+        wechatConnected,
+        accountId: activeAccount?.accountId,
+        agents: store.getAgents(),
+        uptime: store.getUptime()
+      };
+      json(res, 200, status);
+      return;
+    }
+    if (method === "POST" && path2 === "/agents") {
+      const body = JSON.parse(await readBody(req));
+      if (!body.agentId) {
+        json(res, 400, { error: "agentId required" });
+        return;
+      }
+      const reg = store.registerAgent(body.agentId, body.name);
+      log(`Agent registered: ${reg.agentId} (${reg.name})`);
+      json(res, 200, reg);
+      return;
+    }
+    if (method === "DELETE" && path2.startsWith("/agents/")) {
+      const agentId = decodeURIComponent(path2.slice("/agents/".length));
+      const removed = store.unregisterAgent(agentId);
+      if (removed) log(`Agent unregistered: ${agentId}`);
+      json(res, 200, { removed });
+      return;
+    }
+    if (method === "GET" && path2.startsWith("/messages/")) {
+      const agentId = decodeURIComponent(path2.slice("/messages/".length));
+      if (!store.hasAgent(agentId)) {
+        json(res, 404, { error: "agent not registered" });
+        return;
+      }
+      const messages = await store.pollMessages(agentId, DAEMON_LONG_POLL_MS);
+      const resp = { messages };
+      json(res, 200, resp);
+      return;
+    }
+    if (method === "POST" && path2 === "/send") {
+      const body = JSON.parse(await readBody(req));
+      if (!body.to || !body.text) {
+        json(res, 400, { success: false, error: "to and text required" });
+        return;
+      }
+      if (!activeAccount) {
+        json(res, 503, { success: false, error: "WeChat not connected" });
+        return;
+      }
+      const contextToken = getContactToken(body.to);
+      if (!contextToken) {
+        json(res, 404, {
+          success: false,
+          error: `No context token for "${body.to}". User must message the bot first.`
+        });
+        return;
+      }
+      try {
+        for (let i = 0; i < body.text.length; i += MAX_WECHAT_MSG_LENGTH) {
+          await sendTextMessage(
+            activeAccount.baseUrl,
+            activeAccount.token,
+            body.to,
+            body.text.slice(i, i + MAX_WECHAT_MSG_LENGTH),
+            contextToken
+          );
+        }
+        json(res, 200, { success: true });
+      } catch (err) {
+        json(res, 500, {
+          success: false,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+      return;
+    }
+    if (method === "GET" && path2 === "/contacts") {
+      json(res, 200, { contacts: loadContacts() });
+      return;
+    }
+    json(res, 404, { error: "not found" });
+  } catch (err) {
+    log(`HTTP error: ${err instanceof Error ? err.message : String(err)}`);
+    json(res, 500, { error: "internal error" });
+  }
+}
+async function startPolling(account) {
+  let buf = loadSyncBuf();
+  let failures = 0;
+  if (buf) log(`Restored sync state (${buf.length} bytes)`);
+  log("Listening for WeChat messages...");
+  wechatConnected = true;
+  while (true) {
+    try {
+      const resp = await getUpdates(account.baseUrl, account.token, buf);
+      const isError = resp.ret !== void 0 && resp.ret !== 0 || resp.errcode !== void 0 && resp.errcode !== 0;
+      if (isError) {
+        failures++;
+        log(`getUpdates error: ret=${resp.ret} errcode=${resp.errcode} errmsg=${resp.errmsg ?? ""}`);
+        if (failures >= MAX_CONSECUTIVE_FAILURES) {
+          wechatConnected = false;
+          failures = 0;
+          await new Promise((r) => setTimeout(r, BACKOFF_DELAY_MS));
+        } else {
+          await new Promise((r) => setTimeout(r, RETRY_DELAY_MS));
+        }
+        continue;
+      }
+      failures = 0;
+      wechatConnected = true;
+      if (resp.get_updates_buf) {
+        buf = resp.get_updates_buf;
+        saveSyncBuf(buf);
+      }
+      for (const msg of resp.msgs ?? []) {
+        if (msg.message_type !== MSG_TYPE_USER) continue;
+        const text = extractTextFromMessage(msg);
+        if (!text) continue;
+        const senderId = msg.from_user_id ?? "unknown";
+        const contextToken = msg.context_token ?? "";
+        if (contextToken) {
+          saveContact(senderId, contextToken);
+        }
+        const routed = routeMessage(store, senderId, text, contextToken);
+        if (routed) {
+          log(`Message routed: from=${senderId} agent=${routed.targetAgent} text="${text.slice(0, 50)}..."`);
+        } else {
+          log(`Message dropped (no agents): from=${senderId} text="${text.slice(0, 50)}..."`);
+        }
+      }
+    } catch (err) {
+      failures++;
+      log(`Poll error: ${err instanceof Error ? err.message : String(err)}`);
+      if (failures >= MAX_CONSECUTIVE_FAILURES) {
+        wechatConnected = false;
+        failures = 0;
+        await new Promise((r) => setTimeout(r, BACKOFF_DELAY_MS));
+      } else {
+        await new Promise((r) => setTimeout(r, RETRY_DELAY_MS));
+      }
+    }
+  }
+}
+async function startDaemon() {
+  const account = loadCredentials();
+  if (!account) {
+    log("No credentials found. Run `wechat-mcp setup` first.");
+    process.exit(1);
+  }
+  activeAccount = account;
+  const server = http.createServer((req, res) => {
+    handleRequest(req, res).catch(() => {
+      if (!res.headersSent) json(res, 500, { error: "internal error" });
+    });
+  });
+  await new Promise((resolve, reject) => {
+    server.listen(0, DAEMON_HOST, () => resolve());
+    server.on("error", reject);
+  });
+  const addr = server.address();
+  if (!addr || typeof addr === "string") {
+    log("Failed to get server address");
+    process.exit(1);
+  }
+  const port = addr.port;
+  saveDaemonPid(process.pid);
+  saveDaemonInfo({ pid: process.pid, port, startedAt: (/* @__PURE__ */ new Date()).toISOString() });
+  log(`Daemon running on ${DAEMON_HOST}:${port} (PID ${process.pid})`);
+  log(`Account: ${account.accountId}`);
+  const cleanup = () => {
+    log("Shutting down...");
+    removeDaemonInfo();
+    server.close();
+    process.exit(0);
+  };
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+  startPolling(account).catch((err) => {
+    log(`Fatal polling error: ${err instanceof Error ? err.message : String(err)}`);
+    cleanup();
+  });
+}
+if (process.argv[1] && (process.argv[1].endsWith("daemon/server.js") || process.argv[1].endsWith("daemon/server.ts"))) {
+  startDaemon();
+}
+export {
+  startDaemon
+};