cli-wechat-bridge 1.0.5 → 1.0.7

package/dist/daemon/wechat-daemon.js

@@ -5,11 +5,11 @@ import path from "node:path";
 import { spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { resolveDefaultAdapterCommand, } from "../bridge/bridge-adapters.js";
-import { delay, quoteWindowsCommandArg, } from "../bridge/bridge-adapters.shared.js";
+import { delay, getSharedSessionIdFromAdapterState, quoteWindowsCommandArg, } from "../bridge/bridge-adapters.shared.js";
 import { BridgeController } from "../bridge/bridge-controller.js";
 import { forwardWechatFinalReply } from "../bridge/bridge-final-reply.js";
 import { readBridgeLockFile, } from "../bridge/bridge-state.js";
-import { killProcessTreeSync, reapOrphanedOpencodeProcesses, reapPeerBridgeProcesses, } from "../bridge/bridge-process-reaper.js";
+import { getProcessRecordByPid, isWechatDaemonCommandLine, killProcessTreeSync, listWechatDaemonProcesses, reapOrphanedOpencodeProcesses, reapPeerBridgeProcesses, } from "../bridge/bridge-process-reaper.js";
 import { buildOneTimeCode, buildWechatInboundPrompt, formatApprovalMessage, formatDuration, formatMirroredUserInputMessage, formatPendingApprovalReminder, formatPendingUserInputReminder, formatSessionSwitchMessage, formatTaskFailedMessage, formatUserInputRequestMessage, MESSAGE_START_GRACE_MS, nowIso, OutputBatcher, parsePendingUserInputAnswerCommand, parseWechatControlCommand, truncatePreview, } from "../bridge/bridge-utils.js";
 import { formatUserFacingBridgeFatalError, formatUserFacingInboundError, formatWechatContextTokenStaleLogEntry, formatWechatSendFailureLogEntry, isRetryableWechatSendError, shouldForwardBridgeEventToWechat, } from "../bridge/wechat-bridge.js";
 import { BRIDGE_LOCK_FILE, BRIDGE_LOG_FILE, ensureChannelDataDir, migrateLegacyChannelFiles, } from "../wechat/channel-config.js";
@@ -17,7 +17,7 @@ import { ensureWechatCredentials } from "../wechat/setup.js";
 import { classifyWechatTransportError, DEFAULT_LONG_POLL_TIMEOUT_MS, describeWechatTransportError, isWechatContextTokenStaleError, WeChatTransport, } from "../wechat/wechat-transport.js";
 import { createRuntimeHost, } from "../runtime/create-runtime-host.js";
 import { clearLocalCompanionEndpoint, clearLocalCompanionOccupancy, readLocalCompanionEndpoint, } from "../companion/local-companion-link.js";
-import { attachDaemonRequestListener, buildDaemonToken, clearDaemonEndpoint, DAEMON_PROTOCOL_VERSION, isDaemonEndpointAlive, isPidAlive, readDaemonEndpoint, sendDaemonResponse, writeDaemonEndpoint, } from "./daemon-link.js";
+import { attachDaemonRequestListener, buildDaemonToken, clearDaemonEndpoint, DAEMON_PROTOCOL_VERSION, isPidAlive, readDaemonEndpoint, sendDaemonRequest, sendDaemonResponse, writeDaemonEndpoint, } from "./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";
@@ -29,6 +29,9 @@ const WECHAT_SEND_RETRY_BASE_MS = 750;
 const SINGLE_BRIDGE_STOP_TIMEOUT_MS = 10_000;
 const SINGLE_BRIDGE_FORCE_STOP_TIMEOUT_MS = 3_000;
 const SINGLE_BRIDGE_STOP_POLL_MS = 250;
+const DAEMON_TAKEOVER_STOP_TIMEOUT_MS = 10_000;
+const DAEMON_TAKEOVER_FORCE_STOP_TIMEOUT_MS = 3_000;
+const DAEMON_TAKEOVER_STOP_POLL_MS = 250;
 const VISIBLE_CLIENT_CONNECT_TIMEOUT_MS = 15_000;
 const VISIBLE_CLIENT_CONNECT_POLL_MS = 250;
 const DAEMON_ADAPTERS = ["codex", "claude", "opencode"];
@@ -132,6 +135,27 @@ export function parseDaemonSwitchCommand(text) {
             return null;
     }
 }
