@unlinearity/cli-wechat-bridge 1.0.0

package/src/commands/check-update.ts

@@ -0,0 +1,46 @@
+#!/usr/bin/env bun
+
+import {
+  checkForUpdate,
+  getCurrentVersion,
+  fetchLatestVersion,
+  compareVersions,
+} from "../utils/version-checker.ts";
+
+async function main(): Promise<void> {
+  const currentVersion = await getCurrentVersion();
+
+  console.log(`CLI WeChat Bridge Version Check`);
+  console.log(`Current version: v${currentVersion}\n`);
+
+  console.log(`Checking for updates...`);
+
+  const versionInfo = await checkForUpdate(true); // 强制检查
+
+  if (!versionInfo) {
+    console.log(`ERROR: Unable to check for updates, please check your network connection`);
+    process.exit(1);
+  }
+
+  if (!versionInfo.hasUpdate) {
+    console.log(`OK: Already up to date (v${versionInfo.latest})`);
+    process.exit(0);
+  }
+
+  console.log(`[New Version Available] v${versionInfo.latest}`);
+  console.log(`Current version: v${versionInfo.current}\n`);
+
+  console.log(`Update instructions:`);
+  console.log(`   cd CLI-WeChat-Bridge`);
+  console.log(`   git pull`);
+  console.log(`   bun install`);
+  console.log(`   npm install -g .\n`);
+
+  console.log(`For more information:`);
+  console.log(`   https://github.com/UNLINEARITY/CLI-WeChat-Bridge/releases`);
+}
+
+main().catch((error) => {
+  console.error(`Error checking for updates: ${error.message}`);
+  process.exit(1);
+});

package/src/companion/codex-panel-link.ts

@@ -0,0 +1,151 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import type net from "node:net";
+
+import {
+  ensureWorkspaceChannelDir,
+  getWorkspaceChannelPaths,
+} from "../wechat/channel-config.ts";
+import type { BridgeAdapterState, BridgeEvent } from "../bridge/bridge-types.ts";
+
+export type CodexPanelCommand =
+  | { command: "send_input"; text: string }
+  | { command: "list_resume_sessions"; limit?: number }
+  | { command: "list_resume_threads"; limit?: number }
+  | { command: "resume_session"; sessionId: string }
+  | { command: "resume_thread"; threadId: string }
+  | { command: "interrupt" }
+  | { command: "reset" }
+  | { command: "dispose" }
+  | { command: "resolve_approval"; action: "confirm" | "deny" };
+
+export type CodexPanelEndpoint = {
+  instanceId: string;
+  port: number;
+  token: string;
+  cwd: string;
+  command: string;
+  profile?: string;
+  sharedThreadId?: string;
+  startedAt: string;
+};
+
+export type CodexPanelMessage =
+  | {
+      type: "hello";
+      token: string;
+      panelPid: number;
+    }
+  | {
+      type: "hello_ack";
+    }
+  | {
+      type: "request";
+      id: string;
+      payload: CodexPanelCommand;
+    }
+  | {
+      type: "response";
+      id: string;
+      ok: boolean;
+      result?: unknown;
+      error?: string;
+    }
+  | {
+      type: "event";
+      event: BridgeEvent;
+    }
+  | {
+      type: "state";
+      state: BridgeAdapterState;
+    };
+
+export function buildCodexPanelToken(): string {
+  return crypto.randomBytes(18).toString("hex");
+}
+
+export function writeCodexPanelEndpoint(endpoint: CodexPanelEndpoint): void {
+  const { endpointFile } = ensureWorkspaceChannelDir(endpoint.cwd);
+  fs.writeFileSync(
+    endpointFile,
+    JSON.stringify(endpoint, null, 2),
+    "utf8",
+  );
+}
+
+export function readCodexPanelEndpoint(cwd: string): CodexPanelEndpoint | null {
+  try {
+    const { endpointFile } = getWorkspaceChannelPaths(cwd);
+    if (!fs.existsSync(endpointFile)) {
+      return null;
+    }
+    return JSON.parse(
+      fs.readFileSync(endpointFile, "utf8"),
+    ) as CodexPanelEndpoint;
+  } catch {
+    return null;
+  }
+}
+
+export function clearCodexPanelEndpoint(cwd: string, instanceId?: string): void {
+  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: net.Socket,
+  message: CodexPanelMessage,
+): void {
+  socket.write(`${JSON.stringify(message)}\n`);
+}
+
+export function attachCodexPanelMessageListener(
+  socket: net.Socket,
+  onMessage: (message: CodexPanelMessage) => void,
+): () => void {
+  let buffer = "";
+  const onData = (chunk: string | Buffer) => {
+    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) as CodexPanelMessage);
+      } catch {
+        // Ignore malformed local IPC frames.
+      }
+    }
+  };
+
+  socket.setEncoding("utf8");
+  socket.on("data", onData);
+  return () => {
+    socket.off("data", onData);
+  };
+}

