cli-wechat-bridge 1.0.5

package/dist/media/media-types.js

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

package/dist/runtime/create-runtime-host.js

@@ -0,0 +1,12 @@
+import { createBridgeAdapter } from "../bridge/bridge-adapters.js";
+import { CodexPtyAdapter } from "../bridge/bridge-adapters.codex.js";
+import { LegacyAdapterRuntime } from "./legacy-adapter-runtime.js";
+export function createRuntimeHost(options) {
+    if (options.kind === "codex") {
+        return new CodexPtyAdapter({
+            ...options,
+            renderMode: options.renderMode ?? "headless",
+        });
+    }
+    return new LegacyAdapterRuntime(createBridgeAdapter(options));
+}

package/dist/runtime/legacy-adapter-runtime.js

@@ -0,0 +1,46 @@
+export class LegacyAdapterRuntime {
+    runtimeKind = "legacy_adapter";
+    adapter;
+    constructor(adapter) {
+        this.adapter = adapter;
+    }
+    setEventSink(sink) {
+        this.adapter.setEventSink(sink);
+    }
+    async start() {
+        await this.adapter.start();
+    }
+    async sendInput(text) {
+        await this.adapter.sendInput(text);
+    }
+    async listResumeSessions(limit) {
+        return await this.adapter.listResumeSessions(limit);
+    }
+    async resumeSession(sessionId) {
+        await this.adapter.resumeSession(sessionId);
+    }
+    async createSession() {
+        if (!this.adapter.createSession) {
+            throw new Error(`/${this.adapter.getState().kind} does not support creating sessions from WeChat.`);
+        }
+        await this.adapter.createSession();
+    }
+    async interrupt() {
+        return await this.adapter.interrupt();
+    }
+    async reset() {
+        await this.adapter.reset();
+    }
+    async resolveApproval(action) {
+        return await this.adapter.resolveApproval(action);
+    }
+    async submitUserInput(answers) {
+        return await this.adapter.submitUserInput(answers);
+    }
+    async dispose() {
+        await this.adapter.dispose();
+    }
+    getState() {
+        return this.adapter.getState();
+    }
+}

package/dist/runtime/runtime-types.js

@@ -0,0 +1,5 @@
+export const LOCAL_CLIENT_PROTOCOL_VERSION = 2;
+export const CODEX_REMOTE_AUTH_TOKEN_ENV = "WECHAT_BRIDGE_CODEX_REMOTE_AUTH_TOKEN";
+export function hasLocalClientEndpointProvider(runtime) {
+    return typeof runtime.getLocalClientEndpoint === "function";
+}

package/dist/utils/version-checker.js

