cli-wechat-bridge 1.0.6 → 1.0.9

package/dist/daemon/wechat-daemon.js

@@ -2,22 +2,23 @@
 import fs from "node:fs";
 import net from "node:net";
 import path from "node:path";
-import { spawn } from "node:child_process";
+import { execFileSync, 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";
 import { ensureWechatCredentials } from "../wechat/setup.js";
+import { listBindings, loadEmojiBindings, removeBinding, resolveEmojiCommand, setBinding, } from "./emoji-bindings.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 +30,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 +136,43 @@ export function parseDaemonSwitchCommand(text) {
             return null;
     }
 }
+export function parseEmojiBindingsCommand(text) {
+    const trimmed = text.trim();
+    const lower = trimmed.toLowerCase();
+    if (lower === "/bindings") {
+        return { type: "list" };
+    }
+    const bindMatch = trimmed.match(/^\/bind\s+(\[[^\]]+\])\s+(.+)$/i);
+    if (bindMatch) {
+        return { type: "bind", emoji: bindMatch[1], command: bindMatch[2].trim() };
+    }
+    const unbindMatch = trimmed.match(/^\/unbind\s+(\[[^\]]+\])$/i);
+    if (unbindMatch) {
+        return { type: "unbind", emoji: unbindMatch[1] };
+    }
+    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 +209,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;
 }
@@ -181,6 +225,33 @@ export function buildWindowsVisibleClientLaunchCommand(params) {
         ...params.args.map((arg) => quoteWindowsCommandArg(arg)),
     ].join(" ");
 }
+const LINUX_TERMINALS = [
+    { cmd: "gnome-terminal", buildArgs: (title) => ["--title", title, "--"] },
+    { cmd: "konsole", buildArgs: (title) => ["-p", `tabtitle=${title}`, "-e"] },
+    { cmd: "xfce4-terminal", buildArgs: (title) => ["--title", title, "-e"] },
+    { cmd: "xterm", buildArgs: (title) => ["-title", title, "-e"] },
+];
+let cachedLinuxTerminal;
+function detectLinuxTerminal() {
+    if (cachedLinuxTerminal !== undefined) {
+        return cachedLinuxTerminal;
+    }
+    for (const entry of LINUX_TERMINALS) {
+        try {
+            execFileSync("which", [entry.cmd], { stdio: "ignore" });
+            cachedLinuxTerminal = entry;
+            return entry;
+        }
+        catch {
+            // not found, try next
+        }
+    }
+    cachedLinuxTerminal = null;
+    return null;
+}
+function shellQuotePosix(s) {
+    return "'" + s.replace(/'/g, "'\\''") + "'";
+}
 function formatLaunchPreview(launch) {
     return [launch.command, ...launch.args].join(" ");
 }
@@ -215,12 +286,53 @@ function openVisibleClient(params) {
             pid: child.pid,
         };
     }
