@unlinearity/cli-wechat-bridge 1.0.6 → 1.0.9

package/dist/wechat/channel-config.js

@@ -23,6 +23,7 @@ export const CODEX_PANEL_ENDPOINT_FILE = path.join(CHANNEL_DATA_DIR, "codex-pane
 export const WORKSPACES_DIR = path.join(CHANNEL_DATA_DIR, "workspaces");
 export const INBOUND_MESSAGE_CLAIMS_DIR = path.join(CHANNEL_DATA_DIR, "inbound-message-claims");
 export const INBOUND_ATTACHMENTS_DIR = path.join(CHANNEL_DATA_DIR, "inbound-attachments");
+export const EMOJI_BINDINGS_FILE = path.join(CHANNEL_DATA_DIR, "emoji-bindings.json");
 const LEGACY_GLOBAL_CHANNEL_DATA_DIR = path.join(os.homedir(), ".claude", "channels", "wechat");
 const LEGACY_REPO_CHANNEL_DATA_DIR = path.join(PROJECT_DIR, "~", ".claude", "channels", "wechat");
 const LEGACY_ENV_CHANNEL_DATA_DIR = process.env.CLAUDE_WECHAT_CHANNEL_DATA_DIR?.trim()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unlinearity/cli-wechat-bridge",
-  "version": "1.0.6",
+  "version": "1.0.9",
   "description": "CLI WeChat Bridge for Codex, Claude Code, OpenCode, and PowerShell over WeChat",
   "type": "module",
   "files": [
@@ -19,7 +19,7 @@
     "terminal"
   ],
   "author": "UNLINEARITY",
-  "license": "MIT",
+  "license": "AGPL-3.0-or-later",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/UNLINEARITY/CLI-WeChat-Bridge.git"
@@ -48,10 +48,8 @@
     "wechat-check-update": "bin/wechat-check-update.mjs"
   },
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.80.0",
     "@modelcontextprotocol/sdk": "^1.27.1",
     "@opencode-ai/sdk": "^1.3.2",
-    "ajv-formats": "^3.0.1",
     "node-pty": "^1.1.0",
     "qrcode-terminal": "^0.12.0"
   },

package/dist/companion/codex-panel-link.js

@@ -1,72 +0,0 @@
-import crypto from "node:crypto";
-import fs from "node:fs";
-import { ensureWorkspaceChannelDir, getWorkspaceChannelPaths, } from "../wechat/channel-config.js";
-export function buildCodexPanelToken() {
-    return crypto.randomBytes(18).toString("hex");
-}
-export function writeCodexPanelEndpoint(endpoint) {
-    const { endpointFile } = ensureWorkspaceChannelDir(endpoint.cwd);
-    fs.writeFileSync(endpointFile, JSON.stringify(endpoint, null, 2), "utf8");
-}
-export function readCodexPanelEndpoint(cwd) {
-    try {
-        const { endpointFile } = getWorkspaceChannelPaths(cwd);
-        if (!fs.existsSync(endpointFile)) {
-            return null;
-        }
-        return JSON.parse(fs.readFileSync(endpointFile, "utf8"));
-    }
-    catch {
-        return null;
-    }
-}
-export function clearCodexPanelEndpoint(cwd, instanceId) {
-    try {
-        const { endpointFile } = getWorkspaceChannelPaths(cwd);
-        if (!fs.existsSync(endpointFile)) {
-            return;
-        }
-        if (!instanceId) {
-            fs.rmSync(endpointFile, { force: true });
-            return;
-        }
-        const endpoint = readCodexPanelEndpoint(cwd);
-        if (!endpoint || endpoint.instanceId === instanceId) {
-            fs.rmSync(endpointFile, { force: true });
-        }
-    }
-    catch {
-        // Best effort cleanup.
-    }
-}
-export function sendCodexPanelMessage(socket, message) {
-    socket.write(`${JSON.stringify(message)}\n`);
-}
-export function attachCodexPanelMessageListener(socket, onMessage) {
-    let buffer = "";
-    const onData = (chunk) => {
-        buffer += typeof chunk === "string" ? chunk : chunk.toString("utf8");
-        while (true) {
-            const newlineIndex = buffer.indexOf("\n");
-            if (newlineIndex < 0) {
-                return;
-            }
-            const line = buffer.slice(0, newlineIndex).trim();
-            buffer = buffer.slice(newlineIndex + 1);
-            if (!line) {
-                continue;
-            }
-            try {
-                onMessage(JSON.parse(line));
-            }
-            catch {
-                // Ignore malformed local IPC frames.
-            }
-        }
-    };
-    socket.setEncoding("utf8");
-    socket.on("data", onData);
-    return () => {
-        socket.off("data", onData);
-    };
-}

package/dist/companion/codex-panel.js