@@ -0,0 +1,161 @@
+import fs from "node:fs";
+import path from "node:path";
+import { execSync } from "node:child_process";
+import { CHANNEL_DATA_DIR, ensureChannelDataDir } from "../wechat/channel-config.js";
+const UPDATE_CHECK_FILE = path.join(CHANNEL_DATA_DIR, "update-check.json");
+const CACHE_DURATION_MS = 24 * 60 * 60 * 1000; // 24小时
+/**
+ * 使用 git 命令获取远程仓库最新版本号
+ */
+export async function fetchLatestVersion() {
+    try {
+        // 尝试使用 git ls-remote 获取所有 tags
+        const tagsOutput = execSync('git ls-remote --tags origin', {
+            cwd: path.resolve(import.meta.dirname, "..", ".."),
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'ignore']
+        });
+        if (!tagsOutput) {
+            return null;
+        }
+        // 解析 tags，找到版本号格式（如 0.1.0, 0.2.0 等）
+        const versionTags = tagsOutput
+            .split('\n')
+            .filter(line => {
+            // 匹配 refs/tags/0.5.0 格式（不是 v0.5.0）
+            return line.includes('refs/tags/') &&
+                !line.includes('^{}') &&
+                /^\w+\s+refs\/tags\/\d+\.\d+\.\d+$/.test(line);
+        })
+            .map(line => {
+            const match = line.match(/refs\/tags\/(\d+\.\d+\.\d+)$/);
+            return match ? match[1] : null;
+        })
+            .filter((v) => v !== null);
+        if (versionTags.length === 0) {
+            return null;
+        }
+        // 按版本号排序，返回最新的
+        versionTags.sort((a, b) => compareVersions(b, a));
+        return versionTags[0] ?? null;
+    }
+    catch (error) {
+        // 如果 git 命令失败，静默返回 null
+        return null;
+    }
+}
+/**
+ * 从本地 package.json 读取当前版本
+ */
+export async function getCurrentVersion() {
+    const packageJsonPath = path.resolve(import.meta.dirname, "..", "..", "package.json");
+    try {
+        const content = await fs.promises.readFile(packageJsonPath, "utf-8");
+        const packageJson = JSON.parse(content);
+        return packageJson.version || "0.0.0";
+    }
+    catch (error) {
+        return "0.0.0";
+    }
+}
+/**
+ * 读取更新检查缓存
+ */
+function readUpdateCache() {
+    try {
+        if (!fs.existsSync(UPDATE_CHECK_FILE)) {
+            return null;
+        }
+        const content = fs.readFileSync(UPDATE_CHECK_FILE, "utf-8");
+        return JSON.parse(content);
+    }
+    catch (error) {
+        return null;
+    }
+}
+/**
+ * 写入更新检查缓存
+ */
+function writeUpdateCache(cache) {
+    try {
+        ensureChannelDataDir();
+        fs.writeFileSync(UPDATE_CHECK_FILE, JSON.stringify(cache, null, 2));
+    }
+    catch (error) {
+        // 静默失败，不影响正常使用
+    }
+}
+/**
+ * 比较两个版本号
+ * @returns 返回值 > 0 表示 version1 更新，< 0 表示 version2 更新，= 0 表示相等
+ */
+export function compareVersions(v1, v2) {
+    const parts1 = v1.split(".").map(Number);
+    const parts2 = v2.split(".").map(Number);
+    for (let i = 0; i < 3; i++) {
+        const num1 = parts1[i] || 0;
+        const num2 = parts2[i] || 0;
+        if (num1 > num2)
+            return 1;
+        if (num1 < num2)
+            return -1;
+    }
+    return 0;
+}
+/**
+ * 检查是否有新版本可用
+ * @param forceCheck 是否强制检查（忽略缓存）
+ */
+export async function checkForUpdate(forceCheck = false) {
+    const currentVersion = await getCurrentVersion();
+    // 检查缓存
+    if (!forceCheck) {
+        const cache = readUpdateCache();
+        if (cache) {
+            const lastCheckTime = new Date(cache.lastCheck).getTime();
+            const now = Date.now();
+            // 如果缓存未过期（24小时内），且已经通知过最新版本
+            if (now - lastCheckTime < CACHE_DURATION_MS) {
+                // 如果缓存的版本与当前版本一致，说明已经通知过
+                if (cache.lastNotifiedVersion === currentVersion) {
+                    return null;
+                }
+            }
+        }
+    }
+    // 从 GitHub 获取最新版本
+    const latestVersion = await fetchLatestVersion();
+    if (!latestVersion) {
+        return null;
+    }
+    // 比较版本
+    const hasUpdate = compareVersions(latestVersion, currentVersion) > 0;
+    // 更新缓存
+    writeUpdateCache({
+        lastCheck: new Date().toISOString(),
+        lastNotifiedVersion: currentVersion,
+    });
+    return {
+        current: currentVersion,
+        latest: latestVersion,
+        hasUpdate,
+    };
+}
+/**
+ * 格式化更新提示信息
+ */
+export function formatUpdateMessage(versionInfo) {
+    const { current, latest } = versionInfo;
+    return `
+[Update Available] Version ${latest} is available (current: ${current})
+
+Update instructions:
+   cd CLI-WeChat-Bridge
+   git pull
+   bun install
+   npm install -g .
+
+For more information:
+   https://github.com/UNLINEARITY/CLI-WeChat-Bridge/releases
+`;
+}

package/dist/wechat/channel-config.js