+    const title = `wechat-${params.adapter}`;
+    const fullArgs = [process.execPath, ...args];
+    if (process.platform === "darwin") {
+        const cmdLine = fullArgs.map(shellQuotePosix).join(" ");
+        const script = `tell application "Terminal"
+activate
+do script "cd ${shellQuotePosix(params.cwd)} && exec ${cmdLine}"
+end tell`;
+        const child = spawn("osascript", ["-e", script], {
+            cwd: params.cwd,
+            detached: true,
+            stdio: "ignore",
+        });
+        child.once("error", (error) => {
+            params.onError?.(error instanceof Error ? error : new Error(String(error)));
+        });
+        child.unref();
+        return {
+            command: "osascript",
+            args: ["-e", script],
+            pid: child.pid,
+        };
+    }
+    const terminal = detectLinuxTerminal();
+    if (terminal) {
+        const termArgs = [...terminal.buildArgs(title), ...fullArgs];
+        const child = spawn(terminal.cmd, termArgs, {
+            cwd: params.cwd,
+            env: process.env,
+            detached: true,
+            stdio: "ignore",
+        });
+        child.once("error", (error) => {
+            params.onError?.(error instanceof Error ? error : new Error(String(error)));
+        });
+        child.unref();
+        return {
+            command: terminal.cmd,
+            args: termArgs,
+            pid: child.pid,
+        };
+    }
     const child = spawn(process.execPath, args, {
         cwd: params.cwd,
         env: process.env,
         detached: true,
         stdio: "ignore",
-        windowsHide: false,
     });
     child.once("error", (error) => {
         params.onError?.(error instanceof Error ? error : new Error(String(error)));
@@ -291,6 +403,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."
@@ -337,6 +460,7 @@ class WechatDaemon {
     startedAt = new Date().toISOString();
     bridgeStartedAtMs = Date.now();
     activeAdapter = null;
+    takenOverAdapter;
     textSendChain = Promise.resolve();
     attachmentSendChain = Promise.resolve();
     pendingWechatForwardTasks = new Set();
@@ -542,32 +666,60 @@ 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 ??
+                (adapter === this.takenOverAdapter ? "restore" : defaultDaemonSessionStartMode(adapter));
+            if (adapter === this.takenOverAdapter) {
+                this.takenOverAdapter = undefined;
+            }
             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 +740,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 +762,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 +783,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();
@@ -775,13 +951,41 @@ class WechatDaemon {
             await this.queueWechatMessage(message.senderId, "Unauthorized. This daemon only accepts messages from the configured WeChat owner.");
             return;
         }
+        const emojiMatch = resolveEmojiCommand(message.text);
+        if (emojiMatch) {
+            const switchTarget = parseDaemonSwitchCommand(emojiMatch.command);
+            if (switchTarget && emojiMatch.remainder) {
+                const result = await this.ensureSlot(switchTarget, {
+                    openVisible: true,
+                    reuseExistingVisible: true,
+                });
+                if (result.activated) {
+                    message = { ...message, text: emojiMatch.remainder };
+                }
+                else {
+                    const detail = formatDaemonSwitchResultDetail(result);
+                    await this.queueWechatMessage(message.senderId, `Could not activate terminal: ${switchTarget}.\n${detail}`);
+                    return;
+                }
+            }
+            else {
+                const rewritten = emojiMatch.remainder
+                    ? `${emojiMatch.command} ${emojiMatch.remainder}`
+                    : emojiMatch.command;
+                message = { ...message, text: rewritten };
+            }
+        }
         const switchAdapter = parseDaemonSwitchCommand(message.text);
         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") {
@@ -791,6 +995,11 @@ class WechatDaemon {
             }, 0);
             return;
         }
+        const bindingsCmd = parseEmojiBindingsCommand(message.text);
+        if (bindingsCmd) {
+            await this.handleEmojiBindingsCommand(message.senderId, bindingsCmd);
+            return;
+        }
         const slot = this.getActiveSlot();
         if (!slot) {
             await this.queueWechatMessage(message.senderId, formatNoActiveAdapterMessage());
@@ -820,6 +1029,32 @@ class WechatDaemon {
         }
         await this.dispatchInboundWechatText(message, slot);
     }
+    async handleEmojiBindingsCommand(senderId, cmd) {
+        switch (cmd.type) {
+            case "list": {
+                const map = listBindings();
+                if (map.size === 0) {
+                    await this.queueWechatMessage(senderId, "No emoji bindings configured.");
+                    return;
+                }
+                const lines = Array.from(map.entries()).map(([emoji, command]) => `${emoji} → ${command}`);
+                await this.queueWechatMessage(senderId, `Emoji bindings:\n${lines.join("\n")}`);
+                return;
+            }
+            case "bind": {
+                setBinding(cmd.emoji, cmd.command);
+                await this.queueWechatMessage(senderId, `Bound ${cmd.emoji} → ${cmd.command}`);
+                return;
+            }
+            case "unbind": {
+                const removed = removeBinding(cmd.emoji);
+                await this.queueWechatMessage(senderId, removed
+                    ? `Unbound ${cmd.emoji}`
+                    : `No binding found for ${cmd.emoji}`);
+                return;
+            }
+        }
+    }
     async handleSystemCommand(message, activeSlot, command) {
         switch (command.type) {
             case "status":
@@ -1027,15 +1262,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 };
     }
-    clearDaemonEndpoint(endpoint.pid);
+    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)}`);
+    }
+    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;
@@ -1067,7 +1467,7 @@ export async function cleanupSingleBridgeBeforeDaemon(deps = {}) {
     const readLock = deps.readLock ?? readBridgeLockFile;
     const isAlive = deps.isAlive ?? isPidAlive;
     const killProcess = deps.killProcess ?? ((pid, signal) => {
-        if (signal === "SIGKILL") {
+        if (signal === "SIGKILL" || process.platform === "win32") {
             killProcessTreeSync(pid);
             return;
         }
@@ -1077,6 +1477,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 +1491,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 +1516,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,13 +1538,14 @@ 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 cleanupSingleBridgeBeforeDaemon();
+    loadEmojiBindings();
+    await cleanupDaemonBeforeStart({ cwd: options.cwd });
+    const cleanupResult = await cleanupSingleBridgeBeforeDaemon();
     const reapedPeerPids = await reapPeerBridgeProcesses({
         logger: (message) => appendDaemonLog(message),
     });
@@ -1170,17 +1572,26 @@ export async function runDaemon(options) {
         authorizedUserId: credentials.userId,
         transport: new WeChatTransport({ log, logError }),
     });
+    if (cleanupResult.action === "stopped" && isDaemonAdapterKind(cleanupResult.lock.adapter)) {
+        daemon.takenOverAdapter = cleanupResult.lock.adapter;
+    }
     await daemon.startIpcServer();
     await daemon.runInitialAdapter(options);
-    const requestShutdown = (signal) => {
+    let shutdownInProgress = false;
+    const handleSignal = (signal) => {
+        if (shutdownInProgress) {
+            log(`Received ${signal} during shutdown, forcing exit.`);
+            process.exit(1);
+        }
+        shutdownInProgress = true;
         log(`Received ${signal}. Stopping daemon.`);
         void daemon.shutdown().finally(() => process.exit(0));
     };
-    process.once("SIGINT", () => requestShutdown("SIGINT"));
-    process.once("SIGTERM", () => requestShutdown("SIGTERM"));
-    process.once("SIGHUP", () => requestShutdown("SIGHUP"));
+    process.on("SIGINT", () => handleSignal("SIGINT"));
+    process.on("SIGTERM", () => handleSignal("SIGTERM"));
+    process.on("SIGHUP", () => handleSignal("SIGHUP"));
     if (process.platform === "win32") {
-        process.once("SIGBREAK", () => requestShutdown("SIGBREAK"));
+        process.on("SIGBREAK", () => handleSignal("SIGBREAK"));
     }
     process.on("exit", () => {
         clearDaemonEndpoint();