weixin-mcp 1.2.2 → 1.3.1

package/dist/accounts.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Account management commands:
+ *   npx weixin-mcp accounts list        — list all accounts (default)
+ *   npx weixin-mcp accounts remove <id> — remove a specific account
+ *   npx weixin-mcp accounts clean       — remove duplicate accounts (same userId), keep newest
+ *   npx weixin-mcp accounts use <id>    — print export WEIXIN_ACCOUNT_ID=<id>
+ */
+export declare function manageAccounts(args: string[]): Promise<void>;

package/dist/accounts.js

@@ -0,0 +1,132 @@
+/**
+ * Account management commands:
+ *   npx weixin-mcp accounts list        — list all accounts (default)
+ *   npx weixin-mcp accounts remove <id> — remove a specific account
+ *   npx weixin-mcp accounts clean       — remove duplicate accounts (same userId), keep newest
+ *   npx weixin-mcp accounts use <id>    — print export WEIXIN_ACCOUNT_ID=<id>
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { ACCOUNTS_DIR } from "./paths.js";
+function listFiles() {
+    try {
+        return fs
+            .readdirSync(ACCOUNTS_DIR)
+            .filter((f) => f.endsWith(".json") && !f.endsWith(".sync.json") && !f.endsWith(".cursor.json"));
+    }
+    catch {
+        return [];
+    }
+}
+function loadAccount(file) {
+    const accountId = file.replace(".json", "");
+    const data = JSON.parse(fs.readFileSync(path.join(ACCOUNTS_DIR, file), "utf-8"));
+    return { ...data, accountId };
+}
+function removeAccount(accountId) {
+    const filePath = path.join(ACCOUNTS_DIR, `${accountId}.json`);
+    const cursorPath = path.join(ACCOUNTS_DIR, `${accountId}.cursor.json`);
+    let removed = false;
+    if (fs.existsSync(filePath)) {
+        fs.unlinkSync(filePath);
+        removed = true;
+    }
+    if (fs.existsSync(cursorPath)) {
+        fs.unlinkSync(cursorPath);
+    }
+    return removed;
+}
+export async function manageAccounts(args) {
+    const subcommand = args[0] ?? "list";
+    if (subcommand === "list") {
+        const files = listFiles();
+        if (files.length === 0) {
+            console.log("No accounts found. Run: npx weixin-mcp login");
+            return;
+        }
+        const active = process.env.WEIXIN_ACCOUNT_ID ?? files[0].replace(".json", "");
+        console.log(`Accounts (${files.length}):\n`);
+        for (const file of files) {
+            const acc = loadAccount(file);
+            const isActive = acc.accountId === active;
+            const savedAt = acc.savedAt ? new Date(acc.savedAt).toLocaleString() : "unknown";
+            console.log(`${isActive ? "● " : "  "}${acc.accountId}`);
+            const displayId = acc.userId?.replace(/@im\.wechat(@im\.wechat)+$/, "@im.wechat") ?? "(unknown)";
+            console.log(`    User:  ${displayId}`);
+            console.log(`    Saved: ${savedAt}`);
+        }
+        if (files.length > 1) {
+            console.log(`\nActive: ${active} (set WEIXIN_ACCOUNT_ID to change)`);
+        }
+    }
+    else if (subcommand === "remove") {
+        const accountId = args[1];
+        if (!accountId) {
+            console.error("Usage: accounts remove <accountId>");
+            process.exit(1);
+        }
+        if (removeAccount(accountId)) {
+            console.log(`✅ Removed: ${accountId}`);
+        }
+        else {
+            console.error(`❌ Account not found: ${accountId}`);
+            process.exit(1);
+        }
+    }
+    else if (subcommand === "clean") {
+        const files = listFiles();
+        const byUserId = new Map();
+        for (const file of files) {
+            const acc = loadAccount(file);
+            // Normalize userId: strip duplicate @im.wechat suffix
+            const rawId = acc.userId ?? acc.accountId;
+            const key = rawId.replace(/@im\.wechat(@im\.wechat)+$/, "@im.wechat");
+            if (!byUserId.has(key))
+                byUserId.set(key, []);
+            byUserId.get(key).push(acc);
+        }
+        let removed = 0;
+        for (const [userId, accounts] of byUserId) {
+            if (accounts.length <= 1)
+                continue;
+            // Sort by savedAt desc — keep newest
+            accounts.sort((a, b) => {
+                const ta = a.savedAt ? new Date(a.savedAt).getTime() : 0;
+                const tb = b.savedAt ? new Date(b.savedAt).getTime() : 0;
+                return tb - ta;
+            });
+            const [keep, ...remove] = accounts;
+            console.log(`UserId: ${userId}`);
+            console.log(`  ✓ Keep:   ${keep.accountId} (${keep.savedAt ?? "?"})`);
+            for (const acc of remove) {
+                removeAccount(acc.accountId);
+                console.log(`  ✗ Removed: ${acc.accountId} (${acc.savedAt ?? "?"})`);
+                removed++;
+            }
+        }
+        if (removed === 0) {
+            console.log("✅ No duplicates found.");
+        }
+        else {
+            console.log(`\n✅ Cleaned ${removed} duplicate account(s).`);
+        }
+    }
+    else if (subcommand === "use") {
+        const accountId = args[1];
+        if (!accountId) {
+            console.error("Usage: accounts use <accountId>");
+            process.exit(1);
+        }
+        const filePath = path.join(ACCOUNTS_DIR, `${accountId}.json`);
+        if (!fs.existsSync(filePath)) {
+            console.error(`❌ Account not found: ${accountId}`);
+            process.exit(1);
+        }
+        console.log(`export WEIXIN_ACCOUNT_ID="${accountId}"`);
+    }
+    else {
+        console.error(`Unknown accounts subcommand: ${subcommand}`);
+        console.error("Usage: accounts [list|remove <id>|clean|use <id>]");
+        process.exit(1);
+    }
+}

package/dist/cli.d.ts

@@ -1,10 +1,14 @@
 #!/usr/bin/env node
 /**
- * weixin-mcp CLI entry point
+ * weixin-mcp CLI
  *
- * Usage:
- *   npx weixin-mcp           — start MCP server (stdio)
- *   npx weixin-mcp login     — QR code login
- *   npx weixin-mcp status    — show current account status
+ * Commands:
+ *   (no args)              Start MCP server in stdio mode (for Claude Desktop)
+ *   login                  QR code login
+ *   status                 Show account + daemon status
+ *   start [--port <n>]     Start HTTP MCP daemon in background
+ *   stop                   Stop daemon
+ *   restart [--port <n>]   Restart daemon
+ *   logs [-f]              Show daemon logs (tail -f with -f flag)
  */
 export {};

