claude-wechat-channel 0.1.0

package/README.md

@@ -0,0 +1,88 @@
+# claude-wechat-channel
+
+微信 Channel for [Claude Code](https://docs.anthropic.com/en/docs/claude-code)。
+
+让 Claude Code 直接通过微信收发消息 — 微信消息到达后，Claude Code 在当前 session 中处理并回复，完整保留上下文和工具能力。
+
+## 工作原理
+
+本项目是一个 MCP server，声明了 `claude/channel` capability（[Claude Code Channel](https://docs.anthropic.com/en/docs/claude-code) v2.1.80+ 的官方扩展机制）。三方各司其职：
+
+| 角色 | 职责 |
+|------|------|
+| **微信** | 用户发送/接收消息的 IM 平台 |
+| **claude-wechat-channel** | 轮询微信 API 获取新消息，推送 MCP notification 给 Claude Code；接收 Claude Code 的 reply tool 调用，将回复发送到微信（自动分段、markdown 转纯文本） |
+| **Claude Code** | 接收 channel 推送的消息，在当前 session 中处理（可使用所有工具能力），通过 reply tool 回复，原生管理会话上下文 |
+
+## 快速开始
+
+### 前置条件
+
+- [Claude Code](https://docs.anthropic.com/en/docs/claude-code) v2.1.80+
+- [Bun](https://bun.sh/) 运行时
+
+### 1. 注册 MCP server
+
+在你想让 Claude Code 工作的目录下，创建或编辑 `.mcp.json`：
+
+```json
+{
+  "mcpServers": {
+    "wechat": {
+      "command": "npx",
+      "args": ["claude-wechat-channel"]
+    }
+  }
+}
+```
+
+### 2. 启动 Claude Code
+
+```bash
+claude --dangerously-load-development-channels server:wechat
+```
+
+首次启动会在终端显示微信二维码，用微信扫码登录。登录凭证会保存到 `~/.wechat-claude/`，后续启动自动恢复。
+
+### 3. 开始使用
+
+从另一个微信账号给登录的账号发消息，Claude Code 会自动接收并回复。
+
+## 配置
+
+通过环境变量配置，在 `.mcp.json` 中传入：
+
+```json
+{
+  "mcpServers": {
+    "wechat": {
+      "command": "npx",
+      "args": ["claude-wechat-channel"],
+      "env": {
+        "DATA_DIR": "~/.wechat-claude",
+        "DEBUG": "1"
+      }
+    }
+  }
+}
+```
+
+| 变量 | 默认值 | 说明 |
+|------|--------|------|
+| `DATA_DIR` | `~/.wechat-claude` | 数据持久化目录（账号凭证、同步状态） |
+| `DEBUG` | 未设置 | 设置任意值开启调试日志 |
+
+## 内置处理
+
+- **自动分段**：微信单条消息限制 4000 字符，超长回复会自动拆分为多条发送
+- **Markdown 转纯文本**：Claude 的回复会自动去除 markdown 格式（微信不支持渲染）
+- **凭证持久化**：微信登录凭证保存在 `DATA_DIR` 目录下，重启自动恢复登录状态
+
+## 注意事项
+
+- Channel 功能目前是 Claude Code 的实验性特性，需要 `--dangerously-load-development-channels` 标志
+- `DATA_DIR` 下的凭证文件请妥善保管
+
+## License
+
+MIT

package/dist/config.d.ts

@@ -0,0 +1,6 @@
+export type Config = {
+    weixinBaseUrl: string;
+    weixinCdnBaseUrl: string;
+    dataDir: string;
+};
+export declare function loadConfig(): Config;

package/dist/config.js

@@ -0,0 +1,24 @@
+import { z } from "zod";
+import path from "node:path";
+import os from "node:os";
+const configSchema = z.object({
+    WEIXIN_BASE_URL: z.string().default("https://ilinkai.weixin.qq.com"),
+    WEIXIN_CDN_BASE_URL: z.string().default("https://novac2c.cdn.weixin.qq.com/c2c"),
+    DATA_DIR: z.string().default("~/.wechat-claude"),
+    DEBUG: z.string().optional(),
+});
+function expandHome(p) {
+    if (p.startsWith("~/")) {
+        return path.join(os.homedir(), p.slice(2));
+    }
+    return p;
+}
+export function loadConfig() {
+    const raw = configSchema.parse(process.env);
+    const dataDir = expandHome(raw.DATA_DIR);
+    return {
+        weixinBaseUrl: raw.WEIXIN_BASE_URL,
+        weixinCdnBaseUrl: raw.WEIXIN_CDN_BASE_URL,
+        dataDir,
+    };
+}

package/dist/logger.d.ts

@@ -0,0 +1,7 @@
+/** Simple logger — all output to stderr to avoid conflicting with MCP stdio transport on stdout. */
+export declare const logger: {
+    info: (msg: string) => void;
+    warn: (msg: string) => void;
+    error: (msg: string) => void;
+    debug: (msg: string) => void;
+};

package/dist/logger.js

@@ -0,0 +1,10 @@
+/** Simple logger — all output to stderr to avoid conflicting with MCP stdio transport on stdout. */
+export const logger = {
+    info: (msg) => console.error(`[INFO] ${msg}`),
+    warn: (msg) => console.error(`[WARN] ${msg}`),
+    error: (msg) => console.error(`[ERROR] ${msg}`),
+    debug: (msg) => {
+        if (process.env.DEBUG)
+            console.error(`[DEBUG] ${msg}`);
+    },
+};

package/dist/monitor.d.ts

@@ -0,0 +1,10 @@
+import type { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import type { Config } from "./config.js";
+export type MonitorOpts = {
+    config: Config;
+    token: string;
+    accountId: string;
+    mcp: Server;
+    abortSignal?: AbortSignal;
+};
+export declare function startMonitor(opts: MonitorOpts): Promise<void>;

package/dist/monitor.js

@@ -0,0 +1,126 @@
+import { getUpdates } from "./weixin/api.js";
+import { SESSION_EXPIRED_ERRCODE, pauseSession, getRemainingPauseMs } from "./weixin/session-guard.js";
+import { bodyFromItemList, setContextToken } from "./weixin/inbound.js";
+import { loadSyncBuf, saveSyncBuf } from "./weixin/auth.js";
+import { logger } from "./logger.js";
+import { MessageType } from "./weixin/types.js";
+const DEFAULT_LONG_POLL_TIMEOUT_MS = 35_000;
+const MAX_CONSECUTIVE_FAILURES = 3;
+const BACKOFF_DELAY_MS = 30_000;
+const RETRY_DELAY_MS = 2_000;
+export async function startMonitor(opts) {
+    const { config, token, accountId, mcp, abortSignal } = opts;
+    const baseUrl = config.weixinBaseUrl;
+    logger.info(`monitor started: baseUrl=${baseUrl} accountId=${accountId}`);
+    let getUpdatesBuf = loadSyncBuf();
+    if (getUpdatesBuf) {
+        logger.info(`resuming from previous sync buf (${getUpdatesBuf.length} bytes)`);
+    }
+    else {
+        logger.info(`no previous sync buf, starting fresh`);
+    }
+    let nextTimeoutMs = DEFAULT_LONG_POLL_TIMEOUT_MS;
+    let consecutiveFailures = 0;
+    while (!abortSignal?.aborted) {
+        try {
+            const resp = await getUpdates({
+                baseUrl,
+                token,
+                get_updates_buf: getUpdatesBuf,
+                timeoutMs: nextTimeoutMs,
+            });
+            if (resp.longpolling_timeout_ms != null && resp.longpolling_timeout_ms > 0) {
+                nextTimeoutMs = resp.longpolling_timeout_ms;
+            }
+            const isApiError = (resp.ret !== undefined && resp.ret !== 0) ||
+                (resp.errcode !== undefined && resp.errcode !== 0);
+            if (isApiError) {
+                const isSessionExpired = resp.errcode === SESSION_EXPIRED_ERRCODE || resp.ret === SESSION_EXPIRED_ERRCODE;
+                if (isSessionExpired) {
+                    pauseSession(accountId);
+                    const pauseMs = getRemainingPauseMs(accountId);
+                    logger.error(`getUpdates: session expired (errcode=${resp.errcode}), pausing for ${Math.ceil(pauseMs / 60_000)} min`);
+                    consecutiveFailures = 0;
+                    await sleep(pauseMs, abortSignal);
+                    continue;
+                }
+                consecutiveFailures += 1;
+                logger.error(`getUpdates failed: ret=${resp.ret} errcode=${resp.errcode} errmsg=${resp.errmsg ?? ""} (${consecutiveFailures}/${MAX_CONSECUTIVE_FAILURES})`);
+                if (consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {
+                    logger.error(`${MAX_CONSECUTIVE_FAILURES} consecutive failures, backing off 30s`);
+                    consecutiveFailures = 0;
+                    await sleep(BACKOFF_DELAY_MS, abortSignal);
+                }
+                else {
+                    await sleep(RETRY_DELAY_MS, abortSignal);
+                }
+                continue;
+            }
+            consecutiveFailures = 0;
+            if (resp.get_updates_buf != null && resp.get_updates_buf !== "") {
+                saveSyncBuf(resp.get_updates_buf);
+                getUpdatesBuf = resp.get_updates_buf;
+            }
+            const msgs = resp.msgs ?? [];
+            for (const msg of msgs) {
+                // Skip bot's own messages
+                if (msg.message_type === MessageType.BOT)
+                    continue;
+                const fromUserId = msg.from_user_id ?? "";
+                if (!fromUserId)
+                    continue;
+                // Cache context token
+                if (msg.context_token) {
+                    setContextToken(fromUserId, msg.context_token);
+                }
+                // Extract text
+                const text = bodyFromItemList(msg.item_list);
+                if (!text) {
+                    logger.debug(`skipping non-text message from ${fromUserId}`);
+                    continue;
+                }
+                logger.info(`inbound: from=${fromUserId} text="${text.substring(0, 100)}"`);
+                // Push notification to Claude Code via MCP channel
+                try {
+                    await mcp.notification({
+                        method: "notifications/claude/channel",
+                        params: {
+                            content: text,
+                            meta: { sender: fromUserId, user_id: fromUserId },
+                        },
+                    });
+                    logger.info(`notification pushed for ${fromUserId}`);
+                }
+                catch (err) {
+                    logger.error(`failed to push notification for ${fromUserId}: ${String(err)}`);
+                }
+            }
+        }
+        catch (err) {
+            if (abortSignal?.aborted) {
+                logger.info("monitor stopped (aborted)");
+                return;
+            }
+            consecutiveFailures += 1;
+            logger.error(`getUpdates error (${consecutiveFailures}/${MAX_CONSECUTIVE_FAILURES}): ${String(err)}`);
+            if (consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {
+                logger.error(`${MAX_CONSECUTIVE_FAILURES} consecutive failures, backing off 30s`);
+                consecutiveFailures = 0;
+                await sleep(BACKOFF_DELAY_MS, abortSignal);
+            }
+            else {
+                await sleep(RETRY_DELAY_MS, abortSignal);
+            }
+        }
+    }
+    logger.info("monitor ended");
+}
+function sleep(ms, signal) {
+    return new Promise((resolve, reject) => {
+        const t = setTimeout(resolve, ms);
+        signal?.addEventListener("abort", () => {
+            clearTimeout(t);
+            reject(new Error("aborted"));
+        }, { once: true });
+    });
+}

package/dist/server.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/server.js

@@ -0,0 +1,179 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import path from "node:path";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { ListToolsRequestSchema, CallToolRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { loadConfig } from "./config.js";
+import { logger } from "./logger.js";
+import { setDataDir, loadAccount, saveAccount, loginWithQR } from "./weixin/auth.js";
+import { getContextToken } from "./weixin/inbound.js";
+import { sendMessageWeixin, markdownToPlainText } from "./weixin/send.js";
+import { startMonitor } from "./monitor.js";
+// ── .env loading ──────────────────────────────────────────────────────────────
+try {
+    const envPath = path.resolve(process.cwd(), ".env");
+    if (fs.existsSync(envPath)) {
+        const content = fs.readFileSync(envPath, "utf-8");
+        for (const line of content.split("\n")) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith("#"))
+                continue;
+            const eqIdx = trimmed.indexOf("=");
+            if (eqIdx <= 0)
+                continue;
+            const key = trimmed.substring(0, eqIdx).trim();
+            const value = trimmed.substring(eqIdx + 1).trim();
+            if (!process.env[key]) {
+                process.env[key] = value;
+            }
+        }
+    }
+}
+catch {
+    /* ignore */
+}
+// ── Config ────────────────────────────────────────────────────────────────────
+const config = loadConfig();
+fs.mkdirSync(config.dataDir, { recursive: true });
+setDataDir(config.dataDir);
+// ── MCP Server ────────────────────────────────────────────────────────────────
+const WEIXIN_MAX_CHARS = 4000;
+function splitMessage(text) {
+    if (text.length <= WEIXIN_MAX_CHARS)
+        return [text];
+    const chunks = [];
+    let remaining = text;
+    while (remaining.length > 0) {
+        if (remaining.length <= WEIXIN_MAX_CHARS) {
+            chunks.push(remaining);
+            break;
+        }
+        let splitAt = remaining.lastIndexOf("\n", WEIXIN_MAX_CHARS);
+        if (splitAt <= 0 || splitAt < WEIXIN_MAX_CHARS * 0.5) {
+            splitAt = WEIXIN_MAX_CHARS;
+        }
+        chunks.push(remaining.substring(0, splitAt));
+        remaining = remaining.substring(splitAt).trimStart();
+    }
+    return chunks;
+}
+const mcp = new Server({ name: "wechat", version: "0.1.0" }, {
+    capabilities: {
+        experimental: { "claude/channel": {} },
+        tools: {},
+    },
+    instructions: `微信消息以 <channel source="wechat" sender="..." user_id="..."> 格式到达。
+用 reply tool 回复，传入 user_id 参数。回复内容用纯文本，不要用 markdown 格式。
+超过 ${WEIXIN_MAX_CHARS} 字的回复会自动分段发送。`,
+});
+// ── Tools ─────────────────────────────────────────────────────────────────────
+mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [
+        {
+            name: "reply",
+            description: "回复微信消息。text 会自动从 markdown 转换为纯文本，超长消息会自动分段。",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    user_id: { type: "string", description: "接收消息的微信用户 ID" },
+                    text: { type: "string", description: "回复内容" },
+                },
+                required: ["user_id", "text"],
+            },
+        },
+    ],
+}));
+let weixinToken = "";
+mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
+    if (req.params.name === "reply") {
+        const { user_id, text } = req.params.arguments;
+        const contextToken = getContextToken(user_id);
+        if (!contextToken) {
+            return {
+                content: [{ type: "text", text: `错误: 没有 user_id=${user_id} 的 contextToken，无法发送` }],
+                isError: true,
+            };
+        }
+        const chunks = splitMessage(markdownToPlainText(text));
+        for (const chunk of chunks) {
+            await sendMessageWeixin({
+                to: user_id,
+                text: chunk,
+                opts: {
+                    baseUrl: config.weixinBaseUrl,
+                    token: weixinToken,
+                    contextToken,
+                },
+            });
+        }
+        logger.info(`reply sent to ${user_id}: ${chunks.length} chunk(s)`);
+        return { content: [{ type: "text", text: "sent" }] };
+    }
+    return {
+        content: [{ type: "text", text: `未知工具: ${req.params.name}` }],
+        isError: true,
+    };
+});
+// ── Bootstrap ─────────────────────────────────────────────────────────────────
+async function bootstrap() {
+    // Connect MCP transport first (stdio)
+    const transport = new StdioServerTransport();
+    await mcp.connect(transport);
+    logger.info("MCP server connected via stdio");
+    // WeChat login
+    let account = loadAccount();
+    if (!account?.token || !account?.accountId) {
+        logger.info("未找到已保存的账号，开始微信登录...");
+        const result = await loginWithQR({ apiBaseUrl: config.weixinBaseUrl });
+        if (!result.connected || !result.botToken || !result.accountId) {
+            logger.error(`登录失败: ${result.message}`);
+            process.exit(1);
+        }
+        saveAccount(result.accountId, {
+            token: result.botToken,
+            baseUrl: result.baseUrl,
+            userId: result.userId,
+        });
+        logger.info(result.message);
+        account = loadAccount();
+    }
+    if (!account?.token || !account?.accountId) {
+        logger.error("无法加载账号信息");
+        process.exit(1);
+    }
+    weixinToken = account.token;
+    logger.info(`已登录账号: ${account.accountId}`);
+    // Graceful shutdown
+    const abortController = new AbortController();
+    const shutdown = () => {
+        logger.info("正在退出...");
+        abortController.abort();
+        setTimeout(() => process.exit(0), 2000);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    // Start monitor (pushes notifications to Claude via mcp)
+    try {
+        await startMonitor({
+            config,
+            token: account.token,
+            accountId: account.accountId,
+            mcp,
+            abortSignal: abortController.signal,
+        });
+    }
+    catch (err) {
+        if (abortController.signal.aborted) {
+            logger.info("程序已退出");
+        }
+        else {
+            logger.error(`monitor 异常退出: ${String(err)}`);
+            process.exit(1);
+        }
+    }
+}
+bootstrap().catch((err) => {
+    logger.error(`Fatal error: ${String(err)}`);
+    process.exit(1);
+});

package/dist/weixin/api.d.ts

@@ -0,0 +1,26 @@
+import type { BaseInfo, GetUploadUrlReq, GetUploadUrlResp, GetUpdatesReq, GetUpdatesResp, SendMessageReq, SendTypingReq, GetConfigResp } from "./types.js";
+export type WeixinApiOptions = {
+    baseUrl: string;
+    token?: string;
+    timeoutMs?: number;
+    longPollTimeoutMs?: number;
+    routeTag?: string;
+};
+export declare function buildBaseInfo(): BaseInfo;
+export declare function getUpdates(params: GetUpdatesReq & {
+    baseUrl: string;
+    token?: string;
+    routeTag?: string;
+    timeoutMs?: number;
+}): Promise<GetUpdatesResp>;
+export declare function getUploadUrl(params: GetUploadUrlReq & WeixinApiOptions): Promise<GetUploadUrlResp>;
+export declare function sendMessage(params: WeixinApiOptions & {
+    body: SendMessageReq;
+}): Promise<void>;
+export declare function getConfig(params: WeixinApiOptions & {
+    ilinkUserId: string;
+    contextToken?: string;
+}): Promise<GetConfigResp>;
+export declare function sendTyping(params: WeixinApiOptions & {
+    body: SendTypingReq;
+}): Promise<void>;

package/dist/weixin/api.js

@@ -0,0 +1,161 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { logger } from "../logger.js";
+import { redactBody, redactUrl } from "./util/redact.js";
+function readChannelVersion() {
+    try {
+        const dir = path.dirname(fileURLToPath(import.meta.url));
+        const pkgPath = path.resolve(dir, "..", "..", "package.json");
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+        return pkg.version ?? "unknown";
+    }
+    catch {
+        return "unknown";
+    }
+}
+const CHANNEL_VERSION = readChannelVersion();
+export function buildBaseInfo() {
+    return { channel_version: CHANNEL_VERSION };
+}
+const DEFAULT_LONG_POLL_TIMEOUT_MS = 35_000;
+const DEFAULT_API_TIMEOUT_MS = 15_000;
+const DEFAULT_CONFIG_TIMEOUT_MS = 10_000;
+function ensureTrailingSlash(url) {
+    return url.endsWith("/") ? url : `${url}/`;
+}
+function randomWechatUin() {
+    const uint32 = crypto.randomBytes(4).readUInt32BE(0);
+    return Buffer.from(String(uint32), "utf-8").toString("base64");
+}
+function buildHeaders(opts) {
+    const headers = {
+        "Content-Type": "application/json",
+        AuthorizationType: "ilink_bot_token",
+        "Content-Length": String(Buffer.byteLength(opts.body, "utf-8")),
+        "X-WECHAT-UIN": randomWechatUin(),
+    };
+    if (opts.token?.trim()) {
+        headers.Authorization = `Bearer ${opts.token.trim()}`;
+    }
+    if (opts.routeTag) {
+        headers.SKRouteTag = opts.routeTag;
+    }
+    return headers;
+}
+async function apiFetch(params) {
+    const base = ensureTrailingSlash(params.baseUrl);
+    const url = new URL(params.endpoint, base);
+    const hdrs = buildHeaders({ token: params.token, body: params.body, routeTag: params.routeTag });
+    logger.debug(`POST ${redactUrl(url.toString())} body=${redactBody(params.body)}`);
+    const controller = new AbortController();
+    const t = setTimeout(() => controller.abort(), params.timeoutMs);
+    try {
+        const res = await fetch(url.toString(), {
+            method: "POST",
+            headers: hdrs,
+            body: params.body,
+            signal: controller.signal,
+        });
+        clearTimeout(t);
+        const rawText = await res.text();
+        logger.debug(`${params.label} status=${res.status} raw=${redactBody(rawText)}`);
+        if (!res.ok) {
+            throw new Error(`${params.label} ${res.status}: ${rawText}`);
+        }
+        return rawText;
+    }
+    catch (err) {
+        clearTimeout(t);
+        throw err;
+    }
+}
+export async function getUpdates(params) {
+    const timeout = params.timeoutMs ?? DEFAULT_LONG_POLL_TIMEOUT_MS;
+    try {
+        const rawText = await apiFetch({
+            baseUrl: params.baseUrl,
+            endpoint: "ilink/bot/getupdates",
+            body: JSON.stringify({
+                get_updates_buf: params.get_updates_buf ?? "",
+                base_info: buildBaseInfo(),
+            }),
+            token: params.token,
+            routeTag: params.routeTag,
+            timeoutMs: timeout,
+            label: "getUpdates",
+        });
+        return JSON.parse(rawText);
+    }
+    catch (err) {
+        if (err instanceof Error && err.name === "AbortError") {
+            logger.debug(`getUpdates: client-side timeout after ${timeout}ms, returning empty response`);
+            return { ret: 0, msgs: [], get_updates_buf: params.get_updates_buf };
+        }
+        throw err;
+    }
+}
+export async function getUploadUrl(params) {
+    const rawText = await apiFetch({
+        baseUrl: params.baseUrl,
+        endpoint: "ilink/bot/getuploadurl",
+        body: JSON.stringify({
+            filekey: params.filekey,
+            media_type: params.media_type,
+            to_user_id: params.to_user_id,
+            rawsize: params.rawsize,
+            rawfilemd5: params.rawfilemd5,
+            filesize: params.filesize,
+            thumb_rawsize: params.thumb_rawsize,
+            thumb_rawfilemd5: params.thumb_rawfilemd5,
+            thumb_filesize: params.thumb_filesize,
+            no_need_thumb: params.no_need_thumb,
+            aeskey: params.aeskey,
+            base_info: buildBaseInfo(),
+        }),
+        token: params.token,
+        routeTag: params.routeTag,
+        timeoutMs: params.timeoutMs ?? DEFAULT_API_TIMEOUT_MS,
+        label: "getUploadUrl",
+    });
+    return JSON.parse(rawText);
+}
+export async function sendMessage(params) {
+    await apiFetch({
+        baseUrl: params.baseUrl,
+        endpoint: "ilink/bot/sendmessage",
+        body: JSON.stringify({ ...params.body, base_info: buildBaseInfo() }),
+        token: params.token,
+        routeTag: params.routeTag,
+        timeoutMs: params.timeoutMs ?? DEFAULT_API_TIMEOUT_MS,
+        label: "sendMessage",
+    });
+}
+export async function getConfig(params) {
+    const rawText = await apiFetch({
+        baseUrl: params.baseUrl,
+        endpoint: "ilink/bot/getconfig",
+        body: JSON.stringify({
+            ilink_user_id: params.ilinkUserId,
+            context_token: params.contextToken,
+            base_info: buildBaseInfo(),
+        }),
+        token: params.token,
+        routeTag: params.routeTag,
+        timeoutMs: params.timeoutMs ?? DEFAULT_CONFIG_TIMEOUT_MS,
+        label: "getConfig",
+    });
+    return JSON.parse(rawText);
+}
+export async function sendTyping(params) {
+    await apiFetch({
+        baseUrl: params.baseUrl,
+        endpoint: "ilink/bot/sendtyping",
+        body: JSON.stringify({ ...params.body, base_info: buildBaseInfo() }),
+        token: params.token,
+        routeTag: params.routeTag,
+        timeoutMs: params.timeoutMs ?? DEFAULT_CONFIG_TIMEOUT_MS,
+        label: "sendTyping",
+    });
+}

package/dist/weixin/auth.d.ts

@@ -0,0 +1,29 @@
+export type WeixinAccountData = {
+    token?: string;
+    savedAt?: string;
+    baseUrl?: string;
+    userId?: string;
+    accountId?: string;
+};
+export declare function setDataDir(dir: string): void;
+export declare function loadAccount(): WeixinAccountData | null;
+export declare function saveAccount(accountId: string, data: Partial<WeixinAccountData>): void;
+export declare function loadSyncBuf(): string;
+export declare function saveSyncBuf(buf: string): void;
+export declare const DEFAULT_ILINK_BOT_TYPE = "3";
+export type LoginResult = {
+    connected: boolean;
+    botToken?: string;
+    accountId?: string;
+    baseUrl?: string;
+    userId?: string;
+    message: string;
+};
+/**
+ * Full QR login flow: fetch QR → display in terminal → poll status → return credentials.
+ */
+export declare function loginWithQR(opts: {
+    apiBaseUrl: string;
+    botType?: string;
+    timeoutMs?: number;
+}): Promise<LoginResult>;