@unlinearity/cli-wechat-bridge 1.0.4 → 1.0.6

package/dist/bridge/wechat-bridge.js

@@ -8,9 +8,10 @@ import { ensureWechatCredentials } from "../wechat/setup.js";
 import { BridgeStateStore } from "./bridge-state.js";
 import { reapOrphanedOpencodeProcesses, reapPeerBridgeProcesses } from "./bridge-process-reaper.js";
 import { createRuntimeHost } from "../runtime/create-runtime-host.js";
-import { buildWechatInboundPrompt, buildOneTimeCode, formatApprovalMessage, formatPendingApprovalReminder, formatDuration, formatMirroredUserInputMessage, formatSessionSwitchMessage, formatStatusReport, formatTaskFailedMessage, MESSAGE_START_GRACE_MS, nowIso, OutputBatcher, parseWechatControlCommand, truncatePreview, } from "./bridge-utils.js";
-import { classifyWechatTransportError, DEFAULT_LONG_POLL_TIMEOUT_MS, WeChatTransport, describeWechatTransportError, } from "../wechat/wechat-transport.js";
+import { buildWechatInboundPrompt, buildOneTimeCode, formatApprovalMessage, formatPendingApprovalReminder, formatPendingUserInputReminder, formatDuration, formatMirroredUserInputMessage, formatSessionSwitchMessage, formatStatusReport, formatTaskFailedMessage, formatUserInputRequestMessage, MESSAGE_START_GRACE_MS, nowIso, OutputBatcher, parsePendingUserInputAnswerCommand, parseWechatControlCommand, truncatePreview, } from "./bridge-utils.js";
+import { classifyWechatTransportError, DEFAULT_LONG_POLL_TIMEOUT_MS, WeChatTransport, describeWechatTransportError, isWechatContextTokenStaleError, } from "../wechat/wechat-transport.js";
 import { checkForUpdate, formatUpdateMessage, } from "../utils/version-checker.js";
+import { clearDaemonEndpoint, isDaemonEndpointAlive, readDaemonEndpoint, } from "../daemon/daemon-link.js";
 const POLL_RETRY_BASE_MS = 1_000;
 const POLL_RETRY_MAX_MS = 30_000;
 const PARENT_PROCESS_POLL_MS = 5_000;
