@web-auto/webauto 0.1.8 → 0.1.9

package/apps/desktop-console/dist/main/index.mjs

@@ -1,10 +1,10 @@
 // src/main/index.mts
 import electron from "electron";
-import { spawn as spawn2 } from "node:child_process";
+import { spawn as spawn2, spawnSync as spawnSync2 } from "node:child_process";
 import os5 from "node:os";
-import path6 from "node:path";
+import path7 from "node:path";
 import { fileURLToPath as fileURLToPath2, pathToFileURL as pathToFileURL3 } from "node:url";
-import { mkdirSync, promises as fs4 } from "node:fs";
+import { mkdirSync, readFileSync, promises as fs4 } from "node:fs";
 
 // src/main/desktop-settings.mts
 import { existsSync, promises as fs } from "node:fs";
@@ -273,7 +273,9 @@ import path2 from "path";
 import { existsSync as existsSync2 } from "fs";
 import { fileURLToPath } from "url";
 var REPO_ROOT = path2.resolve(path2.dirname(fileURLToPath(import.meta.url)), "../../../..");
-var CORE_HEALTH_URLS = ["http://127.0.0.1:7701/health", "http://127.0.0.1:7704/health"];
+var UNIFIED_API_HEALTH_URL = "http://127.0.0.1:7701/health";
+var CAMO_RUNTIME_HEALTH_URL = "http://127.0.0.1:7704/health";
+var CORE_HEALTH_URLS = [UNIFIED_API_HEALTH_URL, CAMO_RUNTIME_HEALTH_URL];
 var START_API_SCRIPT = path2.join(REPO_ROOT, "runtime", "infra", "utils", "scripts", "service", "start-api.mjs");
 var STOP_API_SCRIPT = path2.join(REPO_ROOT, "runtime", "infra", "utils", "scripts", "service", "stop-api.mjs");
 function sleep(ms) {
@@ -323,6 +325,9 @@ async function areCoreServicesHealthy() {
   const health = await Promise.all(CORE_HEALTH_URLS.map((url) => checkHttpHealth(url)));
   return health.every(Boolean);
 }
+async function isUnifiedApiHealthy() {
+  return checkHttpHealth(UNIFIED_API_HEALTH_URL);
+}
 async function runNodeScript(scriptPath, timeoutMs) {
   return new Promise((resolve) => {
     const nodeBin = resolveNodeBin();
@@ -405,14 +410,18 @@ async function startCoreDaemon() {
     4e4
   );
   if (!startedBrowser) {
-    console.error("[CoreDaemonManager] Failed to start camo browser backend");
-    return false;
+    console.warn("[CoreDaemonManager] Failed to start camo browser backend, continue in degraded mode");
   }
   for (let i = 0; i < 20; i += 1) {
-    if (await areCoreServicesHealthy()) return true;
+    const [allHealthy, unifiedHealthy] = await Promise.all([
+      areCoreServicesHealthy(),
+      isUnifiedApiHealthy()
+    ]);
+    if (allHealthy) return true;
+    if (unifiedHealthy) return true;
     await sleep(300);
   }
-  console.error("[CoreDaemonManager] Services still unhealthy after start");
+  console.error("[CoreDaemonManager] Unified API still unhealthy after start");
   return false;
 }
 async function stopCoreDaemon() {
@@ -817,6 +826,13 @@ function resolvePathFromOutput(stdout) {
   }
   return "";
 }
+function resolveCamoufoxExecutable(installRoot) {
+  return process.platform === "win32" ? path4.join(installRoot, "camoufox.exe") : path4.join(installRoot, "camoufox");
+}
+function isValidCamoufoxInstallRoot(installRoot) {
+  if (!installRoot || !existsSync3(installRoot)) return false;
+  return existsSync3(resolveCamoufoxExecutable(installRoot));
+}
 async function checkCamoCli() {
   const camoCandidates = process.platform === "win32" ? ["camo.cmd", "camo.exe", "camo.bat", "camo.ps1"] : ["camo"];
   for (const candidate of camoCandidates) {
@@ -858,10 +874,12 @@ async function checkServices() {
 }
 async function checkFirefox() {
   const candidates = process.platform === "win32" ? [
+    { command: "camoufox", args: ["path"] },
     { command: "python", args: ["-m", "camoufox", "path"] },
     { command: "py", args: ["-3", "-m", "camoufox", "path"] },
     { command: resolveNpxBin2(), args: ["--yes", "--package=camoufox", "camoufox", "path"] }
   ] : [
+    { command: "camoufox", args: ["path"] },
     { command: "python3", args: ["-m", "camoufox", "path"] },
     { command: resolveNpxBin2(), args: ["--yes", "--package=camoufox", "camoufox", "path"] }
   ];
@@ -874,7 +892,10 @@ async function checkFirefox() {
       });
       if (ret.status !== 0) continue;
       const resolvedPath = resolvePathFromOutput(String(ret.stdout || ""));
-      return resolvedPath ? { installed: true, path: resolvedPath } : { installed: true };
+      if (resolvedPath && isValidCamoufoxInstallRoot(resolvedPath)) {
+        return { installed: true, path: resolvedPath };
+      }
+      if (!resolvedPath) return { installed: true };
     } catch {
     }
   }
@@ -894,8 +915,16 @@ async function checkEnvironment() {
     checkFirefox(),
     checkGeoIP()
   ]);
-  const allReady = camo.installed && services.unifiedApi && firefox.installed;
-  return { camo, services, firefox, geoip, allReady };
+  const browserReady = Boolean(firefox.installed || services.camoRuntime);
+  const missing = {
+    core: !services.unifiedApi,
+    runtimeService: !services.camoRuntime,
+    camo: !camo.installed,
+    runtime: !browserReady,
+    geoip: !geoip.installed
+  };
+  const allReady = camo.installed && services.unifiedApi && browserReady;
+  return { camo, services, firefox, geoip, browserReady, missing, allReady };
 }
 
 // src/main/ui-cli-bridge.mts
@@ -985,6 +1014,20 @@ function buildSnapshotScript() {
       if ('value' in el) return String(el.value ?? '');
       return String(el.textContent || '').trim();
     };
+    const firstText = (selectors) => {
+      for (const sel of selectors) {
+        const v = text(sel);
+        if (v) return v;
+      }
+      return '';
+    };
+    const firstValue = (selectors) => {
+      for (const sel of selectors) {
+        const v = value(sel);
+        if (v) return v;
+      }
+      return '';
+    };
     const activeTab = document.querySelector('.tab.active');
     const errors = Array.from(document.querySelectorAll('#recent-errors-list li'))
       .map((el) => String(el.textContent || '').trim())
@@ -1000,10 +1043,10 @@ function buildSnapshotScript() {
       currentPhase: text('#current-phase'),
       currentAction: text('#current-action'),
       progressPercent: text('#progress-percent'),
-      keyword: value('#keyword-input'),
-      target: value('#target-input'),
-      account: value('#account-select'),
-      env: value('#env-select'),
+      keyword: firstValue(['#task-keyword', '#keyword-input', '#task-keyword-input']),
+      target: firstValue(['#task-target', '#target-input', '#task-target-input']),
+      account: firstValue(['#task-account', '#task-profile', '#account-select']),
+      env: firstValue(['#task-env', '#env-select']),
       recentErrors: errors,
       ts: new Date().toISOString(),
     };
@@ -1451,28 +1494,337 @@ var UiCliBridge = class {
   }
 };
 
