cli-wechat-bridge 1.0.5

package/dist/wechat/setup.js

@@ -0,0 +1,283 @@
+#!/usr/bin/env bun
+/**
+ * CLI WeChat Bridge setup.
+ *
+ * Installed bridge commands run this automatically on first use.
+ * To force a relogin manually:
+ *   wechat-setup
+ */
+import crypto from "node:crypto";
+import fs from "node:fs";
+import readline from "node:readline";
+import { BOT_TYPE, CONTEXT_CACHE_FILE, CREDENTIALS_FILE, DEFAULT_BASE_URL, ensureChannelDataDir, migrateLegacyChannelFiles, SYNC_BUF_FILE, } from "./channel-config.js";
+import { isWechatSyncSessionTimeout } from "./wechat-transport.js";
+const CHANNEL_VERSION = "0.3.0";
+export function loadExistingCredentials() {
+    try {
+        if (!fs.existsSync(CREDENTIALS_FILE)) {
+            return null;
+        }
+        return JSON.parse(fs.readFileSync(CREDENTIALS_FILE, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+export function getWechatLoginRequiredReason(account, options = {}) {
+    if (!account) {
+        return "No saved WeChat credentials found.";
+    }
+    if (options.requireUserId && !account.userId) {
+        return "Saved WeChat credentials are missing userId.";
+    }
+    return null;
+}
+function randomWechatUin() {
+    const uint32 = crypto.randomBytes(4).readUInt32BE(0);
+    return Buffer.from(String(uint32), "utf-8").toString("base64");
+}
+export async function getStoredCredentialsInvalidReason(account, options = {}) {
+    const baseUrl = account.baseUrl || DEFAULT_BASE_URL;
+    const base = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+    const url = `${base}ilink/bot/getupdates`;
+    const body = JSON.stringify({
+        get_updates_buf: "",
+        base_info: { channel_version: CHANNEL_VERSION },
+    });
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), options.timeoutMs ?? 5_000);
+    try {
+        const res = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "Content-Length": String(Buffer.byteLength(body, "utf-8")),
+                AuthorizationType: "ilink_bot_token",
+                Authorization: `Bearer ${account.token}`,
+                "X-WECHAT-UIN": randomWechatUin(),
+            },
+            body,
+            signal: controller.signal,
+        });
+        const text = await res.text();
+        if (res.status === 401 || res.status === 403) {
+            return "Saved WeChat credentials were rejected by the server.";
+        }
+        if (!res.ok) {
+            return null;
+        }
+        const response = JSON.parse(text);
+        if (isWechatSyncSessionTimeout(response)) {
+            return "Saved WeChat login has expired.";
+        }
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === "AbortError") {
+            return null;
+        }
+        return null;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+    return null;
+}
+async function fetchQRCode(baseUrl) {
+    const base = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+    const url = `${base}ilink/bot/get_bot_qrcode?bot_type=${BOT_TYPE}`;
+    const res = await fetch(url);
+    if (!res.ok) {
+        throw new Error(`QR fetch failed: ${res.status}`);
+    }
+    return (await res.json());
+}
+async function pollQRStatus(baseUrl, qrcode) {
+    const base = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+    const url = `${base}ilink/bot/get_qrcode_status?qrcode=${encodeURIComponent(qrcode)}`;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 35_000);
+    try {
+        const res = await fetch(url, {
+            headers: { "iLink-App-ClientVersion": "1" },
+            signal: controller.signal,
+        });
+        clearTimeout(timer);
+        if (!res.ok) {
+            throw new Error(`QR status failed: ${res.status}`);
+        }
+        return (await res.json());
+    }
+    catch (err) {
+        clearTimeout(timer);
+        if (err instanceof Error && err.name === "AbortError") {
+            return { status: "wait" };
+        }
+        throw err;
+    }
+}
+async function askYesNo(prompt) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    try {
+        const answer = await new Promise((resolve) => {
+            rl.question(prompt, resolve);
+        });
+        return answer.trim().toLowerCase() === "y";
+    }
+    finally {
+        rl.close();
+    }
+}
+async function printQRCode(qrContent, write) {
+    try {
+        const qrterm = await import("qrcode-terminal");
+        await new Promise((resolve) => {
+            qrterm.default.generate(qrContent, { small: true }, (qr) => {
+                write(`${qr}\n`);
+                resolve();
+            });
+        });
+    }
+    catch {
+        write(`Open this QR code URL in a browser: ${qrContent}\n\n`);
+    }
+}
+function saveCredentials(account) {
+    ensureChannelDataDir();
+    fs.writeFileSync(CREDENTIALS_FILE, JSON.stringify(account, null, 2), "utf-8");
+    for (const staleStateFile of [SYNC_BUF_FILE, CONTEXT_CACHE_FILE]) {
+        try {
+            fs.rmSync(staleStateFile, { force: true });
+        }
+        catch {
+            // Best effort cleanup.
+        }
+    }
+    try {
+        fs.chmodSync(CREDENTIALS_FILE, 0o600);
+    }
+    catch {
+        // Best effort on Windows.
+    }
+}
+function printPostLoginHelp(log) {
+    log("This WeChat account is now authorized for the bridge.");
+    log("");
+    log("Start from any project directory with one of:");
+    log("  wechat-codex-start");
+    log("  wechat-claude-start");
+    log("  wechat-opencode-start");
+    log("  wechat-bridge-shell");
+    log("");
+    log("Manual two-terminal mode is also available:");
+    log("  wechat-bridge-codex  +  wechat-codex");
+    log("  wechat-bridge-claude +  wechat-claude");
+    log("  wechat-bridge-opencode + wechat-opencode");
+    log("");
+    log("Run wechat-setup again any time you need to refresh the login.");
+}
+export async function runWechatLogin(options = {}) {
+    const baseUrl = options.baseUrl ?? DEFAULT_BASE_URL;
+    const log = options.log ?? ((message) => console.log(message));
+    const write = options.write ?? ((message) => process.stdout.write(message));
+    const timeoutMs = options.timeoutMs ?? 480_000;
+    const pollIntervalMs = options.pollIntervalMs ?? 1_000;
+    log("Fetching WeChat login QR code...\n");
+    const qrResp = await fetchQRCode(baseUrl);
+    await printQRCode(qrResp.qrcode_img_content, write);
+    log("Scan the QR code above with WeChat, then confirm the login on your phone.\n");
+    const deadline = Date.now() + timeoutMs;
+    let scannedPrinted = false;
+    while (Date.now() < deadline) {
+        const status = await pollQRStatus(baseUrl, qrResp.qrcode);
+        switch (status.status) {
+            case "wait":
+                write(".");
+                break;
+            case "scaned":
+                if (!scannedPrinted) {
+                    log("\nQR code scanned. Confirm the login in WeChat...");
+                    scannedPrinted = true;
+                }
+                break;
+            case "expired":
+                throw new Error("The QR code expired. Run setup again.");
+            case "confirmed": {
+                if (!status.ilink_bot_id || !status.bot_token) {
+                    throw new Error("Login failed: missing bot credentials from server.");
+                }
+                if (options.requireUserId && !status.ilink_user_id) {
+                    throw new Error("Login failed: missing WeChat userId from server.");
+                }
+                const account = {
+                    token: status.bot_token,
+                    baseUrl: status.baseurl || baseUrl,
+                    accountId: status.ilink_bot_id,
+                    userId: status.ilink_user_id,
+                    savedAt: new Date().toISOString(),
+                };
+                saveCredentials(account);
+                log("\nWeChat login completed.");
+                log(`Account ID: ${account.accountId}`);
+                log(`User ID: ${account.userId ?? "(unknown)"}`);
+                log(`Credentials saved to: ${CREDENTIALS_FILE}`);
+                log("");
+                return account;
+            }
+        }
+        await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+    }
+    throw new Error("Login timed out. Run setup again.");
+}
+export async function ensureWechatCredentials(options = {}) {
+    const log = options.log ?? ((message) => console.log(message));
+    migrateLegacyChannelFiles(log);
+    const existing = loadExistingCredentials();
+    const loginReason = getWechatLoginRequiredReason(existing, {
+        requireUserId: options.requireUserId,
+    });
+    if (!loginReason) {
+        const account = existing;
+        if (options.validateExisting) {
+            const invalidReason = await getStoredCredentialsInvalidReason(account, {
+                timeoutMs: options.validationTimeoutMs,
+            });
+            if (invalidReason) {
+                log(`${invalidReason} Starting WeChat login...`);
+                const login = options.login ?? (() => runWechatLogin(options));
+                return login();
+            }
+        }
+        return account;
+    }
+    log(`${loginReason} Starting WeChat login...`);
+    const login = options.login ?? (() => runWechatLogin(options));
+    return login();
+}
+async function main() {
+    migrateLegacyChannelFiles((message) => console.log(message));
+    const existing = loadExistingCredentials();
+    if (existing) {
+        console.log(`Found saved account: ${existing.accountId}`);
+        console.log(`Saved at: ${existing.savedAt}`);
+        console.log(`Credentials file: ${CREDENTIALS_FILE}`);
+        console.log();
+        const shouldRelogin = await askYesNo("Log in again? (y/N) ");
+        if (!shouldRelogin) {
+            console.log("Keeping existing credentials.");
+            return;
+        }
+    }
+    await runWechatLogin({ requireUserId: true });
+    printPostLoginHelp((message) => console.log(message));
+}
+const isDirectRun = Boolean(import.meta.main);
+if (isDirectRun) {
+    main().catch((err) => {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(`Error: ${message}`);
+        process.exit(1);
+    });
+}

