@unlinearity/cli-wechat-bridge 1.0.0 → 1.0.1

package/dist/wechat/channel-config.js

@@ -0,0 +1,87 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
+const PROJECT_DIR = path.resolve(MODULE_DIR, "..", "..");
+export const DEFAULT_BASE_URL = process.env.WECHAT_ILINK_BASE_URL?.trim() || "https://ilinkai.weixin.qq.com";
+export const BOT_TYPE = "3";
+export const CHANNEL_DATA_DIR = process.env.CLAUDE_WECHAT_CHANNEL_DATA_DIR?.trim()
+    ? path.resolve(process.env.CLAUDE_WECHAT_CHANNEL_DATA_DIR.trim())
+    : path.join(os.homedir(), ".claude", "channels", "wechat");
+export const GLOBAL_CHANNEL_DATA_DIR = path.join(os.homedir(), ".claude", "channels", "wechat");
+export const CREDENTIALS_FILE = path.join(CHANNEL_DATA_DIR, "account.json");
+export const SYNC_BUF_FILE = path.join(CHANNEL_DATA_DIR, "sync_buf.txt");
+export const CONTEXT_CACHE_FILE = path.join(CHANNEL_DATA_DIR, "context_tokens.json");
+export const BRIDGE_STATE_FILE = path.join(CHANNEL_DATA_DIR, "bridge-state.json");
+export const BRIDGE_LOG_FILE = path.join(CHANNEL_DATA_DIR, "bridge.log");
+export const BRIDGE_LOCK_FILE = path.join(CHANNEL_DATA_DIR, "bridge.lock.json");
+export const CODEX_PANEL_ENDPOINT_FILE = path.join(CHANNEL_DATA_DIR, "codex-panel-endpoint.json");
+export const WORKSPACES_DIR = path.join(CHANNEL_DATA_DIR, "workspaces");
+export const INBOUND_MESSAGE_CLAIMS_DIR = path.join(GLOBAL_CHANNEL_DATA_DIR, "inbound-message-claims");
+const LEGACY_CHANNEL_DATA_DIR = path.join(PROJECT_DIR, "~", ".claude", "channels", "wechat");
+const LEGACY_CREDENTIALS_FILE = path.join(LEGACY_CHANNEL_DATA_DIR, "account.json");
+const LEGACY_SYNC_BUF_FILE = path.join(LEGACY_CHANNEL_DATA_DIR, "sync_buf.txt");
+export function ensureChannelDataDir() {
+    fs.mkdirSync(CHANNEL_DATA_DIR, { recursive: true });
+}
+export function normalizeWorkspacePath(cwd) {
+    return path.resolve(cwd);
+}
+function buildComparableWorkspacePath(cwd) {
+    const normalized = normalizeWorkspacePath(cwd);
+    return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+function sanitizeWorkspaceSegment(value) {
+    const sanitized = value
+        .replace(/[^a-zA-Z0-9._-]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 40);
+    return sanitized || "workspace";
+}
+export function buildWorkspaceKey(cwd) {
+    const normalized = normalizeWorkspacePath(cwd);
+    const digest = crypto
+        .createHash("sha256")
+        .update(buildComparableWorkspacePath(normalized))
+        .digest("hex")
+        .slice(0, 12);
+    const label = sanitizeWorkspaceSegment(path.basename(normalized));
+    return `${label}-${digest}`;
+}
+export function getWorkspaceChannelPaths(cwd) {
+    const workspaceDir = path.join(WORKSPACES_DIR, buildWorkspaceKey(cwd));
+    return {
+        workspaceDir,
+        stateFile: path.join(workspaceDir, "bridge-state.json"),
+        endpointFile: path.join(workspaceDir, "codex-panel-endpoint.json"),
+    };
+}
+export function ensureWorkspaceChannelDir(cwd) {
+    ensureChannelDataDir();
+    const paths = getWorkspaceChannelPaths(cwd);
+    fs.mkdirSync(paths.workspaceDir, { recursive: true });
+    return paths;
+}
+export function migrateLegacyChannelFiles(log) {
+    const migrated = [];
+    if (!fs.existsSync(LEGACY_CREDENTIALS_FILE) &&
+        !fs.existsSync(LEGACY_SYNC_BUF_FILE)) {
+        return migrated;
+    }
+    ensureChannelDataDir();
+    const copyIfNeeded = (fromPath, toPath, label) => {
+        if (!fs.existsSync(fromPath) || fs.existsSync(toPath)) {
+            return;
+        }
+        fs.copyFileSync(fromPath, toPath);
+        migrated.push(label);
+    };
+    copyIfNeeded(LEGACY_CREDENTIALS_FILE, CREDENTIALS_FILE, "credentials");
+    copyIfNeeded(LEGACY_SYNC_BUF_FILE, SYNC_BUF_FILE, "sync state");
+    if (migrated.length && log) {
+        log(`Migrated legacy ${migrated.join(" and ")} from ${LEGACY_CHANNEL_DATA_DIR} to ${CHANNEL_DATA_DIR}.`);
+    }
+    return migrated;
+}

package/dist/wechat/setup.js

@@ -0,0 +1,184 @@
+#!/usr/bin/env bun
+/**
+ * CLI WeChat Bridge setup.
+ *
+ * Run this before starting CLI WeChat Bridge:
+ *   bun run setup
+ */
+import fs from "node:fs";
+import readline from "node:readline";
+import { BOT_TYPE, CREDENTIALS_FILE, DEFAULT_BASE_URL, ensureChannelDataDir, migrateLegacyChannelFiles, } from "./channel-config.js";
+function loadExistingCredentials() {
+    try {
+        if (!fs.existsSync(CREDENTIALS_FILE)) {
+            return null;
+        }
+        return JSON.parse(fs.readFileSync(CREDENTIALS_FILE, "utf-8"));
+    }
+    catch {
+        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) {
+    try {
+        const qrterm = await import("qrcode-terminal");
+        await new Promise((resolve) => {
+            qrterm.default.generate(qrContent, { small: true }, (qr) => {
+                console.log(qr);
+                resolve();
+            });
+        });
+    }
+    catch {
+        console.log(`Open this QR code URL in a browser: ${qrContent}\n`);
+    }
+}
+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;
+        }
+    }
+    console.log("Fetching WeChat login QR code...\n");
+    const qrResp = await fetchQRCode(DEFAULT_BASE_URL);
+    await printQRCode(qrResp.qrcode_img_content);
+    console.log("Scan the QR code in WeChat, then confirm on your phone.\n");
+    const deadline = Date.now() + 480_000;
+    let scannedPrinted = false;
+    while (Date.now() < deadline) {
+        const status = await pollQRStatus(DEFAULT_BASE_URL, qrResp.qrcode);
+        switch (status.status) {
+            case "wait":
+                process.stdout.write(".");
+                break;
+            case "scaned":
+                if (!scannedPrinted) {
+                    console.log("\nQR code scanned. Confirm the login in WeChat...");
+                    scannedPrinted = true;
+                }
+                break;
+            case "expired":
+                console.log("\nThe QR code expired. Run setup again.");
+                process.exit(1);
+                break;
+            case "confirmed": {
+                if (!status.ilink_bot_id || !status.bot_token) {
+                    console.error("\nLogin failed: missing bot credentials from server.");
+                    process.exit(1);
+                }
+                const account = {
+                    token: status.bot_token,
+                    baseUrl: status.baseurl || DEFAULT_BASE_URL,
+                    accountId: status.ilink_bot_id,
+                    userId: status.ilink_user_id,
+                    savedAt: new Date().toISOString(),
+                };
+                ensureChannelDataDir();
+                fs.writeFileSync(CREDENTIALS_FILE, JSON.stringify(account, null, 2), "utf-8");
+                try {
+                    fs.chmodSync(CREDENTIALS_FILE, 0o600);
+                }
+                catch {
+                    // Best effort on Windows.
+                }
+                console.log("\nWeChat login completed.");
+                console.log(`Account ID: ${account.accountId}`);
+                console.log(`User ID: ${account.userId ?? "(unknown)"}`);
+                console.log(`Credentials saved to: ${CREDENTIALS_FILE}`);
+                console.log();
+                console.log("No /pair step is required.");
+                console.log("The logged-in WeChat account above becomes the only authorized bridge owner.");
+                console.log();
+                console.log("After installing the package globally (for example: npm install -g . or npm link),");
+                console.log("start the WeChat bridge from any directory with:");
+                console.log("  wechat-bridge-codex");
+                console.log("  wechat-codex         # start this in a second terminal in the same directory");
+                console.log("  wechat-bridge-opencode");
+                console.log("  wechat-opencode      # start this in a second terminal in the same directory");
+                console.log("  wechat-bridge-claude");
+                console.log("  wechat-claude        # start this in a second terminal in the same directory");
+                console.log("  wechat-bridge-shell");
+                console.log("  On Linux/macOS, wechat-bridge-shell defaults to pwsh, then bash, zsh, or sh.");
+                console.log("  Shell mode is a headless remote executor for non-interactive commands and scripts.");
+                console.log();
+                console.log("Repo-local development entrypoints are still available:");
+                console.log("  bun run bridge:codex");
+                console.log("  bun run codex:panel");
+                console.log("  bun run bridge:opencode");
+                console.log("  bun run opencode:panel");
+                console.log("  bun run opencode:start");
+                console.log("  bun run bridge:claude");
+                console.log("  bun run claude:companion");
+                console.log("  bun run bridge:shell");
+                console.log();
+                console.log("Legacy MCP server entrypoint:");
+                console.log("  bun run start");
+                return;
+            }
+        }
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+    }
+    console.log("\nLogin timed out. Run setup again.");
+    process.exit(1);
+}
+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,356 @@
+#!/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 fs from "node:fs";
+import os from "node:os";
+import crypto from "node:crypto";
+import Anthropic from "@anthropic-ai/sdk";
+// Constants
+const HOME_DIR = os.homedir();
+const CREDENTIALS_FILE = `${HOME_DIR}/.claude/channels/wechat/account.json`;
+const SYNC_BUF_FILE = `${HOME_DIR}/.claude/channels/wechat/sync_buf.txt`;
+const LOG_DIR = `${HOME_DIR}/.claude/channels/wechat/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("");
+    // 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);
+});