@unlinearity/cli-wechat-bridge 1.0.0 → 1.0.2

package/dist/wechat/channel-config.js

@@ -0,0 +1,103 @@
+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;
+}
+function channelDataDirHasState() {
+    try {
+        if (!fs.existsSync(CHANNEL_DATA_DIR)) {
+            return false;
+        }
+        return fs.readdirSync(CHANNEL_DATA_DIR).length > 0;
+    }
+    catch {
+        return true;
+    }
+}
+export function shouldMigrateLegacyCredentials(params) {
+    return (params.legacyCredentialsExists &&
+        !params.credentialsExists &&
+        !params.channelDataDirHadState);
+}
+export function migrateLegacyChannelFiles(log) {
+    const migrated = [];
+    const channelDataDirHadState = channelDataDirHasState();
+    if (!fs.existsSync(LEGACY_CREDENTIALS_FILE) &&
+        !fs.existsSync(LEGACY_SYNC_BUF_FILE)) {
+        return migrated;
+    }
+    ensureChannelDataDir();
+    if (shouldMigrateLegacyCredentials({
+        channelDataDirHadState,
+        credentialsExists: fs.existsSync(CREDENTIALS_FILE),
+        legacyCredentialsExists: fs.existsSync(LEGACY_CREDENTIALS_FILE),
+    })) {
+        fs.copyFileSync(LEGACY_CREDENTIALS_FILE, CREDENTIALS_FILE);
+        migrated.push("credentials");
+    }
+    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,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);
+    });
+}