@web-auto/webauto 0.1.4 → 0.1.6

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

@@ -1,13 +1,13 @@
 // src/main/index.mts
 import electron from "electron";
 import { spawn as spawn2 } from "node:child_process";
-import os4 from "node:os";
-import path5 from "node:path";
+import os5 from "node:os";
+import path6 from "node:path";
 import { fileURLToPath as fileURLToPath2, pathToFileURL as pathToFileURL3 } from "node:url";
-import { mkdirSync, promises as fs3 } from "node:fs";
+import { mkdirSync, promises as fs4 } from "node:fs";
 
 // src/main/desktop-settings.mts
-import { promises as fs } from "node:fs";
+import { existsSync, promises as fs } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
@@ -19,9 +19,26 @@ function resolveHomeDir() {
 function resolveLegacySettingsPath() {
   return path.join(resolveHomeDir(), ".webauto", "ui-settings.console.json");
 }
-function resolveDefaultDownloadRoot() {
-  if (process.platform === "win32") return "D:\\webauto";
-  return path.join(resolveHomeDir(), ".webauto", "download");
+function hasWindowsDriveD() {
+  try {
+    return existsSync("D:\\");
+  } catch {
+    return false;
+  }
+}
+function normalizeWindowsDefaultRoot(input) {
+  const value = String(input || "").trim();
+  if (!value) return path.join(resolveHomeDir(), ".webauto");
+  if (!/^[dD]:[\\/]/.test(value)) return value;
+  if (hasWindowsDriveD()) return value;
+  return path.join(resolveHomeDir(), ".webauto");
+}
+function resolveDefaultDownloadRoot(options) {
+  const platform = String(options?.platform || process.platform).trim();
+  const homeDir = String(options?.homeDir || resolveHomeDir()).trim() || resolveHomeDir();
+  if (platform !== "win32") return path.join(homeDir, ".webauto", "download");
+  const driveExists = typeof options?.windowsDriveDExists === "boolean" ? options.windowsDriveDExists : hasWindowsDriveD();
+  return driveExists ? "D:\\webauto" : path.join(homeDir, ".webauto");
 }
 function normalizeAiReplyConfig(raw) {
   if (!raw || typeof raw !== "object") {
@@ -67,10 +84,12 @@ function normalizeSettings(defaults, input) {
   }
   const merged = {
     unifiedApiUrl: String(input.unifiedApiUrl || defaults.unifiedApiUrl || "http://127.0.0.1:7701"),
-    browserServiceUrl: String(input.browserServiceUrl || defaults.browserServiceUrl || "http://127.0.0.1:7704"),
+    camoRuntimeUrl: String(
+      input.camoRuntimeUrl || input.browserServiceUrl || defaults.camoRuntimeUrl || defaults.browserServiceUrl || "http://127.0.0.1:7704"
+    ),
     searchGateUrl: String(input.searchGateUrl || defaults.searchGateUrl || "http://127.0.0.1:7790"),
     downloadRoot: String(input.downloadRoot || defaults.downloadRoot || resolveDefaultDownloadRoot()),
-    defaultEnv: String(input.defaultEnv || defaults.defaultEnv || "debug") === "prod" ? "prod" : "debug",
+    defaultEnv: String(input.defaultEnv || defaults.defaultEnv || "prod") === "prod" ? "prod" : "debug",
     defaultKeyword: String(input.defaultKeyword ?? defaults.defaultKeyword ?? ""),
     defaultTarget: Math.max(1, Math.floor(Number(input.defaultTarget ?? defaults.defaultTarget ?? 20) || 20)),
     defaultDryRun: Boolean(input.defaultDryRun ?? defaults.defaultDryRun ?? false),
@@ -95,10 +114,30 @@ function normalizeSettings(defaults, input) {
     profileAliases: aliases,
     profileColors: normalizeColorMap(input.profileColors ?? defaults.profileColors ?? {}),
     aiReply: normalizeAiReplyConfig(input.aiReply ?? defaults.aiReply ?? {}),
+    envRepairHistory: normalizeRepairHistory(
+      input.envRepairHistory ?? defaults.envRepairHistory ?? []
+    ),
     lastCrawlConfig: input.lastCrawlConfig ?? defaults.lastCrawlConfig ?? void 0
   };
   return merged;
 }
+function normalizeRepairHistory(raw) {
+  if (!Array.isArray(raw)) return [];
+  const out = [];
+  for (const item of raw) {
+    if (!item || typeof item !== "object") continue;
+    const ts = String(item.ts || "").trim();
+    const action = String(item.action || "").trim();
+    if (!ts || !action) continue;
+    out.push({
+      ts,
+      action,
+      ok: Boolean(item.ok),
+      detail: String(item.detail || "").trim() || void 0
+    });
+  }
+  return out.slice(-30);
+}
 function normalizeColorMap(raw) {
   const out = {};
   if (!raw || typeof raw !== "object") return out;
@@ -122,13 +161,14 @@ async function readDefaultSettingsFromAppRoot(appRoot) {
   }
   const base = {
     unifiedApiUrl: raw.unifiedApiUrl,
-    browserServiceUrl: raw.browserServiceUrl,
+    camoRuntimeUrl: raw.camoRuntimeUrl || raw.browserServiceUrl,
     searchGateUrl: raw.searchGateUrl,
     defaultEnv: raw.defaultEnv,
     defaultKeyword: raw.defaultKeyword,
     timeouts: raw.timeouts
   };
-  const downloadRoot = typeof raw.downloadRoot === "string" ? String(raw.downloadRoot) : process.platform === "win32" && typeof raw.downloadRootWindows === "string" ? String(raw.downloadRootWindows) : process.platform !== "win32" && typeof raw.downloadRootPosix === "string" ? String(raw.downloadRootPosix) : Array.isArray(raw.downloadRootParts) ? path.join(resolveHomeDir(), ...raw.downloadRootParts.map((x) => String(x))) : resolveDefaultDownloadRoot();
+  const downloadRootRaw = typeof raw.downloadRoot === "string" ? String(raw.downloadRoot) : process.platform === "win32" && typeof raw.downloadRootWindows === "string" ? String(raw.downloadRootWindows) : process.platform !== "win32" && typeof raw.downloadRootPosix === "string" ? String(raw.downloadRootPosix) : Array.isArray(raw.downloadRootParts) ? path.join(resolveHomeDir(), ...raw.downloadRootParts.map((x) => String(x))) : resolveDefaultDownloadRoot();
+  const downloadRoot = process.platform === "win32" ? normalizeWindowsDefaultRoot(downloadRootRaw) : downloadRootRaw;
   return normalizeSettings({ ...base, downloadRoot }, {});
 }
 async function readLegacySettings() {
@@ -546,6 +586,10 @@ var StateBridge = class {
   win = null;
   tasks = /* @__PURE__ */ new Map();
   handlersRegistered = false;
+  emitBusEvent(payload) {
+    if (!this.win) return;
+    this.win.webContents.send("bus:event", payload);
+  }
   start(win2) {
     this.win = win2;
     this.connect();
@@ -561,12 +605,26 @@ var StateBridge = class {
       this.ws.on("open", () => {
         console.log("[StateBridge] connected to", UNIFIED_API_WS);
         this.ws?.send(JSON.stringify({ type: "subscribe", topic: "task:*" }));
+        this.emitBusEvent({ type: "env:unified", ok: true, ts: Date.now() });
       });
       this.ws.on("message", (data) => {
         try {
           const msg = JSON.parse(data.toString());
           if (msg.type === "task:update" && msg.data) {
             this.handleTaskUpdate(msg.data);
+            return;
+          }
+          if (msg.type === "event" && msg.topic === "bus.message") {
+            const raw = msg?.payload?.data;
+            if (typeof raw === "string" && raw.trim()) {
+              try {
+                const parsed = JSON.parse(raw);
+                if (parsed && typeof parsed === "object") {
+                  this.emitBusEvent(parsed);
+                }
+              } catch {
+              }
+            }
           }
         } catch (err) {
           console.warn("[StateBridge] parse error:", err);
@@ -574,6 +632,7 @@ var StateBridge = class {
       });
       this.ws.on("close", () => {
         console.log("[StateBridge] disconnected, reconnecting...");
+        this.emitBusEvent({ type: "env:unified", ok: false, ts: Date.now() });
         this.scheduleReconnect();
       });
       this.ws.on("error", (err) => {
@@ -634,12 +693,29 @@ var stateBridge = new StateBridge();
 // src/main/env-check.mts
 import { promisify } from "node:util";
 import { exec, spawnSync } from "node:child_process";
-import { existsSync } from "node:fs";
+import { existsSync as existsSync2 } from "node:fs";
 import path4 from "node:path";
 import os3 from "node:os";
 var execAsync = promisify(exec);
+function resolveWebautoRoot() {
+  const portableRoot = String(process.env.WEBAUTO_PORTABLE_ROOT || process.env.WEBAUTO_ROOT || "").trim();
+  return portableRoot ? path4.join(portableRoot, ".webauto") : path4.join(os3.homedir(), ".webauto");
+}
 function resolveNpxBin2() {
-  return process.platform === "win32" ? "npx.cmd" : "npx";
+  if (process.platform !== "win32") return "npx";
+  const resolved = resolveOnPath(["npx.cmd", "npx.exe", "npx.bat", "npx.ps1"]);
+  return resolved || "npx.cmd";
+}
+function resolveOnPath(candidates) {
+  const pathEnv = process.env.PATH || process.env.Path || "";
+  const dirs = pathEnv.split(path4.delimiter).filter(Boolean);
+  for (const dir of dirs) {
+    for (const name of candidates) {
+      const full = path4.join(dir, name);
+      if (existsSync2(full)) return full;
+    }
+  }
+  return null;
 }
 function resolveCamoVersionFromText(stdout, stderr) {
   const merged = `${String(stdout || "")}
@@ -653,13 +729,35 @@ ${String(stderr || "")}`.trim();
   }
   return "unknown";
 }
+function quoteCmdArg(value) {
+  if (!value) return '""';
+  if (!/[\s"]/u.test(value)) return value;
+  return `"${value.replace(/"/g, '""')}"`;
+}
 function runVersionCheck(command, args, explicitPath) {
   try {
-    const ret = spawnSync(command, args, {
-      encoding: "utf8",
-      timeout: 8e3,
-      windowsHide: true
-    });
+    const lower = String(command || "").toLowerCase();
+    let ret;
+    if (process.platform === "win32" && (lower.endsWith(".cmd") || lower.endsWith(".bat"))) {
+      const cmdLine = [quoteCmdArg(command), ...args.map(quoteCmdArg)].join(" ");
+      ret = spawnSync("cmd.exe", ["/d", "/s", "/c", cmdLine], {
+        encoding: "utf8",
+        timeout: 8e3,
+        windowsHide: true
+      });
+    } else if (process.platform === "win32" && lower.endsWith(".ps1")) {
+      ret = spawnSync("powershell.exe", ["-NoProfile", "-ExecutionPolicy", "Bypass", "-File", command, ...args], {
+        encoding: "utf8",
+        timeout: 8e3,
+        windowsHide: true
+      });
+    } else {
+      ret = spawnSync(command, args, {
+        encoding: "utf8",
+        timeout: 8e3,
+        windowsHide: true
+      });
+    }
     if (ret.status !== 0) {
       return {
         installed: false,
@@ -676,19 +774,24 @@ function runVersionCheck(command, args, explicitPath) {
   }
 }
 async function checkCamoCli() {
-  const pathCheck = runVersionCheck(process.platform === "win32" ? "camo.cmd" : "camo", ["help"], "PATH:camo");
-  if (pathCheck.installed) return pathCheck;
+  const camoCandidates = process.platform === "win32" ? ["camo.cmd", "camo.exe", "camo.bat", "camo.ps1"] : ["camo"];
+  for (const candidate of camoCandidates) {
+    const pathCheck = runVersionCheck(candidate, ["help"], `PATH:${candidate}`);
+    if (pathCheck.installed) return pathCheck;
+  }
   const cwd = process.cwd();
-  const suffix = process.platform === "win32" ? "camo.cmd" : "camo";
-  const localCandidates = [
-    path4.resolve(cwd, "node_modules", ".bin", suffix),
-    path4.resolve(cwd, "..", "node_modules", ".bin", suffix),
-    path4.resolve(cwd, "..", "..", "node_modules", ".bin", suffix)
+  const localRoots = [
+    path4.resolve(cwd, "node_modules", ".bin"),
+    path4.resolve(cwd, "..", "node_modules", ".bin"),
+    path4.resolve(cwd, "..", "..", "node_modules", ".bin")
   ];
-  for (const candidate of localCandidates) {
-    if (!existsSync(candidate)) continue;
-    const ret = runVersionCheck(candidate, ["help"], candidate);
-    if (ret.installed) return ret;
+  for (const localRoot of localRoots) {
+    for (const suffix of camoCandidates) {
+      const candidate = path4.resolve(localRoot, suffix);
+      if (!existsSync2(candidate)) continue;
+      const ret = runVersionCheck(candidate, ["help"], candidate);
+      if (ret.installed) return ret;
+    }
   }
   const npxCheck = runVersionCheck(
     resolveNpxBin2(),
@@ -702,12 +805,12 @@ async function checkCamoCli() {
   };
 }
 async function checkServices() {
-  const [unifiedApi, browserService, searchGate] = await Promise.all([
+  const [unifiedApi, camoRuntime, searchGate] = await Promise.all([
     fetch("http://127.0.0.1:7701/health", { signal: AbortSignal.timeout(3e3) }).then((r) => r.ok).catch(() => false),
     fetch("http://127.0.0.1:7704/health", { signal: AbortSignal.timeout(3e3) }).then((r) => r.ok).catch(() => false),
     fetch("http://127.0.0.1:7790/health", { signal: AbortSignal.timeout(3e3) }).then((r) => r.ok).catch(() => false)
   ]);
-  return { unifiedApi, browserService, searchGate };
+  return { unifiedApi, camoRuntime, searchGate };
 }
 async function checkFirefox() {
   try {
@@ -739,12 +842,12 @@ async function checkFirefox() {
         path4.join(localAppData, "Mozilla Firefox", "firefox.exe")
       ];
       for (const firefoxPath2 of possiblePaths) {
-        if (existsSync(firefoxPath2)) return { installed: true, path: firefoxPath2 };
+        if (existsSync2(firefoxPath2)) return { installed: true, path: firefoxPath2 };
       }
       return { installed: false };
     }
     const macBundle = "/Applications/Firefox.app/Contents/MacOS/firefox";
-    if (platform === "darwin" && existsSync(macBundle)) return { installed: true, path: macBundle };
+    if (platform === "darwin" && existsSync2(macBundle)) return { installed: true, path: macBundle };
     const { stdout } = await execAsync("which firefox", { timeout: 3e3 });
     const firefoxPath = String(stdout || "").trim();
     return firefoxPath ? { installed: true, path: firefoxPath } : { installed: false };
@@ -753,8 +856,8 @@ async function checkFirefox() {
   }
 }
 async function checkGeoIP() {
-  const geoIpPath = path4.join(os3.homedir(), ".webauto", "geoip", "GeoLite2-City.mmdb");
-  if (existsSync(geoIpPath)) {
+  const geoIpPath = path4.join(resolveWebautoRoot(), "geoip", "GeoLite2-City.mmdb");
+  if (existsSync2(geoIpPath)) {
     return { installed: true, path: geoIpPath };
   }
   return { installed: false };
@@ -766,32 +869,585 @@ async function checkEnvironment() {
     checkFirefox(),
     checkGeoIP()
   ]);
-  const allReady = camo.installed && services.unifiedApi && services.browserService && firefox.installed && geoip.installed;
+  const allReady = camo.installed && services.unifiedApi && firefox.installed;
   return { camo, services, firefox, geoip, allReady };
 }
 
+// src/main/ui-cli-bridge.mts
+import { createServer } from "node:http";
+import os4 from "node:os";
+import path5 from "node:path";
+import { promises as fs3 } from "node:fs";
+var DEFAULT_HOST = "127.0.0.1";
+var DEFAULT_PORT = 7716;
+var CONTROL_FILE = path5.join(os4.homedir(), ".webauto", "run", "ui-cli.json");
+function readInt(input, fallback) {
+  const n = Number(input);
+  return Number.isFinite(n) && n > 0 ? Math.floor(n) : fallback;
+}
+function sendJson(res, code, payload) {
+  const body = JSON.stringify(payload);
+  res.statusCode = code;
+  res.setHeader("Content-Type", "application/json; charset=utf-8");
+  res.setHeader("Content-Length", Buffer.byteLength(body));
+  res.end(body);
+}
+function parseBody(req) {
+  return new Promise((resolve) => {
+    const chunks = [];
+    req.on("data", (c) => chunks.push(c));
+    req.on("end", () => {
+      const raw = Buffer.concat(chunks).toString("utf8").trim();
+      if (!raw) return resolve({});
+      try {
+        resolve(JSON.parse(raw));
+      } catch {
+        resolve({});
+      }
+    });
+    req.on("error", () => resolve({}));
+  });
+}
+function isUiReady(win2) {
+  if (!win2 || win2.isDestroyed()) return false;
+  const wc = win2.webContents;
+  if (!wc || wc.isDestroyed()) return false;
+  if (typeof wc.isCrashed === "function" && wc.isCrashed()) return false;
+  return true;
+}
+function toActionError(input, error, extra = {}) {
+  const action = String(input?.action || "").trim();
+  const selector = String(input?.selector || "").trim();
+  const state = String(input?.state || "").trim();
+  const payload = {
+    ok: false,
+    error: String(error || "unknown_error"),
+    action: action || null,
+    selector: selector || null,
+    state: state || null,
+    ...extra
+  };
+  return payload;
+}
+async function writeControlFile(host, port) {
+  const payload = {
+    pid: process.pid,
+    host,
+    port,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  try {
+    await fs3.mkdir(path5.dirname(CONTROL_FILE), { recursive: true });
+    await fs3.writeFile(CONTROL_FILE, JSON.stringify(payload, null, 2), "utf8");
+  } catch {
+  }
+}
+async function removeControlFile() {
+  try {
+    await fs3.unlink(CONTROL_FILE);
+  } catch {
+  }
+}
+function buildSnapshotScript() {
+  return `(() => {
+    const text = (sel) => {
+      const el = document.querySelector(sel);
+      return el ? String(el.textContent || '').trim() : '';
+    };
+    const value = (sel) => {
+      const el = document.querySelector(sel);
+      if (!el) return '';
+      if ('value' in el) return String(el.value ?? '');
+      return String(el.textContent || '').trim();
+    };
+    const activeTab = document.querySelector('.tab.active');
+    const errors = Array.from(document.querySelectorAll('#recent-errors-list li'))
+      .map((el) => String(el.textContent || '').trim())
+      .filter(Boolean)
+      .slice(0, 20);
+    return {
+      ready: true,
+      activeTabId: String(activeTab?.dataset?.tabId || '').trim(),
+      activeTabLabel: String(activeTab?.textContent || '').trim(),
+      status: text('#status'),
+      runId: text('#run-id-text'),
+      errorCount: text('#error-count-text'),
+      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'),
+      recentErrors: errors,
+      ts: new Date().toISOString(),
+    };
+  })()`;
+}
+function buildActionScript(action) {
+  const payloadJson = JSON.stringify(action);
+  const snapshotScript = buildSnapshotScript();
+  return `(() => {
+    const payload = ${payloadJson};
+    const normalize = (v) => String(v || '').trim();
+    const isVisible = (el) => {
+      if (!el) return false;
+      const rect = el.getBoundingClientRect();
+      if (!rect || rect.width <= 0 || rect.height <= 0) return false;
+      const style = window.getComputedStyle(el);
+      return style.display !== 'none' && style.visibility !== 'hidden' && style.opacity !== '0';
+    };
+    const query = (selector) => {
+      const s = normalize(selector);
+      if (!s) return null;
+      return document.querySelector(s);
+    };
+    const queryAll = (selector) => {
+      const s = normalize(selector) || 'body';
+      return Array.from(document.querySelectorAll(s));
+    };
+    const findByText = ({ selector, text, exact, nth }) => {
+      const q = normalize(selector) || 'button';
+      const target = normalize(text);
+      const lower = target.toLowerCase();
+      if (!target) return null;
+      const nodes = Array.from(document.querySelectorAll(q));
+      const matched = nodes.filter((el) => {
+        const t = normalize(el.textContent);
+        if (!t) return false;
+        if (exact === true) return t === target;
+        return t.toLowerCase().includes(lower);
+      });
+      const index = Number.isFinite(Number(nth)) ? Math.max(0, Math.floor(Number(nth))) : 0;
+      return matched[index] || null;
+    };
+    const getElementDetails = (el) => {
+      if (!el) return null;
+      const rect = el.getBoundingClientRect();
+      const style = window.getComputedStyle(el);
+      const attrs = {};
+      for (const attr of el.attributes) {
+        attrs[attr.name] = attr.value;
+      }
+      return {
+        rect: {
+          x: Math.round(rect.x),
+          y: Math.round(rect.y),
+          width: Math.round(rect.width),
+          height: Math.round(rect.height),
+          top: Math.round(rect.top),
+          left: Math.round(rect.left),
+          right: Math.round(rect.right),
+          bottom: Math.round(rect.bottom),
+        },
+        computedStyle: {
+          display: style.display,
+          visibility: style.visibility,
+          opacity: style.opacity,
+          backgroundColor: style.backgroundColor,
+          color: style.color,
+          fontSize: style.fontSize,
+          fontFamily: style.fontFamily,
+          position: style.position,
+          zIndex: style.zIndex,
+        },
+        attributes: attrs,
+        innerText: el.innerText,
+        outerHTML: el.outerHTML?.slice(0, 2000),
+        tagName: el.tagName,
+        className: el.className,
+        id: el.id,
+      };
+    };
+    const focusEl = (el) => {
+      if (!el || typeof el.focus !== 'function') return false;
+      el.focus();
+      return document.activeElement === el;
+    };
+    const clickEl = (el) => {
+      if (!el || typeof el.click !== 'function') return false;
+      if (typeof el.scrollIntoView === 'function') {
+        try { el.scrollIntoView({ block: 'center', inline: 'nearest' }); } catch {}
+      }
+      focusEl(el);
+      el.click();
+      return true;
+    };
+    const setInputValue = (el, value) => {
+      if (!el) return false;
+      const text = String(value ?? '');
+      if ('value' in el) {
+        el.value = text;
+      } else {
+        el.textContent = text;
+      }
+      el.dispatchEvent(new Event('input', { bubbles: true }));
+      el.dispatchEvent(new Event('change', { bubbles: true }));
+      return true;
+    };
+    const pressKey = (el, key) => {
+      const k = normalize(key) || 'Enter';
+      const target = el || document.activeElement || document.body;
+      const code = k === 'Escape' ? 'Escape' : k === 'Enter' ? 'Enter' : k;
+      const init = { key: k, code, bubbles: true, cancelable: true };
+      target.dispatchEvent(new KeyboardEvent('keydown', init));
+      target.dispatchEvent(new KeyboardEvent('keyup', init));
+      return true;
+    };
+    const findTab = () => {
+      const tabId = normalize(payload.tabId || payload.value);
+      const tabLabel = normalize(payload.tabLabel || payload.selector);
+      const tabs = Array.from(document.querySelectorAll('.tab'));
+      if (tabId) {
+        const byId = tabs.find((el) => normalize(el?.dataset?.tabId) === tabId);
+        if (byId) return byId;
+      }
+      if (tabLabel) {
+        const lower = tabLabel.toLowerCase();
+        return tabs.find((el) => normalize(el.textContent).toLowerCase().includes(lower)) || null;
+      }
+      return null;
+    };
+
+    if (payload.action === 'snapshot') {
+      return { ok: true, snapshot: ${snapshotScript} };
+    }
+    if (payload.action === 'dialogs') {
+      const mode = normalize(payload.value).toLowerCase();
+      const w = window;
+      const key = '__webauto_ui_cli_dialogs__';
+      if (mode === 'silent') {
+        if (!w[key]) {
+          w[key] = {
+            alert: w.alert,
+            confirm: w.confirm,
+            prompt: w.prompt,
+          };
+        }
+        w.alert = () => {};
+        w.confirm = () => true;
+        w.prompt = () => '';
+        return { ok: true, mode: 'silent' };
+      }
+      if (mode === 'restore') {
+        if (w[key]) {
+          w.alert = w[key].alert;
+          w.confirm = w[key].confirm;
+          w.prompt = w[key].prompt;
+          delete w[key];
+        }
+        return { ok: true, mode: 'restore' };
+      }
+      return { ok: false, error: 'unsupported_dialog_mode' };
+    }
+    if (payload.action === 'tab') {
+      const tab = findTab();
+      if (!tab) return { ok: false, error: 'tab_not_found' };
+      clickEl(tab);
+      return { ok: true, tab: normalize(tab.textContent), tabId: normalize(tab?.dataset?.tabId) };
+    }
+    if (payload.action === 'click') {
+      const el = query(payload.selector);
+      if (!el) return { ok: false, error: 'selector_not_found', selector: normalize(payload.selector) };
+      clickEl(el);
+      return { ok: true };
+    }
+    if (payload.action === 'focus') {
+      const el = query(payload.selector);
+      if (!el) return { ok: false, error: 'selector_not_found', selector: normalize(payload.selector) };
+      const focused = focusEl(el);
+      return { ok: focused, focused };
+    }
+    if (payload.action === 'input') {
+      const el = query(payload.selector);
+      if (!el) return { ok: false, error: 'selector_not_found', selector: normalize(payload.selector) };
+      focusEl(el);
+      const written = setInputValue(el, payload.value || '');
+      return { ok: written, value: String(payload.value || '') };
+    }
+    if (payload.action === 'select') {
+      const el = query(payload.selector);
+      if (!el || el.tagName !== 'SELECT') return { ok: false, error: 'select_not_found', selector: normalize(payload.selector) };
+      el.value = String(payload.value || '');
+      el.dispatchEvent(new Event('input', { bubbles: true }));
+      el.dispatchEvent(new Event('change', { bubbles: true }));
+      return { ok: true, value: el.value };
+    }
+    if (payload.action === 'press') {
+      const el = query(payload.selector);
+      const ok = pressKey(el, payload.key);
+      return { ok, key: normalize(payload.key) || 'Enter' };
+    }
+    if (payload.action === 'click_text') {
+      const el = findByText({
+        selector: payload.selector,
+        text: payload.text || payload.value,
+        exact: payload.exact === true,
+        nth: payload.nth,
+      });
+      if (!el) return { ok: false, error: 'text_not_found', text: normalize(payload.text || payload.value), selector: normalize(payload.selector) };
+      clickEl(el);
+      return { ok: true, text: normalize(el.textContent) };
+    }
+    if (payload.action === 'probe') {
+      const selector = normalize(payload.selector) || 'body';
+      const nodes = queryAll(selector);
+      const first = nodes[0] || null;
+      const firstVisible = isVisible(first);
+      const text = normalize(first?.textContent);
+      const value = first && 'value' in first ? String(first.value ?? '') : text;
+      const checked = Boolean(first && 'checked' in first && first.checked === true);
+      const disabled = Boolean(first && 'disabled' in first && first.disabled === true);
+      const probeText = normalize(payload.text || payload.value);
+      let details = null;
+      if (first && payload.detailed === true) {
+        details = getElementDetails(first);
+      }
+      let textMatchedCount = 0;
+      if (probeText) {
+        const target = payload.exact === true ? probeText : probeText.toLowerCase();
+        textMatchedCount = nodes.filter((el) => {
+          const current = normalize(el.textContent);
+          if (!current) return false;
+          if (payload.exact === true) return current === target;
+          return current.toLowerCase().includes(target);
+        }).length;
+      }
+      return {
+        ok: true,
+        selector,
+        exists: Boolean(first),
+        count: nodes.length,
+        visible: firstVisible,
+        text,
+        value,
+        checked,
+        disabled,
+        tagName: first?.tagName || '',
+        className: first?.className || '',
+        details,
+        textMatchedCount,
+      };
+    }
+    if (payload.action === 'close_window') {
+      window.close();
+      return { ok: true };
+    }
+    return { ok: false, error: 'unsupported_action', action: normalize(payload.action) };
+  })()`;
+}
+var UiCliBridge = class {
+  server = null;
+  options;
+  host;
+  port;
+  constructor(options) {
+    this.options = options;
+    this.host = String(options.host || process.env.WEBAUTO_UI_CLI_HOST || DEFAULT_HOST);
+    this.port = readInt(options.port || process.env.WEBAUTO_UI_CLI_PORT, DEFAULT_PORT);
+  }
+  getAddress() {
+    return { host: this.host, port: this.port };
+  }
+  async start() {
+    if (this.server) return this.getAddress();
+    await new Promise((resolve, reject) => {
+      const server = createServer((req, res) => {
+        void this.handleRequest(req, res);
+      });
+      server.on("error", (err) => reject(err));
+      server.listen(this.port, this.host, () => {
+        this.server = server;
+        resolve();
+      });
+    });
+    await writeControlFile(this.host, this.port);
+    return this.getAddress();
+  }
+  async stop() {
+    if (!this.server) {
+      await removeControlFile();
+      return;
+    }
+    const srv = this.server;
+    this.server = null;
+    await new Promise((resolve) => srv.close(() => resolve()));
+    await removeControlFile();
+  }
+  async handleRequest(req, res) {
+    const method = String(req.method || "GET").toUpperCase();
+    const url = new URL(req.url || "/", `http://${this.host}:${this.port}`);
+    if (method === "GET" && url.pathname === "/health") {
+      return sendJson(res, 200, await this.status());
+    }
+    if (method === "GET" && (url.pathname === "/status" || url.pathname === "/snapshot")) {
+      return sendJson(res, 200, await this.status(true));
+    }
+    if (method === "POST" && url.pathname === "/action") {
+      const body = await parseBody(req);
+      const result = await this.handleAction(body || {});
+      return sendJson(res, result.ok ? 200 : 400, result);
+    }
+    return sendJson(res, 404, { ok: false, error: "not_found" });
+  }
+  async status(includeSnapshot = false) {
+    const win2 = this.options.getWindow();
+    const ready = isUiReady(win2);
+    if (!ready) {
+      return {
+        ok: false,
+        pid: process.pid,
+        ready: false,
+        host: this.host,
+        port: this.port,
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        error: "window_not_ready"
+      };
+    }
+    let snapshot;
+    if (includeSnapshot) {
+      try {
+        snapshot = await win2.webContents.executeJavaScript(buildSnapshotScript(), true);
+      } catch (err) {
+        return {
+          ok: false,
+          pid: process.pid,
+          ready,
+          host: this.host,
+          port: this.port,
+          ts: (/* @__PURE__ */ new Date()).toISOString(),
+          error: err?.message || String(err)
+        };
+      }
+    }
+    return {
+      ok: true,
+      pid: process.pid,
+      ready,
+      host: this.host,
+      port: this.port,
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      snapshot
+    };
+  }
+  async handleAction(input) {
+    const action = String(input?.action || "").trim();
+    if (!action) return toActionError(input, "missing_action");
+    if (action === "wait") {
+      return this.waitForSelector(input);
+    }
+    const win2 = this.options.getWindow();
+    if (!isUiReady(win2)) return toActionError(input, "window_not_ready");
+    try {
+      const out = await win2.webContents.executeJavaScript(buildActionScript(input), true);
+      return out && typeof out === "object" ? out : toActionError(input, "empty_result");
+    } catch (err) {
+      return toActionError(input, err?.message || String(err), { details: err?.stack || null });
+    }
+  }
+  async waitForSelector(input) {
+    const selector = String(input.selector || "").trim();
+    if (!selector) return toActionError(input, "missing_selector");
+    const expected = input.state || "visible";
+    const timeoutMs = readInt(input.timeoutMs, 15e3);
+    const intervalMs = readInt(input.intervalMs, 250);
+    const startedAt = Date.now();
+    while (Date.now() - startedAt <= timeoutMs) {
+      const win2 = this.options.getWindow();
+      if (!isUiReady(win2)) return toActionError(input, "window_not_ready");
+      try {
+        const checkScript = `(() => {
+          const el = document.querySelector(${JSON.stringify(selector)});
+          const visible = (() => {
+            if (!el) return false;
+            const rect = el.getBoundingClientRect();
+            if (!rect || rect.width <= 0 || rect.height <= 0) return false;
+            const style = window.getComputedStyle(el);
+            return style.display !== 'none' && style.visibility !== 'hidden' && style.opacity !== '0';
+          })();
+          const text = String(el?.textContent || '').trim();
+          const value = el && 'value' in el ? String(el.value ?? '') : '';
+          const disabled = Boolean(el && 'disabled' in el && el.disabled === true);
+          return { exists: Boolean(el), visible, text, value, disabled };
+        })()`;
+        const state = await win2.webContents.executeJavaScript(checkScript, true);
+        const exists = Boolean(state?.exists);
+        const visible = Boolean(state?.visible);
+        const text = String(state?.text || "");
+        const value = String(state?.value || "");
+        const disabled = Boolean(state?.disabled);
+        let matched = false;
+        let reason = "";
+        switch (expected) {
+          case "exists":
+            matched = exists;
+            reason = exists ? "element exists" : "element not found";
+            break;
+          case "visible":
+            matched = visible;
+            reason = visible ? "element visible" : "element not visible";
+            break;
+          case "hidden":
+            matched = !exists || !visible;
+            reason = matched ? "element hidden or absent" : "element is visible";
+            break;
+          case "text_contains":
+            matched = exists && text.includes(String(input.value || ""));
+            reason = matched ? "text matched" : `text '${text}' does not contain '${input.value || ""}'`;
+            break;
+          case "text_equals":
+            matched = exists && text === String(input.value || "");
+            reason = matched ? "text matched" : `text '${text}' !== '${input.value || ""}'`;
+            break;
+          case "value_equals":
+            matched = exists && value === String(input.value || "");
+            reason = matched ? "value matched" : `value '${value}' !== '${input.value || ""}'`;
+            break;
+          case "not_disabled":
+            matched = exists && !disabled;
+            reason = matched ? "element enabled" : "element disabled";
+            break;
+          default:
+            return toActionError(input, "unsupported_state", { expected });
+        }
+        if (matched) {
+          return { ok: true, selector, expected, exists, visible, text, value, disabled, elapsedMs: Date.now() - startedAt, reason };
+        }
+      } catch (err) {
+        return toActionError(input, err?.message || String(err), { details: err?.stack || null });
+      }
+      await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    }
+    return toActionError(input, "wait_timeout", {
+      expected,
+      timeoutMs,
+      elapsedMs: Date.now() - startedAt
+    });
+  }
+};
+
 // src/main/index.mts
 var { app, BrowserWindow: BrowserWindow2, ipcMain: ipcMain2, shell, clipboard } = electron;
-var __dirname = path5.dirname(fileURLToPath2(import.meta.url));
-var APP_ROOT = path5.resolve(__dirname, "../..");
-var REPO_ROOT2 = path5.resolve(APP_ROOT, "../..");
-var DESKTOP_HEARTBEAT_FILE = path5.join(
-  os4.homedir(),
+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(
+  os5.homedir(),
   ".webauto",
   "run",
   "desktop-console-heartbeat.json"
 );
 var profileStore = createProfileStore({ repoRoot: REPO_ROOT2 });
-var XHS_SCRIPTS_ROOT = path5.join(REPO_ROOT2, "scripts", "xiaohongshu");
+var XHS_SCRIPTS_ROOT = path6.join(REPO_ROOT2, "scripts", "xiaohongshu");
 var XHS_FULL_COLLECT_RE = /collect-content\.mjs$/;
 function configureElectronPaths() {
   try {
     const downloadRoot = resolveDefaultDownloadRoot();
-    const normalized = path5.normalize(downloadRoot);
-    const baseDir = path5.basename(normalized).toLowerCase() === "download" ? path5.dirname(normalized) : normalized;
-    const userDataRoot = path5.join(baseDir, "desktop-console");
-    const cacheRoot = path5.join(userDataRoot, "cache");
-    const gpuCacheRoot = path5.join(cacheRoot, "gpu");
+    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");
     try {
       mkdirSync(cacheRoot, { recursive: true });
     } catch {
@@ -833,6 +1489,8 @@ var GroupQueue = class {
 };
 var groupQueues = /* @__PURE__ */ new Map();
 var runs = /* @__PURE__ */ new Map();
+var trackedRunPids = /* @__PURE__ */ new Set();
+var appExitCleanupPromise = null;
 var UI_HEARTBEAT_TIMEOUT_MS = resolveUiHeartbeatTimeoutMs(process.env);
 var lastUiHeartbeatAt = Date.now();
 var heartbeatWatchdog = null;
@@ -849,8 +1507,8 @@ async function writeCoreServiceHeartbeat(status) {
     source: "desktop-console"
   };
   try {
-    await fs3.mkdir(path5.dirname(filePath), { recursive: true });
-    await fs3.writeFile(filePath, JSON.stringify(payload), "utf8");
+    await fs4.mkdir(path6.dirname(filePath), { recursive: true });
+    await fs4.writeFile(filePath, JSON.stringify(payload), "utf8");
   } catch {
   }
 }
@@ -887,11 +1545,31 @@ function ensureStateBridge() {
   }
 }
 var win = null;
+var uiCliBridge = new UiCliBridge({ getWindow: getWin });
 configureElectronPaths();
+var singleInstanceLock = app.requestSingleInstanceLock();
+if (!singleInstanceLock) {
+  app.quit();
+}
 function getWin() {
   if (!win || win.isDestroyed()) return null;
   return win;
 }
+if (singleInstanceLock) {
+  app.on("second-instance", () => {
+    const w = getWin();
+    if (w) {
+      if (w.isMinimized()) w.restore();
+      w.focus();
+      return;
+    }
+    if (app.isReady()) {
+      createWindow();
+    } else {
+      app.whenReady().then(() => createWindow());
+    }
+  });
+}
 function isUiOperational() {
   const w = getWin();
   if (!w) return false;
@@ -951,6 +1629,85 @@ function killAllRuns(reason = "ui_heartbeat_timeout") {
     void stopCoreServicesBestEffort(reason);
   }
 }
+function trackRunPid(child) {
+  const pid = Number(child?.pid || 0);
+  if (pid > 0) trackedRunPids.add(pid);
+}
+function untrackRunPid(child) {
+  const pid = Number(child?.pid || 0);
+  if (pid > 0) trackedRunPids.delete(pid);
+}
+async function cleanupTrackedRunPidsBestEffort(reason) {
+  for (const pid of Array.from(trackedRunPids.values())) {
+    try {
+      if (process.platform === "win32") {
+        spawn2("taskkill", ["/PID", String(pid), "/T", "/F"], { stdio: "ignore", windowsHide: true });
+      } else {
+        spawn2("pkill", ["-TERM", "-P", String(pid)], { stdio: "ignore" }).on("error", () => {
+        });
+        process.kill(pid, "SIGTERM");
+      }
+    } catch {
+    }
+    trackedRunPids.delete(pid);
+  }
+  if (trackedRunPids.size > 0) {
+    console.warn(`[desktop-console] residual run pids after cleanup (${reason}): ${trackedRunPids.size}`);
+    trackedRunPids.clear();
+  }
+}
+async function cleanupCamoSessionsBestEffort(reason, includeLocks) {
+  const camoCli = path6.join(REPO_ROOT2, "bin", "camoufox-cli.mjs");
+  const invoke = async (args, timeoutMs = 6e4) => runJson({
+    title: `camo ${args.join(" ")}`,
+    cwd: REPO_ROOT2,
+    args: [camoCli, ...args, "--json"],
+    timeoutMs
+  }).catch((err) => ({ ok: false, error: err?.message || String(err) }));
+  const stopAll = await invoke(["stop", "all"]);
+  if (!stopAll?.ok) {
+    console.warn(`[desktop-console] camo stop all failed (${reason})`, stopAll?.error || stopAll?.stderr || stopAll?.stdout || stopAll);
+  }
+  if (!includeLocks) return;
+  const cleanupLocks = await invoke(["cleanup", "locks"]);
+  if (!cleanupLocks?.ok) {
+    console.warn(`[desktop-console] camo cleanup locks failed (${reason})`, cleanupLocks?.error || cleanupLocks?.stderr || cleanupLocks?.stdout || cleanupLocks);
+  }
+}
+async function cleanupRuntimeEnvironment(reason, options = {}) {
+  killAllRuns(reason);
+  await cleanupTrackedRunPidsBestEffort(reason);
+  await cleanupCamoSessionsBestEffort(reason, options.includeLockCleanup !== false);
+  if (options.stopUiBridge) {
+    await uiCliBridge.stop().catch(() => null);
+  }
+  if (options.stopHeartbeat) {
+    stopCoreServiceHeartbeat();
+  }
+  if (heartbeatWatchdog) {
+    clearInterval(heartbeatWatchdog);
+    heartbeatWatchdog = null;
+  }
+  if (options.stopCoreServices) {
+    await stopCoreServicesBestEffort(reason);
+  }
+  if (options.stopStateBridge) {
+    stateBridge.stop();
+  }
+}
+function ensureAppExitCleanup(reason, options = {}) {
+  if (appExitCleanupPromise) return appExitCleanupPromise;
+  appExitCleanupPromise = cleanupRuntimeEnvironment(reason, {
+    stopUiBridge: true,
+    stopHeartbeat: true,
+    stopCoreServices: true,
+    stopStateBridge: options.stopStateBridge === true,
+    includeLockCleanup: true
+  }).finally(() => {
+    appExitCleanupPromise = null;
+  });
+  return appExitCleanupPromise;
+}
 function ensureHeartbeatWatchdog() {
   if (heartbeatWatchdog) return;
   heartbeatWatchdog = setInterval(() => {
@@ -1028,13 +1785,13 @@ function resolveNodeBin2() {
 function resolveCwd(input) {
   const raw = String(input || "").trim();
   if (!raw) return REPO_ROOT2;
-  return path5.isAbsolute(raw) ? raw : path5.resolve(REPO_ROOT2, raw);
+  return path6.isAbsolute(raw) ? raw : path6.resolve(REPO_ROOT2, raw);
 }
 var cachedStateMod = null;
 async function getStateModule() {
   if (cachedStateMod) return cachedStateMod;
   try {
-    const p = path5.join(REPO_ROOT2, "dist", "modules", "state", "src", "xiaohongshu-collect-state.js");
+    const p = path6.join(REPO_ROOT2, "dist", "modules", "state", "src", "xiaohongshu-collect-state.js");
     cachedStateMod = await import(pathToFileURL3(p).href);
     return cachedStateMod;
   } catch {
@@ -1047,6 +1804,34 @@ async function spawnCommand(spec) {
   const groupKey = spec.groupKey || "xiaohongshu";
   const q = getQueue(groupKey);
   const cwd = resolveCwd(spec.cwd);
+  const args = Array.isArray(spec.args) ? spec.args : [];
+  const isXhsRunCommand = args.some((item) => /xhs-(orchestrate|unified)\.mjs$/i.test(String(item || "").replace(/\\/g, "/")));
+  const extractProfilesFromArgs = (argv) => {
+    const out = [];
+    for (let i = 0; i < argv.length; i += 1) {
+      const flag = String(argv[i] || "").trim();
+      if (flag === "--profile" || flag === "--profile-id") {
+        const value = String(argv[i + 1] || "").trim();
+        if (value) out.push(value);
+      } else if (flag === "--profiles") {
+        const value = String(argv[i + 1] || "").trim();
+        if (value) {
+          value.split(",").map((v) => v.trim()).filter(Boolean).forEach((v) => out.push(v));
+        }
+      }
+    }
+    return Array.from(new Set(out));
+  };
+  const requestedProfiles = isXhsRunCommand ? extractProfilesFromArgs(args) : [];
+  if (requestedProfiles.length > 0) {
+    for (const run of runs.values()) {
+      const activeProfiles = Array.isArray(run.profiles) ? run.profiles : [];
+      const conflict = requestedProfiles.find((p) => activeProfiles.includes(p));
+      if (conflict) {
+        throw new Error(`profile already running: ${conflict}`);
+      }
+    }
+  }
   q.enqueue(
     () => new Promise((resolve) => {
       let finished = false;
@@ -1059,7 +1844,7 @@ async function spawnCommand(spec) {
         runs.delete(runId);
         resolve();
       };
-      const child = spawn2(resolveNodeBin2(), spec.args, {
+      const child = spawn2(resolveNodeBin2(), args, {
         cwd,
         env: {
           ...process.env,
@@ -1070,7 +1855,8 @@ async function spawnCommand(spec) {
         stdio: ["ignore", "pipe", "pipe"],
         windowsHide: true
       });
-      runs.set(runId, { child, title: spec.title, startedAt: now() });
+      trackRunPid(child);
+      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");
@@ -1089,6 +1875,7 @@ async function spawnCommand(spec) {
         exitSignal = signal;
       });
       child.on("close", (code, signal) => {
+        untrackRunPid(child);
         stdoutLines.flush();
         stderrLines.flush();
         finalize(exitCode ?? code ?? null, exitSignal ?? signal ?? null);
@@ -1134,21 +1921,21 @@ async function runJson(spec) {
 }
 async function scanResults(input) {
   const downloadRoot = String(input.downloadRoot || resolveDefaultDownloadRoot());
-  const root = path5.join(downloadRoot, "xiaohongshu");
+  const root = path6.join(downloadRoot, "xiaohongshu");
   const result = { ok: true, root, entries: [] };
   try {
     const stateMod = await getStateModule();
-    const envDirs = await fs3.readdir(root, { withFileTypes: true });
+    const envDirs = await fs4.readdir(root, { withFileTypes: true });
     for (const envEnt of envDirs) {
       if (!envEnt.isDirectory()) continue;
       const env = envEnt.name;
-      const envPath = path5.join(root, env);
-      const keywordDirs = await fs3.readdir(envPath, { withFileTypes: true });
+      const envPath = path6.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 = path5.join(envPath, keyword);
-        const stat = await fs3.stat(kwPath).catch(() => null);
+        const kwPath = path6.join(envPath, keyword);
+        const stat = await fs4.stat(kwPath).catch(() => null);
         let stateSummary = null;
         if (stateMod?.loadXhsCollectState) {
           try {
@@ -1176,13 +1963,13 @@ async function scanResults(input) {
 }
 async function listXhsFullCollectScripts() {
   try {
-    const entries = await fs3.readdir(XHS_SCRIPTS_ROOT, { withFileTypes: true });
+    const entries = await fs4.readdir(XHS_SCRIPTS_ROOT, { withFileTypes: true });
     const scripts = entries.filter((ent) => ent.isFile() && XHS_FULL_COLLECT_RE.test(ent.name)).map((ent) => {
       const name = ent.name;
       return {
         id: `xhs:${name}`,
         label: `Full Collect (${name})`,
-        path: path5.join(XHS_SCRIPTS_ROOT, name)
+        path: path6.join(XHS_SCRIPTS_ROOT, name)
       };
     });
     return { ok: true, scripts };
@@ -1195,7 +1982,7 @@ async function readTextPreview(input) {
   const maxBytes = typeof input.maxBytes === "number" ? input.maxBytes : 8e4;
   const maxLines = typeof input.maxLines === "number" ? input.maxLines : 200;
   try {
-    const raw = await fs3.readFile(filePath, "utf8");
+    const raw = await fs4.readFile(filePath, "utf8");
     const clipped = raw.slice(0, maxBytes);
     const lines = clipped.split(/\r?\n/g).slice(0, maxLines);
     return { ok: true, path: filePath, text: lines.join("\n") };
@@ -1208,14 +1995,14 @@ async function readTextTail(input) {
   const filePath = String(input?.path || "");
   const requestedOffset = typeof input?.fromOffset === "number" ? Math.max(0, Math.floor(input.fromOffset)) : 0;
   const maxBytes = typeof input?.maxBytes === "number" ? Math.max(1024, Math.floor(input.maxBytes)) : 256e3;
-  const st = await fs3.stat(filePath);
+  const st = await fs4.stat(filePath);
   const size = Number(st?.size || 0);
   const fromOffset = requestedOffset > size ? 0 : requestedOffset;
   const toRead = Math.max(0, Math.min(maxBytes, size - fromOffset));
   if (toRead <= 0) {
     return { ok: true, path: filePath, text: "", fromOffset, nextOffset: fromOffset, fileSize: size };
   }
-  const fh = await fs3.open(filePath, "r");
+  const fh = await fs4.open(filePath, "r");
   try {
     const buf = Buffer.allocUnsafe(toRead);
     const { bytesRead } = await fh.read(buf, 0, toRead, fromOffset);
@@ -1235,7 +2022,7 @@ async function readTextTail(input) {
 async function readFileBase64(input) {
   const filePath = String(input.path || "");
   const maxBytes = typeof input.maxBytes === "number" ? input.maxBytes : 8e6;
-  const buf = await fs3.readFile(filePath);
+  const buf = await fs4.readFile(filePath);
   if (buf.byteLength > maxBytes) {
     return { ok: false, error: `file too large: ${buf.byteLength}` };
   }
@@ -1249,14 +2036,14 @@ async function listDir(input) {
   const stack = [root];
   while (stack.length > 0 && entries.length < maxEntries) {
     const dir = stack.pop();
-    const items = await fs3.readdir(dir, { withFileTypes: true }).catch(() => []);
+    const items = await fs4.readdir(dir, { withFileTypes: true }).catch(() => []);
     for (const ent of items) {
       if (entries.length >= maxEntries) break;
-      const full = path5.join(dir, ent.name);
-      const st = await fs3.stat(full).catch(() => null);
+      const full = path6.join(dir, ent.name);
+      const st = await fs4.stat(full).catch(() => null);
       entries.push({
         path: full,
-        rel: path5.relative(root, full),
+        rel: path6.relative(root, full),
         name: ent.name,
         isDir: ent.isDirectory(),
         size: st?.size || 0,
@@ -1279,7 +2066,7 @@ function createWindow() {
     minWidth: 920,
     minHeight: 800,
     webPreferences: {
-      preload: path5.join(APP_ROOT, "dist", "main", "preload.mjs"),
+      preload: path6.join(APP_ROOT, "dist", "main", "preload.mjs"),
       contextIsolation: true,
       nodeIntegration: false,
       sandbox: false,
@@ -1287,28 +2074,19 @@ function createWindow() {
       backgroundThrottling: false
     }
   });
-  const htmlPath = path5.join(APP_ROOT, "dist", "renderer", "index.html");
+  const htmlPath = path6.join(APP_ROOT, "dist", "renderer", "index.html");
   void win.loadFile(htmlPath);
   ensureStateBridge();
 }
 app.on("window-all-closed", () => {
-  killAllRuns("window_closed");
+  void ensureAppExitCleanup("window_closed");
   app.quit();
 });
 app.on("before-quit", () => {
-  killAllRuns("before_quit");
-  stopCoreServiceHeartbeat();
-  void stopCoreServicesBestEffort("before_quit");
-  if (heartbeatWatchdog) {
-    clearInterval(heartbeatWatchdog);
-    heartbeatWatchdog = null;
-  }
+  void ensureAppExitCleanup("before_quit");
 });
 app.on("will-quit", () => {
-  killAllRuns("will_quit");
-  stopCoreServiceHeartbeat();
-  void stopCoreServicesBestEffort("will_quit");
-  stateBridge.stop();
+  void ensureAppExitCleanup("will_quit", { stopStateBridge: true });
 });
 app.whenReady().then(async () => {
   startCoreServiceHeartbeat();
@@ -1319,6 +2097,9 @@ app.whenReady().then(async () => {
   markUiHeartbeat("main_ready");
   ensureHeartbeatWatchdog();
   createWindow();
+  await uiCliBridge.start().catch((err) => {
+    console.warn("[desktop-console] ui-cli bridge start failed", err);
+  });
 });
 ipcMain2.on("preload:test", () => {
   console.log("[preload-test] window.api OK");
@@ -1468,9 +2249,58 @@ ipcMain2.handle("env:checkGeoIP", async () => checkGeoIP());
 ipcMain2.handle("env:checkAll", async () => checkEnvironment());
 ipcMain2.handle("env:repairCore", async () => {
   const ok = await startCoreDaemon().catch(() => false);
-  const services = await checkServices().catch(() => ({ unifiedApi: false, browserService: false }));
+  const services = await checkServices().catch(() => ({ unifiedApi: false, camoRuntime: false }));
   return { ok, services };
 });
+ipcMain2.handle("env:repairDeps", async (_evt, input) => {
+  const wantCore = Boolean(input?.core);
+  const wantBrowser = Boolean(input?.browser);
+  const wantGeoip = Boolean(input?.geoip);
+  const wantReinstall = Boolean(input?.reinstall);
+  const wantUninstall = Boolean(input?.uninstall);
+  const result = { ok: true, core: null, install: null, env: null };
+  if (wantCore) {
+    const coreOk = await startCoreDaemon().catch(() => false);
+    result.core = {
+      ok: coreOk,
+      services: await checkServices().catch(() => ({ unifiedApi: false, camoRuntime: false }))
+    };
+    if (!coreOk) result.ok = false;
+  }
+  if (wantBrowser || wantGeoip) {
+    const args = [path6.join("apps", "webauto", "entry", "xhs-install.mjs")];
+    if (wantReinstall) args.push("--reinstall");
+    else if (wantUninstall) args.push("--uninstall");
+    else args.push("--install");
+    if (wantBrowser) args.push("--download-browser");
+    if (wantGeoip) args.push("--download-geoip");
+    if (!wantUninstall) args.push("--ensure-backend");
+    const installRes = await runJson({
+      title: "env repair deps",
+      cwd: REPO_ROOT2,
+      args,
+      timeoutMs: 3e5
+    }).catch((err) => ({ ok: false, error: err?.message || String(err) }));
+    result.install = installRes;
+    if (!installRes?.ok) result.ok = false;
+  }
+  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 };
@@ -1561,7 +2391,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 = [path5.join(REPO_ROOT2, "scripts", "xiaohongshu", "phase1-boot.mjs"), "--profile", profileId, "--headless", "false"];
+  const args = [path6.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) => {