package/dist/cli.js

@@ -1,15 +1,18 @@
 #!/usr/bin/env node
 /**
- * weixin-mcp CLI entry point
+ * weixin-mcp CLI
  *
- * Usage:
- *   npx weixin-mcp           — start MCP server (stdio)
- *   npx weixin-mcp login     — QR code login
- *   npx weixin-mcp status    — show current account status
+ * Commands:
+ *   (no args)              Start MCP server in stdio mode (for Claude Desktop)
+ *   login                  QR code login
+ *   status                 Show account + daemon status
+ *   start [--port <n>]     Start HTTP MCP daemon in background
+ *   stop                   Stop daemon
+ *   restart [--port <n>]   Restart daemon
+ *   logs [-f]              Show daemon logs (tail -f with -f flag)
  */
 const command = process.argv[2];
 if (command === "login") {
-    // Run the login flow
     const { main } = await import("./login.js");
     await main();
 }
@@ -17,16 +20,53 @@ else if (command === "status") {
     const { showStatus } = await import("./status.js");
     await showStatus();
 }
-else if (command === undefined || command === "serve" || command === "start") {
-    // Default: start MCP server
+else if (command === "start") {
+    const portArg = process.argv.indexOf("--port");
+    const port = portArg !== -1 ? Number(process.argv[portArg + 1]) : undefined;
+    const { startDaemon } = await import("./daemon.js");
+    await startDaemon(port);
+}
+else if (command === "stop") {
+    const { stopDaemon } = await import("./daemon.js");
+    stopDaemon();
+}
+else if (command === "restart") {
+    const portArg = process.argv.indexOf("--port");
+    const port = portArg !== -1 ? Number(process.argv[portArg + 1]) : undefined;
+    const { restartDaemon } = await import("./daemon.js");
+    await restartDaemon(port);
+}
+else if (command === "logs") {
+    const follow = process.argv.includes("-f") || process.argv.includes("--follow");
+    const { showLogs } = await import("./daemon.js");
+    showLogs(follow);
+}
+else if (command === "accounts") {
+    const { manageAccounts } = await import("./accounts.js");
+    await manageAccounts(process.argv.slice(3)); // [subcommand, ...args]
+}
+else if (command === undefined || command === "serve") {
+    // Default: stdio MCP server (for Claude Desktop integration)
     await import("./index.js");
 }
 else {
     console.error(`Unknown command: ${command}`);
-    console.error(`Usage:
-  npx weixin-mcp           Start MCP server
-  npx weixin-mcp login     QR code login
-  npx weixin-mcp status    Show current account status`);
+    console.error(`
+Usage: npx weixin-mcp [command]
+
+Commands:
+  (no args)                    Start stdio MCP server (Claude Desktop mode)
+  login                        QR code login
+  status                       Show account and daemon status
+  start [--port n]             Start HTTP MCP daemon in background (default: 3001)
+  stop                         Stop daemon
+  restart                      Restart daemon
+  logs [-f]                    Show daemon logs (-f to follow)
+  accounts [list]              List all accounts
+  accounts remove <id>         Remove an account
+  accounts clean               Remove duplicate accounts (same userId), keep newest
+  accounts use <id>            Print export command for switching accounts
+`);
     process.exit(1);
 }
 export {};

package/dist/daemon.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Daemon management for weixin-mcp HTTP server.
+ *
+ * Daemon runs as a child process, writing its PID and port to ~/.weixin-mcp/daemon.json.
+ * All daemon output is appended to ~/.weixin-mcp/daemon.log.
+ */
+interface DaemonInfo {
+    pid: number;
+    port: number;
+    startedAt: string;
+}
+export declare function daemonStatus(): {
+    running: boolean;
+    info: DaemonInfo | null;
+};
+export declare function startDaemon(port?: number): Promise<void>;
+export declare function stopDaemon(): void;
+export declare function restartDaemon(port?: number): Promise<void>;
+export declare function showLogs(follow?: boolean): void;
+export {};

package/dist/daemon.js

@@ -0,0 +1,122 @@
+/**
+ * Daemon management for weixin-mcp HTTP server.
+ *
+ * Daemon runs as a child process, writing its PID and port to ~/.weixin-mcp/daemon.json.
+ * All daemon output is appended to ~/.weixin-mcp/daemon.log.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+const DATA_DIR = path.join(os.homedir(), ".weixin-mcp");
+const PID_FILE = path.join(DATA_DIR, "daemon.json");
+const LOG_FILE = path.join(DATA_DIR, "daemon.log");
+const DEFAULT_PORT = 3001;
+function readDaemonInfo() {
+    try {
+        return JSON.parse(fs.readFileSync(PID_FILE, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+function isRunning(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function daemonStatus() {
+    const info = readDaemonInfo();
+    if (!info)
+        return { running: false, info: null };
+    const running = isRunning(info.pid);
+    if (!running) {
+        // stale PID file
+        try {
+            fs.unlinkSync(PID_FILE);
+        }
+        catch { }
+    }
+    return { running, info: running ? info : null };
+}
+export async function startDaemon(port = DEFAULT_PORT) {
+    const { running, info } = daemonStatus();
+    if (running && info) {
+        console.log(`⚠️  Daemon already running (pid ${info.pid}, port ${info.port})`);
+        return;
+    }
+    fs.mkdirSync(DATA_DIR, { recursive: true });
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+    const serverScript = path.join(__dirname, "server-http.js");
+    const logFd = fs.openSync(LOG_FILE, "a");
+    const child = spawn(process.execPath, [serverScript, String(port)], {
+        detached: true,
+        stdio: ["ignore", logFd, logFd],
+        env: { ...process.env, WEIXIN_MCP_PORT: String(port) },
+    });
+    child.unref();
+    fs.closeSync(logFd);
+    // Wait briefly for the process to start
+    await new Promise((r) => setTimeout(r, 800));
+    if (!isRunning(child.pid)) {
+        console.error("❌ Daemon failed to start. Check logs:");
+        console.error(`   npx weixin-mcp logs`);
+        process.exit(1);
+    }
+    const daemonInfo = {
+        pid: child.pid,
+        port,
+        startedAt: new Date().toISOString(),
+    };
+    fs.writeFileSync(PID_FILE, JSON.stringify(daemonInfo, null, 2));
+    console.log(`✅ weixin-mcp daemon started`);
+    console.log(`   PID:  ${child.pid}`);
+    console.log(`   Port: ${port}`);
+    console.log(`   URL:  http://localhost:${port}/mcp`);
+    console.log(`   Logs: ${LOG_FILE}`);
+}
+export function stopDaemon() {
+    const { running, info } = daemonStatus();
+    if (!running || !info) {
+        console.log("ℹ️  Daemon is not running.");
+        return;
+    }
+    try {
+        process.kill(info.pid, "SIGTERM");
+        try {
+            fs.unlinkSync(PID_FILE);
+        }
+        catch { }
+        console.log(`✅ Daemon stopped (pid ${info.pid})`);
+    }
+    catch (err) {
+        console.error(`❌ Failed to stop daemon: ${String(err)}`);
+    }
+}
+export async function restartDaemon(port) {
+    const { info } = daemonStatus();
+    stopDaemon();
+    await new Promise((r) => setTimeout(r, 500));
+    await startDaemon(port ?? info?.port ?? DEFAULT_PORT);
+}
+export function showLogs(follow = false) {
+    if (!fs.existsSync(LOG_FILE)) {
+        console.log("No log file yet. Start the daemon first:");
+        console.log("  npx weixin-mcp start");
+        return;
+    }
+    if (follow) {
+        const tail = spawn("tail", ["-f", LOG_FILE], { stdio: "inherit" });
+        process.on("SIGINT", () => tail.kill());
+    }
+    else {
+        const lines = fs.readFileSync(LOG_FILE, "utf-8").split("\n").slice(-50).join("\n");
+        console.log(lines);
+    }
+}

package/dist/login.js

@@ -76,7 +76,8 @@ export async function main() {
             // Use bot_id or a random ID as account identifier
             const accountId = status.ilink_bot_id?.replace("@", "-").replace(".", "-")
                 ?? crypto.randomBytes(6).toString("hex") + "-im-bot";
-            saveAccount(accountId, token, baseUrl, userId ? `${userId}@im.wechat` : undefined);
+            // userId from API already contains @im.wechat suffix — don't append again
+            saveAccount(accountId, token, baseUrl, userId ?? undefined);
             console.log(`\n🎉 Logged in! Account: ${accountId}`);
             console.log(`   UserId: ${userId ?? "(unknown)"}`);
             console.log("\nYou can now start the MCP server:");

package/dist/server-http.d.ts

@@ -0,0 +1,7 @@
+/**
+ * HTTP MCP server — runs as a daemon process.
+ * Spawned by `weixin-mcp start`, listens on a given port.
+ *
+ * Clients connect via: http://localhost:<port>/mcp
+ */
+export {};

package/dist/server-http.js

@@ -0,0 +1,156 @@
+/**
+ * HTTP MCP server — runs as a daemon process.
+ * Spawned by `weixin-mcp start`, listens on a given port.
+ *
+ * Clients connect via: http://localhost:<port>/mcp
+ */
+import express from "express";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { randomUUID } from "node:crypto";
+// Reuse the same tool definitions and handlers from the main server
+import { DEFAULT_BASE_URL, getUpdates, getConfig, sendTextMessage, loadCursor, saveCursor, WeixinAuthError, WeixinNetworkError, } from "./api.js";
+import { ACCOUNTS_DIR } from "./paths.js";
+import fs from "node:fs";
+import path from "node:path";
+const port = Number(process.env.WEIXIN_MCP_PORT ?? process.argv[2] ?? 3001);
+function loadAccount() {
+    const files = fs.readdirSync(ACCOUNTS_DIR).filter((f) => f.endsWith(".json") && !f.endsWith(".sync.json") && !f.endsWith(".cursor.json"));
+    if (files.length === 0)
+        throw new Error("No WeChat account. Run: npx weixin-mcp login");
+    const accountId = process.env.WEIXIN_ACCOUNT_ID ?? files[0].replace(".json", "");
+    const data = JSON.parse(fs.readFileSync(path.join(ACCOUNTS_DIR, `${accountId}.json`), "utf-8"));
+    if (!data.token)
+        throw new Error(`No token for ${accountId}. Run: npx weixin-mcp login`);
+    return { ...data, accountId };
+}
+function assertStr(v, f) {
+    if (typeof v !== "string" || !v.trim())
+        throw new Error(`"${f}" must be a non-empty string`);
+    return v.trim();
+}
+function fmtErr(e) {
+    if (e instanceof WeixinAuthError || e instanceof WeixinNetworkError || e instanceof Error)
+        return e.message;
+    return String(e);
+}
+// ── MCP server factory ─────────────────────────────────────────────────────
+function createMCPServer() {
+    const server = new Server({ name: "weixin-mcp", version: "1.2.2" }, { capabilities: { tools: {} } });
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({
+        tools: [
+            {
+                name: "weixin_send",
+                description: "Send a WeChat text message. Pass context_token from a received message to link the reply.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        to: { type: "string" },
+                        text: { type: "string" },
+                        context_token: { type: "string" },
+                    },
+                    required: ["to", "text"],
+                },
+            },
+            {
+                name: "weixin_poll",
+                description: "Poll for new WeChat messages (cursor-based, no duplicates).",
+                inputSchema: {
+                    type: "object",
+                    properties: { reset_cursor: { type: "boolean" } },
+                },
+            },
+            {
+                name: "weixin_get_config",
+                description: "Get user config (typing ticket, etc.).",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        user_id: { type: "string" },
+                        context_token: { type: "string" },
+                    },
+                    required: ["user_id"],
+                },
+            },
+        ],
+    }));
+    server.setRequestHandler(CallToolRequestSchema, async (req) => {
+        const { token, baseUrl = DEFAULT_BASE_URL, accountId } = loadAccount();
+        const { name, arguments: args } = req.params;
+        try {
+            let result;
+            if (name === "weixin_send") {
+                const a = (args ?? {});
+                result = await sendTextMessage(assertStr(a.to, "to"), assertStr(a.text, "text"), token, baseUrl, a.context_token);
+            }
+            else if (name === "weixin_poll") {
+                const { reset_cursor } = (args ?? {});
+                const cursor = reset_cursor ? "" : loadCursor(accountId);
+                const resp = await getUpdates(token, baseUrl, cursor);
+                if (resp.get_updates_buf)
+                    saveCursor(accountId, resp.get_updates_buf);
+                result = resp;
+            }
+            else if (name === "weixin_get_config") {
+                const a = (args ?? {});
+                result = await getConfig(assertStr(a.user_id, "user_id"), token, baseUrl, a.context_token);
+            }
+            else {
+                throw new Error(`Unknown tool: ${name}`);
+            }
+            return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (err) {
+            return { content: [{ type: "text", text: `Error: ${fmtErr(err)}` }], isError: true };
+        }
+    });
+    return server;
+}
+// ── Express HTTP server ────────────────────────────────────────────────────
+const app = express();
+app.use(express.json());
+// Session store for stateful transports
+const sessions = new Map();
+app.post("/mcp", async (req, res) => {
+    // Check if this is an existing session
+    const sessionId = req.headers["mcp-session-id"];
+    let transport = sessionId ? sessions.get(sessionId) : undefined;
+    if (!transport) {
+        // New session
+        const newSessionId = randomUUID();
+        transport = new StreamableHTTPServerTransport({
+            sessionIdGenerator: () => newSessionId,
+            onsessioninitialized: (id) => { sessions.set(id, transport); },
+        });
+        transport.onclose = () => { sessions.delete(newSessionId); };
+        const server = createMCPServer();
+        await server.connect(transport);
+    }
+    await transport.handleRequest(req, res, req.body);
+});
+app.get("/mcp", async (req, res) => {
+    const sessionId = req.headers["mcp-session-id"];
+    const transport = sessionId ? sessions.get(sessionId) : undefined;
+    if (!transport) {
+        res.status(404).json({ error: "Session not found" });
+        return;
+    }
+    await transport.handleRequest(req, res);
+});
+app.delete("/mcp", async (req, res) => {
+    const sessionId = req.headers["mcp-session-id"];
+    const transport = sessionId ? sessions.get(sessionId) : undefined;
+    if (!transport) {
+        res.status(404).json({ error: "Session not found" });
+        return;
+    }
+    await transport.handleRequest(req, res);
+});
+app.get("/health", (_req, res) => {
+    res.json({ status: "ok", port, sessions: sessions.size });
+});
+app.listen(port, () => {
+    console.log(`[weixin-mcp] HTTP MCP server listening on port ${port}`);
+    console.log(`[weixin-mcp] MCP endpoint: http://localhost:${port}/mcp`);
+});

