weixin-mcp 1.2.1 → 1.3.0

package/dist/api.js

@@ -1,7 +1,6 @@
 import crypto from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
-import os from "node:os";
 export const DEFAULT_BASE_URL = "https://ilinkai.weixin.qq.com";
 const CHANNEL_VERSION = "1.0.2";
 export class WeixinAuthError extends Error {
@@ -35,10 +34,9 @@ function buildHeaders(token, bodyStr) {
     };
 }
 // ── Cursor persistence ─────────────────────────────────────────────────────
-const STATE_DIR = process.env.OPENCLAW_STATE_DIR?.trim() ||
-    path.join(os.homedir(), ".openclaw");
+import { ACCOUNTS_DIR } from "./paths.js";
 function cursorPath(accountId) {
-    return path.join(STATE_DIR, "openclaw-weixin", "accounts", `${accountId}.cursor.json`);
+    return path.join(ACCOUNTS_DIR, `${accountId}.cursor.json`);
 }
 export function loadCursor(accountId) {
     try {

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,45 @@ 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 === 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 port: 3001)
+  stop               Stop daemon
+  restart            Restart daemon
+  logs [-f]          Show daemon logs (-f to follow)
+`);
     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/index.js

@@ -8,13 +8,10 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 import fs from "node:fs";
 import path from "node:path";
-import os from "node:os";
 import { DEFAULT_BASE_URL, getUpdates, getConfig, sendTextMessage, loadCursor, saveCursor, WeixinAuthError, WeixinNetworkError, } from "./api.js";
+import { ACCOUNTS_DIR } from "./paths.js";
 // ── Auth / config ──────────────────────────────────────────────────────────
-const STATE_DIR = process.env.OPENCLAW_STATE_DIR?.trim() ||
-    process.env.CLAWDBOT_STATE_DIR?.trim() ||
-    path.join(os.homedir(), ".openclaw");
-const WEIXIN_DIR = path.join(STATE_DIR, "openclaw-weixin", "accounts");
+const WEIXIN_DIR = ACCOUNTS_DIR;
 function loadAccount() {
     const files = fs
         .readdirSync(WEIXIN_DIR)

package/dist/login.d.ts

@@ -1,10 +1,8 @@
 #!/usr/bin/env node
 /**
- * weixin-login — standalone QR login for weixin-mcp
- * Usage: node dist/login.js
+ * weixin-login — QR login for weixin-mcp
+ * Usage: npx weixin-mcp login
  *
- * Fetches a QR code from Weixin API, renders it in terminal,
- * polls for scan confirmation, then saves token to:
- *   ~/.openclaw/openclaw-weixin/accounts/<accountId>.json
+ * Token saved to: ~/.weixin-mcp/accounts/ (or ~/.openclaw/openclaw-weixin/accounts/ if OpenClaw is installed)
  */
 export declare function main(): Promise<void>;

package/dist/login.js

@@ -1,23 +1,18 @@
 #!/usr/bin/env node
 /**
- * weixin-login — standalone QR login for weixin-mcp
- * Usage: node dist/login.js
+ * weixin-login — QR login for weixin-mcp
+ * Usage: npx weixin-mcp login
  *
- * Fetches a QR code from Weixin API, renders it in terminal,
- * polls for scan confirmation, then saves token to:
- *   ~/.openclaw/openclaw-weixin/accounts/<accountId>.json
+ * Token saved to: ~/.weixin-mcp/accounts/ (or ~/.openclaw/openclaw-weixin/accounts/ if OpenClaw is installed)
  */
 import fs from "node:fs";
 import path from "node:path";
-import os from "node:os";
 import crypto from "node:crypto";
 // @ts-ignore — no types for qrcode-terminal
 import qrcode from "qrcode-terminal";
+import { ACCOUNTS_DIR } from "./paths.js";
 const BASE_URL = "https://ilinkai.weixin.qq.com";
 const BOT_TYPE = "3";
-const STATE_DIR = process.env.OPENCLAW_STATE_DIR?.trim() ||
-    path.join(os.homedir(), ".openclaw");
-const ACCOUNTS_DIR = path.join(STATE_DIR, "openclaw-weixin", "accounts");
 async function fetchQRCode() {
     const base = BASE_URL.endsWith("/") ? BASE_URL : `${BASE_URL}/`;
     const url = `${base}ilink/bot/get_bot_qrcode?bot_type=${BOT_TYPE}`;

package/dist/paths.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Resolve the accounts directory.
+ *
+ * Priority:
+ * 1. WEIXIN_MCP_DIR env var (explicit override)
+ * 2. If OpenClaw state dir exists → ~/.openclaw/openclaw-weixin/accounts/ (backward compat)
+ * 3. Default → ~/.weixin-mcp/accounts/
+ */
+export declare const ACCOUNTS_DIR: string;

package/dist/paths.js

@@ -0,0 +1,28 @@
+/**
+ * Resolve the accounts directory.
+ *
+ * Priority:
+ * 1. WEIXIN_MCP_DIR env var (explicit override)
+ * 2. If OpenClaw state dir exists → ~/.openclaw/openclaw-weixin/accounts/ (backward compat)
+ * 3. Default → ~/.weixin-mcp/accounts/
+ */
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+function resolveAccountsDir() {
+    // Explicit override
+    if (process.env.WEIXIN_MCP_DIR?.trim()) {
+        return process.env.WEIXIN_MCP_DIR.trim();
+    }
+    // OpenClaw compat: if the OpenClaw weixin accounts dir exists, use it
+    const openclawStateDir = process.env.OPENCLAW_STATE_DIR?.trim() ||
+        process.env.CLAWDBOT_STATE_DIR?.trim() ||
+        path.join(os.homedir(), ".openclaw");
+    const openclawAccountsDir = path.join(openclawStateDir, "openclaw-weixin", "accounts");
+    if (fs.existsSync(openclawAccountsDir)) {
+        return openclawAccountsDir;
+    }
+    // Default: standalone ~/.weixin-mcp/accounts/
+    return path.join(os.homedir(), ".weixin-mcp", "accounts");
+}
+export const ACCOUNTS_DIR = resolveAccountsDir();

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,11 +1,21 @@
 import fs from "node:fs";
 import path from "node:path";
-import os from "node:os";
-const STATE_DIR = process.env.OPENCLAW_STATE_DIR?.trim() ||
-    path.join(os.homedir(), ".openclaw");
-const ACCOUNTS_DIR = path.join(STATE_DIR, "openclaw-weixin", "accounts");
+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.1",
+  "version": "1.3.0",
   "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/api.ts

@@ -1,7 +1,6 @@
 import crypto from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
-import os from "node:os";
 
 export const DEFAULT_BASE_URL = "https://ilinkai.weixin.qq.com";
 const CHANNEL_VERSION = "1.0.2";
@@ -44,12 +43,10 @@ function buildHeaders(token: string, bodyStr: string): Record<string, string> {
 
 // ── Cursor persistence ─────────────────────────────────────────────────────
 
-const STATE_DIR =
-  process.env.OPENCLAW_STATE_DIR?.trim() ||
-  path.join(os.homedir(), ".openclaw");
+import { ACCOUNTS_DIR } from "./paths.js";
 
 function cursorPath(accountId: string): string {
-  return path.join(STATE_DIR, "openclaw-weixin", "accounts", `${accountId}.cursor.json`);
+  return path.join(ACCOUNTS_DIR, `${accountId}.cursor.json`);
 }
 
 export function loadCursor(accountId: string): string {

package/src/cli.ts

@@ -1,30 +1,65 @@
 #!/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 === 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 port: 3001)
+  stop               Stop daemon
+  restart            Restart daemon
+  logs [-f]          Show daemon logs (-f to follow)
+`);
   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/index.ts