+export function defaultDaemonSessionStartMode(adapter) {
+    return adapter === "claude" || adapter === "opencode" ? "new" : "restore";
+}
+export function resolveDaemonSessionStartMode(params) {
+    if (params.reuseExistingVisible && params.visibleConnected) {
+        return "restore";
+    }
+    if (params.explicitSessionStartMode) {
+        return params.explicitSessionStartMode;
+    }
+    if (params.adapter === "codex") {
+        return "restore";
+    }
+    if (params.slotCreated) {
+        return "new";
+    }
+    if (!params.visibleConnected && !params.sharedSessionId) {
+        return "new";
+    }
+    return "restore";
+}
 function toPendingApproval(request) {
     const rawRequest = request.request;
     if (typeof rawRequest.code === "string") {
@@ -168,6 +192,9 @@ export function buildVisibleClientLaunchArgs(params) {
     if (params.adapter !== "codex") {
         args.push("--adapter", params.adapter);
     }
+    if (params.sessionStartMode && params.sessionStartMode !== "restore") {
+        args.push("--session-start-mode", params.sessionStartMode);
+    }
     args.push("--cwd", params.cwd, ...(params.cliArgs ?? []));
     return args;
 }
@@ -291,6 +318,17 @@ function formatNoActiveAdapterMessage() {
     ].join("\n");
 }
 export function formatDaemonSwitchResultDetail(result) {
+    if (result.activated === false) {
+        const previous = result.previousActiveAdapter
+            ? ` Active terminal remains ${result.previousActiveAdapter}.`
+            : " No terminal is active yet.";
+        if (result.openedVisible) {
+            return result.created
+                ? `Started the bridge slot and tried to open the visible CLI, but it has not connected yet.${previous} Check ${BRIDGE_LOG_FILE}.`
+                : `Tried to open a visible CLI for the existing slot, but it has not connected yet.${previous} Check ${BRIDGE_LOG_FILE}.`;
+        }
+        return `The visible CLI is not connected yet.${previous} Check ${BRIDGE_LOG_FILE}.`;
+    }
     if (result.openedVisible && result.visibleConnected) {
         return result.created
             ? "Started a new visible CLI."
@@ -542,32 +580,56 @@ class WechatDaemon {
                     profile: request.profile,
                     cliArgs: request.cliArgs,
                     openVisible: request.openVisible ?? true,
+                    sessionStartMode: request.sessionStartMode,
+                    reuseExistingVisible: request.reuseExistingVisible ?? true,
                 });
             case "switch_adapter":
                 return await this.ensureSlot(request.adapter, {
                     profile: request.profile,
                     cliArgs: request.cliArgs,
                     openVisible: request.openVisible ?? true,
+                    sessionStartMode: request.sessionStartMode,
+                    reuseExistingVisible: request.reuseExistingVisible ?? true,
                 });
         }
     }
     async ensureSlot(adapter, options = {}) {
+        const previousActiveAdapter = this.activeAdapter ?? undefined;
         let slot = this.slots.get(adapter);
         let created = false;
         if (!slot) {
+            const createSessionStartMode = options.sessionStartMode ?? defaultDaemonSessionStartMode(adapter);
             slot = await this.createSlot(adapter, {
                 profile: options.profile ?? this.profile,
+                sessionStartMode: createSessionStartMode,
             });
             this.slots.set(adapter, slot);
             created = true;
         }
-        this.activeAdapter = adapter;
         let openedVisible = false;
         let visibleConnected = isVisibleClientAlive(this.cwd, adapter);
+        const sessionStartMode = resolveDaemonSessionStartMode({
+            adapter,
+            explicitSessionStartMode: options.sessionStartMode,
+            slotCreated: created,
+            visibleConnected,
+            sharedSessionId: getSharedSessionIdFromAdapterState(slot.runtime.getState()),
+            reuseExistingVisible: options.reuseExistingVisible !== false,
+        });
+        if (!created &&
+            options.reuseExistingVisible === false &&
+            sessionStartMode === "new" &&
+            (adapter === "claude" || adapter === "opencode") &&
+            visibleConnected) {
+            await this.startFreshSlotSession(slot);
+            appendDaemonLog(`fresh_session_started: adapter=${adapter} source=start_command`);
+        }
         if (options.openVisible !== false && !visibleConnected) {
+            slot.controller.syncLocalClientEndpoint();
             const launch = openVisibleClient({
                 adapter,
                 cwd: this.cwd,
+                sessionStartMode,
                 cliArgs: options.cliArgs,
                 onError: (error) => {
                     appendDaemonLog(`visible_client_open_error: adapter=${adapter} error=${truncatePreview(error.message, 400)}`);
@@ -588,12 +650,18 @@ class WechatDaemon {
                 appendDaemonLog(`visible_client_connect_timeout: adapter=${adapter} cwd=${this.cwd} timeout_ms=${VISIBLE_CLIENT_CONNECT_TIMEOUT_MS} cleaned_launcher=${cleanedLauncher}`);
             }
         }
-        appendDaemonLog(`switch_adapter: adapter=${adapter} created=${created} opened_visible=${openedVisible} visible_connected=${visibleConnected}`);
+        const activated = options.openVisible === false || visibleConnected;
+        if (activated) {
+            this.activeAdapter = adapter;
+        }
+        appendDaemonLog(`switch_adapter: adapter=${adapter} created=${created} opened_visible=${openedVisible} visible_connected=${visibleConnected} activated=${activated} previous_active=${previousActiveAdapter ?? "(none)"} session_start_mode=${sessionStartMode}`);
         return {
             activeAdapter: adapter,
             created,
             openedVisible,
             visibleConnected,
+            activated,
+            previousActiveAdapter,
         };
     }
     async createSlot(adapter, options) {
@@ -604,6 +672,7 @@ class WechatDaemon {
             cwd: this.cwd,
             profile: options.profile,
             lifecycle: "persistent",
+            sessionStartMode: options.sessionStartMode,
             companionLaunchMode: "daemon_auto",
         });
         const controller = new BridgeController(runtime, this.cwd);
@@ -624,9 +693,26 @@ class WechatDaemon {
         });
         await runtime.start();
         controller.syncLocalClientEndpoint();
-        appendDaemonLog(`slot_started: adapter=${adapter} command=${resolveDefaultAdapterCommand(adapter)} cwd=${this.cwd}`);
+        appendDaemonLog(`slot_started: adapter=${adapter} command=${resolveDefaultAdapterCommand(adapter)} cwd=${this.cwd} session_start_mode=${options.sessionStartMode ?? "restore"}`);
         return slot;
     }
+    async startFreshSlotSession(slot) {
+        await slot.outputBatcher.flushNow();
+        slot.outputBatcher.clear();
+        slot.pendingConfirmation = null;
+        slot.pendingUserInput = null;
+        slot.activeTask = null;
+        if (slot.adapter === "claude") {
+            await slot.runtime.reset();
+        }
+        else if (slot.adapter === "opencode") {
+            if (!slot.runtime.createSession) {
+                throw new Error("/new is not available in opencode mode.");
+            }
+            await slot.runtime.createSession();
+        }
+        slot.controller.syncLocalClientEndpoint();
+    }
     handleSlotEvent(slot, event) {
         slot.controller.syncLocalClientEndpoint();
         const adapterState = slot.runtime.getState();
@@ -703,7 +789,7 @@ class WechatDaemon {
                     const pending = toPendingUserInput(event.request);
                     slot.pendingUserInput = pending;
                     appendDaemonLog(`user_input_required: adapter=${slot.adapter} questions=${pending.questions.length}`);
-                    await this.queueWechatMessage(this.authorizedUserId, prefixDaemonAdapterMessage(slot.adapter, formatUserInputRequestMessage(pending, adapterState)), "approval_required");
+                    await this.queueWechatMessage(this.authorizedUserId, prefixDaemonAdapterMessage(slot.adapter, formatUserInputRequestMessage(pending, adapterState)), "user_input_required");
                 }));
                 break;
             case "mirrored_user_input":