+// src/main/task-gateway.mts
+import path6 from "node:path";
+var KEYWORD_REQUIRED_TYPES = /* @__PURE__ */ new Set(["xhs-unified", "weibo-search", "1688-search"]);
+var RUN_AT_TYPES = /* @__PURE__ */ new Set(["once", "daily", "weekly"]);
+function asText(value) {
+  return String(value ?? "").trim();
+}
+function asPositiveInt(value, fallback) {
+  const n = Number(value);
+  if (!Number.isFinite(n) || n <= 0) return fallback;
+  return Math.max(1, Math.floor(n));
+}
+function asBool(value, fallback) {
+  if (typeof value === "boolean") return value;
+  const text = asText(value).toLowerCase();
+  if (!text) return fallback;
+  if (["1", "true", "yes", "y", "on"].includes(text)) return true;
+  if (["0", "false", "no", "n", "off"].includes(text)) return false;
+  return fallback;
+}
+function asOptionalRunAt(value) {
+  const runAt = asText(value);
+  return runAt ? runAt : null;
+}
+function normalizeScheduleType(value) {
+  const raw = asText(value);
+  if (raw === "once" || raw === "daily" || raw === "weekly") return raw;
+  return "interval";
+}
+function deriveTaskName(commandType, argv) {
+  const keyword = asText(argv.keyword);
+  const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
+  return keyword ? `${commandType}-${keyword}` : `${commandType}-${stamp}`;
+}
+function getPlatformFromCommandType(commandType) {
+  const value = asText(commandType).toLowerCase();
+  if (value.startsWith("weibo")) return "weibo";
+  if (value.startsWith("1688")) return "1688";
+  return "xiaohongshu";
+}
+function hasExplicitProfileArg(argv) {
+  return Boolean(asText(argv?.profile) || asText(argv?.profiles) || asText(argv?.profilepool));
+}
+async function pickDefaultProfileForPlatform(options, platform) {
+  const accountScript = path6.join(options.repoRoot, "apps", "webauto", "entry", "account.mjs");
+  const ret = await options.runJson({
+    title: `account list --platform ${platform}`,
+    cwd: options.repoRoot,
+    args: [accountScript, "list", "--platform", platform, "--json"],
+    timeoutMs: 2e4
+  });
+  if (!ret?.ok) return "";
+  const rows = Array.isArray(ret?.json?.profiles) ? ret.json.profiles : [];
+  const validRows = rows.filter((row) => row?.valid === true && asText(row?.accountId)).sort((a, b) => {
+    const ta = Date.parse(asText(a?.updatedAt) || "") || 0;
+    const tb = Date.parse(asText(b?.updatedAt) || "") || 0;
+    if (tb !== ta) return tb - ta;
+    return asText(a?.profileId).localeCompare(asText(b?.profileId));
+  });
+  return asText(validRows[0]?.profileId) || "";
+}
+async function ensureProfileArg(options, commandType, argv) {
+  if (hasExplicitProfileArg(argv)) return argv;
+  const platform = getPlatformFromCommandType(commandType);
+  const profileId = await pickDefaultProfileForPlatform(options, platform);
+  if (!profileId) {
+    throw new Error(`\u672A\u6307\u5B9A Profile\uFF0C\u4E14\u672A\u627E\u5230\u5E73\u53F0(${platform})\u6709\u6548\u8D26\u53F7\u3002\u8BF7\u5148\u5728\u8D26\u53F7\u9875\u767B\u5F55\u5E76\u6821\u9A8C\u540E\u91CD\u8BD5\u3002`);
+  }
+  return {
+    ...argv,
+    profile: profileId
+  };
+}
+function normalizeWeiboTaskType(commandType) {
+  if (commandType === "weibo-search") return "search";
+  if (commandType === "weibo-monitor") return "monitor";
+  return "timeline";
+}
+function createUiTriggerId() {
+  return `ui-${Date.now()}-${Math.random().toString(16).slice(2, 10)}`;
+}
+function normalizeSavePayload(payload) {
+  const commandType = asText(payload?.commandType) || "xhs-unified";
+  const argv = payload?.argv && typeof payload.argv === "object" ? { ...payload.argv } : {};
+  const scheduleType = normalizeScheduleType(payload?.scheduleType);
+  const runAt = asOptionalRunAt(payload?.runAt);
+  const intervalMinutes = asPositiveInt(payload?.intervalMinutes, 30);
+  const maxRunsRaw = Number(payload?.maxRuns);
+  const maxRuns = Number.isFinite(maxRunsRaw) && maxRunsRaw > 0 ? Math.max(1, Math.floor(maxRunsRaw)) : null;
+  const name = asText(payload?.name) || deriveTaskName(commandType, argv);
+  const enabled = asBool(payload?.enabled, true);
+  const id = asText(payload?.id);
+  if (KEYWORD_REQUIRED_TYPES.has(commandType) && !asText(argv.keyword)) {
+    throw new Error("\u5173\u952E\u8BCD\u4E0D\u80FD\u4E3A\u7A7A");
+  }
+  if (commandType.startsWith("weibo-")) {
+    argv["task-type"] = asText(argv["task-type"]) || normalizeWeiboTaskType(commandType);
+    if (commandType === "weibo-monitor" && !asText(argv["user-id"])) {
+      throw new Error("\u5FAE\u535A monitor \u4EFB\u52A1\u9700\u8981 user-id");
+    }
+  }
+  if (RUN_AT_TYPES.has(scheduleType) && !runAt) {
+    throw new Error(`${scheduleType} \u4EFB\u52A1\u9700\u8981\u951A\u70B9\u65F6\u95F4`);
+  }
+  return {
+    id,
+    name,
+    enabled,
+    commandType,
+    scheduleType,
+    intervalMinutes,
+    runAt,
+    maxRuns,
+    argv
+  };
+}
+async function runScheduleJson(options, args, timeoutMs) {
+  const script = path6.join(options.repoRoot, "apps", "webauto", "entry", "schedule.mjs");
+  const ret = await options.runJson({
+    title: `schedule ${args.join(" ")}`.trim(),
+    cwd: options.repoRoot,
+    args: [script, ...args, "--json"],
+    timeoutMs: typeof timeoutMs === "number" && timeoutMs > 0 ? timeoutMs : void 0
+  });
+  if (!ret?.ok) {
+    const reason = asText(ret?.error) || asText(ret?.stderr) || asText(ret?.stdout) || "schedule command failed";
+    return { ok: false, error: reason };
+  }
+  return { ok: true, json: ret?.json || {} };
+}
+async function scheduleInvoke(options, input) {
+  try {
+    const action = asText(input?.action);
+    const timeoutMs = input?.timeoutMs;
+    if (action === "list") return runScheduleJson(options, ["list"], timeoutMs);
+    if (action === "get") {
+      const taskId = asText(input?.taskId);
+      if (!taskId) return { ok: false, error: "missing taskId" };
+      return runScheduleJson(options, ["get", taskId], timeoutMs);
+    }
+    if (action === "save") {
+      const payload = normalizeSavePayload(input?.payload);
+      payload.argv = await ensureProfileArg(options, payload.commandType, payload.argv);
+      const args = payload.id ? ["update", payload.id] : ["add"];
+      args.push("--name", payload.name);
+      args.push("--enabled", String(payload.enabled));
+      args.push("--command-type", payload.commandType);
+      args.push("--schedule-type", payload.scheduleType);
+      if (RUN_AT_TYPES.has(payload.scheduleType)) {
+        args.push("--run-at", String(payload.runAt || ""));
+      } else {
+        args.push("--interval-minutes", String(payload.intervalMinutes));
+      }
+      args.push("--max-runs", payload.maxRuns === null ? "0" : String(payload.maxRuns));
+      args.push("--argv-json", JSON.stringify(payload.argv));
+      return runScheduleJson(options, args, timeoutMs);
+    }
+    if (action === "run") {
+      const taskId = asText(input?.taskId);
+      if (!taskId) return { ok: false, error: "missing taskId" };
+      return runScheduleJson(options, ["run", taskId], timeoutMs);
+    }
+    if (action === "delete") {
+      const taskId = asText(input?.taskId);
+      if (!taskId) return { ok: false, error: "missing taskId" };
+      return runScheduleJson(options, ["delete", taskId], timeoutMs);
+    }
+    if (action === "export") {
+      const taskId = asText(input?.taskId);
+      return taskId ? runScheduleJson(options, ["export", taskId], timeoutMs) : runScheduleJson(options, ["export"], timeoutMs);
+    }
+    if (action === "import") {
+      const payloadJson = asText(input?.payloadJson);
+      if (!payloadJson) return { ok: false, error: "missing payloadJson" };
+      const mode = asText(input?.mode) === "replace" ? "replace" : "merge";
+      return runScheduleJson(options, ["import", "--payload-json", payloadJson, "--mode", mode], timeoutMs);
+    }
+    if (action === "run-due") {
+      const limit = asPositiveInt(input?.limit, 20);
+      return runScheduleJson(options, ["run-due", "--limit", String(limit)], timeoutMs);
+    }
+    if (action === "daemon-start") {
+      const interval = asPositiveInt(input?.intervalSec, 30);
+      const limit = asPositiveInt(input?.limit, 20);
+      const script = path6.join(options.repoRoot, "apps", "webauto", "entry", "schedule.mjs");
+      const ret = await options.spawnCommand({
+        title: `schedule daemon ${interval}s`,
+        cwd: options.repoRoot,
+        args: [script, "daemon", "--interval-sec", String(Math.max(5, interval)), "--limit", String(limit), "--json"],
+        groupKey: "scheduler"
+      });
+      return { ok: true, runId: asText(ret?.runId) };
+    }
+    return { ok: false, error: `unsupported action: ${action || "<empty>"}` };
+  } catch (err) {
+    return { ok: false, error: err?.message || String(err) };
+  }
+}
+async function runEphemeralTask(options, input) {
+  try {
+    const commandType = asText(input?.commandType) || "xhs-unified";
+    let argv = input?.argv && typeof input.argv === "object" ? { ...input.argv } : {};
+    argv = await ensureProfileArg(options, commandType, argv);
+    const profile = asText(argv.profile);
+    const keyword = asText(argv.keyword);
+    const target = asPositiveInt(argv["max-notes"] ?? argv.target, 50);
+    const env = asText(argv.env) || "debug";
+    if (!profile) return { ok: false, error: "\u8BF7\u8F93\u5165 Profile ID" };
+    if (KEYWORD_REQUIRED_TYPES.has(commandType) && !keyword) {
+      return { ok: false, error: "\u8BF7\u8F93\u5165\u5173\u952E\u8BCD" };
+    }
+    if (commandType === "xhs-unified") {
+      const uiTriggerId = createUiTriggerId();
+      const script = path6.join(options.repoRoot, "apps", "webauto", "entry", "xhs-unified.mjs");
+      const ret = await options.spawnCommand({
+        title: `xhs unified: ${keyword}`,
+        cwd: options.repoRoot,
+        groupKey: "xhs-unified",
+        args: [
+          script,
+          "--profile",
+          profile,
+          "--keyword",
+          keyword,
+          "--target",
+          String(target),
+          "--max-notes",
+          String(target),
+          "--env",
+          env,
+          "--do-comments",
+          String(asBool(argv["do-comments"], true)),
+          "--fetch-body",
+          String(asBool(argv["fetch-body"], true)),
+          "--do-likes",
+          String(asBool(argv["do-likes"], false)),
+          "--like-keywords",
+          asText(argv["like-keywords"]),
+          "--ui-trigger-id",
+          uiTriggerId
+        ]
+      });
+      return { ok: true, runId: asText(ret?.runId), commandType, profile, uiTriggerId };
+    }
+    if (commandType === "weibo-search") {
+      const script = path6.join(options.repoRoot, "apps", "webauto", "entry", "weibo-unified.mjs");
+      const ret = await options.spawnCommand({
+        title: `weibo: ${keyword}`,
+        cwd: options.repoRoot,
+        groupKey: "weibo-search",
+        args: [
+          script,
+          "search",
+          "--profile",
+          profile,
+          "--keyword",
+          keyword,
+          "--target",
+          String(target),
+          "--env",
+          env
+        ]
+      });
+      return { ok: true, runId: asText(ret?.runId), commandType, profile };
+    }
+    return { ok: false, error: `\u5F53\u524D\u4EFB\u52A1\u7C7B\u578B\u6682\u4E0D\u652F\u6301\u4EC5\u6267\u884C(\u4E0D\u4FDD\u5B58): ${commandType}` };
+  } catch (err) {
+    return { ok: false, error: err?.message || String(err) };
+  }
+}
+
 // src/main/index.mts
 var { app, BrowserWindow: BrowserWindow2, ipcMain: ipcMain2, shell, clipboard } = electron;