@@ -12,7 +12,6 @@ import {
 } from "@modelcontextprotocol/sdk/types.js";
 import fs from "node:fs";
 import path from "node:path";
-import os from "node:os";
 import {
   DEFAULT_BASE_URL,
   getUpdates,
@@ -23,15 +22,11 @@ import {
   WeixinAuthError,
   WeixinNetworkError,
 } from "./api.js";
+import { ACCOUNTS_DIR } from "./paths.js";
 
 // ── Auth / config ──────────────────────────────────────────────────────────
 
-const STATE_DIR =
-  process.env.OPENCLAW_STATE_DIR?.trim() ||
-  process.env.CLAWDBOT_STATE_DIR?.trim() ||
-  path.join(os.homedir(), ".openclaw");
-
-const WEIXIN_DIR = path.join(STATE_DIR, "openclaw-weixin", "accounts");
+const WEIXIN_DIR = ACCOUNTS_DIR;
 
 interface AccountData {
   token?: string;

package/src/login.ts

@@ -1,26 +1,20 @@
 #!/usr/bin/env node
 /**
- * weixin-login — standalone QR login for weixin-mcp
- * Usage: node dist/login.js
+ * weixin-login — QR login for weixin-mcp
+ * Usage: npx weixin-mcp login
  *
- * Fetches a QR code from Weixin API, renders it in terminal,
- * polls for scan confirmation, then saves token to:
- *   ~/.openclaw/openclaw-weixin/accounts/<accountId>.json
+ * Token saved to: ~/.weixin-mcp/accounts/ (or ~/.openclaw/openclaw-weixin/accounts/ if OpenClaw is installed)
  */
 
 import fs from "node:fs";
 import path from "node:path";
-import os from "node:os";
 import crypto from "node:crypto";
 // @ts-ignore — no types for qrcode-terminal
 import qrcode from "qrcode-terminal";
+import { ACCOUNTS_DIR } from "./paths.js";
 
 const BASE_URL = "https://ilinkai.weixin.qq.com";
 const BOT_TYPE = "3";
-const STATE_DIR =
-  process.env.OPENCLAW_STATE_DIR?.trim() ||
-  path.join(os.homedir(), ".openclaw");
-const ACCOUNTS_DIR = path.join(STATE_DIR, "openclaw-weixin", "accounts");
 
 async function fetchQRCode(): Promise<{ qrcode: string; qrcode_img_content: string }> {
   const base = BASE_URL.endsWith("/") ? BASE_URL : `${BASE_URL}/`;

package/src/paths.ts

@@ -0,0 +1,35 @@
+/**
+ * Resolve the accounts directory.
+ *
+ * Priority:
+ * 1. WEIXIN_MCP_DIR env var (explicit override)
+ * 2. If OpenClaw state dir exists → ~/.openclaw/openclaw-weixin/accounts/ (backward compat)
+ * 3. Default → ~/.weixin-mcp/accounts/
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+
+function resolveAccountsDir(): string {
+  // Explicit override
+  if (process.env.WEIXIN_MCP_DIR?.trim()) {
+    return process.env.WEIXIN_MCP_DIR.trim();
+  }
+
+  // OpenClaw compat: if the OpenClaw weixin accounts dir exists, use it
+  const openclawStateDir =
+    process.env.OPENCLAW_STATE_DIR?.trim() ||
+    process.env.CLAWDBOT_STATE_DIR?.trim() ||
+    path.join(os.homedir(), ".openclaw");
+
+  const openclawAccountsDir = path.join(openclawStateDir, "openclaw-weixin", "accounts");
+  if (fs.existsSync(openclawAccountsDir)) {
+    return openclawAccountsDir;
+  }
+
+  // Default: standalone ~/.weixin-mcp/accounts/
+  return path.join(os.homedir(), ".weixin-mcp", "accounts");
+}
+
+export const ACCOUNTS_DIR = resolveAccountsDir();

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,16 +1,23 @@
 import fs from "node:fs";
 import path from "node:path";
-import os from "node:os";
-
-const STATE_DIR =
-  process.env.OPENCLAW_STATE_DIR?.trim() ||
-  path.join(os.homedir(), ".openclaw");
-
-const ACCOUNTS_DIR = path.join(STATE_DIR, "openclaw-weixin", "accounts");
+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(