cli-wechat-bridge 1.0.5

package/dist/companion/local-companion-start.js

@@ -0,0 +1,420 @@
+#!/usr/bin/env node
+import net from "node:net";
+import path from "node:path";
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { BRIDGE_LOG_FILE } from "../wechat/channel-config.js";
+import { ensureWechatCredentials } from "../wechat/setup.js";
+import { readBridgeLockFile, shouldAutoReclaimBridgeLock, } from "../bridge/bridge-state.js";
+import { clearLocalCompanionOccupancy, clearLocalCompanionEndpoint, readLocalCompanionEndpoint, } from "./local-companion-link.js";
+import { runCodexRemoteClient } from "./codex-remote-client.js";
+import { runLocalCompanion } from "./local-companion.js";
+import { clearDaemonEndpoint, isDaemonEndpointAlive, readDaemonEndpoint, sendDaemonRequest, } from "../daemon/daemon-link.js";
+const MODULE_FILE = fileURLToPath(import.meta.url);
+const MODULE_DIR = path.dirname(MODULE_FILE);
+const RUNTIME_ENTRY_EXTENSION = path.extname(MODULE_FILE) === ".ts" ? ".ts" : ".js";
+const DEFAULT_WAIT_TIMEOUT_MS = 15_000;
+const DEFAULT_ADAPTER = "codex";
+function log(adapter, message) {
+    process.stderr.write(`[wechat-${adapter}-start] ${message}\n`);
+}
+export function normalizeComparablePath(cwd) {
+    const normalized = path.resolve(cwd);
+    return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+export function isSameWorkspaceCwd(left, right) {
+    return normalizeComparablePath(left) === normalizeComparablePath(right);
+}
+export function formatAlreadyActiveMessage(cwd) {
+    return `Current workspace is already active: ${cwd}. Visible companion is already running, so nothing else was opened.`;
+}
+export function formatSwitchMessage(fromCwd, toCwd) {
+    return `Detected active workspace ${fromCwd}. Switching to ${toCwd}...`;
+}
+export function formatSwitchFailureMessage(cwd) {
+    return `Failed to stop the previous workspace bridge. Switch canceled; current workspace remains ${cwd}.`;
+}
+export function formatRestartUnhealthyMessage(cwd) {
+    return `Detected unhealthy companion state for ${cwd}. Restarting bridge...`;
+}
+export function decideLaunchAction(input) {
+    if (input.lockShouldAutoReclaim) {
+        return {
+            kind: "start_bridge",
+            message: `Detected reclaimable bridge lock for ${input.runningLock.cwd}. Replacing it for ${input.requestedCwd}...`,
+        };
+    }
+    const sameWorkspace = input.runningLock.adapter === input.requestedAdapter &&
+        isSameWorkspaceCwd(input.runningLock.cwd, input.requestedCwd);
+    if (!sameWorkspace) {
+        return {
+            kind: "switch_workspace",
+            fromCwd: input.runningLock.cwd,
+            toCwd: input.requestedCwd,
+            message: formatSwitchMessage(input.runningLock.cwd, input.requestedCwd),
+            failureMessage: formatSwitchFailureMessage(input.runningLock.cwd),
+        };
+    }
+    if (!input.endpoint || !input.endpointIsReachable) {
+        return {
+            kind: "restart_unhealthy",
+            message: formatRestartUnhealthyMessage(input.requestedCwd),
+        };
+    }
+    if (input.companionIsAlive &&
+        (input.endpoint.companionStatus === "stopped" ||
+            input.endpoint.companionStatus === "error")) {
+        return {
+            kind: "restart_unhealthy",
+            message: formatRestartUnhealthyMessage(input.requestedCwd),
+        };
+    }
+    if (input.endpoint && input.endpointIsReachable && input.companionIsAlive) {
+        return {
+            kind: "already_active",
+            message: formatAlreadyActiveMessage(input.requestedCwd),
+        };
+    }
+    return {
+        kind: "open_companion",
+        message: `Found running bridge for ${input.requestedCwd}. Opening companion...`,
+    };
+}
+export function parseCliArgs(argv) {
+    let adapter = DEFAULT_ADAPTER;
+    let cwd = process.cwd();
+    let profile;
+    let timeoutMs = DEFAULT_WAIT_TIMEOUT_MS;
+    const cliArgs = [];
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (!arg) {
+            continue;
+        }
+        const next = argv[i + 1];
+        if (arg === "--help" || arg === "-h") {
+            process.stdout.write([
+                "Usage: wechat-codex-start [--cwd <path>] [--profile <name-or-path>] [--timeout-ms <ms>] [...codex args]",
+                "       wechat-claude-start [--cwd <path>] [--profile <name-or-path>] [--timeout-ms <ms>] [...claude args]",
+                "       wechat-opencode-start [--cwd <path>] [--profile <name-or-path>] [--timeout-ms <ms>] [...opencode args]",
+                "       local-companion-start [--adapter <codex|claude|opencode>] [--cwd <path>] [--profile <name-or-path>] [--timeout-ms <ms>] [...cli args]",
+                "",
+                "Starts or reuses a Codex, Claude, or OpenCode bridge for the current directory, waits for the local endpoint, then opens the visible companion or panel.",
+                "All adapters are companion-bound: closing the companion/panel also stops the bridge.",
+                "Unknown arguments are forwarded to the visible CLI client.",
+                "",
+            ].join("\n"));
+            process.exit(0);
+        }
+        if (arg === "--adapter") {
+            if (!next || !["codex", "claude", "opencode"].includes(next)) {
+                throw new Error(`Invalid adapter: ${next ?? "(missing)"}`);
+            }
+            adapter = next;
+            i += 1;
+            continue;
+        }
+        if (arg === "--cwd") {
+            if (!next) {
+                throw new Error("--cwd requires a value");
+            }
+            cwd = path.resolve(next);
+            i += 1;
+            continue;
+        }
+        if (arg === "--profile") {
+            if (!next) {
+                throw new Error("--profile requires a value");
+            }
+            profile = next;
+            i += 1;
+            continue;
+        }
+        if (arg === "--timeout-ms") {
+            if (!next) {
+                throw new Error("--timeout-ms requires a value");
+            }
+            const parsed = Number(next);
+            if (!Number.isFinite(parsed) || parsed < 1000) {
+                throw new Error("--timeout-ms must be a number >= 1000");
+            }
+            timeoutMs = Math.trunc(parsed);
+            i += 1;
+            continue;
+        }
+        cliArgs.push(arg);
+    }
+    return { adapter, cwd, profile, timeoutMs, cliArgs };
+}
+function isPidAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0) {
+        return false;
+    }
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function waitForProcessExit(pid, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (!isPidAlive(pid)) {
+            return true;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 250));
+    }
+    return !isPidAlive(pid);
+}
+async function stopExistingBridge(lock, requestedAdapter) {
+    const { pid, cwd } = lock;
+    log(requestedAdapter, `Stopping existing bridge for ${cwd} (pid=${pid})...`);
+    try {
+        process.kill(pid);
+    }
+    catch (error) {
+        if (isPidAlive(pid)) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to stop existing bridge pid=${pid}: ${message}`, {
+                cause: error,
+            });
+        }
+    }
+    if (!(await waitForProcessExit(pid, 10_000))) {
+        throw new Error(`Timed out waiting for existing bridge pid=${pid} to exit.`);
+    }
+    if (lock.adapter === "codex" || lock.adapter === "claude" || lock.adapter === "opencode") {
+        clearLocalCompanionEndpoint(cwd, undefined, { adapter: lock.adapter });
+    }
+    else {
+        clearLocalCompanionEndpoint(cwd);
+    }
+    log(requestedAdapter, `Cleared stale local companion endpoint for previous workspace ${cwd}.`);
+}
+async function isEndpointReachable(endpoint) {
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    return await new Promise((resolve) => {
+        const port = endpoint.serverPort ?? endpoint.port;
+        const socket = net.connect({
+            host: "127.0.0.1",
+            port,
+        });
+        let done = false;
+        const finish = (result) => {
+            if (done) {
+                return;
+            }
+            done = true;
+            socket.destroy();
+            resolve(result);
+        };
+        socket.setTimeout(400);
+        socket.once("connect", () => finish(true));
+        socket.once("timeout", () => finish(false));
+        socket.once("error", () => finish(false));
+    });
+}
+async function readUsableEndpoint(cwd, adapter) {
+    const endpoint = readLocalCompanionEndpoint(cwd, { adapter });
+    if (!endpoint || endpoint.kind !== adapter) {
+        return { endpoint: null };
+    }
+    if (await isEndpointReachable(endpoint)) {
+        return { endpoint };
+    }
+    clearLocalCompanionEndpoint(cwd, endpoint.instanceId, { adapter });
+    log(adapter, `Removed stale local companion endpoint for ${cwd}.`);
+    return { endpoint: null };
+}
+function isCompanionAlive(endpoint) {
+    if (!endpoint?.companionPid) {
+        return false;
+    }
+    if (isPidAlive(endpoint.companionPid)) {
+        return true;
+    }
+    clearLocalCompanionOccupancy(endpoint.cwd, endpoint.instanceId, {
+        adapter: endpoint.kind,
+    });
+    return false;
+}
+export function buildBackgroundBridgeArgs(entryPath, options) {
+    const lifecycle = "companion_bound";
+    const args = ["--no-warnings"];
+    if (path.extname(entryPath) === ".ts") {
+        args.push("--experimental-strip-types");
+    }
+    args.push(entryPath, "--adapter", options.adapter, "--cwd", options.cwd, "--lifecycle", lifecycle);
+    if (options.profile) {
+        args.push("--profile", options.profile);
+    }
+    return args;
+}
+function startBridgeInBackground(options) {
+    const entryPath = path.resolve(MODULE_DIR, "..", "bridge", `wechat-bridge${RUNTIME_ENTRY_EXTENSION}`);
+    const args = buildBackgroundBridgeArgs(entryPath, options);
+    const child = spawn(process.execPath, args, {
+        cwd: options.cwd,
+        env: process.env,
+        detached: true,
+        stdio: "ignore",
+        windowsHide: true,
+    });
+    child.unref();
+}
+async function waitForEndpoint(cwd, adapter, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        const result = await readUsableEndpoint(cwd, adapter);
+        if (result.endpoint) {
+            return result.endpoint;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 250));
+    }
+    throw new Error(`Timed out waiting for the ${adapter} bridge endpoint for ${cwd}. Check ${BRIDGE_LOG_FILE}.`);
+}
+async function ensureBridgeReady(options) {
+    // If the lock is absent or the lock-holding process is dead, do NOT trust a
+    // leftover endpoint.  The bridge (WeChat transport) may have crashed while
+    // the opencode server kept running.  Starting only the panel would leave no
+    // bridge to poll WeChat messages.
+    const lock = readBridgeLockFile();
+    const lockProcessAlive = lock ? isPidAlive(lock.pid) : false;
+    if (!lock || !lockProcessAlive) {
+        if (lock && !lockProcessAlive) {
+            log(options.adapter, `Found stale lock for ${options.cwd} (pid=${lock.pid} dead). Clearing.`);
+            clearLocalCompanionEndpoint(options.cwd, undefined, {
+                adapter: options.adapter,
+            });
+        }
+        log(options.adapter, `Starting bridge in background for ${options.cwd}...`);
+        startBridgeInBackground(options);
+        await waitForEndpoint(options.cwd, options.adapter, options.timeoutMs);
+        return { shouldOpenVisibleClient: true };
+    }
+    // Lock is held by a live process; decide whether to reuse, switch, or replace it.
+    const endpointResult = await readUsableEndpoint(options.cwd, options.adapter);
+    const decision = decideLaunchAction({
+        requestedAdapter: options.adapter,
+        requestedCwd: options.cwd,
+        runningLock: lock,
+        lockShouldAutoReclaim: shouldAutoReclaimBridgeLock(lock),
+        endpoint: endpointResult.endpoint,
+        endpointIsReachable: Boolean(endpointResult.endpoint),
+        companionIsAlive: isCompanionAlive(endpointResult.endpoint),
+    });
+    log(options.adapter, decision.message);
+    if (decision.kind === "already_active") {
+        return { shouldOpenVisibleClient: false };
+    }
+    if (decision.kind === "open_companion") {
+        if (!endpointResult.endpoint) {
+            await waitForEndpoint(options.cwd, options.adapter, options.timeoutMs);
+        }
+        return { shouldOpenVisibleClient: true };
+    }
+    if (decision.kind === "switch_workspace") {
+        try {
+            await stopExistingBridge(lock, options.adapter);
+        }
+        catch (error) {
+            log(options.adapter, decision.failureMessage);
+            throw error;
+        }
+    }
+    else {
+        await stopExistingBridge(lock, options.adapter);
+    }
+    log(options.adapter, `Starting replacement bridge in background for ${options.cwd}...`);
+    startBridgeInBackground(options);
+    await waitForEndpoint(options.cwd, options.adapter, options.timeoutMs);
+    return { shouldOpenVisibleClient: true };
+}
+export async function tryDelegateToDaemon(options, deps = {}) {
+    const readEndpoint = deps.readEndpoint ?? readDaemonEndpoint;
+    const isEndpointAlive = deps.isEndpointAlive ?? isDaemonEndpointAlive;
+    const sendRequest = deps.sendRequest ?? sendDaemonRequest;
+    const clearEndpoint = deps.clearEndpoint ?? clearDaemonEndpoint;
+    const endpoint = readEndpoint();
+    if (!endpoint) {
+        return false;
+    }
+    if (!(await isEndpointAlive(endpoint))) {
+        clearEndpoint(endpoint.pid);
+        return false;
+    }
+    if (!isSameWorkspaceCwd(endpoint.cwd, options.cwd)) {
+        throw new Error(`wechat-daemon is running for ${endpoint.cwd}. This launcher requested ${options.cwd}; v1 daemon switching is limited to its startup cwd.`);
+    }
+    const response = await sendRequest(endpoint, {
+        command: "ensure_slot",
+        adapter: options.adapter,
+        cwd: options.cwd,
+        profile: options.profile,
+        cliArgs: options.cliArgs,
+        openVisible: true,
+    });
+    if (!response.ok) {
+        throw new Error(response.error);
+    }
+    log(options.adapter, `Delegated to running wechat-daemon for ${options.cwd}.`);
+    return true;
+}
+export async function runVisibleClient(options, runners = {}) {
+    // Keep the foreground client in-process so Windows does not briefly flash an
+    // extra bootstrap console before the real companion UI appears.
+    if (options.adapter === "codex") {
+        return await (runners.codexRemoteClient ?? runCodexRemoteClient)({
+            cwd: options.cwd,
+            cliArgs: options.cliArgs,
+        });
+    }
+    return await (runners.localCompanion ?? runLocalCompanion)({
+        adapter: options.adapter,
+        cwd: options.cwd,
+        cliArgs: options.cliArgs,
+    });
+}
+export async function ensureCompanionStartWechatCredentials(adapter, ensureCredentials = ensureWechatCredentials) {
+    await ensureCredentials({
+        requireUserId: true,
+        validateExisting: true,
+        log: (message) => log(adapter, message),
+    });
+}
+export async function runLocalCompanionStart(argv = process.argv.slice(2)) {
+    const options = parseCliArgs(argv);
+    await ensureCompanionStartWechatCredentials(options.adapter);
+    if (await tryDelegateToDaemon(options)) {
+        return 0;
+    }
+    const ready = await ensureBridgeReady(options);
+    if (!ready.shouldOpenVisibleClient) {
+        return 0;
+    }
+    return await runVisibleClient(options);
+}
+export async function main(argv = process.argv.slice(2)) {
+    try {
+        const exitCode = await runLocalCompanionStart(argv);
+        process.exit(exitCode);
+    }
+    catch (error) {
+        const adapter = (() => {
+            try {
+                return parseCliArgs(argv).adapter;
+            }
+            catch {
+                return DEFAULT_ADAPTER;
+            }
+        })();
+        log(adapter, error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+}
+const isDirectRun = Boolean(import.meta.main);
+if (isDirectRun) {
+    void main();
+}