@@ -1,179 +0,0 @@
-#!/usr/bin/env bun
-import net from "node:net";
-import path from "node:path";
-import { createBridgeAdapter } from "../bridge/bridge-adapters.js";
-import { attachCodexPanelMessageListener, readCodexPanelEndpoint, sendCodexPanelMessage, } from "./codex-panel-link.js";
-import { migrateLegacyChannelFiles } from "../wechat/channel-config.js";
-function log(message) {
-    process.stderr.write(`[codex-panel] ${message}\n`);
-}
-function parseCliArgs(argv) {
-    let cwd = process.cwd();
-    for (let i = 0; i < argv.length; i += 1) {
-        const arg = argv[i];
-        const next = argv[i + 1];
-        if (arg === "--help" || arg === "-h") {
-            process.stdout.write([
-                "Usage: wechat-codex [--cwd <path>]",
-                "",
-                'Starts the visible Codex panel and connects it to the running "wechat-bridge-codex" instance for the current directory.',
-                "",
-            ].join("\n"));
-            process.exit(0);
-        }
-        if (arg === "--cwd") {
-            if (!next) {
-                throw new Error("--cwd requires a value");
-            }
-            cwd = path.resolve(next);
-            i += 1;
-            continue;
-        }
-        throw new Error(`Unknown argument: ${arg}`);
-    }
-    return { cwd };
-}
-async function main() {
-    migrateLegacyChannelFiles(log);
-    const options = parseCliArgs(process.argv.slice(2));
-    const endpoint = readCodexPanelEndpoint(options.cwd);
-    if (!endpoint) {
-        throw new Error(`No active Codex bridge endpoint was found for ${options.cwd}. Start "wechat-bridge-codex" in that directory first.`);
-    }
-    const socket = await new Promise((resolve, reject) => {
-        const nextSocket = net.connect({
-            host: "127.0.0.1",
-            port: endpoint.port,
-        });
-        nextSocket.once("connect", () => resolve(nextSocket));
-        nextSocket.once("error", (error) => reject(error));
-    });
-    socket.setNoDelay(true);
-    const adapter = createBridgeAdapter({
-        kind: "codex",
-        command: endpoint.command,
-        cwd: endpoint.cwd,
-        profile: endpoint.profile,
-        initialSharedThreadId: endpoint.sharedThreadId,
-        renderMode: "panel",
-    });
-    let shuttingDown = false;
-    let helloAcknowledged = false;
-    let detachListener = null;
-    const publishState = () => {
-        sendCodexPanelMessage(socket, {
-            type: "state",
-            state: adapter.getState(),
-        });
-    };
-    const sendResponse = (id, ok, result, error) => {
-        sendCodexPanelMessage(socket, {
-            type: "response",
-            id,
-            ok,
-            result,
-            error,
-        });
-    };
-    const closePanel = async (exitCode = 0) => {
-        if (shuttingDown) {
-            return;
-        }
-        shuttingDown = true;
-        detachListener?.();
-        detachListener = null;
-        try {
-            await adapter.dispose();
-        }
-        catch {
-            // Best effort cleanup.
-        }
-        try {
-            socket.end();
-            socket.destroy();
-        }
-        catch {
-            // Best effort cleanup.
-        }
-        process.exit(exitCode);
-    };
-    adapter.setEventSink((event) => {
-        sendCodexPanelMessage(socket, {
-            type: "event",
-            event,
-        });
-        publishState();
-    });
-    detachListener = attachCodexPanelMessageListener(socket, (message) => {
-        if (!helloAcknowledged) {
-            if (message.type === "hello_ack") {
-                helloAcknowledged = true;
-            }
-            return;
-        }
-        if (message.type !== "request") {
-            return;
-        }
-        void (async () => {
-            try {
-                switch (message.payload.command) {
-                    case "send_input":
-                        await adapter.sendInput(message.payload.text);
-                        sendResponse(message.id, true);
-                        break;
-                    case "list_resume_sessions":
-                    case "list_resume_threads":
-                        sendResponse(message.id, true, await adapter.listResumeSessions(message.payload.limit));
-                        break;
-                    case "resume_session":
-                        await adapter.resumeSession(message.payload.sessionId);
-                        publishState();
-                        sendResponse(message.id, true);
-                        break;
-                    case "resume_thread":
-                        await adapter.resumeSession(message.payload.threadId);
-                        publishState();
-                        sendResponse(message.id, true);
-                        break;
-                    case "interrupt":
-                        sendResponse(message.id, true, await adapter.interrupt());
-                        break;
-                    case "reset":
-                        await adapter.reset();
-                        publishState();
-                        sendResponse(message.id, true);
-                        break;
-                    case "resolve_approval":
-                        sendResponse(message.id, true, await adapter.resolveApproval(message.payload.action));
-                        break;
-                    case "dispose":
-                        sendResponse(message.id, true);
-                        await closePanel(0);
-                        break;
-                }
-            }
-            catch (error) {
-                const text = error instanceof Error ? error.message : String(error);
-                sendResponse(message.id, false, undefined, text);
-            }
-        })();
-    });
-    socket.once("close", () => {
-        void closePanel(0);
-    });
-    socket.once("error", () => {
-        void closePanel(1);
-    });
-    sendCodexPanelMessage(socket, {
-        type: "hello",
-        token: endpoint.token,
-        panelPid: process.pid,
-    });
-    await adapter.start();
-    publishState();
-    log(`Connected to bridge ${endpoint.instanceId}.`);
-}
-main().catch((error) => {
-    log(error instanceof Error ? error.message : String(error));
-    process.exit(1);
-});

package/dist/media/media-types.js

@@ -1 +0,0 @@
-export {};

package/dist/wechat/standalone-bot.js

@@ -1,355 +0,0 @@
-#!/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);
-});