package/src/companion/codex-panel.ts

@@ -0,0 +1,225 @@
+#!/usr/bin/env bun
+
+import net from "node:net";
+import path from "node:path";
+
+import { createBridgeAdapter } from "../bridge/bridge-adapters.ts";
+import {
+  attachCodexPanelMessageListener,
+  readCodexPanelEndpoint,
+  sendCodexPanelMessage,
+  type CodexPanelMessage,
+} from "./codex-panel-link.ts";
+import { migrateLegacyChannelFiles } from "../wechat/channel-config.ts";
+
+function log(message: string): void {
+  process.stderr.write(`[codex-panel] ${message}\n`);
+}
+
+type CodexPanelCliOptions = {
+  cwd: string;
+};
+
+function parseCliArgs(argv: string[]): CodexPanelCliOptions {
+  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(): Promise<void> {
+  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<net.Socket>((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: (() => void) | null = null;
+
+  const publishState = () => {
+    sendCodexPanelMessage(socket, {
+      type: "state",
+      state: adapter.getState(),
+    });
+  };
+
+  const sendResponse = (id: string, ok: boolean, result?: unknown, error?: string) => {
+    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: CodexPanelMessage) => {
+    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/src/companion/codex-remote-client.ts

@@ -0,0 +1,178 @@
+#!/usr/bin/env node
+
+import { spawn } from "node:child_process";
+import path from "node:path";
+
+import {
+  assertNoReservedExtraCliArgs,
+  buildCliEnvironment,
+  buildCodexCliArgs,
+  resolveSpawnTarget,
+} from "../bridge/bridge-adapters.shared.ts";
+import {
+  clearLocalCompanionOccupancy,
+  readLocalCompanionEndpoint,
+  updateLocalCompanionOccupancy,
+  type LocalCompanionEndpoint,
+} from "./local-companion-link.ts";
+import { migrateLegacyChannelFiles } from "../wechat/channel-config.ts";
+import { CODEX_REMOTE_AUTH_TOKEN_ENV } from "../runtime/runtime-types.ts";
+
+type CodexRemoteClientCliOptions = {
+  cwd: string;
+  cliArgs: string[];
+};
+
+function log(message: string): void {
+  process.stderr.write(`[codex-remote-client] ${message}\n`);
+}
+
+export function parseCliArgs(argv: string[]): CodexRemoteClientCliOptions {
+  let cwd = process.cwd();
+  const cliArgs: string[] = [];
+
+  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>] [...codex args]",
+          "",
+          'Starts the visible native Codex client and connects it to the running "wechat-bridge-codex" instance for the current directory.',
+          "Unknown arguments are forwarded to the Codex client.",
+          "",
+        ].join("\n"),
+      );
+      process.exit(0);
+    }
+
+    if (arg === "--cwd") {
+      if (!next) {
+        throw new Error("--cwd requires a value");
+      }
+      cwd = path.resolve(next);
+      i += 1;
+      continue;
+    }
+
+    cliArgs.push(arg);
+  }
+
+  return { cwd, cliArgs };
+}
+
+export function readCodexRuntimeEndpoint(cwd: string): LocalCompanionEndpoint {
+  const endpoint = readLocalCompanionEndpoint(cwd);
+  if (!endpoint || endpoint.kind !== "codex") {
+    throw new Error(
+      `No active Codex bridge endpoint was found for ${cwd}. Start "wechat-bridge-codex" in that directory first.`,
+    );
+  }
+
+  if (endpoint.runtimeKind !== "codex_runtime_host" || (!endpoint.serverUrl && !endpoint.serverPort)) {
+    throw new Error(
+      `The running Codex bridge for ${cwd} is using an older local companion protocol. Restart "wechat-bridge-codex" in that directory first.`,
+    );
+  }
+
+  return endpoint;
+}
+
+export function buildRemoteCodexClientArgs(
+  endpoint: LocalCompanionEndpoint,
+  options: { extraCliArgs?: string[] } = {},
+): string[] {
+  const extraCliArgs = options.extraCliArgs ?? [];
+  assertNoReservedExtraCliArgs(
+    extraCliArgs,
+    ["--remote", "--remote-auth-token-env"],
+    "Codex remote connection",
+  );
+  const remoteUrl = endpoint.serverUrl ?? `ws://127.0.0.1:${endpoint.serverPort ?? endpoint.port}`;
+  const args = buildCodexCliArgs(remoteUrl, {
+    profile: endpoint.profile,
+    resumeThreadId: endpoint.sharedThreadId,
+  });
+  const tokenEnvName = endpoint.remoteAuthTokenEnv ?? CODEX_REMOTE_AUTH_TOKEN_ENV;
+  return [...args, "--remote-auth-token-env", tokenEnvName, ...extraCliArgs];
+}
+
+export function buildRemoteCodexClientEnv(
+  endpoint: LocalCompanionEndpoint,
+  env: Record<string, string | undefined> = process.env as Record<string, string | undefined>,
+): Record<string, string> {
+  const tokenEnvName = endpoint.remoteAuthTokenEnv ?? CODEX_REMOTE_AUTH_TOKEN_ENV;
+  const nextEnv = buildCliEnvironment("codex", { env });
+  nextEnv[tokenEnvName] = endpoint.token;
+  return nextEnv;
+}
+
+export async function runCodexRemoteClientFromEndpoint(
+  endpoint: LocalCompanionEndpoint,
+  options: { extraCliArgs?: string[] } = {},
+): Promise<number> {
+  const spawnTarget = resolveSpawnTarget(endpoint.command, "codex");
+  const args = buildRemoteCodexClientArgs(endpoint, {
+    extraCliArgs: options.extraCliArgs,
+  });
+  const env = buildRemoteCodexClientEnv(endpoint);
+
+  return await new Promise<number>((resolve, reject) => {
+    const child = spawn(
+      spawnTarget.file,
+      [...spawnTarget.args, ...args],
+      {
+        cwd: endpoint.cwd,
+        env,
+        stdio: "inherit",
+        windowsHide: false,
+      },
+    );
+
+    if (typeof child.pid === "number") {
+      updateLocalCompanionOccupancy(endpoint.cwd, {
+        companionPid: child.pid,
+        companionConnectedAt: new Date().toISOString(),
+      }, endpoint.instanceId);
+    }
+
+    child.once("error", (error) => {
+      clearLocalCompanionOccupancy(endpoint.cwd, endpoint.instanceId);
+      reject(error);
+    });
+    child.once("exit", (code, signal) => {
+      clearLocalCompanionOccupancy(endpoint.cwd, endpoint.instanceId);
+      if (signal) {
+        process.kill(process.pid, signal);
+        return;
+      }
+      resolve(code ?? 0);
+    });
+  });
+}
+
+export async function runCodexRemoteClient(
+  options: CodexRemoteClientCliOptions,
+): Promise<number> {
+  const endpoint = readCodexRuntimeEndpoint(options.cwd);
+  return await runCodexRemoteClientFromEndpoint(endpoint, {
+    extraCliArgs: options.cliArgs,
+  });
+}
+
+async function main(): Promise<void> {
+  migrateLegacyChannelFiles(log);
+  const options = parseCliArgs(process.argv.slice(2));
+  const exitCode = await runCodexRemoteClient(options);
+  process.exit(exitCode);
+}
+
+const isDirectRun = Boolean((import.meta as ImportMeta & { main?: boolean }).main);
+if (isDirectRun) {
+  main().catch((error) => {
+    log(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  });
+}