package/dist/wechat/standalone-bot.js

@@ -0,0 +1,355 @@
+#!/usr/bin/env bun
+/**
+ * Standalone WeChat + Claude bot.
+ *
+ * This script directly connects WeChat ClawBot to Claude API,
+ * bypassing the MCP channel protocol.
+ *
+ * Usage:
+ *   bun run src/wechat/standalone-bot.ts
+ */
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import Anthropic from "@anthropic-ai/sdk";
+import { CHANNEL_DATA_DIR, CREDENTIALS_FILE, migrateLegacyChannelFiles, SYNC_BUF_FILE, } from "./channel-config.js";
+// Constants
+const LOG_DIR = path.join(CHANNEL_DATA_DIR, "logs");
+const BOT_TYPE = "3";
+const CHANNEL_VERSION = "0.1.0";
+const LONG_POLL_TIMEOUT_MS = 35_000;
+const MSG_TYPE_USER = 1;
+const MSG_TYPE_BOT = 2;
+const MSG_ITEM_TEXT = 1;
+const MSG_ITEM_VOICE = 3;
+const MSG_STATE_FINISH = 2;
+// Conversation history per user
+const conversationHistory = new Map();
+const MAX_HISTORY = 10;
+// Logging
+function log(message) {
+    const timestamp = new Date().toISOString();
+    console.log(`[${timestamp}] ${message}`);
+}
+function logError(message) {
+    const timestamp = new Date().toISOString();
+    console.error(`[${timestamp}] ERROR: ${message}`);
+}
+// Load WeChat credentials
+function loadCredentials() {
+    try {
+        if (!fs.existsSync(CREDENTIALS_FILE)) {
+            logError(`Credentials file not found: ${CREDENTIALS_FILE}`);
+            return null;
+        }
+        const content = fs.readFileSync(CREDENTIALS_FILE, "utf-8");
+        return JSON.parse(content);
+    }
+    catch (err) {
+        logError(`Failed to read credentials: ${String(err)}`);
+        return null;
+    }
+}
+// WeChat API utilities
+function randomWechatUin() {
+    const uint32 = crypto.randomBytes(4).readUInt32BE(0);
+    return Buffer.from(String(uint32), "utf-8").toString("base64");
+}
+function buildHeaders(token, body) {
+    const headers = {
+        "Content-Type": "application/json",
+        AuthorizationType: "ilink_bot_token",
+        "X-WECHAT-UIN": randomWechatUin(),
+    };
+    if (body) {
+        headers["Content-Length"] = String(Buffer.byteLength(body, "utf-8"));
+    }
+    if (token?.trim()) {
+        headers.Authorization = `Bearer ${token.trim()}`;
+    }
+    return headers;
+}
+async function apiFetch(params) {
+    const base = params.baseUrl.endsWith("/") ? params.baseUrl : `${params.baseUrl}/`;
+    const url = new URL(params.endpoint, base).toString();
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), params.timeoutMs);
+    try {
+        const res = await fetch(url, {
+            method: "POST",
+            headers: buildHeaders(params.token, params.body),
+            body: params.body,
+            signal: controller.signal,
+        });
+        clearTimeout(timer);
+        const text = await res.text();
+        if (!res.ok) {
+            throw new Error(`HTTP ${res.status}: ${text}`);
+        }
+        return text;
+    }
+    catch (err) {
+        clearTimeout(timer);
+        throw err;
+    }
+}
+async function getUpdates(baseUrl, token, getUpdatesBuf) {
+    try {
+        const raw = await apiFetch({
+            baseUrl,
+            endpoint: "ilink/bot/getupdates",
+            body: JSON.stringify({
+                get_updates_buf: getUpdatesBuf,
+                base_info: { channel_version: CHANNEL_VERSION },
+            }),
+            token,
+            timeoutMs: LONG_POLL_TIMEOUT_MS,
+        });
+        return JSON.parse(raw);
+    }
+    catch (err) {
+        if (err instanceof Error && err.name === "AbortError") {
+            return { ret: 0, msgs: [], get_updates_buf: getUpdatesBuf };
+        }
+        throw err;
+    }
+}
+function extractTextFromMessage(msg) {
+    if (!msg.item_list?.length) {
+        return "";
+    }
+    const lines = [];
+    for (const item of msg.item_list) {
+        if (item.type === MSG_ITEM_TEXT) {
+            const text = item.text_item?.text?.trim();
+            if (text) {
+                lines.push(text);
+            }
+        }
+        if (item.type === MSG_ITEM_VOICE) {
+            const transcript = item.voice_item?.text?.trim();
+            if (transcript) {
+                lines.push(transcript);
+            }
+        }
+    }
+    return lines.join("\n").trim();
+}
+function generateClientId() {
+    return `claude-wechat-bot:${Date.now()}-${crypto.randomBytes(4).toString("hex")}`;
+}
+async function sendTextMessage(baseUrl, token, to, text, contextToken) {
+    const trimmedText = text.trim();
+    if (!trimmedText) {
+        throw new Error("Reply text cannot be empty.");
+    }
+    const clientId = generateClientId();
+    await apiFetch({
+        baseUrl,
+        endpoint: "ilink/bot/sendmessage",
+        body: JSON.stringify({
+            msg: {
+                from_user_id: "",
+                to_user_id: to,
+                client_id: clientId,
+                message_type: MSG_TYPE_BOT,
+                message_state: MSG_STATE_FINISH,
+                item_list: [{ type: MSG_ITEM_TEXT, text_item: { text: trimmedText } }],
+                context_token: contextToken,
+            },
+            base_info: { channel_version: CHANNEL_VERSION },
+        }),
+        token,
+        timeoutMs: 15_000,
+    });
+    return clientId;
+}
+// Message deduplication
+const recentMessageKeys = new Set();
+const recentMessageOrder = [];
+const RECENT_MESSAGE_CACHE_SIZE = 500;
+function buildMessageKey(msg) {
+    return [
+        msg.from_user_id ?? "",
+        msg.client_id ?? "",
+        String(msg.create_time_ms ?? ""),
+        msg.context_token ?? "",
+    ].join("|");
+}
+function rememberMessage(key) {
+    if (!key || recentMessageKeys.has(key)) {
+        return false;
+    }
+    recentMessageKeys.add(key);
+    recentMessageOrder.push(key);
+    while (recentMessageOrder.length > RECENT_MESSAGE_CACHE_SIZE) {
+        const oldest = recentMessageOrder.shift();
+        if (oldest) {
+            recentMessageKeys.delete(oldest);
+        }
+    }
+    return true;
+}
+// Claude API integration
+let anthropic = null;
+function initClaude() {
+    // 使用与 Claude Code 相同的代理配置
+    const baseURL = process.env.ANTHROPIC_BASE_URL || "http://127.0.0.1:15721";
+    anthropic = new Anthropic({
+        apiKey: "dummy-key", // 代理不需要真实的 API key
+        baseURL: baseURL,
+        dangerouslyAllowBrowser: true, // 允许在非标准环境下使用
+    });
+    log(`Claude API initialized (via proxy: ${baseURL})`);
+    return true;
+}
+async function getClaudeResponse(userMessage, userId) {
+    if (!anthropic) {
+        throw new Error("Claude API not initialized");
+    }
+    // Get or create conversation history
+    let history = conversationHistory.get(userId) || [];
+    // Add user message to history
+    history.push({ role: "user", content: userMessage });
+    // Keep only recent messages
+    if (history.length > MAX_HISTORY) {
+        history = history.slice(-MAX_HISTORY);
+    }
+    try {
+        const msg = await anthropic.messages.create({
+            model: "claude-sonnet-4-20250514",
+            max_tokens: 1024,
+            system: "你是一个有帮助的AI助手。请用简洁、友好的方式回复，适合微信聊天场景。",
+            messages: history,
+        });
+        // Extract the response text
+        let responseText = "";
+        for (const block of msg.content) {
+            if (block.type === "text") {
+                responseText += block.text;
+            }
+        }
+        // Add assistant response to history
+        history.push({ role: "assistant", content: responseText });
+        conversationHistory.set(userId, history);
+        return responseText;
+    }
+    catch (err) {
+        logError(`Claude API error: ${String(err)}`);
+        throw err;
+    }
+}
+// Main polling loop
+async function startPolling(account) {
+    const { baseUrl, token } = account;
+    let getUpdatesBuf = "";
+    // Load sync state
+    try {
+        if (fs.existsSync(SYNC_BUF_FILE)) {
+            getUpdatesBuf = fs.readFileSync(SYNC_BUF_FILE, "utf-8");
+            if (getUpdatesBuf) {
+                log(`Recovered sync state from ${SYNC_BUF_FILE}`);
+            }
+        }
+    }
+    catch (err) {
+        logError(`Failed to load sync state: ${String(err)}`);
+    }
+    log("Starting WeChat message polling loop...");
+    log("Press Ctrl+C to stop");
+    const contextTokenCache = new Map();
+    while (true) {
+        try {
+            const resp = await getUpdates(baseUrl, token, getUpdatesBuf);
+            const isError = (resp.ret !== undefined && resp.ret !== 0) ||
+                (resp.errcode !== undefined && resp.errcode !== 0);
+            if (isError) {
+                logError(`getUpdates failed: ret=${resp.ret} errcode=${resp.errcode} errmsg=${resp.errmsg ?? ""}`);
+                await new Promise((resolve) => setTimeout(resolve, 2000));
+                continue;
+            }
+            // Save sync state
+            if (resp.get_updates_buf) {
+                getUpdatesBuf = resp.get_updates_buf;
+                try {
+                    fs.writeFileSync(SYNC_BUF_FILE, getUpdatesBuf, "utf-8");
+                }
+                catch (err) {
+                    logError(`Failed to persist sync state: ${String(err)}`);
+                }
+            }
+            // Process messages
+            for (const msg of resp.msgs ?? []) {
+                if (msg.message_type !== MSG_TYPE_USER) {
+                    continue;
+                }
+                const text = extractTextFromMessage(msg);
+                if (!text) {
+                    continue;
+                }
+                const senderId = msg.from_user_id ?? "unknown";
+                const messageKey = buildMessageKey(msg);
+                if (!rememberMessage(messageKey)) {
+                    continue;
+                }
+                // Cache context token for replies
+                if (msg.context_token) {
+                    contextTokenCache.set(senderId, msg.context_token);
+                }
+                log(`📨 收到消息 from ${senderId}: ${text.slice(0, 50)}${text.length > 50 ? "..." : ""}`);
+                // Get response from Claude
+                try {
+                    const response = await getClaudeResponse(text, senderId);
+                    log(`📤 发送回复 to ${senderId}: ${response.slice(0, 50)}${response.length > 50 ? "..." : ""}`);
+                    const contextToken = contextTokenCache.get(senderId) || "";
+                    await sendTextMessage(baseUrl, token, senderId, response, contextToken);
+                }
+                catch (err) {
+                    logError(`Failed to get/send response: ${String(err)}`);
+                    // Send error message to user
+                    try {
+                        const contextToken = contextTokenCache.get(senderId) || "";
+                        await sendTextMessage(baseUrl, token, senderId, "抱歉，我遇到了一些问题，请稍后再试。", contextToken);
+                    }
+                    catch {
+                        // Ignore
+                    }
+                }
+            }
+        }
+        catch (err) {
+            logError(`Polling error: ${String(err)}`);
+            await new Promise((resolve) => setTimeout(resolve, 2000));
+        }
+    }
+}
+// Main function
+async function main() {
+    log("=== WeChat + Claude 独立机器人 ===");
+    log("");
+    migrateLegacyChannelFiles(log);
+    // Load WeChat credentials
+    log(`正在加载微信凭据: ${CREDENTIALS_FILE}`);
+    const account = loadCredentials();
+    if (!account) {
+        logError("无法加载微信凭据，请先运行: bun run setup");
+        process.exit(1);
+    }
+    log(`✓ 微信账号: ${account.accountId}`);
+    // Initialize Claude API
+    log("");
+    log("正在初始化 Claude API...");
+    if (!initClaude()) {
+        logError("Claude API 初始化失败");
+        process.exit(1);
+    }
+    log("");
+    log("✓ 所有初始化完成！");
+    log("");
+    // Start polling
+    await startPolling(account);
+}
+main().catch((err) => {
+    logError(`Fatal: ${String(err)}`);
+    process.exit(1);
+});