-var __dirname = path6.dirname(fileURLToPath2(import.meta.url));
-var APP_ROOT = path6.resolve(__dirname, "../..");
-var REPO_ROOT2 = path6.resolve(APP_ROOT, "../..");
-var DESKTOP_HEARTBEAT_FILE = path6.join(
+var spawnedBrowserProcesses = /* @__PURE__ */ new Set();
+function trackBrowserProcess(pid) {
+  if (pid > 0) {
+    spawnedBrowserProcesses.add(pid);
+  }
+}
+function cleanupAllBrowserProcesses(reason = "ui_close") {
+  console.log(`[process-cleanup] Cleaning up ${spawnedBrowserProcesses.size} browser process(s) (${reason})`);
+  for (const pid of spawnedBrowserProcesses) {
+    try {
+      if (process.platform === "win32") {
+        spawn2("taskkill", ["/PID", String(pid), "/T", "/F"], { stdio: "ignore", windowsHide: true });
+      } else {
+        process.kill(pid, "SIGTERM");
+      }
+    } catch (err) {
+      console.warn(`[process-cleanup] Failed to kill PID ${pid}:`, err);
+    }
+  }
+  spawnedBrowserProcesses.clear();
+  console.log(`[process-cleanup] Cleanup complete`);
+}
+var __dirname = path7.dirname(fileURLToPath2(import.meta.url));
+var APP_ROOT = path7.resolve(__dirname, "../..");
+var REPO_ROOT2 = path7.resolve(APP_ROOT, "../..");
+function readJsonVersion(filePath) {
+  try {
+    const json = JSON.parse(readFileSync(filePath, "utf8"));
+    return String(json?.version || "").trim();
+  } catch {
+    return "";
+  }
+}
+function resolveVersionInfo() {
+  const webauto = readJsonVersion(path7.join(REPO_ROOT2, "package.json")) || "0.0.0";
+  const desktop = readJsonVersion(path7.join(APP_ROOT, "package.json")) || webauto;
+  const windowTitle = `WebAuto Desktop v${webauto}`;
+  const badge = desktop === webauto ? `v${webauto}` : `webauto v${webauto} \xB7 console v${desktop}`;
+  return { webauto, desktop, windowTitle, badge };
+}
+var VERSION_INFO = resolveVersionInfo();
+var DESKTOP_HEARTBEAT_FILE = path7.join(
   os5.homedir(),
   ".webauto",
   "run",
   "desktop-console-heartbeat.json"
 );
 var profileStore = createProfileStore({ repoRoot: REPO_ROOT2 });
-var XHS_SCRIPTS_ROOT = path6.join(REPO_ROOT2, "scripts", "xiaohongshu");
+var XHS_SCRIPTS_ROOT = path7.join(REPO_ROOT2, "scripts", "xiaohongshu");
 var XHS_FULL_COLLECT_RE = /collect-content\.mjs$/;
 function configureElectronPaths() {
   try {
     const downloadRoot = resolveDefaultDownloadRoot();
-    const normalized = path6.normalize(downloadRoot);
-    const baseDir = path6.basename(normalized).toLowerCase() === "download" ? path6.dirname(normalized) : normalized;
-    const userDataRoot = path6.join(baseDir, "desktop-console");
-    const cacheRoot = path6.join(userDataRoot, "cache");
-    const gpuCacheRoot = path6.join(cacheRoot, "gpu");
+    const normalized = path7.normalize(downloadRoot);
+    const baseDir = path7.basename(normalized).toLowerCase() === "download" ? path7.dirname(normalized) : normalized;
+    const userDataRoot = path7.join(baseDir, "desktop-console");
+    const cacheRoot = path7.join(userDataRoot, "cache");
+    const gpuCacheRoot = path7.join(cacheRoot, "gpu");
     try {
       mkdirSync(cacheRoot, { recursive: true });
     } catch {
@@ -1485,6 +1837,17 @@ function configureElectronPaths() {
     app.setPath("cache", cacheRoot);
     app.commandLine.appendSwitch("disk-cache-dir", cacheRoot);
     app.commandLine.appendSwitch("gpu-cache-dir", gpuCacheRoot);
+    const disableGpuByDefault = process.platform === "win32" && String(process.env.WEBAUTO_ELECTRON_DISABLE_GPU || "1").trim() !== "0";
+    if (disableGpuByDefault) {
+      try {
+        app.disableHardwareAcceleration();
+      } catch {
+      }
+      app.commandLine.appendSwitch("disable-gpu");
+      app.commandLine.appendSwitch("disable-gpu-compositing");
+      app.commandLine.appendSwitch("disable-direct-composition");
+      app.commandLine.appendSwitch("use-angle", "swiftshader");
+    }
   } catch (err) {
     console.warn("[desktop-console] failed to configure cache paths", err);
   }
@@ -1514,8 +1877,35 @@ var GroupQueue = class {
 };
 var groupQueues = /* @__PURE__ */ new Map();
 var runs = /* @__PURE__ */ new Map();
+var runLifecycle = /* @__PURE__ */ new Map();
 var trackedRunPids = /* @__PURE__ */ new Set();
 var appExitCleanupPromise = null;
+function setRunLifecycle(runId, patch) {
+  const rid = String(runId || "").trim();
+  if (!rid) return;
+  const current = runLifecycle.get(rid) || {
+    runId: rid,
+    state: "queued",
+    title: "",
+    queuedAt: now()
+  };
+  const next = {
+    ...current,
+    ...patch,
+    runId: rid
+  };
+  runLifecycle.set(rid, next);
+  if (runLifecycle.size > 400) {
+    const rows = Array.from(runLifecycle.values()).sort((a, b) => (a.queuedAt || 0) - (b.queuedAt || 0));
+    const toDrop = rows.slice(0, Math.max(0, rows.length - 200));
+    for (const row of toDrop) runLifecycle.delete(row.runId);
+  }
+}
+function getRunLifecycle(runId) {
+  const rid = String(runId || "").trim();
+  if (!rid) return null;
+  return runLifecycle.get(rid) || null;
+}
 var UI_HEARTBEAT_TIMEOUT_MS = resolveUiHeartbeatTimeoutMs(process.env);
 var lastUiHeartbeatAt = Date.now();
 var heartbeatWatchdog = null;
@@ -1523,6 +1913,16 @@ var heartbeatTimeoutHandled = false;
 var coreServicesStopRequested = false;
 var coreServiceHeartbeatTimer = null;
 var coreServiceHeartbeatStopped = false;
+var RUN_LOG_DIR = path7.join(os5.homedir(), ".webauto", "logs");
+function appendRunLog(runId, line) {
+  const rid = String(runId || "").trim();
+  const text = String(line || "").replace(/\r?\n/g, " ").trim();
+  if (!rid || !text) return;
+  const logPath = path7.join(RUN_LOG_DIR, `ui-run-${rid}.log`);
+  void fs4.mkdir(RUN_LOG_DIR, { recursive: true }).then(() => fs4.appendFile(logPath, `${text}
+`, "utf8")).catch(() => {
+  });
+}
 async function writeCoreServiceHeartbeat(status) {
   const filePath = String(process.env.WEBAUTO_HEARTBEAT_FILE || DESKTOP_HEARTBEAT_FILE).trim() || DESKTOP_HEARTBEAT_FILE;
   const payload = {
@@ -1532,7 +1932,7 @@ async function writeCoreServiceHeartbeat(status) {
     source: "desktop-console"
   };
   try {
-    await fs4.mkdir(path6.dirname(filePath), { recursive: true });
+    await fs4.mkdir(path7.dirname(filePath), { recursive: true });
     await fs4.writeFile(filePath, JSON.stringify(payload), "utf8");
   } catch {
   }
@@ -1682,7 +2082,7 @@ async function cleanupTrackedRunPidsBestEffort(reason) {
   }
 }
 async function cleanupCamoSessionsBestEffort(reason, includeLocks) {
-  const camoCli = path6.join(REPO_ROOT2, "bin", "camoufox-cli.mjs");
+  const camoCli = path7.join(REPO_ROOT2, "bin", "camoufox-cli.mjs");
   const invoke = async (args, timeoutMs = 6e4) => runJson({
     title: `camo ${args.join(" ")}`,
     cwd: REPO_ROOT2,
@@ -1703,6 +2103,7 @@ async function cleanupRuntimeEnvironment(reason, options = {}) {
   killAllRuns(reason);
   await cleanupTrackedRunPidsBestEffort(reason);
   await cleanupCamoSessionsBestEffort(reason, options.includeLockCleanup !== false);
+  cleanupAllBrowserProcesses(reason);
   if (options.stopUiBridge) {
     await uiCliBridge.stop().catch(() => null);
   }
@@ -1775,12 +2176,13 @@ function getQueue(groupKey) {
 function generateRunId() {
   return `run_${Date.now()}_${Math.random().toString(16).slice(2, 8)}`;
 }
-function createLineEmitter(runId, type) {
+function createLineEmitter(runId, type, onLine) {
   let pending = "";
   const emit = (line) => {
     const normalized = String(line || "").replace(/\r$/, "");
     if (!normalized) return;
     sendEvent({ type, runId, line: normalized, ts: now() });
+    if (typeof onLine === "function") onLine(normalized);
   };
   return {
     push(chunk) {
@@ -1804,19 +2206,44 @@ function resolveNodeBin2() {
   const explicit = String(process.env.WEBAUTO_NODE_BIN || "").trim();
   if (explicit) return explicit;
   const npmNode = String(process.env.npm_node_execpath || "").trim();
-  if (npmNode) return npmNode;
+  if (npmNode) {
+    const base = path7.basename(npmNode).toLowerCase();
+    const isNode = base === "node" || base === "node.exe";
+    if (isNode) return npmNode;
+  }
   return process.platform === "win32" ? "node.exe" : "node";
 }
 function resolveCwd(input) {
   const raw = String(input || "").trim();
   if (!raw) return REPO_ROOT2;
-  return path6.isAbsolute(raw) ? raw : path6.resolve(REPO_ROOT2, raw);
+  return path7.isAbsolute(raw) ? raw : path7.resolve(REPO_ROOT2, raw);
+}
+function isPidAlive(pid) {
+  const target = Number(pid || 0);
+  if (!Number.isFinite(target) || target <= 0) return false;
+  if (process.platform === "win32") {
+    const ret = spawnSync2("tasklist", ["/FI", `PID eq ${target}`], {
+      windowsHide: true,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const out = String(ret.stdout || "");
+    if (!out) return false;
+    const lines = out.split(/\r?\n/g).map((line) => line.trim()).filter(Boolean);
+    return lines.some((line) => line.includes(` ${target}`));
+  }
+  try {
+    process.kill(target, 0);
+    return true;
+  } catch {
+    return false;
+  }
 }
 var cachedStateMod = null;
 async function getStateModule() {
   if (cachedStateMod) return cachedStateMod;
   try {
-    const p = path6.join(REPO_ROOT2, "dist", "modules", "state", "src", "xiaohongshu-collect-state.js");
+    const p = path7.join(REPO_ROOT2, "dist", "modules", "state", "src", "xiaohongshu-collect-state.js");
     cachedStateMod = await import(pathToFileURL3(p).href);
     return cachedStateMod;
   } catch {
@@ -1830,6 +2257,12 @@ async function spawnCommand(spec) {
   const q = getQueue(groupKey);
   const cwd = resolveCwd(spec.cwd);
   const args = Array.isArray(spec.args) ? spec.args : [];
+  appendRunLog(runId, `[queued] title=${String(spec.title || "").trim() || "-"} cwd=${cwd}`);
+  setRunLifecycle(runId, {
+    state: "queued",
+    title: String(spec.title || ""),
+    queuedAt: now()
+  });
   const isXhsRunCommand = args.some((item) => /xhs-(orchestrate|unified)\.mjs$/i.test(String(item || "").replace(/\\/g, "/")));
   const extractProfilesFromArgs = (argv) => {
     const out = [];
@@ -1862,49 +2295,133 @@ async function spawnCommand(spec) {
       let finished = false;
       let exitCode = null;
       let exitSignal = null;
+      let orphanCheckTimer = null;
       const finalize = (code, signal) => {
         if (finished) return;
         finished = true;
+        if (orphanCheckTimer) {
+          clearInterval(orphanCheckTimer);
+          orphanCheckTimer = null;
+        }
+        setRunLifecycle(runId, {
+          state: "exited",
+          exitedAt: now(),
+          exitCode: code,
+          signal
+        });
         sendEvent({ type: "exit", runId, exitCode: code, signal, ts: now() });
+        appendRunLog(runId, `[exit] code=${code ?? "null"} signal=${signal ?? "null"}`);
         runs.delete(runId);
         resolve();
       };
-      const child = spawn2(resolveNodeBin2(), args, {
-        cwd,
-        env: {
-          ...process.env,
-          WEBAUTO_DAEMON: "1",
-          WEBAUTO_UI_HEARTBEAT: "1",
-          ...spec.env || {}
-        },
-        stdio: ["ignore", "pipe", "pipe"],
-        windowsHide: true
-      });
+      let child;
+      try {
+        const nodeBin = resolveNodeBin2();
+        appendRunLog(runId, `[cmd] ${nodeBin}`);
+        child = spawn2(nodeBin, args, {
+          cwd,
+          env: {
+            ...process.env,
+            ...spec.env || {}
+          },
+          stdio: ["ignore", "pipe", "pipe"],
+          windowsHide: true
+        });
+      } catch (err) {
+        const message = err?.message || String(err);
+        setRunLifecycle(runId, {
+          state: "exited",
+          exitedAt: now(),
+          exitCode: null,
+          signal: "spawn_exception",
+          lastError: message
+        });
+        sendEvent({ type: "stderr", runId, line: `[spawn-throw] ${message}`, ts: now() });
+        appendRunLog(runId, `[spawn-throw] ${message}`);
+        finalize(null, "spawn_exception");
+        return;
+      }
+      const stdoutLines = createLineEmitter(runId, "stdout", (line) => appendRunLog(runId, `[stdout] ${line}`));
+      const stderrLines = createLineEmitter(runId, "stderr", (line) => appendRunLog(runId, `[stderr] ${line}`));
+      try {
+        child.stdout?.on("data", (chunk) => {
+          stdoutLines.push(chunk);
+        });
+        child.stderr?.on("data", (chunk) => {
+          const text = chunk.toString("utf8");
+          const lines = text.split(/\r?\n/g).map((line) => line.trim()).filter(Boolean);
+          if (lines.length > 0) {
+            setRunLifecycle(runId, { lastError: lines[lines.length - 1] });
+          }
+          stderrLines.push(chunk);
+        });
+        child.on("error", (err) => {
+          const message = err?.message || String(err);
+          setRunLifecycle(runId, { lastError: message });
+          sendEvent({ type: "stderr", runId, line: `[spawn-error] ${message}`, ts: now() });
+          appendRunLog(runId, `[spawn-error] ${message}`);
+          finalize(null, "error");
+        });
+        child.on("exit", (code, signal) => {
+          exitCode = code;
+          exitSignal = signal;
+          const timer = setTimeout(() => {
+            if (finished) return;
+            untrackRunPid(child);
+            stdoutLines.flush();
+            stderrLines.flush();
+            finalize(exitCode ?? null, exitSignal ?? null);
+          }, 200);
+          if (timer && typeof timer.unref === "function") {
+            timer.unref();
+          }
+        });
+        child.on("close", (code, signal) => {
+          untrackRunPid(child);
+          stdoutLines.flush();
+          stderrLines.flush();
+          finalize(exitCode ?? code ?? null, exitSignal ?? signal ?? null);
+        });
+      } catch (err) {
+        const message = err?.message || String(err);
+        setRunLifecycle(runId, { lastError: message });
+        sendEvent({ type: "stderr", runId, line: `[spawn-setup-error] ${message}`, ts: now() });
+        appendRunLog(runId, `[spawn-setup-error] ${message}`);
+        finalize(null, "setup_error");
+        return;
+      }
       trackRunPid(child);
+      if (child.pid) {
+        trackBrowserProcess(child.pid);
+      }
       runs.set(runId, { child, title: spec.title, startedAt: now(), profiles: requestedProfiles });
-      sendEvent({ type: "started", runId, title: spec.title, pid: child.pid ?? -1, ts: now() });
-      const stdoutLines = createLineEmitter(runId, "stdout");
-      const stderrLines = createLineEmitter(runId, "stderr");
-      child.stdout?.on("data", (chunk) => {
-        stdoutLines.push(chunk);
-      });
-      child.stderr?.on("data", (chunk) => {
-        stderrLines.push(chunk);
-      });
-      child.on("error", (err) => {
-        sendEvent({ type: "stderr", runId, line: `[spawn-error] ${err?.message || String(err)}`, ts: now() });
-        finalize(null, "error");
-      });
-      child.on("exit", (code, signal) => {
-        exitCode = code;
-        exitSignal = signal;
-      });
-      child.on("close", (code, signal) => {
-        untrackRunPid(child);
-        stdoutLines.flush();
-        stderrLines.flush();
-        finalize(exitCode ?? code ?? null, exitSignal ?? signal ?? null);
+      setRunLifecycle(runId, {
+        state: "running",
+        startedAt: now(),
+        pid: child.pid || -1,
+        title: String(spec.title || "")
       });
+      sendEvent({ type: "started", runId, title: spec.title, pid: child.pid ?? -1, ts: now() });
+      appendRunLog(runId, `[started] pid=${child.pid ?? -1} title=${String(spec.title || "").trim() || "-"}`);
+      if (args.length > 0) {
+        appendRunLog(runId, `[args] ${args.join(" ")}`);
+      }
+      const pid = Number(child.pid || 0);
+      if (pid > 0) {
+        orphanCheckTimer = setInterval(() => {
+          if (finished) return;
+          if (!isPidAlive(pid)) {
+            untrackRunPid(child);
+            stdoutLines.flush();
+            stderrLines.flush();
+            appendRunLog(runId, "[watchdog] child pid disappeared before close/exit event");
+            finalize(exitCode, exitSignal || "pid_gone");
+          }
+        }, 1e3);
+        if (orphanCheckTimer && typeof orphanCheckTimer.unref === "function") {
+          orphanCheckTimer.unref();
+        }
+      }
     })
   );
   return { runId };
@@ -1944,9 +2461,106 @@ async function runJson(spec) {
     return { ok: true, code, stdout: out, stderr: err };
   }
 }
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, Math.max(0, ms)));
+}
+function toEpochMs(value) {
+  const raw = String(value ?? "").trim();
+  if (!raw) return 0;
+  const asNum = Number(raw);
+  if (Number.isFinite(asNum) && asNum > 0) return asNum;
+  const asDate = Date.parse(raw);
+  return Number.isFinite(asDate) ? asDate : 0;
+}
+function resolveUnifiedApiBaseUrl() {
+  return String(
+    process.env.WEBAUTO_UNIFIED_API || process.env.WEBAUTO_UNIFIED_URL || "http://127.0.0.1:7701"
+  ).trim().replace(/\/+$/, "");
+}
+async function listUnifiedTasks() {
+  const baseUrl = resolveUnifiedApiBaseUrl();
+  const res = await fetch(`${baseUrl}/api/v1/tasks`, { signal: AbortSignal.timeout(3e3) });
+  if (!res.ok) throw new Error(`HTTP ${res.status}`);
+  const payload = await res.json().catch(() => ({}));
+  return Array.isArray(payload?.data) ? payload.data : [];
+}
+function pickUnifiedRunId(tasks, options) {
+  const profileId = String(options.profileId || "").trim();
+  const keyword = String(options.keyword || "").trim();
+  const uiTriggerId = String(options.uiTriggerId || "").trim();
+  const minTs = Number(options.minTs || 0);
+  const baselineRunIds = options.baselineRunIds instanceof Set ? options.baselineRunIds : /* @__PURE__ */ new Set();
+  const rows = tasks.filter((task) => {
+    const runId = String(task?.runId || task?.id || "").trim();
+    if (!runId) return false;
+    if (baselineRunIds.has(runId)) return false;
+    const phase = String(task?.phase || task?.lastPhase || "").trim().toLowerCase();
+    if (phase !== "unified") return false;
+    const taskProfile = String(task?.profileId || "").trim();
+    const taskKeyword = String(task?.keyword || "").trim();
+    const taskTrigger = String(
+      task?.uiTriggerId || task?.triggerId || task?.meta?.uiTriggerId || task?.context?.uiTriggerId || ""
+    ).trim();
+    if (uiTriggerId && taskTrigger !== uiTriggerId) return false;
+    if (profileId && taskProfile && taskProfile !== profileId) return false;
+    if (keyword && taskKeyword && taskKeyword !== keyword) return false;
+    const createdTs = toEpochMs(task?.createdAt);
+    const startedTs = toEpochMs(task?.startedAt);
+    const ts = createdTs || startedTs;
+    return ts >= minTs;
+  }).sort((a, b) => {
+    const ta = toEpochMs(a?.createdAt) || toEpochMs(a?.startedAt);
+    const tb = toEpochMs(b?.createdAt) || toEpochMs(b?.startedAt);
+    return tb - ta;
+  });
+  const picked = rows[0] || null;
+  return String(picked?.runId || picked?.id || "").trim();
+}
+async function waitForUnifiedRunRegistration(input) {
+  const desktopRunId = String(input.desktopRunId || "").trim();
+  const profileId = String(input.profileId || "").trim();
+  const keyword = String(input.keyword || "").trim();
+  const uiTriggerId = String(input.uiTriggerId || "").trim();
+  const timeoutMs = Math.max(2e3, Number(input.timeoutMs || 2e4) || 2e4);
+  const startedAt = Date.now();
+  const minTs = startedAt - 3e4;
+  const baselineRunIds = input.baselineRunIds instanceof Set ? input.baselineRunIds : /* @__PURE__ */ new Set();
+  let lastFetchError = "";
+  while (Date.now() - startedAt < timeoutMs) {
+    try {
+      const tasks = await listUnifiedTasks();
+      const unifiedRunId = pickUnifiedRunId(tasks, {
+        profileId,
+        keyword,
+        uiTriggerId,
+        minTs,
+        baselineRunIds
+      });
+      if (unifiedRunId) return { ok: true, runId: unifiedRunId };
+      lastFetchError = "";
+    } catch (err) {
+      lastFetchError = err?.message || String(err);
+    }
+    const lifecycle2 = getRunLifecycle(desktopRunId);
+    if (lifecycle2?.state === "exited") {
+      const detail = lifecycle2.lastError || `exit=${lifecycle2.exitCode ?? "null"}`;
+      return { ok: false, error: `\u4EFB\u52A1\u8FDB\u7A0B\u63D0\u524D\u9000\u51FA\uFF0C\u672A\u6CE8\u518C unified runId (${detail})` };
+    }
+    await sleep2(500);
+  }
+  const lifecycle = getRunLifecycle(desktopRunId);
+  if (lifecycle?.state === "queued") {
+    return { ok: false, error: "\u4EFB\u52A1\u4ECD\u5728\u6392\u961F\uFF0C\u672A\u8FDB\u5165\u8FD0\u884C\u6001\uFF08\u8BF7\u68C0\u67E5\u662F\u5426\u6709\u540C\u7C7B\u4EFB\u52A1\u5360\u7528\uFF09" };
+  }
+  if (lifecycle?.state === "running") {
+    return { ok: false, error: "\u4EFB\u52A1\u8FDB\u7A0B\u5DF2\u542F\u52A8\uFF0C\u4F46\u5728\u8D85\u65F6\u5185\u672A\u6CE8\u518C unified runId" };
+  }
+  const suffix = lastFetchError ? `: ${lastFetchError}` : "";
+  return { ok: false, error: `\u672A\u68C0\u6D4B\u5230 unified runId${suffix}` };
+}
 async function scanResults(input) {
   const downloadRoot = String(input.downloadRoot || resolveDefaultDownloadRoot());
-  const root = path6.join(downloadRoot, "xiaohongshu");
+  const root = path7.join(downloadRoot, "xiaohongshu");
   const result = { ok: true, root, entries: [] };
   try {
     const stateMod = await getStateModule();
@@ -1954,12 +2568,12 @@ async function scanResults(input) {
     for (const envEnt of envDirs) {
       if (!envEnt.isDirectory()) continue;
       const env = envEnt.name;
-      const envPath = path6.join(root, env);
+      const envPath = path7.join(root, env);
       const keywordDirs = await fs4.readdir(envPath, { withFileTypes: true });
       for (const kwEnt of keywordDirs) {
         if (!kwEnt.isDirectory()) continue;
         const keyword = kwEnt.name;
-        const kwPath = path6.join(envPath, keyword);
+        const kwPath = path7.join(envPath, keyword);
         const stat = await fs4.stat(kwPath).catch(() => null);
         let stateSummary = null;
         if (stateMod?.loadXhsCollectState) {
@@ -1994,7 +2608,7 @@ async function listXhsFullCollectScripts() {
       return {
         id: `xhs:${name}`,
         label: `Full Collect (${name})`,
-        path: path6.join(XHS_SCRIPTS_ROOT, name)
+        path: path7.join(XHS_SCRIPTS_ROOT, name)
       };
     });
     return { ok: true, scripts };
@@ -2064,11 +2678,11 @@ async function listDir(input) {
     const items = await fs4.readdir(dir, { withFileTypes: true }).catch(() => []);
     for (const ent of items) {
       if (entries.length >= maxEntries) break;
-      const full = path6.join(dir, ent.name);
+      const full = path7.join(dir, ent.name);
       const st = await fs4.stat(full).catch(() => null);
       entries.push({
         path: full,
-        rel: path6.relative(root, full),
+        rel: path7.relative(root, full),
         name: ent.name,
         isDir: ent.isDirectory(),
         size: st?.size || 0,
@@ -2085,13 +2699,13 @@ async function listDir(input) {
 }
 function createWindow() {
   win = new BrowserWindow2({
-    title: "WebAuto Desktop v0.1.1",
+    title: VERSION_INFO.windowTitle,
     width: 1280,
     height: 900,
     minWidth: 920,
     minHeight: 800,
     webPreferences: {
-      preload: path6.join(APP_ROOT, "dist", "main", "preload.mjs"),
+      preload: path7.join(APP_ROOT, "dist", "main", "preload.mjs"),
       contextIsolation: true,
       nodeIntegration: false,
       sandbox: false,
@@ -2099,7 +2713,7 @@ function createWindow() {
       backgroundThrottling: false
     }
   });
-  const htmlPath = path6.join(APP_ROOT, "dist", "renderer", "index.html");
+  const htmlPath = path7.join(APP_ROOT, "dist", "renderer", "index.html");
   void win.loadFile(htmlPath);
   ensureStateBridge();
 }
@@ -2131,6 +2745,7 @@ ipcMain2.on("preload:test", () => {
   setTimeout(() => app.quit(), 200);
 });
 ipcMain2.handle("settings:get", async () => readDesktopConsoleSettings({ appRoot: APP_ROOT, repoRoot: REPO_ROOT2 }));
+ipcMain2.handle("app:getVersion", async () => VERSION_INFO);
 ipcMain2.handle("settings:set", async (_evt, next) => {
   const updated = await writeDesktopConsoleSettings({ appRoot: APP_ROOT, repoRoot: REPO_ROOT2 }, next || {});
   const w = getWin();
@@ -2238,6 +2853,73 @@ ipcMain2.handle("cmd:runJson", async (_evt, spec) => {
   const args = Array.isArray(spec?.args) ? spec.args : [];
   return runJson({ ...spec, cwd, args });
 });
+ipcMain2.handle("schedule:invoke", async (_evt, input) => scheduleInvoke(
+  {
+    repoRoot: REPO_ROOT2,
+    runJson: (spec) => runJson(spec),
+    spawnCommand: (spec) => spawnCommand(spec)
+  },
+  input || { action: "list" }
+));
+ipcMain2.handle("task:runEphemeral", async (_evt, input) => {
+  const payload = input || {};
+  let baselineRunIds = /* @__PURE__ */ new Set();
+  try {
+    const baselineTasks = await listUnifiedTasks();
+    baselineRunIds = new Set(
+      baselineTasks.map((task) => String(task?.runId || task?.id || "").trim()).filter(Boolean)
+    );
+  } catch {
+    baselineRunIds = /* @__PURE__ */ new Set();
+  }
+  const result = await runEphemeralTask(
+    {
+      repoRoot: REPO_ROOT2,
+      runJson: (spec) => runJson(spec),
+      spawnCommand: (spec) => spawnCommand(spec)
+    },
+    payload
+  );
+  if (!result?.ok) return result;
+  const commandType = String(result?.commandType || payload?.commandType || "").trim().toLowerCase();
+  const desktopRunId = String(result?.runId || "").trim();
+  if (commandType !== "xhs-unified" || !desktopRunId) {
+    return result;
+  }
+  const profileId = String(result?.profile || payload?.argv?.profile || "").trim();
+  const keyword = String(payload?.argv?.keyword || payload?.argv?.k || "").trim();
+  const uiTriggerId = String(result?.uiTriggerId || payload?.argv?.["ui-trigger-id"] || "").trim();
+  appendRunLog(
+    desktopRunId,
+    `[wait-register] profile=${profileId || "-"} keyword=${keyword || "-"} uiTriggerId=${uiTriggerId || "-"}`
+  );
+  const waited = await waitForUnifiedRunRegistration({
+    desktopRunId,
+    profileId,
+    keyword,
+    uiTriggerId,
+    baselineRunIds,
+    timeoutMs: 2e4
+  });
+  if (!waited.ok) {
+    appendRunLog(desktopRunId, `[wait-register-failed] ${String(waited.error || "unknown_error")}`);
+    return {
+      ok: false,
+      error: waited.error,
+      runId: desktopRunId,
+      commandType: result?.commandType || "xhs-unified",
+      profile: profileId,
+      uiTriggerId
+    };
+  }
+  appendRunLog(desktopRunId, `[wait-register-ok] unifiedRunId=${waited.runId || "-"} uiTriggerId=${uiTriggerId || "-"}`);
+  return {
+    ...result,
+    runId: desktopRunId,
+    unifiedRunId: waited.runId,
+    uiTriggerId
+  };
+});
 ipcMain2.handle("results:scan", async (_evt, spec) => scanResults(spec || {}));
 ipcMain2.handle("fs:listDir", async (_evt, spec) => listDir(spec));
 ipcMain2.handle(
@@ -2277,6 +2959,49 @@ ipcMain2.handle("env:repairCore", async () => {
   const services = await checkServices().catch(() => ({ unifiedApi: false, camoRuntime: false }));
   return { ok, services };
 });
+ipcMain2.handle("env:cleanup", async () => {
+  markUiHeartbeat("env_cleanup");
+  console.log("[env:cleanup] Starting environment cleanup...");
+  await cleanupRuntimeEnvironment("env_cleanup_requested", {
+    stopUiBridge: false,
+    stopHeartbeat: false,
+    stopCoreServices: false,
+    stopStateBridge: false,
+    includeLockCleanup: true
+  });
+  let locksCleared = 0;
+  try {
+    const profiles = await profileStore.listProfiles();
+    for (const p of profiles) {
+      const lockFile = path7.join(p.path, ".lock");
+      try {
+        await fs4.unlink(lockFile);
+        locksCleared++;
+        console.log(`[env:cleanup] Cleared lock for profile ${p.profileId}`);
+      } catch (err) {
+        if (err?.code !== "ENOENT") {
+          console.warn(`[env:cleanup] Failed to clear lock for ${p.profileId}:`, err.message);
+        }
+      }
+    }
+  } catch (err) {
+    console.warn("[env:cleanup] Failed to list profiles:", err);
+  }
+  await stopCoreDaemon().catch(() => null);
+  const restarted = await startCoreDaemon().catch(() => false);
+  const services = await checkServices().catch(() => ({ unifiedApi: false, camoRuntime: false }));
+  const firefox = await checkFirefox().catch(() => ({ installed: false }));
+  const camo = await checkCamoCli().catch(() => ({ installed: false }));
+  console.log("[env:cleanup] Cleanup complete:", { locksCleared, restarted, services, firefox, camo });
+  return {
+    ok: true,
+    locksCleared,
+    coreRestarted: restarted,
+    services,
+    firefox,
+    camo
+  };
+});
 ipcMain2.handle("env:repairDeps", async (_evt, input) => {
   const wantCore = Boolean(input?.core);
   const wantBrowser = Boolean(input?.browser);
@@ -2294,7 +3019,7 @@ ipcMain2.handle("env:repairDeps", async (_evt, input) => {
     if (!coreOk) result.ok = false;
   }
   if (wantBrowser || wantGeoip) {
-    const args = [path6.join("apps", "webauto", "entry", "xhs-install.mjs")];
+    const args = [path7.join("apps", "webauto", "entry", "xhs-install.mjs")];
     if (wantReinstall) args.push("--reinstall");
     else if (wantUninstall) args.push("--uninstall");
     else args.push("--install");
@@ -2313,20 +3038,6 @@ ipcMain2.handle("env:repairDeps", async (_evt, input) => {
   result.env = await checkEnvironment().catch(() => null);
   return result;
 });
-ipcMain2.handle("env:cleanup", async () => {
-  markUiHeartbeat("env_cleanup");
-  await cleanupRuntimeEnvironment("env_cleanup", {
-    stopUiBridge: false,
-    stopHeartbeat: false,
-    stopCoreServices: false,
-    stopStateBridge: false,
-    includeLockCleanup: true
-  });
-  return {
-    ok: true,
-    services: await checkServices().catch(() => ({ unifiedApi: false, camoRuntime: false }))
-  };
-});
 ipcMain2.handle("config:saveLast", async (_evt, config) => {
   await saveCrawlConfig({ appRoot: APP_ROOT, repoRoot: REPO_ROOT2 }, config);
   return { ok: true };
@@ -2417,7 +3128,7 @@ ipcMain2.handle("runtime:kill", async (_evt, input) => {
 ipcMain2.handle("runtime:restartPhase1", async (_evt, input) => {
   const profileId = String(input?.profileId || "").trim();
   if (!profileId) return { ok: false, error: "missing profileId" };
-  const args = [path6.join(REPO_ROOT2, "scripts", "xiaohongshu", "phase1-boot.mjs"), "--profile", profileId, "--headless", "false"];
+  const args = [path7.join(REPO_ROOT2, "scripts", "xiaohongshu", "phase1-boot.mjs"), "--profile", profileId, "--headless", "false"];
   return spawnCommand({ title: `Phase1 restart ${profileId}`, cwd: REPO_ROOT2, args, groupKey: "phase1" });
 });
 ipcMain2.handle("runtime:setBrowserTitle", async (_evt, input) => {