@@ -779,9 +865,13 @@ class WechatDaemon {
         if (switchAdapter) {
             const result = await this.ensureSlot(switchAdapter, {
                 openVisible: true,
+                reuseExistingVisible: true,
             });
             const detail = formatDaemonSwitchResultDetail(result);
-            await this.queueWechatMessage(message.senderId, `Active terminal: ${switchAdapter}.\n${detail}`);
+            const heading = result.activated
+                ? `Active terminal: ${switchAdapter}.`
+                : `Could not activate terminal: ${switchAdapter}.`;
+            await this.queueWechatMessage(message.senderId, `${heading}\n${detail}`);
             return;
         }
         if (message.text.trim().toLowerCase() === "/daemon-stop") {
@@ -1027,15 +1117,180 @@ class WechatDaemon {
         }
     }
 }
-async function assertNoLiveDaemon() {
-    const endpoint = readDaemonEndpoint();
+function clearDaemonWorkspaceEndpoints(endpoint) {
+    for (const adapter of DAEMON_ADAPTERS) {
+        clearLocalCompanionEndpoint(endpoint.cwd, undefined, { adapter });
+    }
+}
+function isEndpointDaemonProcess(endpoint) {
+    const record = getProcessRecordByPid(endpoint.pid);
+    return Boolean(record && isWechatDaemonCommandLine(record.commandLine));
+}
+function selectDaemonProcessesToStop(records, excludedPids) {
+    const recordPids = new Set(records.map((record) => record.pid));
+    return records.filter((record) => {
+        if (excludedPids.has(record.pid)) {
+            return false;
+        }
+        return !records.some((candidate) => candidate.parentPid === record.pid &&
+            recordPids.has(candidate.pid) &&
+            !excludedPids.has(candidate.pid));
+    });
+}
+async function stopDaemonPeerProcesses(params) {
+    const excludedPids = new Set([process.pid, process.ppid]);
+    const peerRecords = selectDaemonProcessesToStop(params.listDaemonProcesses(params.cwd), excludedPids);
+    const stoppedPids = [];
+    for (const peer of peerRecords) {
+        params.daemonLog(`daemon_peer_takeover_attempt: pid=${peer.pid} cwd=${params.cwd} command=${truncatePreview(peer.commandLine, 400)}`);
+        params.killProcess(peer.pid);
+        if (await waitForProcessExit({
+            pid: peer.pid,
+            timeoutMs: params.timeoutMs,
+            pollMs: params.pollMs,
+            isAlive: params.isAlive,
+            sleep: params.sleep,
+        })) {
+            stoppedPids.push(peer.pid);
+            params.daemonLog(`daemon_peer_takeover_complete: pid=${peer.pid}`);
+        }
+        else {
+            params.daemonLog(`daemon_peer_takeover_timeout: pid=${peer.pid}`);
+        }
+    }
+    return stoppedPids;
+}
+export async function cleanupDaemonBeforeStart(deps = {}) {
+    const readEndpoint = deps.readEndpoint ?? readDaemonEndpoint;
+    const isAlive = deps.isAlive ?? isPidAlive;
+    const sendRequest = deps.sendRequest ?? sendDaemonRequest;
+    const killProcess = deps.killProcess ?? killProcessTreeSync;
+    const clearEndpoint = deps.clearEndpoint ?? clearDaemonEndpoint;
+    const clearWorkspaceEndpoints = deps.clearWorkspaceEndpoints ?? clearDaemonWorkspaceEndpoints;
+    const isDaemonProcess = deps.isDaemonProcess ?? isEndpointDaemonProcess;
+    const listDaemonProcesses = deps.listDaemonProcesses ??
+        ((cwd) => listWechatDaemonProcesses({
+            cwd,
+            excludePids: [process.pid, process.ppid],
+        }));
+    const sleepFn = deps.sleep ?? sleep;
+    const cleanupLog = deps.log ?? log;
+    const daemonLog = deps.daemonLog ?? appendDaemonLog;
+    const stopTimeoutMs = deps.stopTimeoutMs ?? DAEMON_TAKEOVER_STOP_TIMEOUT_MS;
+    const forceStopTimeoutMs = deps.forceStopTimeoutMs ?? DAEMON_TAKEOVER_FORCE_STOP_TIMEOUT_MS;
+    const pollMs = deps.pollMs ?? DAEMON_TAKEOVER_STOP_POLL_MS;
+    const endpoint = readEndpoint();
+    const cleanupCwd = endpoint?.cwd ?? deps.cwd;
     if (!endpoint) {
-        return;
+        if (cleanupCwd) {
+            await stopDaemonPeerProcesses({
+                cwd: cleanupCwd,
+                listDaemonProcesses,
+                killProcess,
+                isAlive,
+                sleep: sleepFn,
+                timeoutMs: forceStopTimeoutMs,
+                pollMs,
+                daemonLog,
+            });
+        }
+        return { action: "none" };
     }
-    if (await isDaemonEndpointAlive(endpoint, { timeoutMs: 500 })) {
-        throw new Error(`wechat-daemon is already running (pid=${endpoint.pid}, cwd=${endpoint.cwd}).`);
+    const clearDaemonArtifacts = () => {
+        clearWorkspaceEndpoints(endpoint);
+        clearEndpoint(endpoint.pid);
+    };
+    if (endpoint.pid === process.pid || !isAlive(endpoint.pid)) {
+        cleanupLog(`Found stale wechat-daemon endpoint for ${endpoint.cwd} (pid=${endpoint.pid}). Cleaning it before daemon startup.`);
+        daemonLog(`daemon_stale_endpoint_cleanup: pid=${endpoint.pid} cwd=${endpoint.cwd}`);
+        clearDaemonArtifacts();
+        await stopDaemonPeerProcesses({
+            cwd: endpoint.cwd,
+            listDaemonProcesses,
+            killProcess,
+            isAlive,
+            sleep: sleepFn,
+            timeoutMs: forceStopTimeoutMs,
+            pollMs,
+            daemonLog,
+        });
+        return { action: "cleared_stale_endpoint", endpoint };
+    }
+    cleanupLog(`Found existing wechat-daemon for ${endpoint.cwd} (pid=${endpoint.pid}). Stopping it before daemon startup...`);
+    daemonLog(`daemon_takeover_attempt: pid=${endpoint.pid} cwd=${endpoint.cwd}`);
+    let shutdownAcknowledged = false;
+    try {
+        const response = await sendRequest(endpoint, { command: "shutdown" }, { timeoutMs: 1_000 });
+        if (response.ok) {
+            shutdownAcknowledged = true;
+        }
+        else {
+            daemonLog(`daemon_shutdown_request_failed: pid=${endpoint.pid} error=${truncatePreview(response.error, 400)}`);
+        }
+    }
+    catch (error) {
+        daemonLog(`daemon_shutdown_request_failed: pid=${endpoint.pid} error=${truncatePreview(error instanceof Error ? error.message : String(error), 400)}`);
     }
-    clearDaemonEndpoint(endpoint.pid);
+    let forced = false;
+    let stopped = await waitForProcessExit({
+        pid: endpoint.pid,
+        timeoutMs: stopTimeoutMs,
+        pollMs,
+        isAlive,
+        sleep: sleepFn,
+    });
+    if (!stopped) {
+        if (!shutdownAcknowledged && !isDaemonProcess(endpoint)) {
+            daemonLog(`daemon_force_stop_skipped_unverified: pid=${endpoint.pid} cwd=${endpoint.cwd}`);
+            clearDaemonArtifacts();
+            await stopDaemonPeerProcesses({
+                cwd: endpoint.cwd,
+                listDaemonProcesses,
+                killProcess,
+                isAlive,
+                sleep: sleepFn,
+                timeoutMs: forceStopTimeoutMs,
+                pollMs,
+                daemonLog,
+            });
+            return { action: "cleared_stale_endpoint", endpoint };
+        }
+        forced = true;
+        cleanupLog(`Existing daemon pid=${endpoint.pid} did not stop in ${formatDuration(stopTimeoutMs)}. Forcing cleanup...`);
+        daemonLog(`daemon_force_stop_attempt: pid=${endpoint.pid} cwd=${endpoint.cwd}`);
+        try {
+            killProcess(endpoint.pid);
+        }
+        catch (error) {
+            if (isAlive(endpoint.pid)) {
+                daemonLog(`daemon_force_stop_failed: pid=${endpoint.pid} error=${truncatePreview(error instanceof Error ? error.message : String(error), 400)}`);
+            }
+        }
+        stopped = await waitForProcessExit({
+            pid: endpoint.pid,
+            timeoutMs: forceStopTimeoutMs,
+            pollMs,
+            isAlive,
+            sleep: sleepFn,
+        });
+    }
+    if (!stopped && isAlive(endpoint.pid)) {
+        throw new Error(`Could not stop existing wechat-daemon automatically (pid=${endpoint.pid}, cwd=${endpoint.cwd}).`);
+    }
+    clearDaemonArtifacts();
+    cleanupLog(`Cleaned previous wechat-daemon for ${endpoint.cwd}; daemon startup can continue.`);
+    daemonLog(`daemon_takeover_complete: pid=${endpoint.pid} cwd=${endpoint.cwd} forced=${forced}`);
+    await stopDaemonPeerProcesses({
+        cwd: endpoint.cwd,
+        listDaemonProcesses,
+        killProcess,
+        isAlive,
+        sleep: sleepFn,
+        timeoutMs: forceStopTimeoutMs,
+        pollMs,
+        daemonLog,
+    });
+    return { action: "stopped", endpoint, forced };
 }
 async function waitForProcessExit(params) {
     const deadline = Date.now() + params.timeoutMs;
@@ -1077,6 +1332,7 @@ export async function cleanupSingleBridgeBeforeDaemon(deps = {}) {
     const clearEndpoint = deps.clearEndpoint ?? clearSingleBridgeEndpoint;
     const sleepFn = deps.sleep ?? sleep;
     const cleanupLog = deps.log ?? log;
+    const daemonLog = deps.daemonLog ?? appendDaemonLog;
     const stopTimeoutMs = deps.stopTimeoutMs ?? SINGLE_BRIDGE_STOP_TIMEOUT_MS;
     const forceStopTimeoutMs = deps.forceStopTimeoutMs ?? SINGLE_BRIDGE_FORCE_STOP_TIMEOUT_MS;
     const pollMs = deps.pollMs ?? SINGLE_BRIDGE_STOP_POLL_MS;
@@ -1090,18 +1346,18 @@ export async function cleanupSingleBridgeBeforeDaemon(deps = {}) {
     };
     if (!isAlive(lock.pid)) {
         cleanupLog(`Found stale single bridge lock for ${lock.cwd} (pid=${lock.pid} dead). Cleaning it before daemon startup.`);
-        appendDaemonLog(`single_bridge_stale_cleanup: pid=${lock.pid} adapter=${lock.adapter} cwd=${lock.cwd}`);
+        daemonLog(`single_bridge_stale_cleanup: pid=${lock.pid} adapter=${lock.adapter} cwd=${lock.cwd}`);
         clearBridgeArtifacts();
         return { action: "cleared_stale_lock", lock };
     }
     cleanupLog(`Found existing single bridge for ${lock.cwd} (pid=${lock.pid}, adapter=${lock.adapter}). Stopping it before daemon startup...`);
-    appendDaemonLog(`single_bridge_takeover_attempt: pid=${lock.pid} adapter=${lock.adapter} cwd=${lock.cwd}`);
+    daemonLog(`single_bridge_takeover_attempt: pid=${lock.pid} adapter=${lock.adapter} cwd=${lock.cwd}`);
     try {
         killProcess(lock.pid, "SIGTERM");
     }
     catch (error) {
         if (isAlive(lock.pid)) {
-            appendDaemonLog(`single_bridge_sigterm_failed: pid=${lock.pid} error=${truncatePreview(error instanceof Error ? error.message : String(error), 400)}`);
+            daemonLog(`single_bridge_sigterm_failed: pid=${lock.pid} error=${truncatePreview(error instanceof Error ? error.message : String(error), 400)}`);
         }
     }
     let forced = false;
@@ -1115,13 +1371,13 @@ export async function cleanupSingleBridgeBeforeDaemon(deps = {}) {
     if (!stopped) {
         forced = true;
         cleanupLog(`Single bridge pid=${lock.pid} did not stop in ${formatDuration(stopTimeoutMs)}. Forcing cleanup...`);
-        appendDaemonLog(`single_bridge_force_stop_attempt: pid=${lock.pid} adapter=${lock.adapter} cwd=${lock.cwd}`);
+        daemonLog(`single_bridge_force_stop_attempt: pid=${lock.pid} adapter=${lock.adapter} cwd=${lock.cwd}`);
         try {
             killProcess(lock.pid, "SIGKILL");
         }
         catch (error) {
             if (isAlive(lock.pid)) {
-                appendDaemonLog(`single_bridge_sigkill_failed: pid=${lock.pid} error=${truncatePreview(error instanceof Error ? error.message : String(error), 400)}`);
+                daemonLog(`single_bridge_sigkill_failed: pid=${lock.pid} error=${truncatePreview(error instanceof Error ? error.message : String(error), 400)}`);
             }
         }
         stopped = await waitForProcessExit({
@@ -1137,12 +1393,12 @@ export async function cleanupSingleBridgeBeforeDaemon(deps = {}) {
     }
     clearBridgeArtifacts();
     cleanupLog(`Cleaned previous single bridge for ${lock.cwd}; daemon startup can continue.`);
-    appendDaemonLog(`single_bridge_takeover_complete: pid=${lock.pid} adapter=${lock.adapter} cwd=${lock.cwd} forced=${forced}`);
+    daemonLog(`single_bridge_takeover_complete: pid=${lock.pid} adapter=${lock.adapter} cwd=${lock.cwd} forced=${forced}`);
     return { action: "stopped", lock, forced };
 }
 export async function runDaemon(options) {
     migrateLegacyChannelFiles((message) => log(message));
-    await assertNoLiveDaemon();
+    await cleanupDaemonBeforeStart({ cwd: options.cwd });
     await cleanupSingleBridgeBeforeDaemon();
     const reapedPeerPids = await reapPeerBridgeProcesses({
         logger: (message) => appendDaemonLog(message),

package/package.json

@@ -1,6 +1,6 @@
 {
-  "name": "cli-wechat-bridge",
-  "version": "1.0.5",
+  "name": "cli-wechat-bridge",
+  "version": "1.0.7",
   "description": "CLI WeChat Bridge for Codex, Claude Code, OpenCode, and PowerShell over WeChat",
   "type": "module",
   "files": [
@@ -55,8 +55,8 @@
     "lint:fix": "eslint bin src test --fix",
     "typecheck:src": "tsc -p tsconfig.typecheck.src.json --noEmit --pretty false",
     "quality": "npm run lint && npm run typecheck:src && bun test test && npm run build",
-    "smoke:global": "node scripts/smoke-global-install.mjs",
-    "publish:dual": "node scripts/publish-dual.mjs",
+    "smoke:global": "node scripts/smoke-global-install.mjs",
+    "publish:dual": "node scripts/publish-dual.mjs",
     "setup": "node --no-warnings --experimental-strip-types src/wechat/setup.ts",
     "start": "node --no-warnings --experimental-strip-types src/wechat/wechat-channel.ts",
     "check": "node --no-warnings --experimental-strip-types src/wechat/wechat-channel.ts --check",
@@ -80,16 +80,15 @@
     "test:watch": "bun test --watch test"
   },
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.80.0",
     "@modelcontextprotocol/sdk": "^1.27.1",
     "@opencode-ai/sdk": "^1.3.2",
-    "ajv-formats": "^3.0.1",
     "node-pty": "^1.1.0",
     "qrcode-terminal": "^0.12.0"
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
     "@types/bun": "latest",
+    "@types/node": "^24.12.4",
     "eslint": "^10.3.0",
     "typescript": "^6.0.2",
     "typescript-eslint": "^8.59.3"

package/dist/companion/codex-panel-link.js

@@ -1,72 +0,0 @@
-import crypto from "node:crypto";
-import fs from "node:fs";
-import { ensureWorkspaceChannelDir, getWorkspaceChannelPaths, } from "../wechat/channel-config.js";
-export function buildCodexPanelToken() {
-    return crypto.randomBytes(18).toString("hex");
-}
-export function writeCodexPanelEndpoint(endpoint) {
-    const { endpointFile } = ensureWorkspaceChannelDir(endpoint.cwd);
-    fs.writeFileSync(endpointFile, JSON.stringify(endpoint, null, 2), "utf8");
-}
-export function readCodexPanelEndpoint(cwd) {
-    try {
-        const { endpointFile } = getWorkspaceChannelPaths(cwd);
-        if (!fs.existsSync(endpointFile)) {
-            return null;
-        }
-        return JSON.parse(fs.readFileSync(endpointFile, "utf8"));
-    }
-    catch {
-        return null;
-    }
-}
-export function clearCodexPanelEndpoint(cwd, instanceId) {
-    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, message) {
-    socket.write(`${JSON.stringify(message)}\n`);
-}
-export function attachCodexPanelMessageListener(socket, onMessage) {
-    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 {
-                onMessage(JSON.parse(line));
-            }
-            catch {
-                // Ignore malformed local IPC frames.
-            }
-        }
-    };
-    socket.setEncoding("utf8");
-    socket.on("data", onData);
-    return () => {
-        socket.off("data", onData);
-    };
-}