@paean-ai/wechat-mcp 0.1.0

package/dist/cli.js

@@ -0,0 +1,1341 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/constants.ts
+var constants_exports = {};
+__export(constants_exports, {
+  BACKOFF_DELAY_MS: () => BACKOFF_DELAY_MS,
+  BOT_TYPE: () => BOT_TYPE,
+  CHANNEL_VERSION: () => CHANNEL_VERSION,
+  CONFIG_DIR: () => CONFIG_DIR,
+  CONTACTS_FILE: () => CONTACTS_FILE,
+  CREDENTIALS_FILE: () => CREDENTIALS_FILE,
+  DAEMON_DEFAULT_PORT: () => DAEMON_DEFAULT_PORT,
+  DAEMON_HOST: () => DAEMON_HOST,
+  DAEMON_INFO_FILE: () => DAEMON_INFO_FILE,
+  DAEMON_LONG_POLL_MS: () => DAEMON_LONG_POLL_MS,
+  DAEMON_PID_FILE: () => DAEMON_PID_FILE,
+  DEFAULT_BASE_URL: () => DEFAULT_BASE_URL,
+  LONG_POLL_TIMEOUT_MS: () => LONG_POLL_TIMEOUT_MS,
+  MAX_CONSECUTIVE_FAILURES: () => MAX_CONSECUTIVE_FAILURES,
+  MAX_WECHAT_MSG_LENGTH: () => MAX_WECHAT_MSG_LENGTH,
+  MESSAGE_QUEUE_MAX_PER_AGENT: () => MESSAGE_QUEUE_MAX_PER_AGENT,
+  MSG_ITEM_TEXT: () => MSG_ITEM_TEXT,
+  MSG_ITEM_VOICE: () => MSG_ITEM_VOICE,
+  MSG_STATE_FINISH: () => MSG_STATE_FINISH,
+  MSG_TYPE_BOT: () => MSG_TYPE_BOT,
+  MSG_TYPE_USER: () => MSG_TYPE_USER,
+  PACKAGE_NAME: () => PACKAGE_NAME,
+  PACKAGE_VERSION: () => PACKAGE_VERSION,
+  QR_LOGIN_TIMEOUT_MS: () => QR_LOGIN_TIMEOUT_MS,
+  QR_POLL_TIMEOUT_MS: () => QR_POLL_TIMEOUT_MS,
+  RETRY_DELAY_MS: () => RETRY_DELAY_MS,
+  SEND_TIMEOUT_MS: () => SEND_TIMEOUT_MS,
+  SYNC_BUF_FILE: () => SYNC_BUF_FILE
+});
+import path from "path";
+import os from "os";
+var PACKAGE_NAME, PACKAGE_VERSION, DEFAULT_BASE_URL, BOT_TYPE, CHANNEL_VERSION, MSG_TYPE_USER, MSG_TYPE_BOT, MSG_STATE_FINISH, MSG_ITEM_TEXT, MSG_ITEM_VOICE, LONG_POLL_TIMEOUT_MS, QR_POLL_TIMEOUT_MS, QR_LOGIN_TIMEOUT_MS, SEND_TIMEOUT_MS, MAX_CONSECUTIVE_FAILURES, BACKOFF_DELAY_MS, RETRY_DELAY_MS, DAEMON_LONG_POLL_MS, DAEMON_DEFAULT_PORT, DAEMON_HOST, CONFIG_DIR, CREDENTIALS_FILE, SYNC_BUF_FILE, CONTACTS_FILE, DAEMON_PID_FILE, DAEMON_INFO_FILE, MAX_WECHAT_MSG_LENGTH, MESSAGE_QUEUE_MAX_PER_AGENT;
+var init_constants = __esm({
+  "src/constants.ts"() {
+    "use strict";
+    PACKAGE_NAME = "@paean-ai/wechat-mcp";
+    PACKAGE_VERSION = "0.1.0";
+    DEFAULT_BASE_URL = "https://ilinkai.weixin.qq.com";
+    BOT_TYPE = "3";
+    CHANNEL_VERSION = "0.1.0";
+    MSG_TYPE_USER = 1;
+    MSG_TYPE_BOT = 2;
+    MSG_STATE_FINISH = 2;
+    MSG_ITEM_TEXT = 1;
+    MSG_ITEM_VOICE = 3;
+    LONG_POLL_TIMEOUT_MS = 35e3;
+    QR_POLL_TIMEOUT_MS = 35e3;
+    QR_LOGIN_TIMEOUT_MS = 48e4;
+    SEND_TIMEOUT_MS = 15e3;
+    MAX_CONSECUTIVE_FAILURES = 3;
+    BACKOFF_DELAY_MS = 3e4;
+    RETRY_DELAY_MS = 2e3;
+    DAEMON_LONG_POLL_MS = 3e4;
+    DAEMON_DEFAULT_PORT = 0;
+    DAEMON_HOST = "127.0.0.1";
+    CONFIG_DIR = path.join(os.homedir(), ".wechat-mcp");
+    CREDENTIALS_FILE = path.join(CONFIG_DIR, "credentials.json");
+    SYNC_BUF_FILE = path.join(CONFIG_DIR, "sync_buf.txt");
+    CONTACTS_FILE = path.join(CONFIG_DIR, "contacts.json");
+    DAEMON_PID_FILE = path.join(CONFIG_DIR, "daemon.pid");
+    DAEMON_INFO_FILE = path.join(CONFIG_DIR, "daemon.json");
+    MAX_WECHAT_MSG_LENGTH = 2048;
+    MESSAGE_QUEUE_MAX_PER_AGENT = 200;
+  }
+});
+
+// src/wechat-api.ts
+var wechat_api_exports = {};
+__export(wechat_api_exports, {
+  extractTextFromMessage: () => extractTextFromMessage,
+  fetchQRCode: () => fetchQRCode,
+  generateClientId: () => generateClientId,
+  getUpdates: () => getUpdates,
+  pollQRStatus: () => pollQRStatus,
+  sendTextMessage: () => sendTextMessage
+});
+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 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,
+      "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 "";
+}
+var init_wechat_api = __esm({
+  "src/wechat-api.ts"() {
+    "use strict";
+    init_constants();
+  }
+});
+
+// src/credentials.ts
+var credentials_exports = {};
+__export(credentials_exports, {
+  getContactToken: () => getContactToken,
+  loadContacts: () => loadContacts,
+  loadCredentials: () => loadCredentials,
+  loadDaemonInfo: () => loadDaemonInfo,
+  loadDaemonPid: () => loadDaemonPid,
+  loadSyncBuf: () => loadSyncBuf,
+  removeCredentials: () => removeCredentials,
+  removeDaemonInfo: () => removeDaemonInfo,
+  saveContact: () => saveContact,
+  saveCredentials: () => saveCredentials,
+  saveDaemonInfo: () => saveDaemonInfo,
+  saveDaemonPid: () => saveDaemonPid,
+  saveSyncBuf: () => saveSyncBuf
+});
+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 saveCredentials(data) {
+  ensureDir();
+  fs.writeFileSync(CREDENTIALS_FILE, JSON.stringify(data, null, 2), "utf-8");
+  try {
+    fs.chmodSync(CREDENTIALS_FILE, 384);
+  } catch {
+  }
+}
+function removeCredentials() {
+  for (const file of [CREDENTIALS_FILE, SYNC_BUF_FILE, CONTACTS_FILE]) {
+    try {
+      if (fs.existsSync(file)) fs.unlinkSync(file);
+    } catch {
+    }
+  }
+}
+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 loadDaemonInfo() {
+  try {
+    if (!fs.existsSync(DAEMON_INFO_FILE)) return null;
+    return JSON.parse(fs.readFileSync(DAEMON_INFO_FILE, "utf-8"));
+  } catch {
+    return 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");
+}
+function loadDaemonPid() {
+  try {
+    if (!fs.existsSync(DAEMON_PID_FILE)) return null;
+    const raw = fs.readFileSync(DAEMON_PID_FILE, "utf-8").trim();
+    const pid = parseInt(raw, 10);
+    return isNaN(pid) ? null : pid;
+  } catch {
+    return null;
+  }
+}
+var init_credentials = __esm({
+  "src/credentials.ts"() {
+    "use strict";
+    init_constants();
+  }
+});
+
+// src/daemon/lifecycle.ts
+var lifecycle_exports = {};
+__export(lifecycle_exports, {
+  checkDaemon: () => checkDaemon,
+  ensureDaemon: () => ensureDaemon,
+  startDaemonProcess: () => startDaemonProcess,
+  stopDaemon: () => stopDaemon
+});
+import { spawn } from "child_process";
+import path2 from "path";
+import { fileURLToPath } from "url";
+function getDaemonScript() {
+  const thisFile = typeof __filename !== "undefined" ? __filename : fileURLToPath(import.meta.url);
+  return path2.resolve(path2.dirname(thisFile), "..", "daemon", "server.js");
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function healthCheck(port) {
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 3e3);
+    const res = await fetch(`http://${DAEMON_HOST}:${port}/health`, {
+      signal: controller.signal
+    });
+    clearTimeout(timer);
+    if (!res.ok) return false;
+    const data = await res.json();
+    return data.ok === true;
+  } catch {
+    return false;
+  }
+}
+async function checkDaemon() {
+  const info = loadDaemonInfo();
+  if (!info) return null;
+  if (!isProcessAlive(info.pid)) {
+    removeDaemonInfo();
+    return null;
+  }
+  const healthy = await healthCheck(info.port);
+  if (!healthy) {
+    removeDaemonInfo();
+    return null;
+  }
+  return info;
+}
+async function startDaemonProcess() {
+  const script = getDaemonScript();
+  const child = spawn(process.execPath, [script], {
+    detached: true,
+    stdio: "ignore",
+    env: { ...process.env }
+  });
+  child.unref();
+  const deadline = Date.now() + 15e3;
+  while (Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, 500));
+    const info = loadDaemonInfo();
+    if (info && isProcessAlive(info.pid)) {
+      const healthy = await healthCheck(info.port);
+      if (healthy) return info;
+    }
+  }
+  throw new Error("Daemon failed to start within 15 seconds");
+}
+async function ensureDaemon() {
+  const existing = await checkDaemon();
+  if (existing) return existing;
+  return startDaemonProcess();
+}
+async function stopDaemon() {
+  const pid = loadDaemonPid();
+  if (!pid) return false;
+  if (!isProcessAlive(pid)) {
+    removeDaemonInfo();
+    return false;
+  }
+  try {
+    process.kill(pid, "SIGTERM");
+    const deadline = Date.now() + 5e3;
+    while (Date.now() < deadline) {
+      await new Promise((r) => setTimeout(r, 200));
+      if (!isProcessAlive(pid)) break;
+    }
+    removeDaemonInfo();
+    return true;
+  } catch {
+    removeDaemonInfo();
+    return false;
+  }
+}
+var init_lifecycle = __esm({
+  "src/daemon/lifecycle.ts"() {
+    "use strict";
+    init_credentials();
+    init_constants();
+  }
+});
+
+// src/client/index.ts
+var client_exports = {};
+__export(client_exports, {
+  DaemonClient: () => DaemonClient
+});
+var DaemonClient;
+var init_client = __esm({
+  "src/client/index.ts"() {
+    "use strict";
+    init_constants();
+    DaemonClient = class {
+      baseUrl;
+      constructor(port) {
+        this.baseUrl = `http://${DAEMON_HOST}:${port}`;
+      }
+      async request(method, path3, body, timeoutMs = 5e3) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeoutMs);
+        try {
+          const res = await fetch(`${this.baseUrl}${path3}`, {
+            method,
+            headers: body ? { "Content-Type": "application/json" } : void 0,
+            body: body ? JSON.stringify(body) : void 0,
+            signal: controller.signal
+          });
+          clearTimeout(timer);
+          const data = await res.json();
+          if (!res.ok) {
+            const errMsg = data.error || `HTTP ${res.status}`;
+            throw new Error(errMsg);
+          }
+          return data;
+        } catch (err) {
+          clearTimeout(timer);
+          throw err;
+        }
+      }
+      async health() {
+        try {
+          const data = await this.request("GET", "/health");
+          return data.ok === true;
+        } catch {
+          return false;
+        }
+      }
+      async status() {
+        return this.request("GET", "/status");
+      }
+      async registerAgent(agentId, name) {
+        return this.request("POST", "/agents", { agentId, name });
+      }
+      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.
+       */
+      async pollMessages(agentId) {
+        const resp = await this.request(
+          "GET",
+          `/messages/${encodeURIComponent(agentId)}`,
+          void 0,
+          35e3
+        );
+        return resp.messages;
+      }
+      async send(to, text, agentId) {
+        return this.request("POST", "/send", { to, text, agentId });
+      }
+      async getContacts() {
+        const data = await this.request("GET", "/contacts");
+        return data.contacts;
+      }
+    };
+  }
+});
+
+// src/mcp/server.ts
+var server_exports = {};
+__export(server_exports, {
+  startMcpServer: () => startMcpServer
+});
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  ListToolsRequestSchema,
+  CallToolRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+function log(msg) {
+  process.stderr.write(`[wechat-mcp:mcp] ${msg}
+`);
+}
+async function startMcpServer(agentId) {
+  log(`Starting MCP server for agent "${agentId}"...`);
+  let daemonInfo;
+  try {
+    daemonInfo = await ensureDaemon();
+    log(`Daemon ready on port ${daemonInfo.port}`);
+  } catch (err) {
+    log(`Failed to start daemon: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+  const client = new DaemonClient(daemonInfo.port);
+  try {
+    await client.registerAgent(agentId, agentId);
+    log(`Registered as agent "${agentId}"`);
+  } catch (err) {
+    log(`Failed to register agent: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+  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")
+    }
+  );
+  mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [
+      {
+        name: "wechat_send",
+        description: "Send a text message to a WeChat user via the shared WeChat connection",
+        inputSchema: {
+          type: "object",
+          properties: {
+            to: {
+              type: "string",
+              description: "Target user ID (xxx@im.wechat format) from a previous message's sender_id"
+            },
+            text: {
+              type: "string",
+              description: "Plain-text message to send (no markdown \u2014 WeChat doesn't render it)"
+            }
+          },
+          required: ["to", "text"]
+        }
+      },
+      {
+        name: "wechat_get_contacts",
+        description: "List known WeChat contacts who have previously messaged the bot",
+        inputSchema: {
+          type: "object",
+          properties: {}
+        }
+      },
+      {
+        name: "wechat_get_status",
+        description: "Get WeChat connection status and list of registered agents",
+        inputSchema: {
+          type: "object",
+          properties: {}
+        }
+      }
+    ]
+  }));
+  mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
+    const { name, arguments: args } = req.params;
+    if (name === "wechat_send") {
+      const { to, text } = args;
+      if (!to || !text) {
+        return { content: [{ type: "text", text: "Error: 'to' and 'text' are required" }] };
+      }
+      try {
+        const result = await client.send(to, text, agentId);
+        if (result.success) {
+          return { content: [{ type: "text", text: "Message sent" }] };
+        }
+        return { content: [{ type: "text", text: `Send failed: ${result.error}` }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }] };
+      }
+    }
+    if (name === "wechat_get_contacts") {
+      try {
+        const contacts = await client.getContacts();
+        if (contacts.length === 0) {
+          return { content: [{ type: "text", text: "No contacts yet. Users must message the bot first." }] };
+        }
+        const lines = contacts.map(
+          (c) => `${c.displayName || c.userId} (${c.userId}) \u2014 last seen: ${c.lastSeen}`
+        );
+        return { content: [{ type: "text", text: lines.join("\n") }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }] };
+      }
+    }
+    if (name === "wechat_get_status") {
+      try {
+        const status = await client.status();
+        const agentList = status.agents.map((a) => `  - ${a.name} (${a.agentId})`).join("\n");
+        const text = [
+          `WeChat connected: ${status.wechatConnected ? "yes" : "no"}`,
+          `Account: ${status.accountId || "N/A"}`,
+          `Uptime: ${Math.round(status.uptime / 1e3)}s`,
+          `Registered agents:
+${agentList || "  (none)"}`
+        ].join("\n");
+        return { content: [{ type: "text", text }] };
+      } 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
+                }
+              }
+            });
+          } catch {
+            log(`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));
+      }
+    }
+  };
+  pollLoop().catch((err) => {
+    log(`Fatal poll error: ${err instanceof Error ? err.message : String(err)}`);
+  });
+  const cleanup = async () => {
+    try {
+      await client.unregisterAgent(agentId);
+    } catch {
+    }
+    process.exit(0);
+  };
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+}
+var init_server = __esm({
+  "src/mcp/server.ts"() {
+    "use strict";
+    init_constants();
+    init_lifecycle();
+    init_client();
+  }
+});
+
+// src/daemon/store.ts
+var DaemonStore;
+var init_store = __esm({
+  "src/daemon/store.ts"() {
+    "use strict";
+    init_constants();
+    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;
+}
+var init_router = __esm({
+  "src/daemon/router.ts"() {
+    "use strict";
+  }
+});
+
+// src/daemon/server.ts
+var server_exports2 = {};
+__export(server_exports2, {
+  startDaemon: () => startDaemon
+});
+import http from "http";
+function log2(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 path3 = url.pathname;
+  try {
+    if (method === "GET" && path3 === "/health") {
+      json(res, 200, { ok: true, pid: process.pid });
+      return;
+    }
+    if (method === "GET" && path3 === "/status") {
+      const status = {
+        running: true,
+        wechatConnected,
+        accountId: activeAccount?.accountId,
+        agents: store.getAgents(),
+        uptime: store.getUptime()
+      };
+      json(res, 200, status);
+      return;
+    }
+    if (method === "POST" && path3 === "/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);
+      log2(`Agent registered: ${reg.agentId} (${reg.name})`);
+      json(res, 200, reg);
+      return;
+    }
+    if (method === "DELETE" && path3.startsWith("/agents/")) {
+      const agentId = decodeURIComponent(path3.slice("/agents/".length));
+      const removed = store.unregisterAgent(agentId);
+      if (removed) log2(`Agent unregistered: ${agentId}`);
+      json(res, 200, { removed });
+      return;
+    }
+    if (method === "GET" && path3.startsWith("/messages/")) {
+      const agentId = decodeURIComponent(path3.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" && path3 === "/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" && path3 === "/contacts") {
+      json(res, 200, { contacts: loadContacts() });
+      return;
+    }
+    json(res, 404, { error: "not found" });
+  } catch (err) {
+    log2(`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) log2(`Restored sync state (${buf.length} bytes)`);
+  log2("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++;
+        log2(`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) {
+          log2(`Message routed: from=${senderId} agent=${routed.targetAgent} text="${text.slice(0, 50)}..."`);
+        } else {
+          log2(`Message dropped (no agents): from=${senderId} text="${text.slice(0, 50)}..."`);
+        }
+      }
+    } catch (err) {
+      failures++;
+      log2(`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) {
+    log2("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") {
+    log2("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() });
+  log2(`Daemon running on ${DAEMON_HOST}:${port} (PID ${process.pid})`);
+  log2(`Account: ${account.accountId}`);
+  const cleanup = () => {
+    log2("Shutting down...");
+    removeDaemonInfo();
+    server.close();
+    process.exit(0);
+  };
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+  startPolling(account).catch((err) => {
+    log2(`Fatal polling error: ${err instanceof Error ? err.message : String(err)}`);
+    cleanup();
+  });
+}
+var store, activeAccount, wechatConnected;
+var init_server2 = __esm({
+  "src/daemon/server.ts"() {
+    "use strict";
+    init_constants();
+    init_credentials();
+    init_wechat_api();
+    init_store();
+    init_router();
+    store = new DaemonStore();
+    activeAccount = null;
+    wechatConnected = false;
+    if (process.argv[1] && (process.argv[1].endsWith("daemon/server.js") || process.argv[1].endsWith("daemon/server.ts"))) {
+      startDaemon();
+    }
+  }
+});
+
+// src/cli.ts
+init_constants();
+import { Command } from "commander";
+var program = new Command();
+program.name("wechat-mcp").description("WeChat MCP middleware \u2014 shared WeChat connection for multiple AI agents").version(PACKAGE_VERSION);
+program.command("setup").description("Authenticate with WeChat via QR code scan").option("-f, --force", "Re-authenticate even if already logged in").action(async (opts) => {
+  const { fetchQRCode: fetchQRCode2, pollQRStatus: pollQRStatus2 } = await Promise.resolve().then(() => (init_wechat_api(), wechat_api_exports));
+  const { loadCredentials: loadCredentials2, saveCredentials: saveCredentials2 } = await Promise.resolve().then(() => (init_credentials(), credentials_exports));
+  const existing = loadCredentials2();
+  if (existing && !opts.force) {
+    console.log(`Existing WeChat account: ${existing.accountId}`);
+    console.log(`Saved at: ${existing.savedAt}
+`);
+    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.");
+      return;
+    }
+  }
+  console.log("Fetching WeChat login QR code...\n");
+  const qrResp = await fetchQRCode2(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(`QR code URL: ${qrResp.qrcode_img_content}
+`);
+  }
+  console.log("Scan the QR code with WeChat...\n");
+  const deadline = Date.now() + QR_LOGIN_TIMEOUT_MS;
+  let scannedPrinted = false;
+  while (Date.now() < deadline) {
+    const status = await pollQRStatus2(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.");
+        process.exit(1);
+        break;
+      case "confirmed": {
+        if (!status.ilink_bot_id || !status.bot_token) {
+          console.error("\nLogin failed: server did not return complete info.");
+          process.exit(1);
+        }
+        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()
+        };
+        saveCredentials2(account);
+        console.log(`
+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(`  {`);
+        console.log(`    "mcpServers": {`);
+        console.log(`      "wechat": {`);
+        console.log(`        "command": "npx",`);
+        console.log(`        "args": ["@paean-ai/wechat-mcp", "serve", "--agent", "my-agent"]`);
+        console.log(`      }`);
+        console.log(`    }`);
+        console.log(`  }`);
+        return;
+      }
+    }
+    await new Promise((r) => setTimeout(r, 1e3));
+  }
+  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) => {
+  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 { startMcpServer: startMcpServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
+  await startMcpServer2(opts.agent);
+});
+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));
+  await startDaemon2();
+});
+program.command("stop").description("Stop the running daemon").action(async () => {
+  const { stopDaemon: stopDaemon2 } = await Promise.resolve().then(() => (init_lifecycle(), lifecycle_exports));
+  const stopped = await stopDaemon2();
+  if (stopped) {
+    console.log("Daemon stopped.");
+  } else {
+    console.log("No daemon was running.");
+  }
+});
+program.command("status").description("Show daemon and WeChat connection status").action(async () => {
+  const { loadCredentials: loadCredentials2 } = await Promise.resolve().then(() => (init_credentials(), credentials_exports));
+  const { checkDaemon: checkDaemon2 } = await Promise.resolve().then(() => (init_lifecycle(), lifecycle_exports));
+  const account = loadCredentials2();
+  console.log("WeChat MCP Status\n");
+  if (account) {
+    console.log(`  WeChat:     Logged in`);
+    console.log(`  Account ID: ${account.accountId}`);
+    console.log(`  User ID:    ${account.userId ?? "N/A"}`);
+    console.log(`  Saved at:   ${account.savedAt}`);
+  } else {
+    console.log(`  WeChat:     Not logged in`);
+    console.log(`  Run: wechat-mcp setup
+`);
+    return;
+  }
+  console.log();
+  const daemonInfo = await checkDaemon2();
+  if (daemonInfo) {
+    console.log(`  Daemon:     Running (PID ${daemonInfo.pid}, port ${daemonInfo.port})`);
+    try {
+      const { DaemonClient: DaemonClient2 } = await Promise.resolve().then(() => (init_client(), client_exports));
+      const client = new DaemonClient2(daemonInfo.port);
+      const status = await client.status();
+      console.log(`  Connected:  ${status.wechatConnected ? "Yes" : "No"}`);
+      console.log(`  Uptime:     ${Math.round(status.uptime / 1e3)}s`);
+      if (status.agents.length > 0) {
+        console.log(`  Agents:`);
+        for (const a of status.agents) {
+          console.log(`    - ${a.name} (${a.agentId})`);
+        }
+      } else {
+        console.log(`  Agents:     (none)`);
+      }
+    } catch {
+      console.log(`  Status:     Unable to query daemon`);
+    }
+  } else {
+    console.log(`  Daemon:     Not running`);
+  }
+});
+program.command("contacts").description("List known WeChat contacts").action(async () => {
+  const { loadContacts: loadContacts2 } = await Promise.resolve().then(() => (init_credentials(), credentials_exports));
+  const contacts = loadContacts2();
+  if (contacts.length === 0) {
+    console.log("No contacts yet. Start the daemon and receive messages first.");
+    return;
+  }
+  console.log(`Known WeChat contacts (${contacts.length}):
+`);
+  for (const c of contacts) {
+    console.log(`  ${c.displayName ?? c.userId}`);
+    console.log(`    User ID:   ${c.userId}`);
+    console.log(`    Last seen: ${c.lastSeen}
+`);
+  }
+});
+program.command("send").description("Send a one-shot message to a WeChat user").requiredOption("--to <userId>", "Target user ID or display name").requiredOption("--text <message>", "Message text to send").action(async (opts) => {
+  const { loadCredentials: loadCredentials2, getContactToken: getContactToken2 } = await Promise.resolve().then(() => (init_credentials(), credentials_exports));
+  const { sendTextMessage: sendTextMessage2 } = await Promise.resolve().then(() => (init_wechat_api(), wechat_api_exports));
+  const { MAX_WECHAT_MSG_LENGTH: MAX_WECHAT_MSG_LENGTH2 } = await Promise.resolve().then(() => (init_constants(), constants_exports));
+  const account = loadCredentials2();
+  if (!account) {
+    console.error("No WeChat credentials. Run `wechat-mcp setup` first.");
+    process.exit(1);
+  }
+  const contextToken = getContactToken2(opts.to);
+  if (!contextToken) {
+    console.error(`No context token for "${opts.to}". User must message the bot first.`);
+    console.error("Run `wechat-mcp contacts` to see known contacts.");
+    process.exit(1);
+  }
+  const text = String(opts.text);
+  try {
+    for (let i = 0; i < text.length; i += MAX_WECHAT_MSG_LENGTH2) {
+      await sendTextMessage2(
+        account.baseUrl,
+        account.token,
+        opts.to,
+        text.slice(i, i + MAX_WECHAT_MSG_LENGTH2),
+        contextToken
+      );
+    }
+    console.log(`Message sent to ${opts.to}`);
+  } catch (err) {
+    console.error(`Failed to send: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+});
+program.command("logout").description("Remove WeChat credentials and stop daemon").action(async () => {
+  const { loadCredentials: loadCredentials2, removeCredentials: removeCredentials2 } = await Promise.resolve().then(() => (init_credentials(), credentials_exports));
+  const { stopDaemon: stopDaemon2 } = await Promise.resolve().then(() => (init_lifecycle(), lifecycle_exports));
+  if (!loadCredentials2()) {
+    console.log("No credentials found. Already logged out.");
+    return;
+  }
+  await stopDaemon2();
+  removeCredentials2();
+  console.log("Credentials removed and daemon stopped.");
+});
+program.parse();