weacpx 0.2.0 → 0.2.1

package/dist/cli.js

@@ -45,8 +45,378 @@ var __export = (target, all) => {
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __promiseAll = (args) => Promise.all(args);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
+// src/daemon/daemon-status.ts
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+
+class DaemonStatusStore {
+  path;
+  constructor(path) {
+    this.path = path;
+  }
+  async load() {
+    try {
+      const content = await readFile(this.path, "utf8");
+      if (content.trim() === "") {
+        return null;
+      }
+      return JSON.parse(content);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return null;
+      }
+      throw error;
+    }
+  }
+  async save(status) {
+    await mkdir(dirname(this.path), { recursive: true });
+    await writeFile(this.path, JSON.stringify(status, null, 2));
+  }
+  async clear() {
+    await rm(this.path, { force: true });
+  }
+}
+var init_daemon_status = () => {};
+
+// src/daemon/daemon-controller.ts
+import { mkdir as mkdir2, readFile as readFile2, rm as rm2, writeFile as writeFile2 } from "node:fs/promises";
+import { dirname as dirname2 } from "node:path";
+
+class DaemonController {
+  paths;
+  deps;
+  statusStore;
+  startupPollIntervalMs;
+  startupTimeoutMs;
+  onStartupPoll;
+  shutdownPollIntervalMs;
+  shutdownTimeoutMs;
+  onShutdownPoll;
+  constructor(paths, deps) {
+    this.paths = paths;
+    this.deps = deps;
+    this.statusStore = new DaemonStatusStore(paths.statusFile);
+    this.startupPollIntervalMs = deps.startupPollIntervalMs ?? 50;
+    this.startupTimeoutMs = deps.startupTimeoutMs ?? 5000;
+    this.shutdownPollIntervalMs = deps.shutdownPollIntervalMs ?? 50;
+    this.shutdownTimeoutMs = deps.shutdownTimeoutMs ?? 5000;
+    this.onStartupPoll = deps.onStartupPoll ?? (async () => {
+      await new Promise((resolve) => setTimeout(resolve, this.startupPollIntervalMs));
+    });
+    this.onShutdownPoll = deps.onShutdownPoll ?? (async () => {
+      await new Promise((resolve) => setTimeout(resolve, this.shutdownPollIntervalMs));
+    });
+  }
+  async getStatus() {
+    const pid = await this.loadPid();
+    const status = await this.statusStore.load();
+    if (!pid) {
+      return { state: "stopped" };
+    }
+    if (!this.deps.isProcessRunning(pid)) {
+      await this.clearRuntimeFiles();
+      return { state: "stopped", stale: true };
+    }
+    if (!status) {
+      return { state: "indeterminate", pid, reason: "missing-status" };
+    }
+    return {
+      state: "running",
+      pid,
+      status
+    };
+  }
+  async start() {
+    const current = await this.getStatus();
+    if (current.state === "running") {
+      return { state: "already-running", pid: current.pid };
+    }
+    if (current.state === "indeterminate") {
+      throw new Error(`weacpx daemon process is already running (pid ${current.pid}) but status metadata is missing`);
+    }
+    await this.statusStore.clear();
+    const pid = await this.deps.spawnDetached();
+    await this.writePid(pid);
+    await this.waitForStartupMetadata(pid);
+    return { state: "started", pid };
+  }
+  async stop() {
+    const pid = await this.loadPid();
+    if (!pid) {
+      return { state: "stopped", detail: "not-running" };
+    }
+    if (this.deps.isProcessRunning(pid)) {
+      await this.deps.terminateProcess(pid);
+      await this.waitForShutdown(pid);
+    }
+    await this.clearRuntimeFiles();
+    return { state: "stopped", detail: "stopped" };
+  }
+  async loadPid() {
+    try {
+      const content = await readFile2(this.paths.pidFile, "utf8");
+      const pid = Number(content.trim());
+      return Number.isFinite(pid) && pid > 0 ? pid : null;
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return null;
+      }
+      throw error;
+    }
+  }
+  async writePid(pid) {
+    await mkdir2(dirname2(this.paths.pidFile), { recursive: true });
+    await writeFile2(this.paths.pidFile, `${pid}
+`);
+  }
+  async clearRuntimeFiles() {
+    await rm2(this.paths.pidFile, { force: true });
+    await this.statusStore.clear();
+  }
+  async waitForStartupMetadata(pid) {
+    const deadline = Date.now() + this.startupTimeoutMs;
+    while (Date.now() < deadline) {
+      const status = await this.statusStore.load();
+      if (status?.pid === pid) {
+        return;
+      }
+      if (!this.deps.isProcessRunning(pid)) {
+        await this.clearRuntimeFiles();
+        throw new Error(`weacpx daemon exited before reporting ready state (pid ${pid})`);
+      }
+      await this.onStartupPoll();
+    }
+    throw new Error(`weacpx daemon did not report ready state within ${this.startupTimeoutMs}ms (pid ${pid})`);
+  }
+  async waitForShutdown(pid) {
+    const deadline = Date.now() + this.shutdownTimeoutMs;
+    while (Date.now() < deadline) {
+      if (!this.deps.isProcessRunning(pid)) {
+        return;
+      }
+      await this.onShutdownPoll();
+    }
+    if (!this.deps.isProcessRunning(pid)) {
+      return;
+    }
+    throw new Error(`weacpx daemon did not exit within ${this.shutdownTimeoutMs}ms (pid ${pid})`);
+  }
+}
+var init_daemon_controller = __esm(() => {
+  init_daemon_status();
+});
+
+// src/daemon/create-daemon-controller.ts
+import { mkdir as mkdir3, open } from "node:fs/promises";
+import { spawn } from "node:child_process";
+function createDaemonController(paths, options) {
+  return new DaemonController(paths, {
+    isProcessRunning: options.isProcessRunning ?? defaultIsProcessRunning,
+    spawnDetached: async () => {
+      await mkdir3(paths.runtimeDir, { recursive: true });
+      const stdoutHandle = await open(paths.stdoutLog, "a");
+      const stderrHandle = await open(paths.stderrLog, "a");
+      try {
+        return await (options.spawnProcess ?? defaultSpawnProcess)(buildSpawnRequest(paths, options, stdoutHandle.fd, stderrHandle.fd));
+      } finally {
+        await stdoutHandle.close();
+        await stderrHandle.close();
+      }
+    },
+    terminateProcess: options.terminateProcess ?? defaultTerminateProcess
+  });
+}
+function defaultIsProcessRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function buildSpawnRequest(paths, options, stdoutFd, stderrFd) {
+  const platform = options.platform ?? process.platform;
+  if (platform === "win32") {
+    return {
+      mode: "windows-hidden",
+      command: "powershell.exe",
+      args: [
+        "-NoProfile",
+        "-NonInteractive",
+        "-EncodedCommand",
+        buildWindowsLauncherScript()
+      ],
+      options: {
+        cwd: options.cwd,
+        env: {
+          ...options.env,
+          WEACPX_DAEMON_COMMAND: options.processExecPath,
+          WEACPX_DAEMON_ARG0: options.cliEntryPath,
+          WEACPX_DAEMON_ARG1: "run",
+          WEACPX_DAEMON_CWD: options.cwd,
+          WEACPX_DAEMON_STDOUT: paths.stdoutLog,
+          WEACPX_DAEMON_STDERR: paths.stderrLog
+        },
+        stdio: ["ignore", "pipe", "ignore"],
+        windowsHide: true
+      }
+    };
+  }
+  return {
+    mode: "direct",
+    command: options.processExecPath,
+    args: [options.cliEntryPath, "run"],
+    options: {
+      cwd: options.cwd,
+      detached: true,
+      env: options.env,
+      stdio: ["ignore", stdoutFd, stderrFd]
+    }
+  };
+}
+function buildWindowsLauncherScript() {
+  const script = [
+    "$process = Start-Process -FilePath $env:WEACPX_DAEMON_COMMAND `",
+    "  -ArgumentList @($env:WEACPX_DAEMON_ARG0, $env:WEACPX_DAEMON_ARG1) `",
+    "  -WorkingDirectory $env:WEACPX_DAEMON_CWD `",
+    "  -RedirectStandardOutput $env:WEACPX_DAEMON_STDOUT `",
+    "  -RedirectStandardError $env:WEACPX_DAEMON_STDERR `",
+    "  -WindowStyle Hidden `",
+    "  -PassThru",
+    "[Console]::Out.WriteLine($process.Id)"
+  ].join(`
+`);
+  return Buffer.from(script, "utf16le").toString("base64");
+}
+async function defaultSpawnProcess(request) {
+  if (request.mode === "windows-hidden") {
+    return await spawnWindowsHiddenProcess(request);
+  }
+  const child = spawn(request.command, request.args, request.options);
+  child.unref();
+  return child.pid ?? 0;
+}
+async function spawnWindowsHiddenProcess(request) {
+  return await new Promise((resolve, reject) => {
+    const child = spawn(request.command, request.args, request.options);
+    let stdout = "";
+    let settled = false;
+    child.stdout?.setEncoding("utf8");
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk;
+      if (settled) {
+        return;
+      }
+      const pid = Number.parseInt(stdout.trim(), 10);
+      if (!Number.isFinite(pid) || pid <= 0) {
+        return;
+      }
+      settled = true;
+      child.stdout?.destroy();
+      child.unref();
+      resolve(pid);
+    });
+    child.on("error", (error) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      reject(error);
+    });
+    child.on("close", (code) => {
+      if (settled) {
+        return;
+      }
+      if (code !== 0) {
+        settled = true;
+        reject(new Error(`Failed to launch hidden Windows daemon process (exit ${code ?? 1})`));
+        return;
+      }
+      const pid = Number.parseInt(stdout.trim(), 10);
+      if (!Number.isFinite(pid) || pid <= 0) {
+        settled = true;
+        reject(new Error("Failed to read daemon pid from hidden Windows launcher"));
+        return;
+      }
+      settled = true;
+      resolve(pid);
+    });
+  });
+}
+async function defaultTerminateProcess(pid) {
+  await terminateProcessTree(pid);
+}
+async function terminateProcessTree(pid, platform = process.platform, runCommand = defaultRunProcessCommand, killProcess = (targetPid, signal) => {
+  process.kill(targetPid, signal);
+}, isProcessRunning = defaultIsProcessRunning) {
+  if (platform === "win32") {
+    try {
+      await runCommand("taskkill", ["/PID", String(pid), "/T", "/F"]);
+    } catch {}
+    return;
+  }
+  const targetPid = pid > 0 ? -pid : pid;
+  try {
+    killProcess(targetPid, "SIGTERM");
+  } catch {
+    return;
+  }
+  const deadline = Date.now() + 5000;
+  while (Date.now() < deadline) {
+    if (!isProcessRunning(targetPid)) {
+      return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  try {
+    killProcess(targetPid, "SIGKILL");
+  } catch {}
+}
+async function defaultRunProcessCommand(command, args) {
+  return await new Promise((resolve, reject) => {
+    const child = spawn(command, args, { stdio: "ignore" });
+    child.on("error", reject);
+    child.on("close", (code) => resolve(code ?? 1));
+  });
+}
+var init_create_daemon_controller = __esm(() => {
+  init_daemon_controller();
+});
+
+// src/daemon/daemon-files.ts
+import { join } from "node:path";
+function resolveDaemonPaths(options) {
+  const runtimeDir = options.runtimeDir ?? join(options.home, ".weacpx", "runtime");
+  return {
+    runtimeDir,
+    pidFile: join(runtimeDir, "daemon.pid"),
+    statusFile: join(runtimeDir, "status.json"),
+    stdoutLog: join(runtimeDir, "stdout.log"),
+    stderrLog: join(runtimeDir, "stderr.log"),
+    appLog: join(runtimeDir, "app.log")
+  };
+}
+var init_daemon_files = () => {};
+
+// src/version.ts
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+function readVersion() {
+  try {
+    const dir = path.dirname(fileURLToPath(import.meta.url));
+    const pkgPath = path.resolve(dir, "..", "..", "package.json");
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+    return pkg.version ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+var init_version = () => {};
+
 // src/weixin/monitor/consumer-lock.ts
 import { mkdir as mkdir5, open as open2, readFile as readFile3, rm as rm4 } from "node:fs/promises";
 import { dirname as dirname4, join as join2 } from "node:path";
@@ -128,9 +498,9 @@ function createWeixinConsumerLock(options = {}) {
     }
   };
 }
-async function loadLockMetadata(path) {
+async function loadLockMetadata(path2) {
   try {
-    const raw = await readFile3(path, "utf8");
+    const raw = await readFile3(path2, "utf8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed.pid !== "number" || !parsed.mode || !parsed.configPath || !parsed.statePath) {
       return null;
@@ -1189,15 +1559,15 @@ var require_main = __commonJS((exports, module) => {
 
 // src/weixin/storage/state-dir.ts
 import os from "node:os";
-import path from "node:path";
+import path2 from "node:path";
 function resolveStateDir() {
-  return process.env.OPENCLAW_STATE_DIR?.trim() || process.env.CLAWDBOT_STATE_DIR?.trim() || path.join(os.homedir(), ".openclaw");
+  return process.env.OPENCLAW_STATE_DIR?.trim() || process.env.CLAWDBOT_STATE_DIR?.trim() || path2.join(os.homedir(), ".openclaw");
 }
 var init_state_dir = () => {};
 
 // src/weixin/auth/accounts.ts
-import fs from "node:fs";
-import path2 from "node:path";
+import fs2 from "node:fs";
+import path3 from "node:path";
 function normalizeAccountId(raw) {
   return raw.trim().toLowerCase().replace(/[@.]/g, "-");
 }
@@ -1211,17 +1581,17 @@ function deriveRawAccountId(normalizedId) {
   return;
 }
 function resolveWeixinStateDir() {
-  return path2.join(resolveStateDir(), "openclaw-weixin");
+  return path3.join(resolveStateDir(), "openclaw-weixin");
 }
 function resolveAccountIndexPath() {
-  return path2.join(resolveWeixinStateDir(), "accounts.json");
+  return path3.join(resolveWeixinStateDir(), "accounts.json");
 }
 function listIndexedWeixinAccountIds() {
   const filePath = resolveAccountIndexPath();
   try {
-    if (!fs.existsSync(filePath))
+    if (!fs2.existsSync(filePath))
       return [];
-    const raw = fs.readFileSync(filePath, "utf-8");
+    const raw = fs2.readFileSync(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!Array.isArray(parsed))
       return [];
@@ -1232,21 +1602,21 @@ function listIndexedWeixinAccountIds() {
 }
 function registerWeixinAccountId(accountId) {
   const dir = resolveWeixinStateDir();
-  fs.mkdirSync(dir, { recursive: true });
-  fs.writeFileSync(resolveAccountIndexPath(), JSON.stringify([accountId], null, 2), "utf-8");
+  fs2.mkdirSync(dir, { recursive: true });
+  fs2.writeFileSync(resolveAccountIndexPath(), JSON.stringify([accountId], null, 2), "utf-8");
 }
 function resolveAccountsDir() {
-  return path2.join(resolveWeixinStateDir(), "accounts");
+  return path3.join(resolveWeixinStateDir(), "accounts");
 }
 function resolveAccountPath(accountId) {
-  return path2.join(resolveAccountsDir(), `${accountId}.json`);
+  return path3.join(resolveAccountsDir(), `${accountId}.json`);
 }
 function loadLegacyToken() {
-  const legacyPath = path2.join(resolveStateDir(), "credentials", "openclaw-weixin", "credentials.json");
+  const legacyPath = path3.join(resolveStateDir(), "credentials", "openclaw-weixin", "credentials.json");
   try {
-    if (!fs.existsSync(legacyPath))
+    if (!fs2.existsSync(legacyPath))
       return;
-    const raw = fs.readFileSync(legacyPath, "utf-8");
+    const raw = fs2.readFileSync(legacyPath, "utf-8");
     const parsed = JSON.parse(raw);
     return typeof parsed.token === "string" ? parsed.token : undefined;
   } catch {
@@ -1255,8 +1625,8 @@ function loadLegacyToken() {
 }
 function readAccountFile(filePath) {
   try {
-    if (fs.existsSync(filePath)) {
-      return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    if (fs2.existsSync(filePath)) {
+      return JSON.parse(fs2.readFileSync(filePath, "utf-8"));
     }
   } catch {}
   return null;
@@ -1278,7 +1648,7 @@ function loadWeixinAccount(accountId) {
 }
 function saveWeixinAccount(accountId, update) {
   const dir = resolveAccountsDir();
-  fs.mkdirSync(dir, { recursive: true });
+  fs2.mkdirSync(dir, { recursive: true });
   const existing = loadWeixinAccount(accountId) ?? {};
   const token = update.token?.trim() || existing.token;
   const baseUrl = update.baseUrl?.trim() || existing.baseUrl;
@@ -1289,14 +1659,14 @@ function saveWeixinAccount(accountId, update) {
     ...userId ? { userId } : {}
   };
   const filePath = resolveAccountPath(accountId);
-  fs.writeFileSync(filePath, JSON.stringify(data, null, 2), "utf-8");
+  fs2.writeFileSync(filePath, JSON.stringify(data, null, 2), "utf-8");
   try {
-    fs.chmodSync(filePath, 384);
+    fs2.chmodSync(filePath, 384);
   } catch {}
 }
 function clearWeixinAccount(accountId) {
   try {
-    fs.unlinkSync(resolveAccountPath(accountId));
+    fs2.unlinkSync(resolveAccountPath(accountId));
   } catch {}
 }
 function clearAllWeixinAccounts() {
@@ -1305,21 +1675,21 @@ function clearAllWeixinAccounts() {
     clearWeixinAccount(id);
   }
   try {
-    fs.writeFileSync(resolveAccountIndexPath(), "[]", "utf-8");
+    fs2.writeFileSync(resolveAccountIndexPath(), "[]", "utf-8");
   } catch {}
 }
 function resolveConfigPath() {
   const envPath = process.env.OPENCLAW_CONFIG?.trim();
   if (envPath)
     return envPath;
-  return path2.join(resolveStateDir(), "openclaw.json");
+  return path3.join(resolveStateDir(), "openclaw.json");
 }
 function loadConfigRouteTag(accountId) {
   try {
     const configPath = resolveConfigPath();
-    if (!fs.existsSync(configPath))
+    if (!fs2.existsSync(configPath))
       return;
-    const raw = fs.readFileSync(configPath, "utf-8");
+    const raw = fs2.readFileSync(configPath, "utf-8");
     const cfg = JSON.parse(raw);
     const channels = cfg.channels;
     const section = channels?.["openclaw-weixin"];
@@ -1367,9 +1737,9 @@ var init_accounts = __esm(() => {
 });
 
 // src/weixin/util/logger.ts
-import fs2 from "node:fs";
+import fs3 from "node:fs";
 import os2 from "node:os";
-import path3 from "node:path";
+import path4 from "node:path";
 function resolveMinLevel() {
   const env = process.env.OPENCLAW_LOG_LEVEL?.toUpperCase();
   if (env && env in LEVEL_IDS)
@@ -1388,7 +1758,7 @@ function localDateKey(now) {
 }
 function resolveMainLogPath() {
   const dateKey = localDateKey(new Date);
-  return path3.join(MAIN_LOG_DIR, `openclaw-${dateKey}.log`);
+  return path4.join(MAIN_LOG_DIR, `openclaw-${dateKey}.log`);
 }
 function buildLoggerName(accountId) {
   return accountId ? `${SUBSYSTEM}/${accountId}` : SUBSYSTEM;
@@ -1417,10 +1787,10 @@ function writeLog(level, message, accountId) {
   });
   try {
     if (!logDirEnsured) {
-      fs2.mkdirSync(MAIN_LOG_DIR, { recursive: true });
+      fs3.mkdirSync(MAIN_LOG_DIR, { recursive: true });
       logDirEnsured = true;
     }
-    fs2.appendFileSync(resolveMainLogPath(), `${entry}
+    fs3.appendFileSync(resolveMainLogPath(), `${entry}
 `, "utf-8");
   } catch {}
 }
@@ -1449,7 +1819,7 @@ function createLogger(accountId) {
 }
 var MAIN_LOG_DIR, SUBSYSTEM = "gateway/channels/openclaw-weixin", RUNTIME = "node", RUNTIME_VERSION, HOSTNAME, PARENT_NAMES, LEVEL_IDS, DEFAULT_LOG_LEVEL = "INFO", minLevelId, logDirEnsured = false, logger;
 var init_logger = __esm(() => {
-  MAIN_LOG_DIR = path3.join("/tmp", "openclaw");
+  MAIN_LOG_DIR = path4.join("/tmp", "openclaw");
   RUNTIME_VERSION = process.versions.node;
   HOSTNAME = os2.hostname() || "unknown";
   PARENT_NAMES = ["openclaw"];
@@ -1500,19 +1870,6 @@ var DEFAULT_BODY_MAX_LEN = 200, DEFAULT_TOKEN_PREFIX_LEN = 6;
 
 // src/weixin/api/api.ts
 import crypto from "node:crypto";
-import fs3 from "node:fs";
-import path4 from "node:path";
-import { fileURLToPath } from "node:url";
-function readChannelVersion() {
-  try {
-    const dir = path4.dirname(fileURLToPath(import.meta.url));
-    const pkgPath = path4.resolve(dir, "..", "..", "package.json");
-    const pkg = JSON.parse(fs3.readFileSync(pkgPath, "utf-8"));
-    return pkg.version ?? "unknown";
-  } catch {
-    return "unknown";
-  }
-}
 function buildBaseInfo() {
   return { channel_version: CHANNEL_VERSION };
 }
@@ -1688,9 +2045,10 @@ async function sendTyping(params) {
 }
 var CHANNEL_VERSION, DEFAULT_LONG_POLL_TIMEOUT_MS = 35000, DEFAULT_API_TIMEOUT_MS = 15000, DEFAULT_CONFIG_TIMEOUT_MS = 1e4;
 var init_api = __esm(() => {
+  init_version();
   init_accounts();
   init_logger();
-  CHANNEL_VERSION = readChannelVersion();
+  CHANNEL_VERSION = readVersion();
 });
 
 // src/weixin/auth/login-qr.ts
@@ -2637,7 +2995,7 @@ function markdownToPlainText(text) {
   result = result.replace(/\[([^\]]+)\]\([^)]*\)/g, "$1");
   result = result.replace(/^\|[\s:|-]+\|$/gm, "");
   result = result.replace(/^\|(.+)\|$/gm, (_, inner) => inner.split("|").map((cell) => cell.trim()).join("  "));
-  result = result.replace(/\*\*(.+?)\*\*/g, "$1").replace(/\*(.+?)\*/g, "$1").replace(/__(.+?)__/g, "$1").replace(/_(.+?)_/g, "$1").replace(/~~(.+?)~~/g, "$1").replace(/`(.+?)`/g, "$1");
+  result = result.replace(/\*\*(.+?)\*\*/g, "$1").replace(/\*(.+?)\*/g, "$1").replace(/__(.+?)__/g, "$1").replace(/~~(.+?)~~/g, "$1").replace(/`(.+?)`/g, "$1");
   return result;
 }
 function buildTextMessageReq(params) {
@@ -3253,6 +3611,9 @@ async function monitorWeixinProvider(opts) {
     log(`[weixin] no previous sync buf, starting fresh`);
   }
   const configManager = new WeixinConfigManager({ baseUrl, token }, log);
+  const seenMessageIds = new Set;
+  const messageIdOrder = [];
+  const DEDUP_WINDOW = 100;
   let nextTimeoutMs = longPollTimeoutMs ?? DEFAULT_LONG_POLL_TIMEOUT_MS2;
   let consecutiveFailures = 0;
   while (!abortSignal?.aborted) {
@@ -3296,6 +3657,18 @@ async function monitorWeixinProvider(opts) {
       }
       const list = resp.msgs ?? [];
       for (const full of list) {
+        const msgId = full.message_id;
+        if (msgId != null) {
+          if (seenMessageIds.has(msgId)) {
+            aLog.info(`duplicate message skipped: message_id=${msgId}`);
+            continue;
+          }
+          seenMessageIds.add(msgId);
+          messageIdOrder.push(msgId);
+          if (messageIdOrder.length > DEDUP_WINDOW) {
+            seenMessageIds.delete(messageIdOrder.shift());
+          }
+        }
         aLog.info(`inbound: from=${full.from_user_id} types=${full.item_list?.map((i) => i.type).join(",") ?? "none"}`);
         const fromUserId = full.from_user_id ?? "";
         const cachedConfig = await configManager.getForUser(fromUserId, full.context_token);
@@ -4485,23 +4858,23 @@ async function handleCancel(context, chatKey) {
 async function handleSessionReset(context, chatKey) {
   return await context.lifecycle.resetCurrentSession(chatKey);
 }
+async function promptWithSession(context, session, text, reply) {
+  const effectiveReplyMode = session.replyMode ?? context.config?.wechat.replyMode ?? "stream";
+  const transportReply = effectiveReplyMode === "stream" ? reply : undefined;
+  const result = await context.interaction.promptTransportSession(session, text, transportReply);
+  return { text: transportReply ? undefined : result.text };
+}
 async function handlePrompt(context, chatKey, text, reply) {
   const session = await context.sessions.getCurrentSession(chatKey);
   if (!session) {
     return { text: NO_CURRENT_SESSION_TEXT };
   }
   try {
-    const effectiveReplyMode = session.replyMode ?? context.config?.wechat.replyMode ?? "stream";
-    const transportReply = effectiveReplyMode === "stream" ? reply : undefined;
-    const result = await context.interaction.promptTransportSession(session, text, transportReply);
-    return { text: result.text };
+    return await promptWithSession(context, session, text, reply);
   } catch (error) {
     const recovered = await context.recovery.tryRecoverMissingSession(session, error);
     if (recovered) {
-      const effectiveReplyMode = recovered.replyMode ?? context.config?.wechat.replyMode ?? "stream";
-      const transportReply = effectiveReplyMode === "stream" ? reply : undefined;
-      const result = await context.interaction.promptTransportSession(recovered, text, transportReply);
-      return { text: result.text };
+      return await promptWithSession(context, recovered, text, reply);
     }
     return context.recovery.renderTransportError(session, error);
   }
@@ -4892,7 +5265,7 @@ async function handleSessionShortcutCommand(context, ops, chatKey, agent, target
 `)
     };
   }
-  const session = ops.resolveSession(alias, agent, workspace.name, `${workspace.name}:${alias}`);
+  const session = ops.resolveSession(alias, agent, workspace.name, alias);
   try {
     await ops.ensureTransportSession(session);
     const exists = await ops.checkTransportSession(session);
@@ -5635,11 +6008,18 @@ var init_ensure_config = __esm(() => {
 
 // src/config/resolve-acpx-command.ts
 import { readFileSync } from "node:fs";
-import { posix, win32 } from "node:path";
 import { createRequire as createRequire2 } from "node:module";
+import { posix, win32 } from "node:path";
 function resolveAcpxCommand(options = {}) {
+  return resolveAcpxCommandMetadata(options).command;
+}
+function resolveAcpxCommandMetadata(options = {}) {
   if (options.configuredCommand) {
-    return options.configuredCommand;
+    return {
+      command: options.configuredCommand,
+      source: "config",
+      explanation: "transport.command is set, so the configured command wins."
+    };
   }
   const platform = options.platform ?? process.platform;
   const resolvePackageJson = options.resolvePackageJson ?? ((id) => require2.resolve(id));
@@ -5651,10 +6031,18 @@ function resolveAcpxCommand(options = {}) {
     const packageDir = pathApi.dirname(packageJsonPath);
     const binPath = typeof pkg.bin === "string" ? pkg.bin : pkg.bin && typeof pkg.bin.acpx === "string" ? pkg.bin.acpx : null;
     if (binPath) {
-      return pathApi.resolve(packageDir, binPath);
+      return {
+        command: pathApi.resolve(packageDir, binPath),
+        source: "bundled",
+        explanation: "transport.command is unset, so the bundled acpx dependency is used."
+      };
     }
   } catch {}
-  return "acpx";
+  return {
+    command: "acpx",
+    source: "PATH",
+    explanation: "transport.command is unset and no bundled acpx was found, so PATH is the fallback."
+  };
 }
 var require2;
 var init_resolve_acpx_command = __esm(() => {
@@ -6634,6 +7022,7 @@ var init_acpx_cli_transport = __esm(() => {
 var exports_main = {};
 __export(exports_main, {
   resolveRuntimePaths: () => resolveRuntimePaths,
+  resolveBridgeEntryPath: () => resolveBridgeEntryPath,
   main: () => main2,
   buildApp: () => buildApp
 });
@@ -6737,362 +7126,974 @@ var init_main = __esm(async () => {
   if (false) {}
 });
 
-// src/cli.ts
-import { homedir as homedir6 } from "node:os";
-import { sep } from "node:path";
-import { fileURLToPath as fileURLToPath4 } from "node:url";
-
-// src/daemon/create-daemon-controller.ts
-import { mkdir as mkdir3, open } from "node:fs/promises";
-import { spawn } from "node:child_process";
-
-// src/daemon/daemon-controller.ts
-import { mkdir as mkdir2, readFile as readFile2, rm as rm2, writeFile as writeFile2 } from "node:fs/promises";
-import { dirname as dirname2 } from "node:path";
+// src/doctor/checks/acpx-check.ts
+import { spawn as spawn4 } from "node:child_process";
+async function checkAcpx(options = {}) {
+  const runtimePaths = (options.resolveRuntimePaths ?? resolveRuntimePaths)();
+  try {
+    const config = await (options.loadConfig ?? loadConfig)(runtimePaths.configPath);
+    const metadata = (options.resolveAcpxCommandMetadata ?? resolveAcpxCommandMetadata)({
+      configuredCommand: config.transport.command
+    });
+    const version = await (options.runVersion ?? defaultRunVersion)(metadata.command);
+    return {
+      id: "acpx",
+      label: "acpx",
+      severity: "pass",
+      summary: `resolved ${metadata.command} (${version})`,
+      details: buildDetails(metadata, version, options.verbose),
+      metadata: {
+        command: metadata.command,
+        source: metadata.source,
+        version
+      }
+    };
+  } catch (error) {
+    const message = formatError(error);
+    const details = [`config path: ${runtimePaths.configPath}`, `error: ${message}`];
+    return {
+      id: "acpx",
+      label: "acpx",
+      severity: "fail",
+      summary: "acpx version check failed",
+      details
+    };
+  }
+}
+function buildDetails(metadata, version, verbose) {
+  const details = [
+    `command: ${metadata.command}`,
+    `source: ${metadata.source}`,
+    `version: ${version}`
+  ];
+  if (verbose) {
+    details.push(`resolution: ${metadata.explanation}`);
+  }
+  return details;
+}
+async function defaultRunVersion(command) {
+  const spawnSpec = resolveSpawnCommand(command, ["--version"]);
+  return await new Promise((resolve2, reject) => {
+    const child = spawn4(spawnSpec.command, spawnSpec.args, {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => {
+      stdout += String(chunk);
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += String(chunk);
+    });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code === 0) {
+        const version = stdout.trim() || stderr.trim();
+        if (version.length > 0) {
+          resolve2(version);
+          return;
+        }
+      }
+      reject(new Error(stderr.trim() || stdout.trim() || `acpx --version exited with code ${code ?? 1}`));
+    });
+  });
+}
+function formatError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+var init_acpx_check = __esm(async () => {
+  init_load_config();
+  init_resolve_acpx_command();
+  init_spawn_command();
+  await init_main();
+});
 
-// src/daemon/daemon-status.ts
-import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
-import { dirname } from "node:path";
+// src/doctor/checks/bridge-check.ts
+async function checkBridge(options = {}) {
+  const runtimePaths = (options.resolveRuntimePaths ?? resolveRuntimePaths)();
+  try {
+    const config = await (options.loadConfig ?? loadConfig)(runtimePaths.configPath);
+    if (config.transport.type === "acpx-cli") {
+      return {
+        id: "bridge",
+        label: "Bridge",
+        severity: "skip",
+        summary: "bridge check skipped for acpx-cli transport"
+      };
+    }
+    const metadata = (options.resolveAcpxCommandMetadata ?? resolveAcpxCommandMetadata)({
+      configuredCommand: config.transport.command
+    });
+    const client = await (options.spawnAcpxBridgeClient ?? spawnAcpxBridgeClient)({
+      acpxCommand: metadata.command,
+      bridgeEntryPath: (options.resolveBridgeEntryPath ?? resolveBridgeEntryPath)(),
+      cwd: options.cwd ?? process.cwd(),
+      permissionMode: config.transport.permissionMode,
+      nonInteractivePermissions: config.transport.nonInteractivePermissions
+    });
+    try {
+      return {
+        id: "bridge",
+        label: "Bridge",
+        severity: "pass",
+        summary: "bridge responded to ping",
+        details: buildDetails2(metadata, options.verbose),
+        metadata: {
+          acpxCommand: metadata.command,
+          source: metadata.source
+        }
+      };
+    } finally {
+      await client.dispose();
+    }
+  } catch (error) {
+    return {
+      id: "bridge",
+      label: "Bridge",
+      severity: "fail",
+      summary: "bridge startup failed",
+      details: [`config path: ${runtimePaths.configPath}`, `error: ${formatError2(error)}`]
+    };
+  }
+}
+function buildDetails2(metadata, verbose) {
+  const details = [`acpx command: ${metadata.command}`, `source: ${metadata.source}`];
+  if (verbose) {
+    details.push(`resolution: ${metadata.explanation}`);
+  }
+  return details;
+}
+function formatError2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+var init_bridge_check = __esm(async () => {
+  init_load_config();
+  init_resolve_acpx_command();
+  init_acpx_bridge_client();
+  await init_main();
+});
 
-class DaemonStatusStore {
-  path;
-  constructor(path) {
-    this.path = path;
+// src/doctor/checks/config-check.ts
+async function checkConfig(options = {}) {
+  const runtimePaths = (options.resolveRuntimePaths ?? resolveRuntimePaths)();
+  const configPath = runtimePaths.configPath;
+  try {
+    const config = await (options.loadConfig ?? loadConfig)(configPath);
+    return {
+      id: "config",
+      label: "Config",
+      severity: "pass",
+      summary: "configuration loaded",
+      details: [`config path: ${configPath}`],
+      metadata: {
+        configPath,
+        config
+      }
+    };
+  } catch (error) {
+    return {
+      id: "config",
+      label: "Config",
+      severity: "fail",
+      summary: "configuration is invalid",
+      details: [`config path: ${configPath}`, `error: ${formatError3(error)}`]
+    };
   }
-  async load() {
-    try {
-      const content = await readFile(this.path, "utf8");
-      if (content.trim() === "") {
-        return null;
+}
+function formatError3(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+var init_config_check = __esm(async () => {
+  init_load_config();
+  await init_main();
+});
+
+// src/doctor/checks/daemon-check.ts
+import { fileURLToPath as fileURLToPath4 } from "node:url";
+import { homedir as homedir6 } from "node:os";
+async function checkDaemon(options = {}) {
+  const home = options.home ?? process.env.HOME ?? homedir6();
+  const paths = (options.resolveDaemonPaths ?? resolveDaemonPaths)({ home });
+  const controller = createDaemonController(paths, {
+    processExecPath: options.processExecPath ?? process.execPath,
+    cliEntryPath: options.cliEntryPath ?? resolveCliEntryPath(),
+    cwd: options.cwd ?? process.cwd(),
+    env: options.env ?? process.env,
+    isProcessRunning: options.isProcessRunning ?? defaultIsProcessRunning3
+  });
+  try {
+    const status = await controller.getStatus();
+    switch (status.state) {
+      case "running":
+        return {
+          id: "daemon",
+          label: "Daemon",
+          severity: "pass",
+          summary: "daemon is running",
+          details: [`pid: ${status.pid}`],
+          metadata: {
+            paths,
+            status
+          }
+        };
+      case "stopped":
+        return {
+          id: "daemon",
+          label: "Daemon",
+          severity: "warn",
+          summary: status.stale ? "daemon was stopped and stale runtime files were cleared" : "daemon is not running",
+          details: status.stale ? ["stale runtime files were cleared"] : undefined,
+          suggestions: ["run: weacpx start"],
+          metadata: {
+            paths,
+            status
+          }
+        };
+      case "indeterminate":
+        return {
+          id: "daemon",
+          label: "Daemon",
+          severity: "fail",
+          summary: "daemon status is indeterminate",
+          details: [`pid: ${status.pid}`, `reason: ${status.reason}`],
+          metadata: {
+            paths,
+            status
+          }
+        };
+    }
+    return {
+      id: "daemon",
+      label: "Daemon",
+      severity: "fail",
+      summary: "daemon status lookup returned an unknown state",
+      details: [`state: ${status.state ?? "unknown"}`],
+      metadata: {
+        paths
       }
-      return JSON.parse(content);
-    } catch (error) {
-      if (error.code === "ENOENT") {
-        return null;
+    };
+  } catch (error) {
+    return {
+      id: "daemon",
+      label: "Daemon",
+      severity: "fail",
+      summary: "daemon status could not be read",
+      details: [
+        `runtime dir: ${paths.runtimeDir}`,
+        `pid file: ${paths.pidFile}`,
+        `status file: ${paths.statusFile}`,
+        `error: ${formatError4(error)}`
+      ],
+      metadata: {
+        paths
       }
-      throw error;
-    }
-  }
-  async save(status) {
-    await mkdir(dirname(this.path), { recursive: true });
-    await writeFile(this.path, JSON.stringify(status, null, 2));
+    };
   }
-  async clear() {
-    await rm(this.path, { force: true });
+}
+function defaultIsProcessRunning3(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
   }
 }
+function resolveCliEntryPath() {
+  return process.argv[1] ?? fileURLToPath4(import.meta.url);
+}
+function formatError4(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+var init_daemon_check = __esm(() => {
+  init_create_daemon_controller();
+  init_daemon_files();
+});
 
-// src/daemon/daemon-controller.ts
-class DaemonController {
-  paths;
-  deps;
-  statusStore;
-  startupPollIntervalMs;
-  startupTimeoutMs;
-  onStartupPoll;
-  shutdownPollIntervalMs;
-  shutdownTimeoutMs;
-  onShutdownPoll;
-  constructor(paths, deps) {
-    this.paths = paths;
-    this.deps = deps;
-    this.statusStore = new DaemonStatusStore(paths.statusFile);
-    this.startupPollIntervalMs = deps.startupPollIntervalMs ?? 50;
-    this.startupTimeoutMs = deps.startupTimeoutMs ?? 5000;
-    this.shutdownPollIntervalMs = deps.shutdownPollIntervalMs ?? 50;
-    this.shutdownTimeoutMs = deps.shutdownTimeoutMs ?? 5000;
-    this.onStartupPoll = deps.onStartupPoll ?? (async () => {
-      await new Promise((resolve) => setTimeout(resolve, this.startupPollIntervalMs));
-    });
-    this.onShutdownPoll = deps.onShutdownPoll ?? (async () => {
-      await new Promise((resolve) => setTimeout(resolve, this.shutdownPollIntervalMs));
-    });
+// src/doctor/checks/runtime-check.ts
+import { constants } from "node:fs";
+import { access as access3, stat as stat2 } from "node:fs/promises";
+import { dirname as dirname10 } from "node:path";
+import { homedir as homedir7 } from "node:os";
+async function checkRuntime(options = {}) {
+  const home = options.home ?? process.env.HOME ?? homedir7();
+  const paths = (options.resolveDaemonPaths ?? resolveDaemonPaths)({ home });
+  const probe = options.probe ?? createRuntimeFsProbe();
+  const platform = options.platform ?? process.platform;
+  const checks = [
+    await checkDirectoryCreatable("runtimeDir", paths.runtimeDir, probe, platform),
+    await checkFileCreatable("pidFile", paths.pidFile, probe, platform),
+    await checkFileCreatable("statusFile", paths.statusFile, probe, platform),
+    await checkFileCreatable("stdoutLog", paths.stdoutLog, probe, platform),
+    await checkFileCreatable("stderrLog", paths.stderrLog, probe, platform),
+    await checkFileCreatable("appLog", paths.appLog, probe, platform)
+  ];
+  const failure = checks.find((check) => !check.ok);
+  if (failure) {
+    return {
+      id: "runtime",
+      label: "Runtime",
+      severity: "fail",
+      summary: "daemon runtime paths are not usable",
+      details: checks.map((check) => check.detail)
+    };
   }
-  async getStatus() {
-    const pid = await this.loadPid();
-    const status = await this.statusStore.load();
-    if (!pid) {
-      return { state: "stopped" };
-    }
-    if (!this.deps.isProcessRunning(pid)) {
-      await this.clearRuntimeFiles();
-      return { state: "stopped", stale: true };
+  return {
+    id: "runtime",
+    label: "Runtime",
+    severity: "pass",
+    summary: "daemon runtime paths are usable",
+    details: checks.map((check) => check.detail),
+    metadata: {
+      paths
     }
-    if (!status) {
-      return { state: "indeterminate", pid, reason: "missing-status" };
+  };
+}
+function createRuntimeFsProbe() {
+  return {
+    stat: async (path11) => await stat2(path11),
+    access: async (path11, mode) => await access3(path11, mode)
+  };
+}
+async function checkDirectoryCreatable(label, path11, probe, platform) {
+  try {
+    const stats = await probe.stat(path11);
+    if (!stats.isDirectory()) {
+      return {
+        ok: false,
+        detail: `${label}: ${path11} (exists but is not a directory)`
+      };
     }
+    await probe.access(path11, directoryAccessMode(platform));
     return {
-      state: "running",
-      pid,
-      status
+      ok: true,
+      detail: `${label}: ${path11} (writable)`
     };
-  }
-  async start() {
-    const current = await this.getStatus();
-    if (current.state === "running") {
-      return { state: "already-running", pid: current.pid };
+  } catch (error) {
+    if (!isMissingPathError(error)) {
+      return {
+        ok: false,
+        detail: `${label}: ${path11} (unusable: ${formatError5(error)})`
+      };
     }
-    if (current.state === "indeterminate") {
-      throw new Error(`weacpx daemon process is already running (pid ${current.pid}) but status metadata is missing`);
+    const parentCheck = await checkCreatableAncestorDirectory(path11, probe, platform);
+    if (!parentCheck.ok) {
+      return {
+        ok: false,
+        detail: `${label}: ${path11} (parent not writable: ${parentCheck.blockingPath})`
+      };
     }
-    await this.statusStore.clear();
-    const pid = await this.deps.spawnDetached();
-    await this.writePid(pid);
-    await this.waitForStartupMetadata(pid);
-    return { state: "started", pid };
+    return {
+      ok: true,
+      detail: `${label}: ${path11} (creatable via ${parentCheck.creatableFrom})`
+    };
   }
-  async stop() {
-    const pid = await this.loadPid();
-    if (!pid) {
-      return { state: "stopped", detail: "not-running" };
+}
+async function checkFileCreatable(label, path11, probe, platform) {
+  try {
+    const stats = await probe.stat(path11);
+    if (stats.isDirectory()) {
+      return {
+        ok: false,
+        detail: `${label}: ${path11} (exists but is a directory)`
+      };
     }
-    if (this.deps.isProcessRunning(pid)) {
-      await this.deps.terminateProcess(pid);
-      await this.waitForShutdown(pid);
+    await probe.access(path11, constants.W_OK);
+    return {
+      ok: true,
+      detail: `${label}: ${path11} (writable)`
+    };
+  } catch (error) {
+    if (!isMissingPathError(error)) {
+      return {
+        ok: false,
+        detail: `${label}: ${path11} (unusable: ${formatError5(error)})`
+      };
     }
-    await this.clearRuntimeFiles();
-    return { state: "stopped", detail: "stopped" };
-  }
-  async loadPid() {
-    try {
-      const content = await readFile2(this.paths.pidFile, "utf8");
-      const pid = Number(content.trim());
-      return Number.isFinite(pid) && pid > 0 ? pid : null;
-    } catch (error) {
-      if (error.code === "ENOENT") {
-        return null;
-      }
-      throw error;
+    const parentCheck = await checkCreatableAncestorDirectory(dirname10(path11), probe, platform);
+    if (!parentCheck.ok) {
+      return {
+        ok: false,
+        detail: `${label}: ${path11} (parent not writable: ${parentCheck.blockingPath})`
+      };
     }
+    return {
+      ok: true,
+      detail: `${label}: ${path11} (creatable via ${parentCheck.creatableFrom})`
+    };
   }
-  async writePid(pid) {
-    await mkdir2(dirname2(this.paths.pidFile), { recursive: true });
-    await writeFile2(this.paths.pidFile, `${pid}
-`);
-  }
-  async clearRuntimeFiles() {
-    await rm2(this.paths.pidFile, { force: true });
-    await this.statusStore.clear();
-  }
-  async waitForStartupMetadata(pid) {
-    const deadline = Date.now() + this.startupTimeoutMs;
-    while (Date.now() < deadline) {
-      const status = await this.statusStore.load();
-      if (status?.pid === pid) {
-        return;
-      }
-      if (!this.deps.isProcessRunning(pid)) {
-        await this.clearRuntimeFiles();
-        throw new Error(`weacpx daemon exited before reporting ready state (pid ${pid})`);
-      }
-      await this.onStartupPoll();
+}
+async function checkCreatableAncestorDirectory(path11, probe, platform) {
+  try {
+    const stats = await probe.stat(path11);
+    if (!stats.isDirectory()) {
+      return {
+        ok: false,
+        creatableFrom: path11,
+        blockingPath: path11
+      };
     }
-    throw new Error(`weacpx daemon did not report ready state within ${this.startupTimeoutMs}ms (pid ${pid})`);
-  }
-  async waitForShutdown(pid) {
-    const deadline = Date.now() + this.shutdownTimeoutMs;
-    while (Date.now() < deadline) {
-      if (!this.deps.isProcessRunning(pid)) {
-        return;
-      }
-      await this.onShutdownPoll();
+    await probe.access(path11, directoryAccessMode(platform));
+    return {
+      ok: true,
+      creatableFrom: path11
+    };
+  } catch (error) {
+    if (!isMissingPathError(error)) {
+      return {
+        ok: false,
+        creatableFrom: path11,
+        blockingPath: path11
+      };
     }
-    if (!this.deps.isProcessRunning(pid)) {
-      return;
+    const parent = dirname10(path11);
+    if (parent === path11) {
+      return {
+        ok: false,
+        creatableFrom: path11,
+        blockingPath: path11
+      };
     }
-    throw new Error(`weacpx daemon did not exit within ${this.shutdownTimeoutMs}ms (pid ${pid})`);
+    const parentCheck = await checkCreatableAncestorDirectory(parent, probe, platform);
+    if (!parentCheck.ok) {
+      return parentCheck;
+    }
+    return {
+      ok: true,
+      creatableFrom: parentCheck.creatableFrom
+    };
   }
 }
-
-// src/daemon/create-daemon-controller.ts
-function createDaemonController(paths, options) {
-  return new DaemonController(paths, {
-    isProcessRunning: options.isProcessRunning ?? defaultIsProcessRunning,
-    spawnDetached: async () => {
-      await mkdir3(paths.runtimeDir, { recursive: true });
-      const stdoutHandle = await open(paths.stdoutLog, "a");
-      const stderrHandle = await open(paths.stderrLog, "a");
-      try {
-        return await (options.spawnProcess ?? defaultSpawnProcess)(buildSpawnRequest(paths, options, stdoutHandle.fd, stderrHandle.fd));
-      } finally {
-        await stdoutHandle.close();
-        await stderrHandle.close();
-      }
-    },
-    terminateProcess: options.terminateProcess ?? defaultTerminateProcess
-  });
+function directoryAccessMode(platform) {
+  return platform === "win32" ? constants.W_OK : DIRECTORY_USABLE;
 }
-function defaultIsProcessRunning(pid) {
+function isMissingPathError(error) {
+  return isErrnoError(error) && (error.code === "ENOENT" || error.code === "ENOTDIR");
+}
+function isErrnoError(error) {
+  return typeof error === "object" && error !== null && "code" in error;
+}
+function formatError5(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+var DIRECTORY_USABLE;
+var init_runtime_check = __esm(() => {
+  init_daemon_files();
+  DIRECTORY_USABLE = constants.W_OK | constants.X_OK;
+});
+
+// src/doctor/checks/smoke-check.ts
+async function checkSmoke(options = {}, deps = {}) {
+  const resolvedOptions = { ...options, ...deps };
+  const runtimePaths = (resolvedOptions.resolveRuntimePaths ?? resolveRuntimePaths)();
   try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
+    const config = await (resolvedOptions.loadConfig ?? loadConfig)(runtimePaths.configPath);
+    const agentSelection = selectAgent(config, resolvedOptions.agent);
+    if (agentSelection.error) {
+      return agentSelection.error;
+    }
+    const workspaceSelection = selectWorkspace(config, resolvedOptions.workspace);
+    if (workspaceSelection.error) {
+      return workspaceSelection.error;
+    }
+    const missingDefaults = [agentSelection.missingDefault, workspaceSelection.missingDefault].filter((value) => typeof value === "string");
+    if (missingDefaults.length > 0) {
+      return {
+        id: "smoke",
+        label: "Smoke",
+        severity: "skip",
+        summary: `smoke prerequisites missing: ${missingDefaults.join(", ")}`,
+        details: [
+          `config path: ${runtimePaths.configPath}`,
+          ...selectionDetails(agentSelection, workspaceSelection)
+        ],
+        suggestions: ["configure at least one agent and one workspace before running --smoke"]
+      };
+    }
+    const agent = agentSelection.value;
+    const workspace = workspaceSelection.value;
+    if (!agent || !workspace) {
+      return {
+        id: "smoke",
+        label: "Smoke",
+        severity: "skip",
+        summary: "smoke prerequisites missing: agent, workspace",
+        details: [
+          `config path: ${runtimePaths.configPath}`,
+          ...selectionDetails(agentSelection, workspaceSelection)
+        ]
+      };
+    }
+    const metadata = (resolvedOptions.resolveAcpxCommandMetadata ?? resolveAcpxCommandMetadata)({
+      configuredCommand: config.transport.command
+    });
+    const transport = await (resolvedOptions.createTransport ?? defaultCreateTransport)({
+      config,
+      metadata,
+      resolveBridgeEntryPath: resolvedOptions.resolveBridgeEntryPath,
+      spawnAcpxBridgeClient: resolvedOptions.spawnAcpxBridgeClient
+    });
+    const session = buildSession({
+      config,
+      agent,
+      workspace,
+      now: resolvedOptions.now
+    });
+    try {
+      await transport.ensureSession(session);
+      const reply = await transport.prompt(session, SMOKE_PROMPT);
+      const replyText = reply.text.trim();
+      if (replyText.length === 0) {
+        return {
+          id: "smoke",
+          label: "Smoke",
+          severity: "fail",
+          summary: "smoke prompt returned empty text",
+          details: buildDetails3({
+            runtimePaths,
+            metadata,
+            session,
+            agentReason: agentSelection.reason,
+            workspaceReason: workspaceSelection.reason,
+            replyText,
+            verbose: resolvedOptions.verbose
+          })
+        };
+      }
+      return {
+        id: "smoke",
+        label: "Smoke",
+        severity: replyText === "ok" ? "pass" : "warn",
+        summary: replyText === "ok" ? "smoke prompt succeeded and reply received" : "smoke prompt succeeded with non-ideal reply",
+        details: buildDetails3({
+          runtimePaths,
+          metadata,
+          session,
+          agentReason: agentSelection.reason,
+          workspaceReason: workspaceSelection.reason,
+          replyText,
+          verbose: resolvedOptions.verbose
+        }),
+        metadata: {
+          agent: session.agent,
+          workspace: session.workspace,
+          transportSession: session.transportSession,
+          replyText
+        }
+      };
+    } finally {
+      await transport.dispose?.();
+    }
+  } catch (error) {
+    return {
+      id: "smoke",
+      label: "Smoke",
+      severity: "fail",
+      summary: "smoke transport probe failed",
+      details: [`config path: ${runtimePaths.configPath}`, `error: ${formatError6(error)}`]
+    };
   }
 }
-function buildSpawnRequest(paths, options, stdoutFd, stderrFd) {
-  const platform = options.platform ?? process.platform;
-  if (platform === "win32") {
+function selectAgent(config, explicitAgent) {
+  if (explicitAgent) {
+    if (!(explicitAgent in config.agents)) {
+      return {
+        reason: "explicit --agent",
+        error: createSelectionFailure(`smoke agent not found: ${explicitAgent}`)
+      };
+    }
     return {
-      mode: "windows-hidden",
-      command: "powershell.exe",
-      args: [
-        "-NoProfile",
-        "-NonInteractive",
-        "-EncodedCommand",
-        buildWindowsLauncherScript()
-      ],
-      options: {
-        cwd: options.cwd,
-        env: {
-          ...options.env,
-          WEACPX_DAEMON_COMMAND: options.processExecPath,
-          WEACPX_DAEMON_ARG0: options.cliEntryPath,
-          WEACPX_DAEMON_ARG1: "run",
-          WEACPX_DAEMON_CWD: options.cwd,
-          WEACPX_DAEMON_STDOUT: paths.stdoutLog,
-          WEACPX_DAEMON_STDERR: paths.stderrLog
-        },
-        stdio: ["ignore", "pipe", "ignore"],
-        windowsHide: true
-      }
+      value: explicitAgent,
+      reason: "explicit --agent"
+    };
+  }
+  const firstAgent = Object.keys(config.agents)[0];
+  if (!firstAgent) {
+    return {
+      missingDefault: "agent",
+      reason: "no configured agent available"
     };
   }
   return {
-    mode: "direct",
-    command: options.processExecPath,
-    args: [options.cliEntryPath, "run"],
-    options: {
-      cwd: options.cwd,
-      detached: true,
-      env: options.env,
-      stdio: ["ignore", stdoutFd, stderrFd]
+    value: firstAgent,
+    reason: "default first configured agent"
+  };
+}
+function selectWorkspace(config, explicitWorkspace) {
+  if (explicitWorkspace) {
+    if (!(explicitWorkspace in config.workspaces)) {
+      return {
+        reason: "explicit --workspace",
+        error: createSelectionFailure(`smoke workspace not found: ${explicitWorkspace}`)
+      };
     }
+    return {
+      value: explicitWorkspace,
+      reason: "explicit --workspace"
+    };
+  }
+  const firstWorkspace = Object.keys(config.workspaces)[0];
+  if (!firstWorkspace) {
+    return {
+      missingDefault: "workspace",
+      reason: "no configured workspace available"
+    };
+  }
+  return {
+    value: firstWorkspace,
+    reason: "default first configured workspace"
   };
 }
-function buildWindowsLauncherScript() {
-  const script = [
-    "$process = Start-Process -FilePath $env:WEACPX_DAEMON_COMMAND `",
-    "  -ArgumentList @($env:WEACPX_DAEMON_ARG0, $env:WEACPX_DAEMON_ARG1) `",
-    "  -WorkingDirectory $env:WEACPX_DAEMON_CWD `",
-    "  -RedirectStandardOutput $env:WEACPX_DAEMON_STDOUT `",
-    "  -RedirectStandardError $env:WEACPX_DAEMON_STDERR `",
-    "  -WindowStyle Hidden `",
-    "  -PassThru",
-    "[Console]::Out.WriteLine($process.Id)"
-  ].join(`
-`);
-  return Buffer.from(script, "utf16le").toString("base64");
+function createSelectionFailure(summary) {
+  return {
+    id: "smoke",
+    label: "Smoke",
+    severity: "fail",
+    summary
+  };
 }
-async function defaultSpawnProcess(request) {
-  if (request.mode === "windows-hidden") {
-    return await spawnWindowsHiddenProcess(request);
+function selectionDetails(agentSelection, workspaceSelection) {
+  const details = [];
+  if (agentSelection.value) {
+    details.push(`agent: ${agentSelection.value} (${agentSelection.reason})`);
+  } else {
+    details.push(`agent: unavailable (${agentSelection.reason})`);
   }
-  const child = spawn(request.command, request.args, request.options);
-  child.unref();
-  return child.pid ?? 0;
+  if (workspaceSelection.value) {
+    details.push(`workspace: ${workspaceSelection.value} (${workspaceSelection.reason})`);
+  } else {
+    details.push(`workspace: unavailable (${workspaceSelection.reason})`);
+  }
+  return details;
 }
-async function spawnWindowsHiddenProcess(request) {
-  return await new Promise((resolve, reject) => {
-    const child = spawn(request.command, request.args, request.options);
-    let stdout = "";
-    let settled = false;
-    child.stdout?.setEncoding("utf8");
-    child.stdout?.on("data", (chunk) => {
-      stdout += chunk;
-      if (settled) {
-        return;
-      }
-      const pid = Number.parseInt(stdout.trim(), 10);
-      if (!Number.isFinite(pid) || pid <= 0) {
-        return;
-      }
-      settled = true;
-      child.stdout?.destroy();
-      child.unref();
-      resolve(pid);
-    });
-    child.on("error", (error) => {
-      if (settled) {
-        return;
-      }
-      settled = true;
-      reject(error);
-    });
-    child.on("close", (code) => {
-      if (settled) {
-        return;
-      }
-      if (code !== 0) {
-        settled = true;
-        reject(new Error(`Failed to launch hidden Windows daemon process (exit ${code ?? 1})`));
-        return;
-      }
-      const pid = Number.parseInt(stdout.trim(), 10);
-      if (!Number.isFinite(pid) || pid <= 0) {
-        settled = true;
-        reject(new Error("Failed to read daemon pid from hidden Windows launcher"));
-        return;
-      }
-      settled = true;
-      resolve(pid);
+function buildSession(options) {
+  const timestamp = (options.now ?? (() => new Date))().getTime();
+  const agentConfig = options.config.agents[options.agent];
+  const workspaceConfig = options.config.workspaces[options.workspace];
+  if (!agentConfig) {
+    throw new Error(`smoke agent not found: ${options.agent}`);
+  }
+  if (!workspaceConfig) {
+    throw new Error(`smoke workspace not found: ${options.workspace}`);
+  }
+  return {
+    alias: "weacpx-doctor",
+    agent: options.agent,
+    ...agentConfig.command ? { agentCommand: agentConfig.command } : {},
+    workspace: options.workspace,
+    transportSession: `weacpx-doctor-${timestamp}`,
+    replyMode: options.config.wechat.replyMode,
+    cwd: workspaceConfig.cwd
+  };
+}
+async function defaultCreateTransport(options) {
+  if (options.config.transport.type === "acpx-bridge") {
+    const client = await (options.spawnAcpxBridgeClient ?? spawnAcpxBridgeClient)({
+      acpxCommand: options.metadata.command,
+      bridgeEntryPath: (options.resolveBridgeEntryPath ?? resolveBridgeEntryPath)(),
+      permissionMode: options.config.transport.permissionMode,
+      nonInteractivePermissions: options.config.transport.nonInteractivePermissions
     });
+    return new AcpxBridgeTransport(client);
+  }
+  return new AcpxCliTransport({
+    ...options.config.transport,
+    command: options.metadata.command
   });
 }
-async function defaultTerminateProcess(pid) {
-  await terminateProcessTree(pid);
+function buildDetails3(options) {
+  const details = [
+    `config path: ${options.runtimePaths.configPath}`,
+    `agent: ${options.session.agent} (${options.agentReason})`,
+    `workspace: ${options.session.workspace} (${options.workspaceReason})`,
+    `transport session: ${options.session.transportSession}`,
+    `reply: ${JSON.stringify(options.replyText)}`
+  ];
+  if (options.verbose) {
+    details.push(`transport type: ${options.session.agentCommand ? "agent-command" : "driver-default"}`);
+    details.push(`acpx command: ${options.metadata.command}`);
+    details.push(`acpx source: ${options.metadata.source}`);
+    details.push(`smoke prompt: ${JSON.stringify(SMOKE_PROMPT)}`);
+  }
+  return details;
 }
-async function terminateProcessTree(pid, platform = process.platform, runCommand = defaultRunProcessCommand, killProcess = (targetPid, signal) => {
-  process.kill(targetPid, signal);
-}, isProcessRunning = defaultIsProcessRunning) {
-  if (platform === "win32") {
+function formatError6(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+var SMOKE_PROMPT = "Reply with exactly: ok";
+var init_smoke_check = __esm(async () => {
+  init_load_config();
+  init_resolve_acpx_command();
+  init_acpx_bridge_client();
+  init_acpx_cli_transport();
+  await init_main();
+});
+
+// src/doctor/checks/wechat-check.ts
+async function checkWechat(options = {}) {
+  const ids = listWeixinAccountIds();
+  const accounts = ids.map((accountId) => {
     try {
-      await runCommand("taskkill", ["/PID", String(pid), "/T", "/F"]);
-    } catch {}
-    return;
+      return {
+        accountId,
+        account: resolveWeixinAccount(accountId)
+      };
+    } catch (error) {
+      return {
+        accountId,
+        error: formatError7(error)
+      };
+    }
+  });
+  const configuredAccount = accounts.find((entry) => ("account" in entry) && entry.account.configured);
+  const loggedIn = Boolean(configuredAccount);
+  if (!loggedIn) {
+    return {
+      id: "wechat",
+      label: "WeChat",
+      severity: "warn",
+      summary: "wechat is not logged in",
+      details: buildVerboseDetails(false, options.verbose, accounts),
+      suggestions: ["weacpx login"]
+    };
   }
-  const targetPid = pid > 0 ? -pid : pid;
-  try {
-    killProcess(targetPid, "SIGTERM");
-  } catch {
+  return {
+    id: "wechat",
+    label: "WeChat",
+    severity: "pass",
+    summary: "wechat is logged in",
+    details: buildVerboseDetails(true, options.verbose, accounts)
+  };
+}
+function buildVerboseDetails(loggedIn, verbose, accounts) {
+  if (!verbose) {
     return;
   }
-  const deadline = Date.now() + 5000;
-  while (Date.now() < deadline) {
-    if (!isProcessRunning(targetPid)) {
-      return;
+  const details = [];
+  details.push(`loggedIn: ${loggedIn}`);
+  details.push(`accountIds: ${accounts.length > 0 ? accounts.map((entry) => entry.accountId).join(", ") : "(none)"}`);
+  for (const entry of accounts) {
+    if ("account" in entry) {
+      details.push(`account[${entry.account.accountId}].configured: ${entry.account.configured}`);
+      details.push(`account[${entry.account.accountId}].baseUrl: ${entry.account.baseUrl}`);
+      continue;
     }
-    await new Promise((resolve) => setTimeout(resolve, 100));
+    details.push(`account[${entry.accountId}].resolveError: ${entry.error ?? "unknown"}`);
   }
-  try {
-    killProcess(targetPid, "SIGKILL");
-  } catch {}
+  return details;
 }
-async function defaultRunProcessCommand(command, args) {
-  return await new Promise((resolve, reject) => {
-    const child = spawn(command, args, { stdio: "ignore" });
-    child.on("error", reject);
-    child.on("close", (code) => resolve(code ?? 1));
-  });
+function formatError7(error) {
+  return error instanceof Error ? error.message : String(error);
 }
+var init_wechat_check = __esm(() => {
+  init_weixin();
+});
 
-// src/daemon/daemon-files.ts
-import { join } from "node:path";
-function resolveDaemonPaths(options) {
-  const runtimeDir = options.runtimeDir ?? join(options.home, ".weacpx", "runtime");
+// src/doctor/render-doctor.ts
+function renderDoctor(report, options = {}) {
+  return options.verbose ? renderVerboseDoctor(report) : renderDefaultDoctor(report);
+}
+function renderDefaultDoctor(report) {
+  const lines = [];
+  for (const check of report.checks) {
+    lines.push(renderCheckLine(check));
+  }
+  lines.push(renderSummaryLine(report.checks));
+  const suggestions = collectSuggestions(report.checks);
+  if (suggestions.length > 0) {
+    lines.push("Next steps:");
+    for (const suggestion of suggestions) {
+      lines.push(`- ${suggestion}`);
+    }
+  }
+  return lines;
+}
+function renderVerboseDoctor(report) {
+  const lines = [];
+  for (const check of report.checks) {
+    lines.push(renderCheckLine(check));
+    for (const detail of check.details ?? []) {
+      lines.push(`  detail: ${detail}`);
+    }
+  }
+  lines.push(renderSummaryLine(report.checks));
+  const suggestions = collectSuggestions(report.checks);
+  if (suggestions.length > 0) {
+    lines.push("Next steps:");
+    for (const suggestion of suggestions) {
+      lines.push(`- ${suggestion}`);
+    }
+  }
+  return lines;
+}
+function renderCheckLine(check) {
+  return `${SEVERITY_LABELS[check.severity]} ${check.label}: ${check.summary}`;
+}
+function renderSummaryLine(checks) {
+  const counts = summarizeChecks(checks);
+  return `Summary: PASS ${counts.pass}, WARN ${counts.warn}, FAIL ${counts.fail}, SKIP ${counts.skip}`;
+}
+function summarizeChecks(checks) {
+  return checks.reduce((counts, check) => {
+    counts[check.severity] += 1;
+    return counts;
+  }, { pass: 0, warn: 0, fail: 0, skip: 0 });
+}
+function collectSuggestions(checks) {
+  const seen = new Set;
+  const suggestions = [];
+  for (const check of checks) {
+    for (const suggestion of check.suggestions ?? []) {
+      if (seen.has(suggestion)) {
+        continue;
+      }
+      seen.add(suggestion);
+      suggestions.push(suggestion);
+    }
+  }
+  return suggestions;
+}
+var SEVERITY_LABELS;
+var init_render_doctor = __esm(() => {
+  SEVERITY_LABELS = {
+    pass: "PASS",
+    warn: "WARN",
+    fail: "FAIL",
+    skip: "SKIP"
+  };
+});
+
+// src/doctor/doctor.ts
+import { homedir as homedir8 } from "node:os";
+import { join as join6 } from "node:path";
+async function runDoctor(options = {}, deps = {}) {
+  const home = deps.home ?? process.env.HOME ?? homedir8();
+  const runtimePaths = resolveDoctorRuntimePaths(home, deps.resolveRuntimePaths);
+  const sharedLoadConfig = createSharedLoadConfig(runtimePaths, deps.loadConfig ?? loadConfig);
+  const checks = [];
+  checks.push(await (deps.checkConfig ?? checkConfig)({
+    loadConfig: sharedLoadConfig,
+    resolveRuntimePaths: () => runtimePaths
+  }));
+  checks.push(await (deps.checkRuntime ?? checkRuntime)({
+    home
+  }));
+  checks.push(await (deps.checkDaemon ?? checkDaemon)({
+    home
+  }));
+  checks.push(await (deps.checkWechat ?? checkWechat)({
+    verbose: options.verbose
+  }));
+  checks.push(await (deps.checkAcpx ?? checkAcpx)({
+    verbose: options.verbose,
+    loadConfig: sharedLoadConfig,
+    resolveRuntimePaths: () => runtimePaths
+  }));
+  checks.push(await (deps.checkBridge ?? checkBridge)({
+    verbose: options.verbose,
+    loadConfig: sharedLoadConfig,
+    resolveRuntimePaths: () => runtimePaths
+  }));
+  checks.push(options.smoke === true ? await (deps.checkSmoke ?? ((runOptions) => defaultCheckSmoke(runOptions, {
+    resolveRuntimePaths: () => runtimePaths,
+    loadConfig: sharedLoadConfig
+  })))(options) : createSmokeSkipResult("smoke probe not requested"));
+  const report = { checks };
+  const output = (deps.renderDoctor ?? renderDoctor)(report, options);
   return {
-    runtimeDir,
-    pidFile: join(runtimeDir, "daemon.pid"),
-    statusFile: join(runtimeDir, "status.json"),
-    stdoutLog: join(runtimeDir, "stdout.log"),
-    stderrLog: join(runtimeDir, "stderr.log"),
-    appLog: join(runtimeDir, "app.log")
+    report,
+    output,
+    exitCode: checks.some((check) => check.severity === "fail") ? 1 : 0
+  };
+}
+function resolveDoctorRuntimePaths(home, resolver) {
+  if (resolver) {
+    return resolver();
+  }
+  if (depsUseExplicitRuntimeOverrides()) {
+    return resolveRuntimePaths();
+  }
+  return {
+    configPath: join6(home, ".weacpx", "config.json"),
+    statePath: join6(home, ".weacpx", "state.json")
+  };
+}
+function depsUseExplicitRuntimeOverrides() {
+  return Boolean(process.env.WEACPX_CONFIG || process.env.WEACPX_STATE);
+}
+function createSharedLoadConfig(runtimePaths, loader) {
+  let pending;
+  return async (configPath) => {
+    if (configPath !== runtimePaths.configPath) {
+      return await loader(configPath);
+    }
+    pending ??= loader(configPath);
+    return await pending;
+  };
+}
+async function defaultCheckSmoke(options, deps) {
+  return await checkSmoke(options, {
+    resolveRuntimePaths: deps.resolveRuntimePaths,
+    loadConfig: deps.loadConfig
+  });
+}
+function createSmokeSkipResult(summary) {
+  return {
+    id: "smoke",
+    label: "Smoke",
+    severity: "skip",
+    summary
   };
 }
+var init_doctor = __esm(async () => {
+  init_load_config();
+  init_daemon_check();
+  init_runtime_check();
+  init_wechat_check();
+  init_render_doctor();
+  await __promiseAll([
+    init_main(),
+    init_acpx_check(),
+    init_bridge_check(),
+    init_config_check(),
+    init_smoke_check()
+  ]);
+});
+
+// src/doctor/index.ts
+var exports_doctor = {};
+__export(exports_doctor, {
+  main: () => main3
+});
+async function main3(options, deps = {}) {
+  const result = await (deps.runDoctor ?? runDoctor)(options);
+  const print = deps.print ?? ((line) => console.log(line));
+  for (const line of result.output) {
+    print(line);
+  }
+  return result.exitCode;
+}
+var init_doctor2 = __esm(async () => {
+  await init_doctor();
+});
+
+// src/cli.ts
+init_create_daemon_controller();
+init_daemon_files();
+import { homedir as homedir9 } from "node:os";
+import { sep } from "node:path";
+import { fileURLToPath as fileURLToPath5 } from "node:url";
 
 // src/daemon/daemon-runtime.ts
+init_daemon_status();
 import { mkdir as mkdir4, rm as rm3, writeFile as writeFile3 } from "node:fs/promises";
 import { dirname as dirname3 } from "node:path";
+
 class DaemonRuntime {
   paths;
   options;
@@ -7140,6 +8141,7 @@ class DaemonRuntime {
 }
 
 // src/cli.ts
+init_version();
 init_consumer_lock();
 var HELP_LINES = [
   "用法：",
@@ -7148,13 +8150,26 @@ var HELP_LINES = [
   "weacpx run    - 前台运行",
   "weacpx start  - 后台启动",
   "weacpx status - 查看状态",
-  "weacpx stop   - 停止服务"
+  "weacpx stop   - 停止服务",
+  "weacpx doctor - 运行诊断",
+  "weacpx version - 查看版本"
 ];
 async function runCli(args, deps = {}) {
   const command = args[0];
   const print = deps.print ?? ((line) => console.log(line));
-  const controller = deps.controller ?? createDefaultController();
   switch (command) {
+    case "version":
+    case "--version":
+    case "-v":
+      print(readVersion());
+      return 0;
+    case "--help":
+    case "-h": {
+      for (const line of HELP_LINES) {
+        print(line);
+      }
+      return 0;
+    }
     case "login":
       await (deps.login ?? defaultLogin)();
       return 0;
@@ -7164,7 +8179,18 @@ async function runCli(args, deps = {}) {
     case "run":
       await (deps.run ?? defaultRun)();
       return 0;
+    case "doctor": {
+      const parsed = parseDoctorArgs(args.slice(1));
+      if (!parsed.ok) {
+        for (const line of HELP_LINES) {
+          print(line);
+        }
+        return 1;
+      }
+      return await (deps.doctor ?? defaultDoctor)(parsed.options);
+    }
     case "start": {
+      const controller = deps.controller ?? createDefaultController();
       const result = await controller.start();
       if (result.state === "already-running") {
         print("weacpx 已在后台运行");
@@ -7176,6 +8202,7 @@ async function runCli(args, deps = {}) {
       return 0;
     }
     case "status": {
+      const controller = deps.controller ?? createDefaultController();
       const status = await controller.getStatus();
       if (status.state === "indeterminate") {
         print("weacpx 进程仍在运行，但状态元数据缺失");
@@ -7198,6 +8225,7 @@ async function runCli(args, deps = {}) {
       return 0;
     }
     case "stop": {
+      const controller = deps.controller ?? createDefaultController();
       const result = await controller.stop();
       if (result.detail === "not-running") {
         print("weacpx 未运行");
@@ -7214,8 +8242,8 @@ async function runCli(args, deps = {}) {
   }
 }
 async function defaultLogin() {
-  const { main: main3 } = await init_login().then(() => exports_login);
-  await main3();
+  const { main: main4 } = await init_login().then(() => exports_login);
+  await main4();
 }
 async function defaultLogout() {
   const { logout: logout2 } = await Promise.resolve().then(() => (init_weixin_sdk(), exports_weixin_sdk));
@@ -7232,7 +8260,7 @@ async function defaultRun() {
   const daemonRuntime = new DaemonRuntime(daemonPaths, { pid: process.pid });
   await runConsole2(runtimePaths, {
     buildApp: (paths) => buildApp2(paths, {
-      defaultLoggingLevel: resolveCliEntryPath().includes(`${sep}src${sep}`) ? "debug" : "info"
+      defaultLoggingLevel: resolveCliEntryPath2().includes(`${sep}src${sep}`) ? "debug" : "info"
     }),
     loadWeixinSdk: loadWeixinSdk2,
     daemonRuntime,
@@ -7244,27 +8272,66 @@ async function defaultRun() {
     })
   });
 }
+async function defaultDoctor(options) {
+  const { main: main4 } = await init_doctor2().then(() => exports_doctor);
+  return await main4(options);
+}
 function createDefaultController() {
   const daemonPaths = resolveDaemonPaths({ home: requireHome() });
   return createDaemonController(daemonPaths, {
     processExecPath: process.execPath,
-    cliEntryPath: resolveCliEntryPath(),
+    cliEntryPath: resolveCliEntryPath2(),
     cwd: process.cwd(),
     env: process.env
   });
 }
 function requireHome() {
-  const home = process.env.HOME ?? homedir6();
+  const home = process.env.HOME ?? homedir9();
   if (!home) {
     throw new Error("Unable to resolve the current user home directory");
   }
   return home;
 }
-function resolveCliEntryPath() {
+function resolveCliEntryPath2() {
   if (process.argv[1]) {
     return process.argv[1];
   }
-  return fileURLToPath4(import.meta.url);
+  return fileURLToPath5(import.meta.url);
+}
+function parseDoctorArgs(args) {
+  const options = {};
+  for (let index = 0;index < args.length; index++) {
+    const arg = args[index];
+    switch (arg) {
+      case "--verbose":
+        options.verbose = true;
+        break;
+      case "--smoke":
+        options.smoke = true;
+        break;
+      case "--agent": {
+        const value = args[index + 1];
+        if (!value || value.startsWith("--")) {
+          return { ok: false };
+        }
+        options.agent = value;
+        index++;
+        break;
+      }
+      case "--workspace": {
+        const value = args[index + 1];
+        if (!value || value.startsWith("--")) {
+          return { ok: false };
+        }
+        options.workspace = value;
+        index++;
+        break;
+      }
+      default:
+        return { ok: false };
+    }
+  }
+  return { ok: true, options };
 }
 if (__require.main == __require.module) {
   process.exitCode = await runCli(process.argv.slice(2));