@paean-ai/claude-code-wechat 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-present Paean AI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,130 @@
+# @paean-ai/claude-code-wechat
+
+Bridge WeChat messages into [Claude Code](https://docs.anthropic.com/en/docs/claude-code) sessions.
+
+This plugin connects WeChat (via the official ClawBot ilink API) to Claude Code's [Channels](https://docs.anthropic.com/en/docs/claude-code) MCP protocol, so you can chat with Claude Code directly from WeChat.
+
+```
+WeChat (iOS) --> ClawBot --> ilink API --> [this plugin] --> Claude Code
+                                                   |
+Claude Code <-- MCP Channel Protocol <-- wechat_reply tool
+```
+
+## Prerequisites
+
+- [Node.js](https://nodejs.org/) >= 18 (or [Bun](https://bun.sh) >= 1.0)
+- [Claude Code](https://docs.anthropic.com/en/docs/claude-code) >= 2.1.80
+- A Claude.ai account (API key auth is not supported)
+- WeChat iOS (latest version with ClawBot support)
+
+## Installation
+
+Install globally with your preferred package manager:
+
+```bash
+# npm
+npm install -g @paean-ai/claude-code-wechat
+
+# bun
+bun add -g @paean-ai/claude-code-wechat
+
+# pnpm
+pnpm add -g @paean-ai/claude-code-wechat
+```
+
+## Quick Start
+
+### 1. Setup (one-time)
+
+Authenticate with WeChat and register the MCP server:
+
+```bash
+claude-wechat setup
+```
+
+This will:
+- Display a QR code in your terminal
+- Wait for you to scan it with WeChat
+- Save credentials to `~/.claude/channels/wechat/account.json`
+- Register the channel server with Claude Code
+
+### 2. Start
+
+Launch Claude Code with the WeChat channel:
+
+```bash
+claude-wechat
+```
+
+That's it! Open WeChat, find the ClawBot conversation, and start chatting. Messages will appear in your Claude Code terminal, and Claude's replies will be sent back to WeChat automatically.
+
+## CLI Reference
+
+| Command | Description |
+|---|---|
+| `claude-wechat setup` | Authenticate with WeChat via QR code and register the MCP server |
+| `claude-wechat start` | Launch Claude Code with the WeChat channel (default command) |
+| `claude-wechat status` | Show current login and configuration status |
+| `claude-wechat logout` | Remove saved credentials and unregister MCP server |
+| `claude-wechat --help` | Show help |
+| `claude-wechat --version` | Show version |
+
+### Options
+
+`claude-wechat setup --force` — Skip the confirmation prompt when re-authenticating.
+
+## How It Works
+
+1. **Authentication**: The `setup` command uses WeChat's ClawBot QR code login flow (`ilink/bot/get_bot_qrcode` + `get_qrcode_status`) to obtain a bearer token.
+
+2. **Message Receiving**: The channel server long-polls `ilink/bot/getupdates` for incoming WeChat messages and forwards them to Claude Code as MCP channel notifications.
+
+3. **Message Sending**: Claude Code uses the `wechat_reply` tool (exposed via MCP) to send replies back through `ilink/bot/sendmessage`.
+
+4. **MCP Integration**: The server implements Claude Code's experimental Channels protocol, registering as a `wechat` channel with tool capabilities.
+
+## Configuration
+
+Credentials are stored at:
+
+```
+~/.claude/channels/wechat/account.json
+```
+
+The file has `0600` permissions (owner-readable only). No credentials are stored in the package itself.
+
+## Programmatic Usage
+
+The package also exports its core API for advanced use cases:
+
+```typescript
+import {
+  loadCredentials,
+  fetchQRCode,
+  pollQRStatus,
+  sendTextMessage,
+} from "@paean-ai/claude-code-wechat";
+```
+
+## Notes
+
+- This is a **research preview** feature. The `--dangerously-load-development-channels` flag is required by Claude Code for channel plugins.
+- The Claude Code session and WeChat channel share the same lifecycle — closing Claude Code disconnects the channel.
+- WeChat ClawBot currently supports iOS only.
+- Each ClawBot instance can connect to one agent at a time.
+
+## Troubleshooting
+
+**"Claude Code CLI not found"** — Make sure `claude` is installed and available in your PATH. See [Claude Code docs](https://docs.anthropic.com/en/docs/claude-code).
+
+**QR code expired** — The QR code is valid for ~8 minutes. Run `claude-wechat setup` again to get a fresh one.
+
+**Messages not arriving** — Check `claude-wechat status` to verify credentials and MCP registration. Try `claude-wechat logout` followed by `claude-wechat setup` to re-authenticate.
+
+## License
+
+[MIT](LICENSE)
+
+## Disclaimer
+
+"Claude" and "Claude Code" are trademarks of Anthropic, PBC. "WeChat" (微信) is a trademark of Tencent Holdings Limited. This project is not affiliated with, endorsed by, or sponsored by Anthropic or Tencent. It is an independent open-source community project.

package/dist/channel.js

@@ -0,0 +1,448 @@
+#!/usr/bin/env node
+
+// src/channel.ts
+import "fs";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  ListToolsRequestSchema,
+  CallToolRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+
+// src/constants.ts
+import path from "path";
+var CHANNEL_NAME = "wechat";
+var CHANNEL_VERSION = "0.1.0";
+var DEFAULT_BASE_URL = "https://ilinkai.weixin.qq.com";
+var BOT_TYPE = "3";
+var CREDENTIALS_DIR = path.join(
+  process.env.HOME || "~",
+  ".claude",
+  "channels",
+  "wechat"
+);
+var CREDENTIALS_FILE = path.join(CREDENTIALS_DIR, "account.json");
+var SYNC_BUF_FILE = path.join(CREDENTIALS_DIR, "sync_buf.txt");
+var LONG_POLL_TIMEOUT_MS = 35e3;
+var MAX_CONSECUTIVE_FAILURES = 3;
+var BACKOFF_DELAY_MS = 3e4;
+var RETRY_DELAY_MS = 2e3;
+var QR_POLL_TIMEOUT_MS = 35e3;
+var SEND_TIMEOUT_MS = 15e3;
+var MSG_TYPE_USER = 1;
+var MSG_ITEM_TEXT = 1;
+var MSG_ITEM_VOICE = 3;
+var MSG_TYPE_BOT = 2;
+var MSG_STATE_FINISH = 2;
+
+// src/credentials.ts
+import fs from "fs";
+function loadCredentials() {
+  try {
+    if (!fs.existsSync(CREDENTIALS_FILE)) return null;
+    return JSON.parse(fs.readFileSync(CREDENTIALS_FILE, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function saveCredentials(data) {
+  fs.mkdirSync(CREDENTIALS_DIR, { recursive: true });
+  fs.writeFileSync(CREDENTIALS_FILE, JSON.stringify(data, null, 2), "utf-8");
+  try {
+    fs.chmodSync(CREDENTIALS_FILE, 384);
+  } catch {
+  }
+}
+function loadSyncBuf() {
+  try {
+    if (fs.existsSync(SYNC_BUF_FILE)) {
+      return fs.readFileSync(SYNC_BUF_FILE, "utf-8");
+    }
+  } catch {
+  }
+  return "";
+}
+function saveSyncBuf(buf) {
+  try {
+    fs.mkdirSync(CREDENTIALS_DIR, { recursive: true });
+    fs.writeFileSync(SYNC_BUF_FILE, buf, "utf-8");
+  } catch {
+  }
+}
+
+// src/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(params) {
+  const url = new URL(params.endpoint, normalizeBaseUrl(params.baseUrl)).toString();
+  const headers = buildHeaders(params.token, params.body);
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), params.timeoutMs);
+  try {
+    const res = await fetch(url, {
+      method: "POST",
+      headers,
+      body: params.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 fetchQRCode(baseUrl) {
+  const url = new URL(
+    `ilink/bot/get_bot_qrcode?bot_type=${encodeURIComponent(BOT_TYPE)}`,
+    normalizeBaseUrl(baseUrl)
+  );
+  const res = await fetch(url.toString());
+  if (!res.ok) throw new Error(`QR fetch failed: ${res.status}`);
+  return await res.json();
+}
+async function pollQRStatus(baseUrl, qrcode) {
+  const url = new URL(
+    `ilink/bot/get_qrcode_status?qrcode=${encodeURIComponent(qrcode)}`,
+    normalizeBaseUrl(baseUrl)
+  );
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), QR_POLL_TIMEOUT_MS);
+  try {
+    const res = await fetch(url.toString(), {
+      headers: { "iLink-App-ClientVersion": "1" },
+      signal: controller.signal
+    });
+    clearTimeout(timer);
+    if (!res.ok) throw new Error(`QR status failed: ${res.status}`);
+    return await res.json();
+  } catch (err) {
+    clearTimeout(timer);
+    if (err instanceof Error && err.name === "AbortError") {
+      return { status: "wait" };
+    }
+    throw err;
+  }
+}
+async function getUpdates(baseUrl, token, getUpdatesBuf) {
+  try {
+    const raw = await apiFetch({
+      baseUrl,
+      endpoint: "ilink/bot/getupdates",
+      body: JSON.stringify({
+        get_updates_buf: getUpdatesBuf,
+        base_info: { channel_version: CHANNEL_VERSION }
+      }),
+      token,
+      timeoutMs: 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 `claude-wechat:${Date.now()}-${crypto.randomBytes(4).toString("hex")}`;
+}
+async function sendTextMessage(baseUrl, token, to, text, contextToken) {
+  const clientId = generateClientId();
+  await apiFetch({
+    baseUrl,
+    endpoint: "ilink/bot/sendmessage",
+    body: 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,
+    timeoutMs: 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/logger.ts
+var PREFIX = "[claude-wechat]";
+function log(msg) {
+  process.stderr.write(`${PREFIX} ${msg}
+`);
+}
+function logError(msg) {
+  process.stderr.write(`${PREFIX} ERROR: ${msg}
+`);
+}
+
+// src/channel.ts
+var contextTokenCache = /* @__PURE__ */ new Map();
+async function doQRLogin(baseUrl) {
+  log("Fetching WeChat login QR code...");
+  const qrResp = await fetchQRCode(baseUrl);
+  log("\nScan the QR code below with WeChat:\n");
+  try {
+    const qrterm = await import("qrcode-terminal");
+    await new Promise((resolve) => {
+      qrterm.default.generate(
+        qrResp.qrcode_img_content,
+        { small: true },
+        (qr) => {
+          process.stderr.write(qr + "\n");
+          resolve();
+        }
+      );
+    });
+  } catch {
+    log(`QR code URL: ${qrResp.qrcode_img_content}`);
+  }
+  log("Waiting for scan...");
+  const deadline = Date.now() + 48e4;
+  let scannedLogged = false;
+  while (Date.now() < deadline) {
+    const status = await pollQRStatus(baseUrl, qrResp.qrcode);
+    switch (status.status) {
+      case "wait":
+        break;
+      case "scaned":
+        if (!scannedLogged) {
+          log("Scanned! Please confirm on your phone...");
+          scannedLogged = true;
+        }
+        break;
+      case "expired":
+        log("QR code expired. Please restart.");
+        return null;
+      case "confirmed": {
+        if (!status.ilink_bot_id || !status.bot_token) {
+          logError("Login confirmed but server did not return bot info");
+          return null;
+        }
+        const account = {
+          token: status.bot_token,
+          baseUrl: status.baseurl || baseUrl,
+          accountId: status.ilink_bot_id,
+          userId: status.ilink_user_id,
+          savedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        saveCredentials(account);
+        log("WeChat connected successfully!");
+        return account;
+      }
+    }
+    await new Promise((r) => setTimeout(r, 1e3));
+  }
+  log("Login timed out");
+  return null;
+}
+var mcp = new Server(
+  { name: CHANNEL_NAME, version: CHANNEL_VERSION },
+  {
+    capabilities: {
+      experimental: { "claude/channel": {} },
+      tools: {}
+    },
+    instructions: [
+      `Messages from WeChat users arrive as <channel source="wechat" sender="..." sender_id="...">`,
+      "Reply using the wechat_reply tool. You MUST pass the sender_id from the inbound tag.",
+      "Messages are from real WeChat users via the WeChat ClawBot interface.",
+      "Respond naturally in Chinese unless the user writes in another language.",
+      "Keep replies concise \u2014 WeChat is a chat app, not an essay platform.",
+      "Strip markdown formatting (WeChat doesn't render it). Use plain text."
+    ].join("\n")
+  }
+);
+mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: [
+    {
+      name: "wechat_reply",
+      description: "Send a text reply back to the WeChat user",
+      inputSchema: {
+        type: "object",
+        properties: {
+          sender_id: {
+            type: "string",
+            description: "The sender_id from the inbound <channel> tag (xxx@im.wechat format)"
+          },
+          text: {
+            type: "string",
+            description: "The plain-text message to send (no markdown)"
+          }
+        },
+        required: ["sender_id", "text"]
+      }
+    }
+  ]
+}));
+var activeAccount = null;
+mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
+  if (req.params.name === "wechat_reply") {
+    const { sender_id, text } = req.params.arguments;
+    if (!activeAccount) {
+      return {
+        content: [{ type: "text", text: "error: not logged in" }]
+      };
+    }
+    const contextToken = contextTokenCache.get(sender_id);
+    if (!contextToken) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `error: no context_token for ${sender_id}. The user may need to send a message first.`
+          }
+        ]
+      };
+    }
+    try {
+      await sendTextMessage(
+        activeAccount.baseUrl,
+        activeAccount.token,
+        sender_id,
+        text,
+        contextToken
+      );
+      return { content: [{ type: "text", text: "sent" }] };
+    } catch (err) {
+      return {
+        content: [
+          { type: "text", text: `send failed: ${String(err)}` }
+        ]
+      };
+    }
+  }
+  throw new Error(`unknown tool: ${req.params.name}`);
+});
+async function startPolling(account) {
+  const { baseUrl, token } = account;
+  let getUpdatesBuf = loadSyncBuf();
+  let consecutiveFailures = 0;
+  if (getUpdatesBuf) {
+    log(`Restored sync state (${getUpdatesBuf.length} bytes)`);
+  }
+  log("Listening for WeChat messages...");
+  while (true) {
+    try {
+      const resp = await getUpdates(baseUrl, token, getUpdatesBuf);
+      const isError = resp.ret !== void 0 && resp.ret !== 0 || resp.errcode !== void 0 && resp.errcode !== 0;
+      if (isError) {
+        consecutiveFailures++;
+        logError(
+          `getUpdates failed: ret=${resp.ret} errcode=${resp.errcode} errmsg=${resp.errmsg ?? ""}`
+        );
+        if (consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {
+          logError(
+            `${MAX_CONSECUTIVE_FAILURES} consecutive failures, backing off ${BACKOFF_DELAY_MS / 1e3}s`
+          );
+          consecutiveFailures = 0;
+          await new Promise((r) => setTimeout(r, BACKOFF_DELAY_MS));
+        } else {
+          await new Promise((r) => setTimeout(r, RETRY_DELAY_MS));
+        }
+        continue;
+      }
+      consecutiveFailures = 0;
+      if (resp.get_updates_buf) {
+        getUpdatesBuf = resp.get_updates_buf;
+        saveSyncBuf(getUpdatesBuf);
+      }
+      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";
+        if (msg.context_token) {
+          contextTokenCache.set(senderId, msg.context_token);
+        }
+        log(`Message received: from=${senderId} text=${text.slice(0, 50)}...`);
+        await mcp.notification({
+          method: "notifications/claude/channel",
+          params: {
+            content: text,
+            meta: {
+              sender: senderId.split("@")[0] || senderId,
+              sender_id: senderId
+            }
+          }
+        });
+      }
+    } catch (err) {
+      consecutiveFailures++;
+      logError(`Poll error: ${String(err)}`);
+      if (consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {
+        consecutiveFailures = 0;
+        await new Promise((r) => setTimeout(r, BACKOFF_DELAY_MS));
+      } else {
+        await new Promise((r) => setTimeout(r, RETRY_DELAY_MS));
+      }
+    }
+  }
+}
+async function main() {
+  await mcp.connect(new StdioServerTransport());
+  log("MCP connection ready");
+  let account = loadCredentials();
+  if (!account) {
+    log("No saved credentials found, starting QR login...");
+    account = await doQRLogin(DEFAULT_BASE_URL);
+    if (!account) {
+      logError("Login failed, exiting.");
+      process.exit(1);
+    }
+  } else {
+    log(`Using saved account: ${account.accountId}`);
+  }
+  activeAccount = account;
+  await startPolling(account);
+}
+main().catch((err) => {
+  logError(`Fatal: ${String(err)}`);
+  process.exit(1);
+});

package/dist/cli.js

@@ -0,0 +1,312 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { execFileSync, execSync } from "child_process";
+import "fs";
+import path2 from "path";
+import { fileURLToPath } from "url";
+import { Command } from "commander";
+
+// src/constants.ts
+import path from "path";
+var CHANNEL_VERSION = "0.1.0";
+var DEFAULT_BASE_URL = "https://ilinkai.weixin.qq.com";
+var BOT_TYPE = "3";
+var CREDENTIALS_DIR = path.join(
+  process.env.HOME || "~",
+  ".claude",
+  "channels",
+  "wechat"
+);
+var CREDENTIALS_FILE = path.join(CREDENTIALS_DIR, "account.json");
+var SYNC_BUF_FILE = path.join(CREDENTIALS_DIR, "sync_buf.txt");
+var QR_LOGIN_TIMEOUT_MS = 48e4;
+var QR_POLL_TIMEOUT_MS = 35e3;
+
+// src/credentials.ts
+import fs from "fs";
+function loadCredentials() {
+  try {
+    if (!fs.existsSync(CREDENTIALS_FILE)) return null;
+    return JSON.parse(fs.readFileSync(CREDENTIALS_FILE, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function saveCredentials(data) {
+  fs.mkdirSync(CREDENTIALS_DIR, { recursive: true });
+  fs.writeFileSync(CREDENTIALS_FILE, JSON.stringify(data, null, 2), "utf-8");
+  try {
+    fs.chmodSync(CREDENTIALS_FILE, 384);
+  } catch {
+  }
+}
+function removeCredentials() {
+  try {
+    if (fs.existsSync(CREDENTIALS_FILE)) fs.unlinkSync(CREDENTIALS_FILE);
+  } catch {
+  }
+  try {
+    if (fs.existsSync(SYNC_BUF_FILE)) fs.unlinkSync(SYNC_BUF_FILE);
+  } catch {
+  }
+}
+
+// src/api.ts
+import crypto from "crypto";
+function normalizeBaseUrl(baseUrl) {
+  return baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+}
+async function fetchQRCode(baseUrl) {
+  const url = new URL(
+    `ilink/bot/get_bot_qrcode?bot_type=${encodeURIComponent(BOT_TYPE)}`,
+    normalizeBaseUrl(baseUrl)
+  );
+  const res = await fetch(url.toString());
+  if (!res.ok) throw new Error(`QR fetch failed: ${res.status}`);
+  return await res.json();
+}
+async function pollQRStatus(baseUrl, qrcode) {
+  const url = new URL(
+    `ilink/bot/get_qrcode_status?qrcode=${encodeURIComponent(qrcode)}`,
+    normalizeBaseUrl(baseUrl)
+  );
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), QR_POLL_TIMEOUT_MS);
+  try {
+    const res = await fetch(url.toString(), {
+      headers: { "iLink-App-ClientVersion": "1" },
+      signal: controller.signal
+    });
+    clearTimeout(timer);
+    if (!res.ok) throw new Error(`QR status failed: ${res.status}`);
+    return await res.json();
+  } catch (err) {
+    clearTimeout(timer);
+    if (err instanceof Error && err.name === "AbortError") {
+      return { status: "wait" };
+    }
+    throw err;
+  }
+}
+
+// src/cli.ts
+var __dirname = path2.dirname(fileURLToPath(import.meta.url));
+function getServerBinPath() {
+  return path2.resolve(__dirname, "channel.js");
+}
+function claudeAvailable() {
+  try {
+    execSync("claude --version", { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isMcpServerRegistered() {
+  try {
+    const output = execSync("claude mcp get wechat", {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    return output.includes("wechat");
+  } catch {
+    return false;
+  }
+}
+function registerMcpServer() {
+  const serverPath = getServerBinPath();
+  try {
+    execSync("claude mcp remove wechat --scope user", {
+      stdio: "ignore"
+    });
+  } catch {
+  }
+  execFileSync("claude", [
+    "mcp",
+    "add",
+    "--scope",
+    "user",
+    "wechat",
+    "--",
+    "node",
+    serverPath
+  ], { stdio: "inherit" });
+}
+function unregisterMcpServer() {
+  try {
+    execSync("claude mcp remove wechat --scope user", { stdio: "inherit" });
+  } catch {
+  }
+}
+async function doInteractiveQRLogin() {
+  console.log("Fetching WeChat login QR code...\n");
+  const qrResp = await fetchQRCode(DEFAULT_BASE_URL);
+  try {
+    const qrterm = await import("qrcode-terminal");
+    await new Promise((resolve) => {
+      qrterm.default.generate(
+        qrResp.qrcode_img_content,
+        { small: true },
+        (qr) => {
+          console.log(qr);
+          resolve();
+        }
+      );
+    });
+  } catch {
+    console.log(`Open this URL to scan: ${qrResp.qrcode_img_content}
+`);
+  }
+  console.log("Scan the QR code above with WeChat...\n");
+  const deadline = Date.now() + QR_LOGIN_TIMEOUT_MS;
+  let scannedPrinted = false;
+  while (Date.now() < deadline) {
+    const status = await pollQRStatus(DEFAULT_BASE_URL, qrResp.qrcode);
+    switch (status.status) {
+      case "wait":
+        process.stdout.write(".");
+        break;
+      case "scaned":
+        if (!scannedPrinted) {
+          console.log("\nScanned! Please confirm on your phone...");
+          scannedPrinted = true;
+        }
+        break;
+      case "expired":
+        console.error("\nQR code expired. Please run setup again.");
+        return null;
+      case "confirmed": {
+        if (!status.ilink_bot_id || !status.bot_token) {
+          console.error("\nLogin failed: server did not return complete info.");
+          return null;
+        }
+        const account = {
+          token: status.bot_token,
+          baseUrl: status.baseurl || DEFAULT_BASE_URL,
+          accountId: status.ilink_bot_id,
+          userId: status.ilink_user_id,
+          savedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        saveCredentials(account);
+        return account;
+      }
+    }
+    await new Promise((r) => setTimeout(r, 1e3));
+  }
+  console.error("\nLogin timed out. Please try again.");
+  return null;
+}
+async function setupCommand(opts) {
+  if (!claudeAvailable()) {
+    console.error("Error: Claude Code CLI not found. Please install it first:");
+    console.error("  https://docs.anthropic.com/en/docs/claude-code");
+    process.exit(1);
+  }
+  const existing = loadCredentials();
+  if (existing && !opts.force) {
+    console.log(`Existing account found: ${existing.accountId}`);
+    console.log(`Saved at: ${existing.savedAt}`);
+    console.log();
+    const readline = await import("readline");
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const answer = await new Promise((resolve) => {
+      rl.question("Re-authenticate? (y/N) ", resolve);
+    });
+    rl.close();
+    if (answer.toLowerCase() !== "y") {
+      console.log("Keeping existing credentials.");
+      if (!isMcpServerRegistered()) {
+        console.log("\nRegistering MCP server...");
+        registerMcpServer();
+        console.log("MCP server registered.");
+      }
+      return;
+    }
+  }
+  const account = await doInteractiveQRLogin();
+  if (!account) {
+    process.exit(1);
+  }
+  console.log(`
+WeChat connected successfully!`);
+  console.log(`  Account ID: ${account.accountId}`);
+  console.log(`  User ID:    ${account.userId ?? "N/A"}`);
+  console.log(`  Saved to:   ${CREDENTIALS_FILE}`);
+  console.log();
+  console.log("Registering MCP server with Claude Code...");
+  registerMcpServer();
+  console.log("Done!\n");
+  console.log("You can now start Claude Code with the WeChat channel:");
+  console.log("  claude-wechat start");
+}
+function startCommand() {
+  if (!claudeAvailable()) {
+    console.error("Error: Claude Code CLI not found. Please install it first:");
+    console.error("  https://docs.anthropic.com/en/docs/claude-code");
+    process.exit(1);
+  }
+  const account = loadCredentials();
+  if (!account) {
+    console.error("No WeChat credentials found. Run setup first:");
+    console.error("  claude-wechat setup");
+    process.exit(1);
+  }
+  if (!isMcpServerRegistered()) {
+    console.log("MCP server not registered. Registering...");
+    registerMcpServer();
+    console.log("Registered.\n");
+  }
+  console.log("Starting Claude Code with WeChat channel...\n");
+  try {
+    execFileSync("claude", [
+      "--dangerously-load-development-channels",
+      "server:wechat"
+    ], { stdio: "inherit" });
+  } catch (err) {
+    const code = err.status;
+    process.exit(code ?? 1);
+  }
+}
+function statusCommand() {
+  console.log("Claude Code WeChat Channel Status\n");
+  const account = loadCredentials();
+  if (account) {
+    console.log(`  Logged in:    Yes`);
+    console.log(`  Account ID:   ${account.accountId}`);
+    console.log(`  User ID:      ${account.userId ?? "N/A"}`);
+    console.log(`  Saved at:     ${account.savedAt}`);
+    console.log(`  Credentials:  ${CREDENTIALS_FILE}`);
+  } else {
+    console.log(`  Logged in:    No`);
+  }
+  console.log();
+  if (claudeAvailable()) {
+    console.log(`  Claude Code:  Installed`);
+    const registered = isMcpServerRegistered();
+    console.log(`  MCP server:   ${registered ? "Registered" : "Not registered"}`);
+  } else {
+    console.log(`  Claude Code:  Not found`);
+  }
+}
+function logoutCommand() {
+  const account = loadCredentials();
+  if (!account) {
+    console.log("No credentials found. Already logged out.");
+    return;
+  }
+  removeCredentials();
+  console.log("Credentials removed.");
+  if (claudeAvailable()) {
+    unregisterMcpServer();
+    console.log("MCP server unregistered.");
+  }
+  console.log("Logged out successfully.");
+}
+var program = new Command();
+program.name("claude-wechat").description("WeChat channel plugin for Claude Code").version(CHANNEL_VERSION);
+program.command("setup").description("Authenticate with WeChat via QR code and register the MCP server").option("-f, --force", "Skip confirmation prompt for re-authentication").action(setupCommand);
+program.command("start", { isDefault: true }).description("Launch Claude Code with the WeChat channel").action(startCommand);
+program.command("status").description("Show current login and configuration status").action(statusCommand);
+program.command("logout").description("Remove saved credentials and MCP registration").action(logoutCommand);
+program.parse();

package/dist/index.d.ts

@@ -0,0 +1,70 @@
+interface AccountData {
+    token: string;
+    baseUrl: string;
+    accountId: string;
+    userId?: string;
+    savedAt: string;
+}
+interface QRCodeResponse {
+    qrcode: string;
+    qrcode_img_content: string;
+}
+interface QRStatusResponse {
+    status: "wait" | "scaned" | "confirmed" | "expired";
+    bot_token?: string;
+    ilink_bot_id?: string;
+    baseurl?: string;
+    ilink_user_id?: string;
+}
+interface TextItem {
+    text?: string;
+}
+interface RefMessage {
+    message_item?: MessageItem;
+    title?: string;
+}
+interface MessageItem {
+    type?: number;
+    text_item?: TextItem;
+    voice_item?: {
+        text?: string;
+    };
+    ref_msg?: RefMessage;
+}
+interface WeixinMessage {
+    from_user_id?: string;
+    to_user_id?: string;
+    client_id?: string;
+    session_id?: string;
+    message_type?: number;
+    message_state?: number;
+    item_list?: MessageItem[];
+    context_token?: string;
+    create_time_ms?: number;
+}
+interface GetUpdatesResp {
+    ret?: number;
+    errcode?: number;
+    errmsg?: string;
+    msgs?: WeixinMessage[];
+    get_updates_buf?: string;
+    longpolling_timeout_ms?: number;
+}
+
+declare function loadCredentials(): AccountData | null;
+declare function saveCredentials(data: AccountData): void;
+declare function removeCredentials(): void;
+
+declare function fetchQRCode(baseUrl: string): Promise<QRCodeResponse>;
+declare function pollQRStatus(baseUrl: string, qrcode: string): Promise<QRStatusResponse>;
+declare function getUpdates(baseUrl: string, token: string, getUpdatesBuf: string): Promise<GetUpdatesResp>;
+declare function sendTextMessage(baseUrl: string, token: string, to: string, text: string, contextToken: string): Promise<string>;
+declare function extractTextFromMessage(msg: WeixinMessage): string;
+
+declare const CHANNEL_NAME = "wechat";
+declare const CHANNEL_VERSION = "0.1.0";
+declare const DEFAULT_BASE_URL = "https://ilinkai.weixin.qq.com";
+declare const CREDENTIALS_DIR: string;
+declare const CREDENTIALS_FILE: string;
+
+export { type AccountData, CHANNEL_NAME, CHANNEL_VERSION, CREDENTIALS_DIR, CREDENTIALS_FILE, DEFAULT_BASE_URL, type GetUpdatesResp, type QRCodeResponse, type QRStatusResponse, type WeixinMessage, extractTextFromMessage, fetchQRCode, getUpdates, loadCredentials, pollQRStatus, removeCredentials, saveCredentials, sendTextMessage };

package/dist/index.js

@@ -0,0 +1,208 @@
+// src/credentials.ts
+import fs from "fs";
+
+// src/constants.ts
+import path from "path";
+var CHANNEL_NAME = "wechat";
+var CHANNEL_VERSION = "0.1.0";
+var DEFAULT_BASE_URL = "https://ilinkai.weixin.qq.com";
+var BOT_TYPE = "3";
+var CREDENTIALS_DIR = path.join(
+  process.env.HOME || "~",
+  ".claude",
+  "channels",
+  "wechat"
+);
+var CREDENTIALS_FILE = path.join(CREDENTIALS_DIR, "account.json");
+var SYNC_BUF_FILE = path.join(CREDENTIALS_DIR, "sync_buf.txt");
+var LONG_POLL_TIMEOUT_MS = 35e3;
+var QR_POLL_TIMEOUT_MS = 35e3;
+var SEND_TIMEOUT_MS = 15e3;
+var MSG_ITEM_TEXT = 1;
+var MSG_ITEM_VOICE = 3;
+var MSG_TYPE_BOT = 2;
+var MSG_STATE_FINISH = 2;
+
+// src/credentials.ts
+function loadCredentials() {
+  try {
+    if (!fs.existsSync(CREDENTIALS_FILE)) return null;
+    return JSON.parse(fs.readFileSync(CREDENTIALS_FILE, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function saveCredentials(data) {
+  fs.mkdirSync(CREDENTIALS_DIR, { recursive: true });
+  fs.writeFileSync(CREDENTIALS_FILE, JSON.stringify(data, null, 2), "utf-8");
+  try {
+    fs.chmodSync(CREDENTIALS_FILE, 384);
+  } catch {
+  }
+}
+function removeCredentials() {
+  try {
+    if (fs.existsSync(CREDENTIALS_FILE)) fs.unlinkSync(CREDENTIALS_FILE);
+  } catch {
+  }
+  try {
+    if (fs.existsSync(SYNC_BUF_FILE)) fs.unlinkSync(SYNC_BUF_FILE);
+  } catch {
+  }
+}
+
+// src/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(params) {
+  const url = new URL(params.endpoint, normalizeBaseUrl(params.baseUrl)).toString();
+  const headers = buildHeaders(params.token, params.body);
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), params.timeoutMs);
+  try {
+    const res = await fetch(url, {
+      method: "POST",
+      headers,
+      body: params.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 fetchQRCode(baseUrl) {
+  const url = new URL(
+    `ilink/bot/get_bot_qrcode?bot_type=${encodeURIComponent(BOT_TYPE)}`,
+    normalizeBaseUrl(baseUrl)
+  );
+  const res = await fetch(url.toString());
+  if (!res.ok) throw new Error(`QR fetch failed: ${res.status}`);
+  return await res.json();
+}
+async function pollQRStatus(baseUrl, qrcode) {
+  const url = new URL(
+    `ilink/bot/get_qrcode_status?qrcode=${encodeURIComponent(qrcode)}`,
+    normalizeBaseUrl(baseUrl)
+  );
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), QR_POLL_TIMEOUT_MS);
+  try {
+    const res = await fetch(url.toString(), {
+      headers: { "iLink-App-ClientVersion": "1" },
+      signal: controller.signal
+    });
+    clearTimeout(timer);
+    if (!res.ok) throw new Error(`QR status failed: ${res.status}`);
+    return await res.json();
+  } catch (err) {
+    clearTimeout(timer);
+    if (err instanceof Error && err.name === "AbortError") {
+      return { status: "wait" };
+    }
+    throw err;
+  }
+}
+async function getUpdates(baseUrl, token, getUpdatesBuf) {
+  try {
+    const raw = await apiFetch({
+      baseUrl,
+      endpoint: "ilink/bot/getupdates",
+      body: JSON.stringify({
+        get_updates_buf: getUpdatesBuf,
+        base_info: { channel_version: CHANNEL_VERSION }
+      }),
+      token,
+      timeoutMs: 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 `claude-wechat:${Date.now()}-${crypto.randomBytes(4).toString("hex")}`;
+}
+async function sendTextMessage(baseUrl, token, to, text, contextToken) {
+  const clientId = generateClientId();
+  await apiFetch({
+    baseUrl,
+    endpoint: "ilink/bot/sendmessage",
+    body: 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,
+    timeoutMs: 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 "";
+}
+export {
+  CHANNEL_NAME,
+  CHANNEL_VERSION,
+  CREDENTIALS_DIR,
+  CREDENTIALS_FILE,
+  DEFAULT_BASE_URL,
+  extractTextFromMessage,
+  fetchQRCode,
+  getUpdates,
+  loadCredentials,
+  pollQRStatus,
+  removeCredentials,
+  saveCredentials,
+  sendTextMessage
+};

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@paean-ai/claude-code-wechat",
+  "version": "0.1.0",
+  "description": "WeChat channel plugin for Claude Code — bridge WeChat messages into Claude Code sessions via the official ilink API",
+  "type": "module",
+  "bin": {
+    "claude-wechat": "./dist/cli.js",
+    "claude-wechat-server": "./dist/channel.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "commander": "^13.0.0",
+    "qrcode-terminal": "^0.12.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "wechat",
+    "mcp",
+    "channel",
+    "weixin",
+    "chatbot",
+    "ai"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/paean-ai/claude-code-wechat.git"
+  },
+  "homepage": "https://github.com/paean-ai/claude-code-wechat#readme",
+  "bugs": {
+    "url": "https://github.com/paean-ai/claude-code-wechat/issues"
+  },
+  "author": "Paean AI",
+  "license": "MIT"
+}