@@ -75,16 +76,22 @@ export function formatUserFacingInboundError(params) {
 export function formatWechatSendFailureLogEntry(params) {
     return `wechat_send_failed: context=${params.context} recipient=${params.recipientId} error=${truncatePreview(describeWechatTransportError(params.error), 400)}`;
 }
+export function formatWechatContextTokenStaleLogEntry(params) {
+    return `wechat_context_token_stale: context=${params.context} recipient=${params.recipientId} action=wechat_message_required error=${truncatePreview(describeWechatTransportError(params.error), 400)}`;
+}
 function formatWechatSendRetryLogEntry(params) {
     return `wechat_send_retry: context=${params.context} recipient=${params.recipientId} attempt=${params.attempt} delay_ms=${params.delayMs} error=${truncatePreview(describeWechatTransportError(params.error), 400)}`;
 }
-function isRetryableWechatSendError(error) {
+export function isRetryableWechatSendError(error) {
+    if (isWechatContextTokenStaleError(error)) {
+        return false;
+    }
     const classification = classifyWechatTransportError(error);
     if (classification.retryable) {
         return true;
     }
     const details = describeWechatTransportError(error);
-    return /^Error: sendmessage failed:/i.test(details) &&
+    return /^(?:Error|WechatApiResponseError): sendmessage failed:/i.test(details) &&
         !/errcode=-14\b.*session timeout/i.test(details);
 }
 function computeWechatSendRetryDelayMs(attempt) {
@@ -104,6 +111,15 @@ function toPendingApproval(request) {
         createdAt: nowIso(),
     };
 }
+function toPendingUserInput(request) {
+    if (typeof request.createdAt === "string") {
+        return request;
+    }
+    return {
+        ...request,
+        createdAt: nowIso(),
+    };
+}
 export function shouldDeferCodexInboundMessage(params) {
     return (params.adapter === "codex" &&
         !params.hasPendingConfirmation &&
@@ -115,11 +131,13 @@ export function canDrainDeferredCodexInboundQueue(params) {
     return (params.adapter === "codex" &&
         params.deferredCount > 0 &&
         !params.hasPendingConfirmation &&
+        !params.hasPendingUserInput &&
         !params.hasPendingApproval &&
         !params.hasActiveTask &&
         !params.activeTurnId &&
         params.status !== "busy" &&
-        params.status !== "awaiting_approval");
+        params.status !== "awaiting_approval" &&
+        params.status !== "awaiting_input");
 }
 export function formatDeferredCodexInboundQueueMessage(queuePosition) {
     return `Queued for delivery after the current local Codex turn finishes. Queue position: ${queuePosition}.`;
@@ -214,6 +232,14 @@ function printUsageAndExit() {
 }
 async function main() {
     const options = parseCliArgs(process.argv.slice(2));
+    const daemonEndpoint = readDaemonEndpoint();
+    if (daemonEndpoint && await isDaemonEndpointAlive(daemonEndpoint, { timeoutMs: 500 })) {
+        throw new Error(`wechat-daemon is already running (pid=${daemonEndpoint.pid}, cwd=${daemonEndpoint.cwd}). Stop it before starting a standalone bridge.`);
+    }
+    if (daemonEndpoint) {
+        clearDaemonEndpoint(daemonEndpoint.pid);
+        log(`Cleared stale wechat-daemon endpoint for pid=${daemonEndpoint.pid}.`);
+    }
     const credentials = await ensureWechatCredentials({
         requireUserId: true,
         validateExisting: true,
@@ -313,6 +339,17 @@ async function main() {
                     return true;
                 }
                 catch (err) {
+                    if (isWechatContextTokenStaleError(err)) {
+                        transport.clearCachedContextToken(senderId);
+                        const hint = "WeChat conversation context is stale. Ask the WeChat owner to send any message first, then local terminal replies can sync back to WeChat.";
+                        logError(`Failed to send WeChat ${context}: ${hint}`);
+                        stateStore.appendLog(formatWechatContextTokenStaleLogEntry({
+                            context,
+                            recipientId: senderId,
+                            error: err,
+                        }));
+                        return false;
+                    }
                     if (attempt < WECHAT_SEND_MAX_ATTEMPTS && isRetryableWechatSendError(err)) {
                         const delayMs = computeWechatSendRetryDelayMs(attempt);
                         logError(`Failed to send WeChat ${context} (attempt ${attempt}). Retrying in ${formatDuration(delayMs)}. ${describeWechatTransportError(err)}`);
@@ -368,6 +405,7 @@ async function main() {
             status: adapterState.status,
             activeTurnId: adapterState.activeTurnId,
             hasPendingConfirmation: Boolean(stateStore.getState().pendingConfirmation),
+            hasPendingUserInput: Boolean(stateStore.getState().pendingUserInput),
             hasPendingApproval: Boolean(adapterState.pendingApproval),
             hasActiveTask: Boolean(activeTask),
         })) {
@@ -691,6 +729,9 @@ function wireAdapterEvents(params) {
         if (bridgeState.pendingConfirmation && !adapterState.pendingApproval) {
             stateStore.clearPendingConfirmation();
         }
+        if (bridgeState.pendingUserInput && !adapterState.pendingUserInput) {
+            stateStore.clearPendingUserInput();
+        }
         const authorizedUserId = stateStore.getState().authorizedUserId;
         switch (event.type) {
             case "stdout":
@@ -749,6 +790,14 @@ function wireAdapterEvents(params) {
                     await queueWechatMessage(authorizedUserId, formatApprovalMessage(pending, adapterState), "approval_required");
                 }));
                 break;
+            case "user_input_required":
+                trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
+                    const pending = toPendingUserInput(event.request);
+                    stateStore.setPendingUserInput(pending);
+                    stateStore.appendLog(`User input requested: questions=${pending.questions.length}`);
+                    await queueWechatMessage(authorizedUserId, formatUserInputRequestMessage(pending, adapterState), "user_input_required");
+                }));
+                break;
             case "mirrored_user_input":
                 stateStore.appendLog(`mirrored_local_input: ${truncatePreview(event.text)}`);
                 if (shouldForwardBridgeEventToWechat(options.adapter, event.type, { text: event.text })) {
@@ -787,6 +836,7 @@ function wireAdapterEvents(params) {
             case "task_complete":
                 trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
                     stateStore.clearPendingConfirmation();
+                    stateStore.clearPendingUserInput();
                     if (options.adapter === "shell") {
                         const summary = buildCompletionSummary({
                             adapter: options.adapter,
@@ -803,6 +853,7 @@ function wireAdapterEvents(params) {
             case "task_failed":
                 trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
                     stateStore.clearPendingConfirmation();
+                    stateStore.clearPendingUserInput();
                     clearActiveTask();
                     await queueWechatMessage(authorizedUserId, formatTaskFailedMessage(options.adapter, event.message), "task_failed");
                     await maybeDrainDeferredInboundMessages();
@@ -812,6 +863,7 @@ function wireAdapterEvents(params) {
                 logError(event.message);
                 stateStore.appendLog(`fatal_error: ${event.message}`);
                 stateStore.clearPendingConfirmation();
+                stateStore.clearPendingUserInput();
                 clearActiveTask();
                 trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
                     await queueWechatMessage(authorizedUserId, formatUserFacingBridgeFatalError(event.message), "fatal_error");
@@ -837,6 +889,17 @@ function buildCompletionSummary(params) {
     lines.push(`recent_output:\n${params.recentOutput}`);
     return lines.join("\n");
 }
+function formatInboundMessagePreview(message) {
+    if (message.text.trim()) {
+        return message.text;
+    }
+    if (message.attachments.length > 0) {
+        return message.attachments
+            .map((attachment) => `${attachment.kind}: ${attachment.path}`)
+            .join("\n");
+    }
+    return "(empty)";
+}
 async function handleInboundMessage(params) {
     const { message, options, stateStore, adapter, queueWechatMessage, outputBatcher, deferInboundMessage, } = params;
     const state = stateStore.getState();
@@ -877,6 +940,7 @@ async function handleInboundMessage(params) {
             await outputBatcher.flushNow();
             outputBatcher.clear();
             stateStore.clearPendingConfirmation();
+            stateStore.clearPendingUserInput();
             stateStore.clearSharedSessionId();
             await adapter.createSession();
             stateStore.appendLog(`New ${options.adapter} session requested by owner.`);
@@ -893,6 +957,7 @@ async function handleInboundMessage(params) {
             await outputBatcher.flushNow();
             outputBatcher.clear();
             stateStore.clearPendingConfirmation();
+            stateStore.clearPendingUserInput();
             stateStore.clearSharedSessionId();
             await adapter.reset();
             stateStore.appendLog("Worker reset by owner.");
@@ -937,11 +1002,39 @@ async function handleInboundMessage(params) {
             await queueWechatMessage(message.senderId, "Approval denied.");
             return null;
         }
+        case "answer": {
+            const pending = state.pendingUserInput;
+            if (!pending) {
+                await queueWechatMessage(message.senderId, "No pending user input request.");
+                return null;
+            }
+            const parsed = parsePendingUserInputAnswerCommand(systemCommand.raw, pending);
+            if ("error" in parsed) {
+                await queueWechatMessage(message.senderId, parsed.error);
+                return null;
+            }
+            const submitted = await adapter.submitUserInput(parsed.answers);
+            if (!submitted) {
+                await queueWechatMessage(message.senderId, "The worker could not apply this answer.");
+                return null;
+            }
+            stateStore.clearPendingUserInput();
+            stateStore.appendLog(`User input answered: ${parsed.preview}`);
+            await queueWechatMessage(message.senderId, "Answer submitted. Continuing...");
+            return {
+                startedAt: Date.now(),
+                inputPreview: parsed.preview,
+            };
+        }
     }
     if (state.pendingConfirmation) {
         await queueWechatMessage(message.senderId, formatPendingApprovalReminder(state.pendingConfirmation, adapter.getState()));
         return null;
     }
+    if (state.pendingUserInput) {
+        await queueWechatMessage(message.senderId, formatPendingUserInputReminder(state.pendingUserInput));
+        return null;
+    }
     const adapterState = adapter.getState();
     if (shouldDeferCodexInboundMessage({
         adapter: options.adapter,
@@ -971,12 +1064,13 @@ async function handleInboundMessage(params) {
 }
 async function dispatchInboundWechatText(params) {
     const { message, options, stateStore, adapter } = params;
+    const preview = formatInboundMessagePreview(message);
     const activeTask = {
         startedAt: Date.now(),
-        inputPreview: truncatePreview(message.text, 180),
+        inputPreview: truncatePreview(preview, 180),
     };
-    stateStore.appendLog(`Forwarded input to ${options.adapter}: ${truncatePreview(message.text)}`);
-    await adapter.sendInput(buildWechatInboundPrompt(message.text));
+    stateStore.appendLog(`Forwarded input to ${options.adapter}: ${truncatePreview(preview)}`);
+    await adapter.sendInput(buildWechatInboundPrompt(message.text, message.attachments));
     return activeTask;
 }
 const isDirectRun = Boolean(import.meta.main);

package/dist/companion/codex-remote-client.js

@@ -40,7 +40,7 @@ export function parseCliArgs(argv) {
     return { cwd, cliArgs };
 }
 export function readCodexRuntimeEndpoint(cwd) {
-    const endpoint = readLocalCompanionEndpoint(cwd);
+    const endpoint = readLocalCompanionEndpoint(cwd, { adapter: "codex" });
     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.`);
     }
@@ -83,14 +83,18 @@ export async function runCodexRemoteClientFromEndpoint(endpoint, options = {}) {
             updateLocalCompanionOccupancy(endpoint.cwd, {
                 companionPid: child.pid,
                 companionConnectedAt: new Date().toISOString(),
-            }, endpoint.instanceId);
+            }, endpoint.instanceId, { adapter: "codex" });
         }
         child.once("error", (error) => {
-            clearLocalCompanionOccupancy(endpoint.cwd, endpoint.instanceId);
+            clearLocalCompanionOccupancy(endpoint.cwd, endpoint.instanceId, {
+                adapter: "codex",
+            });
             reject(error);
         });
         child.once("exit", (code, signal) => {
-            clearLocalCompanionOccupancy(endpoint.cwd, endpoint.instanceId);
+            clearLocalCompanionOccupancy(endpoint.cwd, endpoint.instanceId, {
+                adapter: "codex",
+            });
             if (signal) {
                 process.kill(process.pid, signal);
                 return;

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.`);
     }