@paean-ai/wechat-mcp 0.1.0 → 0.2.0

package/dist/cli.js

@@ -48,7 +48,7 @@ var init_constants = __esm({
   "src/constants.ts"() {
     "use strict";
     PACKAGE_NAME = "@paean-ai/wechat-mcp";
-    PACKAGE_VERSION = "0.1.0";
+    PACKAGE_VERSION = "0.2.0";
     DEFAULT_BASE_URL = "https://ilinkai.weixin.qq.com";
     BOT_TYPE = "3";
     CHANNEL_VERSION = "0.1.0";
@@ -522,22 +522,30 @@ var init_client = __esm({
       async status() {
         return this.request("GET", "/status");
       }
-      async registerAgent(agentId, name) {
-        return this.request("POST", "/agents", { agentId, name });
+      async registerAgent(agentId, name, mode, gatewayUrl, gatewayType) {
+        return this.request("POST", "/agents", {
+          agentId,
+          name,
+          mode,
+          gatewayUrl,
+          gatewayType
+        });
       }
       async unregisterAgent(agentId) {
         return this.request("DELETE", `/agents/${encodeURIComponent(agentId)}`);
       }
       /**
        * Long-poll for messages intended for this agent.
-       * Will block up to ~30s on the daemon side.
+       * Will block up to ~30s on the daemon side by default.
+       * Pass a custom timeoutMs for shorter waits (e.g. 500 for non-blocking read).
        */
-      async pollMessages(agentId) {
+      async pollMessages(agentId, clientTimeoutMs) {
+        const path3 = clientTimeoutMs !== void 0 ? `/messages/${encodeURIComponent(agentId)}?timeout=${clientTimeoutMs}` : `/messages/${encodeURIComponent(agentId)}`;
         const resp = await this.request(
           "GET",
-          `/messages/${encodeURIComponent(agentId)}`,
+          path3,
           void 0,
-          35e3
+          Math.max(clientTimeoutMs ?? 35e3, 35e3)
         );
         return resp.messages;
       }
@@ -567,8 +575,9 @@ function log(msg) {
   process.stderr.write(`[wechat-mcp:mcp] ${msg}
 `);
 }
-async function startMcpServer(agentId) {
-  log(`Starting MCP server for agent "${agentId}"...`);
+async function startMcpServer(opts) {
+  const { agentId, mode, gatewayUrl, gatewayType } = opts;
+  log(`Starting MCP server for agent "${agentId}" (mode=${mode})...`);
   let daemonInfo;
   try {
     daemonInfo = await ensureDaemon();
@@ -579,30 +588,46 @@ async function startMcpServer(agentId) {
   }
   const client = new DaemonClient(daemonInfo.port);
   try {
-    await client.registerAgent(agentId, agentId);
-    log(`Registered as agent "${agentId}"`);
+    await client.registerAgent(agentId, agentId, mode, gatewayUrl, gatewayType);
+    log(`Registered as agent "${agentId}" mode=${mode}`);
   } catch (err) {
     log(`Failed to register agent: ${err instanceof Error ? err.message : String(err)}`);
     process.exit(1);
   }
+  const instructions = [
+    `You are connected to WeChat via the wechat-mcp middleware (agent: "${agentId}", mode: ${mode}).`
+  ];
+  if (mode === "channel") {
+    instructions.push(
+      "Incoming WeChat messages arrive as channel notifications from this server.",
+      "Use the wechat_send tool to reply. Pass the sender_id from the incoming message."
+    );
+  } else if (mode === "poll") {
+    instructions.push(
+      "Use the wechat_read_messages tool to check for new incoming WeChat messages.",
+      "Use the wechat_send tool to reply. Pass the sender_id from the message.",
+      "Check for new messages periodically \u2014 they queue up until you read them."
+    );
+  } else if (mode === "gateway") {
+    instructions.push(
+      "The daemon automatically bridges incoming WeChat messages to your HTTP endpoint.",
+      "Use wechat_send to send proactive messages (not replies to incoming ones)."
+    );
+  }
+  instructions.push(
+    "Messages are from real WeChat users. Respond in Chinese unless the user writes in another language.",
+    "Keep replies concise \u2014 WeChat is a chat app. Strip markdown formatting (WeChat doesn't render it)."
+  );
+  const capabilities = { tools: {} };
+  if (mode === "channel") {
+    capabilities.experimental = { "claude/channel": {} };
+  }
   const mcp = new Server(
     { name: PACKAGE_NAME, version: PACKAGE_VERSION },
-    {
-      capabilities: {
-        tools: {}
-      },
-      instructions: [
-        `You are connected to WeChat via the wechat-mcp middleware (agent: "${agentId}").`,
-        "Incoming WeChat messages arrive as notifications from this server.",
-        "Use the wechat_send tool to reply. You MUST pass the sender_id from the incoming message.",
-        "Messages are from real WeChat users. Respond in Chinese unless the user writes in another language.",
-        "Keep replies concise \u2014 WeChat is a chat app. Strip markdown formatting (WeChat doesn't render it).",
-        "Use wechat_get_contacts to see who has messaged before."
-      ].join("\n")
-    }
+    { capabilities, instructions: instructions.join("\n") }
   );
-  mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
-    tools: [
+  mcp.setRequestHandler(ListToolsRequestSchema, async () => {
+    const tools = [
       {
         name: "wechat_send",
         description: "Send a text message to a WeChat user via the shared WeChat connection",
@@ -637,8 +662,19 @@ async function startMcpServer(agentId) {
           properties: {}
         }
       }
-    ]
-  }));
+    ];
+    if (mode === "poll") {
+      tools.push({
+        name: "wechat_read_messages",
+        description: "Read pending WeChat messages addressed to this agent. Returns immediately with any queued messages (does not block).",
+        inputSchema: {
+          type: "object",
+          properties: {}
+        }
+      });
+    }
+    return { tools };
+  });
   mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
     const { name, arguments: args } = req.params;
     if (name === "wechat_send") {
@@ -673,7 +709,7 @@ async function startMcpServer(agentId) {
     if (name === "wechat_get_status") {
       try {
         const status = await client.status();
-        const agentList = status.agents.map((a) => `  - ${a.name} (${a.agentId})`).join("\n");
+        const agentList = status.agents.map((a) => `  - ${a.name} (${a.agentId}) [${a.mode}]${a.gatewayUrl ? ` \u2192 ${a.gatewayUrl}` : ""}`).join("\n");
         const text = [
           `WeChat connected: ${status.wechatConnected ? "yes" : "no"}`,
           `Account: ${status.accountId || "N/A"}`,
@@ -686,48 +722,60 @@ ${agentList || "  (none)"}`
         return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }] };
       }
     }
+    if (name === "wechat_read_messages") {
+      try {
+        const messages = await client.pollMessages(agentId, 500);
+        if (messages.length === 0) {
+          return { content: [{ type: "text", text: "No new messages." }] };
+        }
+        const formatted = messages.map(
+          (m) => `[${new Date(m.timestamp).toLocaleTimeString()}] ${m.senderName} (${m.senderId}): ${m.text}`
+        ).join("\n\n");
+        return { content: [{ type: "text", text: formatted }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }] };
+      }
+    }
     throw new Error(`Unknown tool: ${name}`);
   });
   const transport = new StdioServerTransport();
   await mcp.connect(transport);
   log("MCP connection ready");
-  const pollLoop = async () => {
-    while (true) {
-      try {
-        const messages = await client.pollMessages(agentId);
-        for (const msg of messages) {
-          log(`Forwarding message: from=${msg.senderId} text="${msg.text.slice(0, 50)}..."`);
-          try {
-            await mcp.notification({
-              method: "notifications/message",
-              params: {
-                level: "info",
-                data: {
-                  type: "wechat_message",
-                  sender: msg.senderName,
-                  sender_id: msg.senderId,
-                  text: msg.text,
-                  raw_text: msg.rawText,
-                  timestamp: msg.timestamp
+  if (mode === "channel") {
+    const pollLoop = async () => {
+      while (true) {
+        try {
+          const messages = await client.pollMessages(agentId);
+          for (const msg of messages) {
+            log(`Channel push: from=${msg.senderId} text="${msg.text.slice(0, 50)}..."`);
+            try {
+              await mcp.notification({
+                method: "notifications/claude/channel",
+                params: {
+                  content: msg.text,
+                  meta: {
+                    sender: msg.senderName,
+                    sender_id: msg.senderId
+                  }
                 }
-              }
-            });
-          } catch {
-            log(`Notification delivery failed for message ${msg.id}`);
+              });
+            } catch {
+              log(`Channel notification delivery failed for message ${msg.id}`);
+            }
           }
+        } catch (err) {
+          const errMsg = err instanceof Error ? err.message : String(err);
+          if (!errMsg.includes("ECONNREFUSED")) {
+            log(`Poll error: ${errMsg}`);
+          }
+          await new Promise((r) => setTimeout(r, 5e3));
         }
-      } catch (err) {
-        const errMsg = err instanceof Error ? err.message : String(err);
-        if (!errMsg.includes("ECONNREFUSED")) {
-          log(`Poll error: ${errMsg}`);
-        }
-        await new Promise((r) => setTimeout(r, 5e3));
       }
-    }
-  };
-  pollLoop().catch((err) => {
-    log(`Fatal poll error: ${err instanceof Error ? err.message : String(err)}`);
-  });
+    };
+    pollLoop().catch((err) => {
+      log(`Fatal poll error: ${err instanceof Error ? err.message : String(err)}`);
+    });
+  }
   const cleanup = async () => {
     try {
       await client.unregisterAgent(agentId);
@@ -757,18 +805,22 @@ var init_store = __esm({
       agents = /* @__PURE__ */ new Map();
       defaultAgentId = null;
       startedAt = Date.now();
-      registerAgent(agentId, name) {
+      registerAgent(agentId, name, mode = "poll", gatewayUrl, gatewayType) {
         const existing = this.agents.get(agentId);
         if (existing) return existing.registration;
         const registration = {
           agentId,
           name: name || agentId,
+          mode,
+          gatewayUrl,
+          gatewayType,
           registeredAt: (/* @__PURE__ */ new Date()).toISOString()
         };
         this.agents.set(agentId, {
           registration,
           messages: [],
-          waiters: []
+          waiters: [],
+          conversationIds: /* @__PURE__ */ new Map()
         });
         if (!this.defaultAgentId) {
           this.defaultAgentId = agentId;
@@ -792,6 +844,9 @@ var init_store = __esm({
       getAgents() {
         return Array.from(this.agents.values()).map((s) => s.registration);
       }
+      getAgent(agentId) {
+        return this.agents.get(agentId)?.registration ?? null;
+      }
       getDefaultAgentId() {
         return this.defaultAgentId;
       }
@@ -801,6 +856,12 @@ var init_store = __esm({
       getUptime() {
         return Date.now() - this.startedAt;
       }
+      getConversationId(agentId, senderId) {
+        return this.agents.get(agentId)?.conversationIds.get(senderId);
+      }
+      setConversationId(agentId, senderId, convId) {
+        this.agents.get(agentId)?.conversationIds.set(senderId, convId);
+      }
       /**
        * Push a message to a specific agent's queue.
        * If an agent has a waiting long-poll, resolve it immediately.
@@ -854,6 +915,18 @@ function parseMention(text) {
   }
   return { agent: match[1].toLowerCase(), rest: match[2] || "" };
 }
+function buildMessage(senderId, text, rawText, contextToken, targetAgent) {
+  return {
+    id: crypto2.randomBytes(8).toString("hex"),
+    senderId,
+    senderName: senderId.split("@")[0] || senderId,
+    text,
+    rawText,
+    contextToken,
+    targetAgent,
+    timestamp: Date.now()
+  };
+}
 function routeMessage(store2, senderId, text, contextToken) {
   const { agent, rest } = parseMention(text);
   let targetAgent = null;
@@ -866,16 +939,11 @@ function routeMessage(store2, senderId, text, contextToken) {
     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()
-  };
+  const message = buildMessage(senderId, strippedText, text, contextToken, targetAgent);
+  const reg = store2.getAgent(targetAgent);
+  if (reg?.mode === "gateway") {
+    return message;
+  }
   store2.pushMessage(targetAgent, message);
   return message;
 }
@@ -885,6 +953,109 @@ var init_router = __esm({
   }
 });
 
+// src/daemon/adapters.ts
+async function readSSEStream(body, handler) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split("\n");
+    buffer = lines.pop() || "";
+    for (const line of lines) {
+      handler(line);
+    }
+  }
+}
+function getAdapter(type) {
+  switch (type) {
+    case "openai":
+      return openaiAdapter;
+    case "claw":
+    default:
+      return clawAdapter;
+  }
+}
+var clawAdapter, openaiAdapter;
+var init_adapters = __esm({
+  "src/daemon/adapters.ts"() {
+    "use strict";
+    clawAdapter = {
+      name: "claw",
+      async send(gatewayUrl, message, signal, conversationId) {
+        const url = `${gatewayUrl.replace(/\/$/, "")}/api/chat`;
+        const body = { message };
+        if (conversationId) body.conversationId = conversationId;
+        const res = await fetch(url, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(body),
+          signal
+        });
+        if (!res.ok || !res.body) {
+          throw new Error(`Gateway error: HTTP ${res.status}`);
+        }
+        let fullContent = "";
+        let returnedConversationId;
+        await readSSEStream(res.body, (line) => {
+          if (!line.startsWith("data: ")) return;
+          try {
+            const event = JSON.parse(line.slice(6));
+            switch (event.type) {
+              case "start":
+                if (event.conversationId) returnedConversationId = event.conversationId;
+                break;
+              case "content":
+                fullContent += event.text || "";
+                break;
+              case "done":
+                if (event.content && !fullContent) fullContent = event.content;
+                break;
+            }
+          } catch {
+          }
+        });
+        return { content: fullContent, conversationId: returnedConversationId };
+      }
+    };
+    openaiAdapter = {
+      name: "openai",
+      async send(gatewayUrl, message, signal) {
+        const url = `${gatewayUrl.replace(/\/$/, "")}/v1/chat/completions`;
+        const res = await fetch(url, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            model: "default",
+            messages: [{ role: "user", content: message }],
+            stream: true
+          }),
+          signal
+        });
+        if (!res.ok || !res.body) {
+          throw new Error(`Gateway error: HTTP ${res.status}`);
+        }
+        let fullContent = "";
+        await readSSEStream(res.body, (line) => {
+          const trimmed = line.trim();
+          if (!trimmed.startsWith("data: ") || trimmed === "data: [DONE]") return;
+          try {
+            const chunk = JSON.parse(trimmed.slice(6));
+            const delta = chunk.choices?.[0]?.delta;
+            if (delta?.content) {
+              fullContent += delta.content;
+            }
+          } catch {
+          }
+        });
+        return { content: fullContent };
+      }
+    };
+  }
+});
+
 // src/daemon/server.ts
 var server_exports2 = {};
 __export(server_exports2, {
@@ -936,8 +1107,19 @@ async function handleRequest(req, res) {
         json(res, 400, { error: "agentId required" });
         return;
       }
-      const reg = store.registerAgent(body.agentId, body.name);
-      log2(`Agent registered: ${reg.agentId} (${reg.name})`);
+      const mode = body.mode || "poll";
+      if (mode === "gateway" && !body.gatewayUrl) {
+        json(res, 400, { error: "gatewayUrl required for gateway mode" });
+        return;
+      }
+      const reg = store.registerAgent(
+        body.agentId,
+        body.name,
+        mode,
+        body.gatewayUrl,
+        body.gatewayType
+      );
+      log2(`Agent registered: ${reg.agentId} (${reg.name}) mode=${reg.mode}${reg.gatewayUrl ? ` gateway=${reg.gatewayUrl}` : ""}`);
       json(res, 200, reg);
       return;
     }
@@ -1006,6 +1188,58 @@ async function handleRequest(req, res) {
     json(res, 500, { error: "internal error" });
   }
 }
+async function bridgeToGateway(agentId, senderId, text, contextToken) {
+  const reg = store.getAgent(agentId);
+  if (!reg?.gatewayUrl) {
+    log2(`Gateway bridge failed: no gatewayUrl for ${agentId}`);
+    return;
+  }
+  const adapter = getAdapter(reg.gatewayType || "claw");
+  const conversationId = store.getConversationId(agentId, senderId);
+  log2(`Gateway bridge: ${agentId} \u2192 ${reg.gatewayUrl} (${adapter.name})`);
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 12e4);
+    const result = await adapter.send(
+      reg.gatewayUrl,
+      text,
+      controller.signal,
+      conversationId
+    );
+    clearTimeout(timeout);
+    if (result.conversationId) {
+      store.setConversationId(agentId, senderId, result.conversationId);
+    }
+    if (result.content && activeAccount && contextToken) {
+      const preview = result.content.length > 80 ? result.content.slice(0, 80) + "..." : result.content;
+      log2(`Gateway response: ${agentId} \u2192 ${senderId}: "${preview}"`);
+      for (let i = 0; i < result.content.length; i += MAX_WECHAT_MSG_LENGTH) {
+        await sendTextMessage(
+          activeAccount.baseUrl,
+          activeAccount.token,
+          senderId,
+          result.content.slice(i, i + MAX_WECHAT_MSG_LENGTH),
+          contextToken
+        );
+      }
+    }
+  } catch (err) {
+    const errMsg = err instanceof Error ? err.message : String(err);
+    log2(`Gateway bridge error for ${agentId}: ${errMsg}`);
+    if (activeAccount && contextToken) {
+      try {
+        await sendTextMessage(
+          activeAccount.baseUrl,
+          activeAccount.token,
+          senderId,
+          `[${agentId}] Error: ${errMsg}`,
+          contextToken
+        );
+      } catch {
+      }
+    }
+  }
+}
 async function startPolling(account) {
   let buf = loadSyncBuf();
   let failures = 0;
@@ -1046,6 +1280,12 @@ async function startPolling(account) {
         const routed = routeMessage(store, senderId, text, contextToken);
         if (routed) {
           log2(`Message routed: from=${senderId} agent=${routed.targetAgent} text="${text.slice(0, 50)}..."`);
+          const reg = routed.targetAgent ? store.getAgent(routed.targetAgent) : null;
+          if (reg?.mode === "gateway") {
+            bridgeToGateway(routed.targetAgent, senderId, routed.text, contextToken).catch((err) => {
+              log2(`Gateway bridge async error: ${err instanceof Error ? err.message : String(err)}`);
+            });
+          }
         } else {
           log2(`Message dropped (no agents): from=${senderId} text="${text.slice(0, 50)}..."`);
         }
@@ -1111,6 +1351,7 @@ var init_server2 = __esm({
     init_wechat_api();
     init_store();
     init_router();
+    init_adapters();
     store = new DaemonStore();
     activeAccount = null;
     wechatConnected = false;
@@ -1199,7 +1440,28 @@ WeChat connected successfully!`);
         console.log(`  Account ID: ${account.accountId}`);
         console.log(`  User ID:    ${account.userId ?? "N/A"}
 `);
-        console.log("Add this to any agent's MCP config to connect:");
+        console.log("Add this to any agent's MCP config to connect:\n");
+        console.log(`  Claude Code (channel mode \u2014 messages arrive automatically):`);
+        console.log(`  {`);
+        console.log(`    "mcpServers": {`);
+        console.log(`      "wechat": {`);
+        console.log(`        "command": "npx",`);
+        console.log(`        "args": ["@paean-ai/wechat-mcp", "serve", "--agent", "claude", "--mode", "channel"]`);
+        console.log(`      }`);
+        console.log(`    }`);
+        console.log(`  }
+`);
+        console.log(`  OpenClaw / other agents (gateway mode \u2014 auto-bridges to HTTP endpoint):`);
+        console.log(`  {`);
+        console.log(`    "mcpServers": {`);
+        console.log(`      "wechat": {`);
+        console.log(`        "command": "npx",`);
+        console.log(`        "args": ["@paean-ai/wechat-mcp", "serve", "--agent", "openclaw", "--mode", "gateway", "--gateway-url", "http://localhost:3000"]`);
+        console.log(`      }`);
+        console.log(`    }`);
+        console.log(`  }
+`);
+        console.log(`  Generic agent (poll mode \u2014 agent calls wechat_read_messages tool):`);
         console.log(`  {`);
         console.log(`    "mcpServers": {`);
         console.log(`      "wechat": {`);
@@ -1216,14 +1478,29 @@ WeChat connected successfully!`);
   console.error("\nLogin timed out. Please try again.");
   process.exit(1);
 });
-program.command("serve").description("Start MCP stdio server for an agent (used in MCP config)").requiredOption("-a, --agent <id>", "Agent identifier (e.g. claude, openclaw, paean)").action(async (opts) => {
+program.command("serve").description("Start MCP stdio server for an agent (used in MCP config)").requiredOption("-a, --agent <id>", "Agent identifier (e.g. claude, openclaw, paean)").option("-m, --mode <mode>", "Message delivery mode: channel, gateway, or poll (default: poll)", "poll").option("--gateway-url <url>", "Agent's HTTP endpoint URL (required for gateway mode)").option("--gateway-type <type>", "Gateway protocol: claw or openai (default: claw)", "claw").action(async (opts) => {
   const { loadCredentials: loadCredentials2 } = await Promise.resolve().then(() => (init_credentials(), credentials_exports));
   if (!loadCredentials2()) {
     process.stderr.write("No WeChat credentials. Run `wechat-mcp setup` first.\n");
     process.exit(1);
   }
+  const mode = opts.mode;
+  if (!["channel", "gateway", "poll"].includes(mode)) {
+    process.stderr.write(`Invalid mode "${opts.mode}". Must be: channel, gateway, or poll
+`);
+    process.exit(1);
+  }
+  if (mode === "gateway" && !opts.gatewayUrl) {
+    process.stderr.write("--gateway-url is required when --mode=gateway\n");
+    process.exit(1);
+  }
   const { startMcpServer: startMcpServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
-  await startMcpServer2(opts.agent);
+  await startMcpServer2({
+    agentId: opts.agent,
+    mode,
+    gatewayUrl: opts.gatewayUrl,
+    gatewayType: opts.gatewayType
+  });
 });
 program.command("daemon").description("Start the daemon process in foreground (usually auto-started)").action(async () => {
   const { startDaemon: startDaemon2 } = await Promise.resolve().then(() => (init_server2(), server_exports2));
@@ -1267,7 +1544,9 @@ program.command("status").description("Show daemon and WeChat connection status"
       if (status.agents.length > 0) {
         console.log(`  Agents:`);
         for (const a of status.agents) {
-          console.log(`    - ${a.name} (${a.agentId})`);
+          const modeStr = a.mode ? ` [${a.mode}]` : "";
+          const gwStr = a.gatewayUrl ? ` \u2192 ${a.gatewayUrl}` : "";
+          console.log(`    - ${a.name} (${a.agentId})${modeStr}${gwStr}`);
         }
       } else {
         console.log(`  Agents:     (none)`);