package/dist/status.js

@@ -1,8 +1,21 @@
 import fs from "node:fs";
 import path from "node:path";
 import { ACCOUNTS_DIR } from "./paths.js";
+import { daemonStatus } from "./daemon.js";
 export async function showStatus() {
     console.log("🔍 weixin-mcp status\n");
+    // Daemon status
+    const { running, info } = daemonStatus();
+    if (running && info) {
+        console.log(`🟢 Daemon:    running (pid ${info.pid}, port ${info.port})`);
+        console.log(`   URL:       http://localhost:${info.port}/mcp`);
+        console.log(`   Started:   ${new Date(info.startedAt).toLocaleString()}`);
+    }
+    else {
+        console.log("⚫ Daemon:    not running");
+        console.log("   Tip:       npx weixin-mcp start");
+    }
+    console.log();
     let files;
     try {
         files = fs.readdirSync(ACCOUNTS_DIR).filter((f) => f.endsWith(".json") && !f.endsWith(".sync.json") && !f.endsWith(".cursor.json"));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "weixin-mcp",
-  "version": "1.2.2",
+  "version": "1.3.1",
   "description": "MCP server for WeChat (Weixin) — send messages via OpenClaw weixin plugin auth",
   "type": "module",
   "main": "dist/index.js",
@@ -16,10 +16,12 @@
     "weixin-login": "dist/weixin-login.js"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.0.0",
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "express": "^5.2.1",
     "qrcode-terminal": "^0.12.0"
   },
   "devDependencies": {
+    "@types/express": "^5.0.6",
     "@types/node": "^22.0.0",
     "typescript": "^5.0.0"
   }

package/src/accounts.ts

@@ -0,0 +1,132 @@
+/**
+ * Account management commands:
+ *   npx weixin-mcp accounts list        — list all accounts (default)
+ *   npx weixin-mcp accounts remove <id> — remove a specific account
+ *   npx weixin-mcp accounts clean       — remove duplicate accounts (same userId), keep newest
+ *   npx weixin-mcp accounts use <id>    — print export WEIXIN_ACCOUNT_ID=<id>
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import { ACCOUNTS_DIR } from "./paths.js";
+
+interface AccountData {
+  token?: string;
+  baseUrl?: string;
+  userId?: string;
+  savedAt?: string;
+}
+
+function listFiles(): string[] {
+  try {
+    return fs
+      .readdirSync(ACCOUNTS_DIR)
+      .filter((f) => f.endsWith(".json") && !f.endsWith(".sync.json") && !f.endsWith(".cursor.json"));
+  } catch {
+    return [];
+  }
+}
+
+function loadAccount(file: string): AccountData & { accountId: string } {
+  const accountId = file.replace(".json", "");
+  const data = JSON.parse(fs.readFileSync(path.join(ACCOUNTS_DIR, file), "utf-8")) as AccountData;
+  return { ...data, accountId };
+}
+
+function removeAccount(accountId: string) {
+  const filePath = path.join(ACCOUNTS_DIR, `${accountId}.json`);
+  const cursorPath = path.join(ACCOUNTS_DIR, `${accountId}.cursor.json`);
+  let removed = false;
+  if (fs.existsSync(filePath)) { fs.unlinkSync(filePath); removed = true; }
+  if (fs.existsSync(cursorPath)) { fs.unlinkSync(cursorPath); }
+  return removed;
+}
+
+export async function manageAccounts(args: string[]) {
+  const subcommand = args[0] ?? "list";
+
+  if (subcommand === "list") {
+    const files = listFiles();
+    if (files.length === 0) {
+      console.log("No accounts found. Run: npx weixin-mcp login");
+      return;
+    }
+    const active = process.env.WEIXIN_ACCOUNT_ID ?? files[0].replace(".json", "");
+    console.log(`Accounts (${files.length}):\n`);
+    for (const file of files) {
+      const acc = loadAccount(file);
+      const isActive = acc.accountId === active;
+      const savedAt = acc.savedAt ? new Date(acc.savedAt).toLocaleString() : "unknown";
+      console.log(`${isActive ? "● " : "  "}${acc.accountId}`);
+      const displayId = acc.userId?.replace(/@im\.wechat(@im\.wechat)+$/, "@im.wechat") ?? "(unknown)";
+      console.log(`    User:  ${displayId}`);
+      console.log(`    Saved: ${savedAt}`);
+    }
+    if (files.length > 1) {
+      console.log(`\nActive: ${active} (set WEIXIN_ACCOUNT_ID to change)`);
+    }
+
+  } else if (subcommand === "remove") {
+    const accountId = args[1];
+    if (!accountId) { console.error("Usage: accounts remove <accountId>"); process.exit(1); }
+    if (removeAccount(accountId)) {
+      console.log(`✅ Removed: ${accountId}`);
+    } else {
+      console.error(`❌ Account not found: ${accountId}`);
+      process.exit(1);
+    }
+
+  } else if (subcommand === "clean") {
+    const files = listFiles();
+    const byUserId = new Map<string, Array<AccountData & { accountId: string }>>();
+
+    for (const file of files) {
+      const acc = loadAccount(file);
+      // Normalize userId: strip duplicate @im.wechat suffix
+      const rawId = acc.userId ?? acc.accountId;
+      const key = rawId.replace(/@im\.wechat(@im\.wechat)+$/, "@im.wechat");
+      if (!byUserId.has(key)) byUserId.set(key, []);
+      byUserId.get(key)!.push(acc);
+    }
+
+    let removed = 0;
+    for (const [userId, accounts] of byUserId) {
+      if (accounts.length <= 1) continue;
+      // Sort by savedAt desc — keep newest
+      accounts.sort((a, b) => {
+        const ta = a.savedAt ? new Date(a.savedAt).getTime() : 0;
+        const tb = b.savedAt ? new Date(b.savedAt).getTime() : 0;
+        return tb - ta;
+      });
+      const [keep, ...remove] = accounts;
+      console.log(`UserId: ${userId}`);
+      console.log(`  ✓ Keep:   ${keep.accountId} (${keep.savedAt ?? "?"})`);
+      for (const acc of remove) {
+        removeAccount(acc.accountId);
+        console.log(`  ✗ Removed: ${acc.accountId} (${acc.savedAt ?? "?"})`);
+        removed++;
+      }
+    }
+
+    if (removed === 0) {
+      console.log("✅ No duplicates found.");
+    } else {
+      console.log(`\n✅ Cleaned ${removed} duplicate account(s).`);
+    }
+
+  } else if (subcommand === "use") {
+    const accountId = args[1];
+    if (!accountId) { console.error("Usage: accounts use <accountId>"); process.exit(1); }
+    const filePath = path.join(ACCOUNTS_DIR, `${accountId}.json`);
+    if (!fs.existsSync(filePath)) {
+      console.error(`❌ Account not found: ${accountId}`);
+      process.exit(1);
+    }
+    console.log(`export WEIXIN_ACCOUNT_ID="${accountId}"`);
+
+  } else {
+    console.error(`Unknown accounts subcommand: ${subcommand}`);
+    console.error("Usage: accounts [list|remove <id>|clean|use <id>]");
+    process.exit(1);
+  }
+}

package/src/cli.ts

@@ -1,30 +1,73 @@
 #!/usr/bin/env node
 /**
- * weixin-mcp CLI entry point
+ * weixin-mcp CLI
  *
- * Usage:
- *   npx weixin-mcp           — start MCP server (stdio)
- *   npx weixin-mcp login     — QR code login
- *   npx weixin-mcp status    — show current account status
+ * Commands:
+ *   (no args)              Start MCP server in stdio mode (for Claude Desktop)
+ *   login                  QR code login
+ *   status                 Show account + daemon status
+ *   start [--port <n>]     Start HTTP MCP daemon in background
+ *   stop                   Stop daemon
+ *   restart [--port <n>]   Restart daemon
+ *   logs [-f]              Show daemon logs (tail -f with -f flag)
  */
 
 const command = process.argv[2];
 
 if (command === "login") {
-  // Run the login flow
   const { main } = await import("./login.js");
   await main();
+
 } else if (command === "status") {
   const { showStatus } = await import("./status.js");
   await showStatus();
-} else if (command === undefined || command === "serve" || command === "start") {
-  // Default: start MCP server
+
+} else if (command === "start") {
+  const portArg = process.argv.indexOf("--port");
+  const port = portArg !== -1 ? Number(process.argv[portArg + 1]) : undefined;
+  const { startDaemon } = await import("./daemon.js");
+  await startDaemon(port);
+
+} else if (command === "stop") {
+  const { stopDaemon } = await import("./daemon.js");
+  stopDaemon();
+
+} else if (command === "restart") {
+  const portArg = process.argv.indexOf("--port");
+  const port = portArg !== -1 ? Number(process.argv[portArg + 1]) : undefined;
+  const { restartDaemon } = await import("./daemon.js");
+  await restartDaemon(port);
+
+} else if (command === "logs") {
+  const follow = process.argv.includes("-f") || process.argv.includes("--follow");
+  const { showLogs } = await import("./daemon.js");
+  showLogs(follow);
+
+} else if (command === "accounts") {
+  const { manageAccounts } = await import("./accounts.js");
+  await manageAccounts(process.argv.slice(3)); // [subcommand, ...args]
+
+} else if (command === undefined || command === "serve") {
+  // Default: stdio MCP server (for Claude Desktop integration)
   await import("./index.js");
+
 } else {
   console.error(`Unknown command: ${command}`);
-  console.error(`Usage:
-  npx weixin-mcp           Start MCP server
-  npx weixin-mcp login     QR code login
-  npx weixin-mcp status    Show current account status`);
+  console.error(`
+Usage: npx weixin-mcp [command]
+
+Commands:
+  (no args)                    Start stdio MCP server (Claude Desktop mode)
+  login                        QR code login
+  status                       Show account and daemon status
+  start [--port n]             Start HTTP MCP daemon in background (default: 3001)
+  stop                         Stop daemon
+  restart                      Restart daemon
+  logs [-f]                    Show daemon logs (-f to follow)
+  accounts [list]              List all accounts
+  accounts remove <id>         Remove an account
+  accounts clean               Remove duplicate accounts (same userId), keep newest
+  accounts use <id>            Print export command for switching accounts
+`);
   process.exit(1);
 }

package/src/daemon.ts

@@ -0,0 +1,136 @@
+/**
+ * Daemon management for weixin-mcp HTTP server.
+ *
+ * Daemon runs as a child process, writing its PID and port to ~/.weixin-mcp/daemon.json.
+ * All daemon output is appended to ~/.weixin-mcp/daemon.log.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+const DATA_DIR = path.join(os.homedir(), ".weixin-mcp");
+const PID_FILE = path.join(DATA_DIR, "daemon.json");
+const LOG_FILE = path.join(DATA_DIR, "daemon.log");
+const DEFAULT_PORT = 3001;
+
+interface DaemonInfo {
+  pid: number;
+  port: number;
+  startedAt: string;
+}
+
+function readDaemonInfo(): DaemonInfo | null {
+  try {
+    return JSON.parse(fs.readFileSync(PID_FILE, "utf-8")) as DaemonInfo;
+  } catch {
+    return null;
+  }
+}
+
+function isRunning(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function daemonStatus(): { running: boolean; info: DaemonInfo | null } {
+  const info = readDaemonInfo();
+  if (!info) return { running: false, info: null };
+  const running = isRunning(info.pid);
+  if (!running) {
+    // stale PID file
+    try { fs.unlinkSync(PID_FILE); } catch {}
+  }
+  return { running, info: running ? info : null };
+}
+
+export async function startDaemon(port = DEFAULT_PORT): Promise<void> {
+  const { running, info } = daemonStatus();
+  if (running && info) {
+    console.log(`⚠️  Daemon already running (pid ${info.pid}, port ${info.port})`);
+    return;
+  }
+
+  fs.mkdirSync(DATA_DIR, { recursive: true });
+
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname = path.dirname(__filename);
+  const serverScript = path.join(__dirname, "server-http.js");
+
+  const logFd = fs.openSync(LOG_FILE, "a");
+  const child = spawn(process.execPath, [serverScript, String(port)], {
+    detached: true,
+    stdio: ["ignore", logFd, logFd],
+    env: { ...process.env, WEIXIN_MCP_PORT: String(port) },
+  });
+
+  child.unref();
+  fs.closeSync(logFd);
+
+  // Wait briefly for the process to start
+  await new Promise((r) => setTimeout(r, 800));
+
+  if (!isRunning(child.pid!)) {
+    console.error("❌ Daemon failed to start. Check logs:");
+    console.error(`   npx weixin-mcp logs`);
+    process.exit(1);
+  }
+
+  const daemonInfo: DaemonInfo = {
+    pid: child.pid!,
+    port,
+    startedAt: new Date().toISOString(),
+  };
+  fs.writeFileSync(PID_FILE, JSON.stringify(daemonInfo, null, 2));
+
+  console.log(`✅ weixin-mcp daemon started`);
+  console.log(`   PID:  ${child.pid}`);
+  console.log(`   Port: ${port}`);
+  console.log(`   URL:  http://localhost:${port}/mcp`);
+  console.log(`   Logs: ${LOG_FILE}`);
+}
+
+export function stopDaemon(): void {
+  const { running, info } = daemonStatus();
+  if (!running || !info) {
+    console.log("ℹ️  Daemon is not running.");
+    return;
+  }
+
+  try {
+    process.kill(info.pid, "SIGTERM");
+    try { fs.unlinkSync(PID_FILE); } catch {}
+    console.log(`✅ Daemon stopped (pid ${info.pid})`);
+  } catch (err) {
+    console.error(`❌ Failed to stop daemon: ${String(err)}`);
+  }
+}
+
+export async function restartDaemon(port?: number): Promise<void> {
+  const { info } = daemonStatus();
+  stopDaemon();
+  await new Promise((r) => setTimeout(r, 500));
+  await startDaemon(port ?? info?.port ?? DEFAULT_PORT);
+}
+
+export function showLogs(follow = false): void {
+  if (!fs.existsSync(LOG_FILE)) {
+    console.log("No log file yet. Start the daemon first:");
+    console.log("  npx weixin-mcp start");
+    return;
+  }
+
+  if (follow) {
+    const tail = spawn("tail", ["-f", LOG_FILE], { stdio: "inherit" });
+    process.on("SIGINT", () => tail.kill());
+  } else {
+    const lines = fs.readFileSync(LOG_FILE, "utf-8").split("\n").slice(-50).join("\n");
+    console.log(lines);
+  }
+}

package/src/login.ts

@@ -104,7 +104,8 @@ export async function main() {
       // Use bot_id or a random ID as account identifier
       const accountId = status.ilink_bot_id?.replace("@", "-").replace(".", "-")
         ?? crypto.randomBytes(6).toString("hex") + "-im-bot";
-      saveAccount(accountId, token, baseUrl, userId ? `${userId}@im.wechat` : undefined);
+      // userId from API already contains @im.wechat suffix — don't append again
+      saveAccount(accountId, token, baseUrl, userId ?? undefined);
       console.log(`\n🎉 Logged in! Account: ${accountId}`);
       console.log(`   UserId: ${userId ?? "(unknown)"}`);
       console.log("\nYou can now start the MCP server:");

package/src/server-http.ts

@@ -0,0 +1,183 @@
+/**
+ * HTTP MCP server — runs as a daemon process.
+ * Spawned by `weixin-mcp start`, listens on a given port.
+ *
+ * Clients connect via: http://localhost:<port>/mcp
+ */
+
+import express from "express";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
+import { randomUUID } from "node:crypto";
+
+// Reuse the same tool definitions and handlers from the main server
+import {
+  DEFAULT_BASE_URL,
+  getUpdates,
+  getConfig,
+  sendTextMessage,
+  loadCursor,
+  saveCursor,
+  WeixinAuthError,
+  WeixinNetworkError,
+} from "./api.js";
+import { ACCOUNTS_DIR } from "./paths.js";
+import fs from "node:fs";
+import path from "node:path";
+
+const port = Number(process.env.WEIXIN_MCP_PORT ?? process.argv[2] ?? 3001);
+
+// ── Account loader ─────────────────────────────────────────────────────────
+
+interface AccountData { token?: string; baseUrl?: string; userId?: string }
+
+function loadAccount(): AccountData & { accountId: string } {
+  const files = fs.readdirSync(ACCOUNTS_DIR).filter(
+    (f) => f.endsWith(".json") && !f.endsWith(".sync.json") && !f.endsWith(".cursor.json"),
+  );
+  if (files.length === 0) throw new Error("No WeChat account. Run: npx weixin-mcp login");
+  const accountId = process.env.WEIXIN_ACCOUNT_ID ?? files[0].replace(".json", "");
+  const data = JSON.parse(fs.readFileSync(path.join(ACCOUNTS_DIR, `${accountId}.json`), "utf-8")) as AccountData;
+  if (!data.token) throw new Error(`No token for ${accountId}. Run: npx weixin-mcp login`);
+  return { ...data, accountId };
+}
+
+function assertStr(v: unknown, f: string): string {
+  if (typeof v !== "string" || !v.trim()) throw new Error(`"${f}" must be a non-empty string`);
+  return v.trim();
+}
+
+function fmtErr(e: unknown): string {
+  if (e instanceof WeixinAuthError || e instanceof WeixinNetworkError || e instanceof Error) return e.message;
+  return String(e);
+}
+
+// ── MCP server factory ─────────────────────────────────────────────────────
+
+function createMCPServer() {
+  const server = new Server(
+    { name: "weixin-mcp", version: "1.2.2" },
+    { capabilities: { tools: {} } },
+  );
+
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [
+      {
+        name: "weixin_send",
+        description: "Send a WeChat text message. Pass context_token from a received message to link the reply.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            to: { type: "string" },
+            text: { type: "string" },
+            context_token: { type: "string" },
+          },
+          required: ["to", "text"],
+        },
+      },
+      {
+        name: "weixin_poll",
+        description: "Poll for new WeChat messages (cursor-based, no duplicates).",
+        inputSchema: {
+          type: "object",
+          properties: { reset_cursor: { type: "boolean" } },
+        },
+      },
+      {
+        name: "weixin_get_config",
+        description: "Get user config (typing ticket, etc.).",
+        inputSchema: {
+          type: "object",
+          properties: {
+            user_id: { type: "string" },
+            context_token: { type: "string" },
+          },
+          required: ["user_id"],
+        },
+      },
+    ],
+  }));
+
+  server.setRequestHandler(CallToolRequestSchema, async (req) => {
+    const { token, baseUrl = DEFAULT_BASE_URL, accountId } = loadAccount();
+    const { name, arguments: args } = req.params;
+    try {
+      let result: unknown;
+      if (name === "weixin_send") {
+        const a = (args ?? {}) as { to?: string; text?: string; context_token?: string };
+        result = await sendTextMessage(assertStr(a.to, "to"), assertStr(a.text, "text"), token!, baseUrl, a.context_token);
+      } else if (name === "weixin_poll") {
+        const { reset_cursor } = (args ?? {}) as { reset_cursor?: boolean };
+        const cursor = reset_cursor ? "" : loadCursor(accountId);
+        const resp = await getUpdates(token!, baseUrl, cursor);
+        if (resp.get_updates_buf) saveCursor(accountId, resp.get_updates_buf);
+        result = resp;
+      } else if (name === "weixin_get_config") {
+        const a = (args ?? {}) as { user_id?: string; context_token?: string };
+        result = await getConfig(assertStr(a.user_id, "user_id"), token!, baseUrl, a.context_token);
+      } else {
+        throw new Error(`Unknown tool: ${name}`);
+      }
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    } catch (err) {
+      return { content: [{ type: "text", text: `Error: ${fmtErr(err)}` }], isError: true };
+    }
+  });
+
+  return server;
+}
+
+// ── Express HTTP server ────────────────────────────────────────────────────
+
+const app = express();
+app.use(express.json());
+
+// Session store for stateful transports
+const sessions = new Map<string, StreamableHTTPServerTransport>();
+
+app.post("/mcp", async (req, res) => {
+  // Check if this is an existing session
+  const sessionId = req.headers["mcp-session-id"] as string | undefined;
+  let transport = sessionId ? sessions.get(sessionId) : undefined;
+
+  if (!transport) {
+    // New session
+    const newSessionId = randomUUID();
+    transport = new StreamableHTTPServerTransport({
+      sessionIdGenerator: () => newSessionId,
+      onsessioninitialized: (id) => { sessions.set(id, transport!); },
+    });
+    transport.onclose = () => { sessions.delete(newSessionId); };
+    const server = createMCPServer();
+    await server.connect(transport);
+  }
+
+  await transport.handleRequest(req, res, req.body);
+});
+
+app.get("/mcp", async (req, res) => {
+  const sessionId = req.headers["mcp-session-id"] as string | undefined;
+  const transport = sessionId ? sessions.get(sessionId) : undefined;
+  if (!transport) { res.status(404).json({ error: "Session not found" }); return; }
+  await transport.handleRequest(req, res);
+});
+
+app.delete("/mcp", async (req, res) => {
+  const sessionId = req.headers["mcp-session-id"] as string | undefined;
+  const transport = sessionId ? sessions.get(sessionId) : undefined;
+  if (!transport) { res.status(404).json({ error: "Session not found" }); return; }
+  await transport.handleRequest(req, res);
+});
+
+app.get("/health", (_req, res) => {
+  res.json({ status: "ok", port, sessions: sessions.size });
+});
+
+app.listen(port, () => {
+  console.log(`[weixin-mcp] HTTP MCP server listening on port ${port}`);
+  console.log(`[weixin-mcp] MCP endpoint: http://localhost:${port}/mcp`);
+});

package/src/status.ts

@@ -1,10 +1,23 @@
 import fs from "node:fs";
 import path from "node:path";
 import { ACCOUNTS_DIR } from "./paths.js";
+import { daemonStatus } from "./daemon.js";
 
 export async function showStatus() {
   console.log("🔍 weixin-mcp status\n");
 
+  // Daemon status
+  const { running, info } = daemonStatus();
+  if (running && info) {
+    console.log(`🟢 Daemon:    running (pid ${info.pid}, port ${info.port})`);
+    console.log(`   URL:       http://localhost:${info.port}/mcp`);
+    console.log(`   Started:   ${new Date(info.startedAt).toLocaleString()}`);
+  } else {
+    console.log("⚫ Daemon:    not running");
+    console.log("   Tip:       npx weixin-mcp start");
+  }
+  console.log();
+
   let files: string[];
   try {
     files = fs.readdirSync(ACCOUNTS_DIR).filter(