@@ -0,0 +1,196 @@
+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 function resolveChannelDataDir(env = process.env, homeDir = os.homedir()) {
+    const configured = env.CLI_BRIDGE_DATA_DIR?.trim();
+    return configured ? path.resolve(configured) : path.join(homeDir, ".cli-bridge");
+}
+export const CHANNEL_DATA_DIR = resolveChannelDataDir();
+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 DAEMON_ENDPOINT_FILE = path.join(CHANNEL_DATA_DIR, "daemon-endpoint.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(CHANNEL_DATA_DIR, "inbound-message-claims");
+export const INBOUND_ATTACHMENTS_DIR = path.join(CHANNEL_DATA_DIR, "inbound-attachments");
+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()
+    ? path.resolve(process.env.CLAUDE_WECHAT_CHANNEL_DATA_DIR.trim())
+    : "";
+const LEGACY_CHANNEL_SOURCE_DIRS = [
+    LEGACY_ENV_CHANNEL_DATA_DIR,
+    LEGACY_GLOBAL_CHANNEL_DATA_DIR,
+    LEGACY_REPO_CHANNEL_DATA_DIR,
+].filter(Boolean);
+const LEGACY_CHANNEL_SOURCES = LEGACY_CHANNEL_SOURCE_DIRS.map((dataDir) => ({
+    dataDir,
+}));
+const LEGACY_MIGRATION_ITEMS = [
+    {
+        label: "credentials",
+        sourceName: "account.json",
+        targetName: "account.json",
+        kind: "file",
+    },
+    {
+        label: "sync state",
+        sourceName: "sync_buf.txt",
+        targetName: "sync_buf.txt",
+        kind: "file",
+    },
+    {
+        label: "context tokens",
+        sourceName: "context_tokens.json",
+        targetName: "context_tokens.json",
+        kind: "file",
+    },
+    {
+        label: "update check cache",
+        sourceName: "update-check.json",
+        targetName: "update-check.json",
+        kind: "file",
+    },
+    {
+        label: "workspace state",
+        sourceName: "workspaces",
+        targetName: "workspaces",
+        kind: "directory",
+    },
+    {
+        label: "inbound attachments",
+        sourceName: "inbound-attachments",
+        targetName: "inbound-attachments",
+        kind: "directory",
+    },
+    {
+        label: "legacy bridge log",
+        sourceName: "bridge.log",
+        targetName: "legacy-bridge.log",
+        kind: "file",
+    },
+];
+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 getWorkspaceAdapterEndpointFile(cwd, adapter) {
+    return path.join(getWorkspaceChannelPaths(cwd).workspaceDir, `${adapter}-companion-endpoint.json`);
+}
+export function ensureWorkspaceChannelDir(cwd) {
+    ensureChannelDataDir();
+    const paths = getWorkspaceChannelPaths(cwd);
+    fs.mkdirSync(paths.workspaceDir, { recursive: true });
+    return paths;
+}
+function isSamePath(left, right) {
+    const normalizedLeft = path.resolve(left);
+    const normalizedRight = path.resolve(right);
+    return process.platform === "win32"
+        ? normalizedLeft.toLowerCase() === normalizedRight.toLowerCase()
+        : normalizedLeft === normalizedRight;
+}
+function legacySourceHasMigratableData(source) {
+    return LEGACY_MIGRATION_ITEMS.some((item) => {
+        const sourcePath = path.join(source.dataDir, item.sourceName);
+        if (!fs.existsSync(sourcePath)) {
+            return false;
+        }
+        try {
+            const stat = fs.statSync(sourcePath);
+            return item.kind === "directory" ? stat.isDirectory() : stat.isFile();
+        }
+        catch {
+            return false;
+        }
+    });
+}
+function findLegacyChannelSource(channelDataDir = CHANNEL_DATA_DIR, legacySources = LEGACY_CHANNEL_SOURCES) {
+    return (legacySources.find((source) => !isSamePath(source.dataDir, channelDataDir) &&
+        legacySourceHasMigratableData(source)) ?? null);
+}
+export function migrateLegacyChannelFiles(log, options = {}) {
+    const channelDataDir = options.channelDataDir ?? CHANNEL_DATA_DIR;
+    const legacySources = (options.legacyDataDirs ?? LEGACY_CHANNEL_SOURCE_DIRS).map((dataDir) => ({ dataDir }));
+    const migrated = [];
+    const skippedExisting = [];
+    const legacySource = findLegacyChannelSource(channelDataDir, legacySources);
+    if (!legacySource) {
+        return migrated;
+    }
+    fs.mkdirSync(channelDataDir, { recursive: true });
+    for (const item of LEGACY_MIGRATION_ITEMS) {
+        const sourcePath = path.join(legacySource.dataDir, item.sourceName);
+        const targetPath = path.join(channelDataDir, item.targetName);
+        if (!fs.existsSync(sourcePath)) {
+            continue;
+        }
+        if (fs.existsSync(targetPath)) {
+            skippedExisting.push(item.label);
+            continue;
+        }
+        const stat = fs.statSync(sourcePath);
+        if (item.kind === "directory") {
+            if (!stat.isDirectory()) {
+                continue;
+            }
+            fs.cpSync(sourcePath, targetPath, { recursive: true });
+        }
+        else {
+            if (!stat.isFile()) {
+                continue;
+            }
+            fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+            fs.copyFileSync(sourcePath, targetPath);
+        }
+        migrated.push(item.label);
+    }
+    if (migrated.length && log) {
+        const skippedText = skippedExisting.length
+            ? ` Skipped existing: ${skippedExisting.join(", ")}.`
+            : "";
+        log(`Migrated legacy ${migrated.join(", ")} from ${legacySource.dataDir} to ${channelDataDir}.${skippedText}`);
+    }
+    return migrated;
+}