@unlinearity/cli-wechat-bridge 1.0.4 → 1.0.5

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

@@ -1,6 +1,6 @@
 import crypto from "node:crypto";
 import fs from "node:fs";
-import { ensureWorkspaceChannelDir, getWorkspaceChannelPaths, } from "../wechat/channel-config.js";
+import { ensureWorkspaceChannelDir, getWorkspaceAdapterEndpointFile, getWorkspaceChannelPaths, } from "../wechat/channel-config.js";
 import { LOCAL_CLIENT_PROTOCOL_VERSION, } from "../runtime/runtime-types.js";
 function normalizeEndpoint(value) {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
@@ -66,51 +66,81 @@ function normalizeEndpoint(value) {
 export function buildLocalCompanionToken() {
     return crypto.randomBytes(18).toString("hex");
 }
-export function writeLocalCompanionEndpoint(endpoint) {
-    const { endpointFile } = ensureWorkspaceChannelDir(endpoint.cwd);
-    const payload = {
+function serializeEndpoint(endpoint) {
+    return {
         ...endpoint,
         protocolVersion: endpoint.protocolVersion ?? LOCAL_CLIENT_PROTOCOL_VERSION,
         sharedThreadId: endpoint.kind === "codex" || endpoint.kind === "opencode"
             ? endpoint.sharedSessionId ?? endpoint.sharedThreadId
             : undefined,
     };
-    fs.writeFileSync(endpointFile, JSON.stringify(payload, null, 2), "utf8");
 }
-export function readLocalCompanionEndpoint(cwd) {
+function readEndpointFile(filePath) {
+    if (!fs.existsSync(filePath)) {
+        return null;
+    }
+    return normalizeEndpoint(JSON.parse(fs.readFileSync(filePath, "utf8")));
+}
+export function writeLocalCompanionEndpoint(endpoint, options = {}) {
+    const { endpointFile } = ensureWorkspaceChannelDir(endpoint.cwd);
+    const payload = {
+        ...serializeEndpoint(endpoint),
+    };
+    fs.writeFileSync(getWorkspaceAdapterEndpointFile(endpoint.cwd, endpoint.kind), JSON.stringify(payload, null, 2), "utf8");
+    if (options.writeLegacy !== false) {
+        fs.writeFileSync(endpointFile, JSON.stringify(payload, null, 2), "utf8");
+    }
+}
+export function readLocalCompanionEndpoint(cwd, options = {}) {
     try {
         const { endpointFile } = getWorkspaceChannelPaths(cwd);
-        if (!fs.existsSync(endpointFile)) {
-            return null;
+        if (options.adapter) {
+            const scoped = readEndpointFile(getWorkspaceAdapterEndpointFile(cwd, options.adapter));
+            if (scoped) {
+                return scoped;
+            }
+            const legacy = readEndpointFile(endpointFile);
+            return legacy?.kind === options.adapter ? legacy : null;
         }
-        return normalizeEndpoint(JSON.parse(fs.readFileSync(endpointFile, "utf8")));
+        return readEndpointFile(endpointFile);
     }
     catch {
         return null;
     }
 }
-export function clearLocalCompanionEndpoint(cwd, instanceId) {
+export function clearLocalCompanionEndpoint(cwd, instanceId, options = {}) {
     try {
         const { endpointFile } = getWorkspaceChannelPaths(cwd);
-        if (!fs.existsSync(endpointFile)) {
-            return;
-        }
-        if (!instanceId) {
-            fs.rmSync(endpointFile, { force: true });
-            return;
-        }
-        const endpoint = readLocalCompanionEndpoint(cwd);
-        if (!endpoint || endpoint.instanceId === instanceId) {
-            fs.rmSync(endpointFile, { force: true });
+        const files = options.adapter
+            ? [getWorkspaceAdapterEndpointFile(cwd, options.adapter), endpointFile]
+            : [
+                endpointFile,
+                getWorkspaceAdapterEndpointFile(cwd, "codex"),
+                getWorkspaceAdapterEndpointFile(cwd, "claude"),
+                getWorkspaceAdapterEndpointFile(cwd, "opencode"),
+                getWorkspaceAdapterEndpointFile(cwd, "shell"),
+            ];
+        for (const filePath of files) {
+            if (!fs.existsSync(filePath)) {
+                continue;
+            }
+            if (!instanceId) {
+                fs.rmSync(filePath, { force: true });
+                continue;
+            }
+            const endpoint = readEndpointFile(filePath);
+            if (!endpoint || endpoint.instanceId === instanceId) {
+                fs.rmSync(filePath, { force: true });
+            }
         }
     }
     catch {
         // Best effort cleanup.
     }
 }
-export function clearLocalCompanionOccupancy(cwd, instanceId) {
+export function clearLocalCompanionOccupancy(cwd, instanceId, options = {}) {
     try {
-        const endpoint = readLocalCompanionEndpoint(cwd);
+        const endpoint = readLocalCompanionEndpoint(cwd, options);
         if (!endpoint) {
             return;
         }
@@ -130,9 +160,9 @@ export function clearLocalCompanionOccupancy(cwd, instanceId) {
         // Best effort cleanup.
     }
 }
-export function updateLocalCompanionHealth(cwd, patch, instanceId) {
+export function updateLocalCompanionHealth(cwd, patch, instanceId, options = {}) {
     try {
-        const endpoint = readLocalCompanionEndpoint(cwd);
+        const endpoint = readLocalCompanionEndpoint(cwd, options);
         if (!endpoint) {
             return;
         }
@@ -150,9 +180,9 @@ export function updateLocalCompanionHealth(cwd, patch, instanceId) {
         // Best effort cleanup.
     }
 }
-export function updateLocalCompanionOccupancy(cwd, patch, instanceId) {
+export function updateLocalCompanionOccupancy(cwd, patch, instanceId, options = {}) {
     try {
-        const endpoint = readLocalCompanionEndpoint(cwd);
+        const endpoint = readLocalCompanionEndpoint(cwd, options);
         if (!endpoint) {
             return;
         }

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

@@ -9,6 +9,7 @@ import { readBridgeLockFile, shouldAutoReclaimBridgeLock, } from "../bridge/brid
 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";
@@ -184,7 +185,12 @@ async function stopExistingBridge(lock, requestedAdapter) {
     if (!(await waitForProcessExit(pid, 10_000))) {
         throw new Error(`Timed out waiting for existing bridge pid=${pid} to exit.`);
     }
-    clearLocalCompanionEndpoint(cwd);
+    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) {
@@ -211,14 +217,14 @@ async function isEndpointReachable(endpoint) {
     });
 }
 async function readUsableEndpoint(cwd, adapter) {
-    const endpoint = readLocalCompanionEndpoint(cwd);
+    const endpoint = readLocalCompanionEndpoint(cwd, { adapter });
     if (!endpoint || endpoint.kind !== adapter) {
         return { endpoint: null };
     }
     if (await isEndpointReachable(endpoint)) {
         return { endpoint };
     }
-    clearLocalCompanionEndpoint(cwd, endpoint.instanceId);
+    clearLocalCompanionEndpoint(cwd, endpoint.instanceId, { adapter });
     log(adapter, `Removed stale local companion endpoint for ${cwd}.`);
     return { endpoint: null };
 }
@@ -229,7 +235,9 @@ function isCompanionAlive(endpoint) {
     if (isPidAlive(endpoint.companionPid)) {
         return true;
     }
-    clearLocalCompanionOccupancy(endpoint.cwd, endpoint.instanceId);
+    clearLocalCompanionOccupancy(endpoint.cwd, endpoint.instanceId, {
+        adapter: endpoint.kind,
+    });
     return false;
 }
 export function buildBackgroundBridgeArgs(entryPath, options) {
@@ -277,7 +285,9 @@ async function ensureBridgeReady(options) {
     if (!lock || !lockProcessAlive) {
         if (lock && !lockProcessAlive) {
             log(options.adapter, `Found stale lock for ${options.cwd} (pid=${lock.pid} dead). Clearing.`);
-            clearLocalCompanionEndpoint(options.cwd);
+            clearLocalCompanionEndpoint(options.cwd, undefined, {
+                adapter: options.adapter,
+            });
         }
         log(options.adapter, `Starting bridge in background for ${options.cwd}...`);
         startBridgeInBackground(options);
@@ -322,6 +332,36 @@ async function ensureBridgeReady(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.
@@ -347,6 +387,9 @@ export async function ensureCompanionStartWechatCredentials(adapter, ensureCrede
 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;

package/dist/companion/local-companion.js

@@ -60,7 +60,9 @@ function delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
 function readMatchingEndpoint(options) {
-    const endpoint = readLocalCompanionEndpoint(options.cwd);
+    const endpoint = readLocalCompanionEndpoint(options.cwd, {
+        adapter: options.adapter,
+    });
     if (!endpoint || endpoint.kind !== options.adapter) {
         throw new Error(`No active ${options.adapter} bridge endpoint was found for ${options.cwd}. Start "wechat-bridge-${options.adapter}" in that directory first.`);
     }

package/dist/daemon/daemon-link.js

@@ -0,0 +1,175 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import net from "node:net";
+import { DAEMON_ENDPOINT_FILE, ensureChannelDataDir, } from "../wechat/channel-config.js";
+export const DAEMON_PROTOCOL_VERSION = 1;
+function normalizeDaemonEndpoint(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    const record = value;
+    if (typeof record.protocolVersion !== "number" ||
+        typeof record.pid !== "number" ||
+        typeof record.port !== "number" ||
+        typeof record.token !== "string" ||
+        typeof record.cwd !== "string" ||
+        typeof record.startedAt !== "string") {
+        return null;
+    }
+    return {
+        protocolVersion: record.protocolVersion,
+        pid: record.pid,
+        port: record.port,
+        token: record.token,
+        cwd: record.cwd,
+        startedAt: record.startedAt,
+    };
+}
+export function buildDaemonToken() {
+    return crypto.randomBytes(18).toString("hex");
+}
+export function writeDaemonEndpoint(endpoint) {
+    ensureChannelDataDir();
+    fs.writeFileSync(DAEMON_ENDPOINT_FILE, JSON.stringify({
+        ...endpoint,
+        protocolVersion: DAEMON_PROTOCOL_VERSION,
+    }, null, 2), "utf8");
+}
+export function readDaemonEndpoint() {
+    try {
+        if (!fs.existsSync(DAEMON_ENDPOINT_FILE)) {
+            return null;
+        }
+        return normalizeDaemonEndpoint(JSON.parse(fs.readFileSync(DAEMON_ENDPOINT_FILE, "utf8")));
+    }
+    catch {
+        return null;
+    }
+}
+export function clearDaemonEndpoint(pid = process.pid) {
+    try {
+        const endpoint = readDaemonEndpoint();
+        if (!endpoint || endpoint.pid === pid) {
+            fs.rmSync(DAEMON_ENDPOINT_FILE, { force: true });
+        }
+    }
+    catch {
+        // Best effort cleanup.
+    }
+}
+export function isPidAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0) {
+        return false;
+    }
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function sendDaemonResponse(socket, id, response) {
+    if (socket.destroyed || socket.writableEnded) {
+        return false;
+    }
+    try {
+        return socket.write(`${JSON.stringify({ id, response })}\n`);
+    }
+    catch {
+        return false;
+    }
+}
+export function attachDaemonRequestListener(socket, onRequest) {
+    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 {
+                onRequest(JSON.parse(line));
+            }
+            catch {
+                // Ignore malformed daemon IPC frames.
+            }
+        }
+    };
+    socket.setEncoding("utf8");
+    socket.on("data", onData);
+    return () => {
+        socket.off("data", onData);
+    };
+}
+export async function sendDaemonRequest(endpoint, payload, options = {}) {
+    const timeoutMs = options.timeoutMs ?? 2_000;
+    const id = crypto.randomUUID();
+    return await new Promise((resolve) => {
+        const socket = net.connect({
+            host: "127.0.0.1",
+            port: endpoint.port,
+        });
+        let buffer = "";
+        let settled = false;
+        const timer = setTimeout(() => {
+            finish({ ok: false, error: "Timed out waiting for daemon response." });
+        }, timeoutMs);
+        const finish = (response) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            clearTimeout(timer);
+            socket.destroy();
+            resolve(response);
+        };
+        socket.setEncoding("utf8");
+        socket.once("connect", () => {
+            socket.write(`${JSON.stringify({
+                id,
+                token: endpoint.token,
+                payload,
+            })}\n`);
+        });
+        socket.on("data", (chunk) => {
+            buffer += chunk;
+            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 {
+                    const frame = JSON.parse(line);
+                    if (frame.id === id) {
+                        finish(frame.response);
+                    }
+                }
+                catch {
+                    // Ignore malformed daemon IPC frames.
+                }
+            }
+        });
+        socket.once("error", () => {
+            finish({ ok: false, error: "Daemon endpoint is not reachable." });
+        });
+    });
+}
+export async function isDaemonEndpointAlive(endpoint, options = {}) {
+    if (!isPidAlive(endpoint.pid)) {
+        return false;
+    }
+    const response = await sendDaemonRequest(endpoint, { command: "status" }, options);
+    return response.ok;
+}