@web-auto/webauto 0.1.1 → 0.1.2

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

@@ -0,0 +1,1618 @@
+// 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 { fileURLToPath as fileURLToPath2, pathToFileURL as pathToFileURL3 } from "node:url";
+import { mkdirSync, promises as fs3 } from "node:fs";
+
+// src/main/desktop-settings.mts
+import { promises as fs } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+function resolveHomeDir() {
+  const homeDir = process.platform === "win32" ? process.env.USERPROFILE || os.homedir() || "" : process.env.HOME || os.homedir() || "";
+  if (!homeDir) throw new Error("\u65E0\u6CD5\u83B7\u53D6\u7528\u6237\u4E3B\u76EE\u5F55\uFF1AHOME/USERPROFILE \u672A\u8BBE\u7F6E");
+  return homeDir;
+}
+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 normalizeAiReplyConfig(raw) {
+  if (!raw || typeof raw !== "object") {
+    return {
+      enabled: false,
+      provider: "openai-compatible",
+      baseUrl: "http://127.0.0.1:5520",
+      apiKey: "",
+      model: "iflow.glm-5",
+      temperature: 0.7,
+      maxChars: 20,
+      timeoutMs: 25e3,
+      stylePreset: "friendly",
+      styleCustom: ""
+    };
+  }
+  const stylePresets = ["friendly", "professional", "humorous", "concise", "custom"];
+  const preset = String(raw.stylePreset || "friendly");
+  return {
+    enabled: Boolean(raw.enabled ?? false),
+    provider: "openai-compatible",
+    baseUrl: String(raw.baseUrl || "http://127.0.0.1:5520"),
+    apiKey: String(raw.apiKey || ""),
+    model: String(raw.model || "iflow.glm-5"),
+    temperature: Math.max(0, Math.min(2, Number(raw.temperature ?? 0.7))),
+    maxChars: Math.max(5, Math.min(500, Math.floor(Number(raw.maxChars ?? 20)))),
+    timeoutMs: Math.max(5e3, Math.floor(Number(raw.timeoutMs ?? 25e3))),
+    stylePreset: stylePresets.includes(preset) ? preset : "friendly",
+    styleCustom: String(raw.styleCustom || "")
+  };
+}
+function normalizeSettings(defaults, input) {
+  const aliasesRaw = input.profileAliases ?? defaults.profileAliases ?? {};
+  const aliases = {};
+  if (aliasesRaw && typeof aliasesRaw === "object") {
+    for (const [k, v] of Object.entries(aliasesRaw)) {
+      const key = String(k || "").trim();
+      const val = String(v || "").trim();
+      if (!key) continue;
+      if (!val) continue;
+      aliases[key] = val;
+    }
+  }
+  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"),
+    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",
+    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),
+    timeouts: {
+      loginTimeoutSec: Math.max(
+        30,
+        Math.floor(
+          Number(
+            input.timeouts?.loginTimeoutSec ?? defaults.timeouts?.loginTimeoutSec ?? 900
+          )
+        )
+      ),
+      cmdTimeoutSec: Math.max(
+        0,
+        Math.floor(
+          Number(
+            input.timeouts?.cmdTimeoutSec ?? defaults.timeouts?.cmdTimeoutSec ?? 0
+          )
+        )
+      )
+    },
+    profileAliases: aliases,
+    profileColors: normalizeColorMap(input.profileColors ?? defaults.profileColors ?? {}),
+    aiReply: normalizeAiReplyConfig(input.aiReply ?? defaults.aiReply ?? {}),
+    lastCrawlConfig: input.lastCrawlConfig ?? defaults.lastCrawlConfig ?? void 0
+  };
+  return merged;
+}
+function normalizeColorMap(raw) {
+  const out = {};
+  if (!raw || typeof raw !== "object") return out;
+  for (const [k, v] of Object.entries(raw)) {
+    const key = String(k || "").trim();
+    const val = String(v || "").trim();
+    if (!key || !val) continue;
+    if (!/^#[0-9a-fA-F]{6}$/.test(val)) continue;
+    out[key] = val;
+  }
+  return out;
+}
+async function readDefaultSettingsFromAppRoot(appRoot) {
+  const defaultsPath = path.join(appRoot, "default-settings.json");
+  let raw = {};
+  try {
+    const text = await fs.readFile(defaultsPath, "utf8");
+    raw = JSON.parse(text) || {};
+  } catch {
+    raw = {};
+  }
+  const base = {
+    unifiedApiUrl: raw.unifiedApiUrl,
+    browserServiceUrl: 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();
+  return normalizeSettings({ ...base, downloadRoot }, {});
+}
+async function readLegacySettings() {
+  const legacyPath = resolveLegacySettingsPath();
+  try {
+    const text = await fs.readFile(legacyPath, "utf8");
+    const parsed = JSON.parse(text) || {};
+    if (!parsed || typeof parsed !== "object") return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function tryLoadConfigApi(repoRoot) {
+  const distEntry = path.join(repoRoot, "dist", "modules", "config", "index.js");
+  try {
+    await fs.access(distEntry);
+  } catch {
+    return null;
+  }
+  try {
+    const mod = await import(pathToFileURL(distEntry).href);
+    if (!mod?.loadConfig || !mod?.saveConfig || !mod?.loader?.ensureExists) return null;
+    return mod;
+  } catch {
+    return null;
+  }
+}
+async function readDesktopConsoleSettings(input) {
+  const defaults = await readDefaultSettingsFromAppRoot(input.appRoot);
+  const configApi = await tryLoadConfigApi(input.repoRoot);
+  if (!configApi) {
+    const legacy2 = await readLegacySettings();
+    return normalizeSettings(defaults, legacy2 || {});
+  }
+  await configApi.loader.ensureExists();
+  const cfg = await configApi.loadConfig();
+  const fromConfig = cfg && cfg.desktopConsole ? cfg.desktopConsole : null;
+  if (fromConfig) {
+    return normalizeSettings(defaults, fromConfig);
+  }
+  const legacy = await readLegacySettings();
+  if (legacy) {
+    const migrated = normalizeSettings(defaults, legacy);
+    const nextCfg2 = configApi.loader.merge(cfg, { desktopConsole: migrated });
+    await configApi.saveConfig(nextCfg2);
+    return migrated;
+  }
+  const seeded = normalizeSettings(defaults, {});
+  const nextCfg = configApi.loader.merge(cfg, { desktopConsole: seeded });
+  await configApi.saveConfig(nextCfg);
+  return seeded;
+}
+async function writeDesktopConsoleSettings(input, next) {
+  const current = await readDesktopConsoleSettings(input);
+  const defaults = await readDefaultSettingsFromAppRoot(input.appRoot);
+  const merged = normalizeSettings(defaults, { ...current, ...next, timeouts: { ...current.timeouts, ...next.timeouts || {} } });
+  const configApi = await tryLoadConfigApi(input.repoRoot);
+  if (configApi) {
+    await configApi.loader.ensureExists();
+    const cfg = await configApi.loadConfig();
+    const nextCfg = configApi.loader.merge(cfg, { desktopConsole: merged });
+    await configApi.saveConfig(nextCfg);
+    return merged;
+  }
+  const legacyPath = resolveLegacySettingsPath();
+  await fs.mkdir(path.dirname(legacyPath), { recursive: true });
+  await fs.writeFile(legacyPath, JSON.stringify(merged, null, 2), "utf8");
+  return merged;
+}
+async function saveCrawlConfig(input, config) {
+  const current = await readDesktopConsoleSettings(input);
+  const next = { ...current, lastCrawlConfig: config };
+  await writeDesktopConsoleSettings(input, next);
+}
+async function loadCrawlConfig(input) {
+  const current = await readDesktopConsoleSettings(input);
+  return current.lastCrawlConfig || null;
+}
+async function exportConfigToFile(filePath, config) {
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  const content = JSON.stringify(config, null, 2);
+  const isWindows = process.platform === "win32";
+  if (isWindows) {
+    const BOM = "\uFEFF";
+    await fs.writeFile(filePath, BOM + content, "utf8");
+  } else {
+    await fs.writeFile(filePath, content, "utf8");
+  }
+  return { ok: true, path: filePath };
+}
+async function importConfigFromFile(filePath) {
+  const content = await fs.readFile(filePath, "utf8");
+  const cleanContent = content.replace(/^\uFEFF/, "");
+  const config = JSON.parse(cleanContent);
+  return { ok: true, config };
+}
+
+// src/main/core-daemon-manager.mts
+import { spawn } from "child_process";
+import path2 from "path";
+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 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) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function resolveNodeBin() {
+  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;
+  return process.platform === "win32" ? "node.exe" : "node";
+}
+function resolveNpxBin() {
+  return process.platform === "win32" ? "npx.cmd" : "npx";
+}
+async function checkHttpHealth(url) {
+  try {
+    const res = await fetch(url, { signal: AbortSignal.timeout(1e3) });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+async function areCoreServicesHealthy() {
+  const health = await Promise.all(CORE_HEALTH_URLS.map((url) => checkHttpHealth(url)));
+  return health.every(Boolean);
+}
+async function runNodeScript(scriptPath, timeoutMs) {
+  return new Promise((resolve) => {
+    const nodeBin = resolveNodeBin();
+    const child = spawn(nodeBin, [scriptPath], {
+      cwd: REPO_ROOT,
+      stdio: "ignore",
+      windowsHide: true,
+      detached: false,
+      env: {
+        ...process.env,
+        BROWSER_SERVICE_AUTO_EXIT: "0"
+      }
+    });
+    const timer = setTimeout(() => {
+      try {
+        child.kill("SIGTERM");
+      } catch {
+      }
+      resolve(false);
+    }, timeoutMs);
+    child.once("error", () => {
+      clearTimeout(timer);
+      resolve(false);
+    });
+    child.once("exit", (code) => {
+      clearTimeout(timer);
+      resolve(code === 0);
+    });
+  });
+}
+async function runCommand(command, args, timeoutMs) {
+  return new Promise((resolve) => {
+    const child = spawn(command, args, {
+      cwd: REPO_ROOT,
+      stdio: "ignore",
+      windowsHide: true,
+      detached: false,
+      env: {
+        ...process.env
+      }
+    });
+    const timer = setTimeout(() => {
+      try {
+        child.kill("SIGTERM");
+      } catch {
+      }
+      resolve(false);
+    }, timeoutMs);
+    child.once("error", () => {
+      clearTimeout(timer);
+      resolve(false);
+    });
+    child.once("exit", (code) => {
+      clearTimeout(timer);
+      resolve(code === 0);
+    });
+  });
+}
+async function startCoreDaemon() {
+  if (await areCoreServicesHealthy()) return true;
+  const startedApi = await runNodeScript(START_API_SCRIPT, 4e4);
+  if (!startedApi) {
+    console.error("[CoreDaemonManager] Failed to start unified API service");
+    return false;
+  }
+  const startedBrowser = await runCommand(resolveNpxBin(), ["--yes", "@web-auto/camo", "init"], 4e4);
+  if (!startedBrowser) {
+    console.error("[CoreDaemonManager] Failed to start camo browser backend");
+    return false;
+  }
+  for (let i = 0; i < 20; i += 1) {
+    if (await areCoreServicesHealthy()) return true;
+    await sleep(300);
+  }
+  console.error("[CoreDaemonManager] Services still unhealthy after start");
+  return false;
+}
+async function stopCoreDaemon() {
+  const stoppedApi = await runNodeScript(STOP_API_SCRIPT, 2e4);
+  if (!stoppedApi) {
+    console.error("[CoreDaemonManager] Failed to stop core services");
+    return false;
+  }
+  return true;
+}
+
+// src/main/profile-store.mts
+import os2 from "node:os";
+import path3 from "node:path";
+import { promises as fs2 } from "node:fs";
+import { pathToFileURL as pathToFileURL2 } from "node:url";
+function resolveHomeDir2(opts) {
+  if (opts.homeDir) return opts.homeDir;
+  const homeDir = process.platform === "win32" ? process.env.USERPROFILE || os2.homedir() || "" : process.env.HOME || os2.homedir() || "";
+  if (!homeDir) throw new Error("\u65E0\u6CD5\u83B7\u53D6\u7528\u6237\u4E3B\u76EE\u5F55\uFF1AHOME/USERPROFILE \u672A\u8BBE\u7F6E");
+  return homeDir;
+}
+function resolvePortableRoot(opts) {
+  const root = String(process.env.WEBAUTO_PORTABLE_ROOT || process.env.WEBAUTO_ROOT || "").trim();
+  if (!root) return "";
+  return path3.join(root, ".webauto");
+}
+function isWithinDir(root, target) {
+  const rel = path3.relative(root, target);
+  return rel === "" || !rel.startsWith("..") && !path3.isAbsolute(rel);
+}
+function validateProfileId(profileId) {
+  const id = String(profileId || "").trim();
+  if (!id) throw new Error("profileId \u4E0D\u80FD\u4E3A\u7A7A");
+  if (id === "." || id === "..") throw new Error("profileId \u975E\u6CD5");
+  if (/[\\/]/.test(id)) throw new Error("profileId \u4E0D\u80FD\u5305\u542B\u8DEF\u5F84\u5206\u9694\u7B26");
+  return id;
+}
+function resolveRoots(opts) {
+  const homeDir = resolveHomeDir2(opts);
+  const envProfiles = String(process.env.WEBAUTO_PATHS_PROFILES || "").trim();
+  const envFingerprints = String(process.env.WEBAUTO_PATHS_FINGERPRINTS || "").trim();
+  const portable = resolvePortableRoot(opts);
+  return {
+    profilesRoot: envProfiles || (portable ? path3.join(portable, "profiles") : path3.join(homeDir, ".webauto", "profiles")),
+    fingerprintsRoot: envFingerprints || (portable ? path3.join(portable, "fingerprints") : path3.join(homeDir, ".webauto", "fingerprints"))
+  };
+}
+function resolveProfileDir(opts, profileId) {
+  const { profilesRoot } = resolveRoots(opts);
+  const profileDir = path3.join(profilesRoot, profileId);
+  if (!isWithinDir(profilesRoot, profileDir)) throw new Error("unsafe profile path");
+  return { profilesRoot, profileDir };
+}
+function resolveFingerprintPath(opts, profileId) {
+  const { fingerprintsRoot } = resolveRoots(opts);
+  const fingerprintPath = path3.join(fingerprintsRoot, `${profileId}.json`);
+  if (!isWithinDir(fingerprintsRoot, fingerprintPath)) throw new Error("unsafe fingerprint path");
+  return { fingerprintsRoot, fingerprintPath };
+}
+function createProfileStore(opts) {
+  let cachedFingerprintMod = null;
+  async function getFingerprintModule() {
+    if (cachedFingerprintMod) return cachedFingerprintMod;
+    const p = path3.join(opts.repoRoot, "dist", "modules", "camo-backend", "src", "internal", "fingerprint.js");
+    cachedFingerprintMod = await import(pathToFileURL2(p).href);
+    return cachedFingerprintMod;
+  }
+  async function listProfiles() {
+    const { profilesRoot } = resolveRoots(opts);
+    const entries = [];
+    try {
+      const dirs = await fs2.readdir(profilesRoot, { withFileTypes: true });
+      for (const ent of dirs) {
+        if (!ent.isDirectory()) continue;
+        const name = ent.name;
+        if (!name || name.startsWith(".")) continue;
+        entries.push(name);
+      }
+    } catch {
+    }
+    entries.sort((a, b) => a.localeCompare(b));
+    return { ok: true, root: profilesRoot, profiles: entries };
+  }
+  async function scanProfiles() {
+    const { profilesRoot, fingerprintsRoot } = resolveRoots(opts);
+    const entries = [];
+    const dirs = await fs2.readdir(profilesRoot, { withFileTypes: true }).catch(() => []);
+    for (const ent of dirs) {
+      if (!ent.isDirectory()) continue;
+      const profileId = ent.name;
+      if (!profileId || profileId.startsWith(".")) continue;
+      const profileDir = path3.join(profilesRoot, profileId);
+      const profileStat = await fs2.stat(profileDir).catch(() => null);
+      const fingerprintPath = path3.join(fingerprintsRoot, `${profileId}.json`);
+      const fpStat = await fs2.stat(fingerprintPath).catch(() => null);
+      let fingerprint = null;
+      if (fpStat?.isFile()) {
+        try {
+          const raw = await fs2.readFile(fingerprintPath, "utf8");
+          const parsed = JSON.parse(raw || "{}");
+          if (parsed && typeof parsed === "object") fingerprint = parsed;
+        } catch {
+          fingerprint = null;
+        }
+      }
+      entries.push({
+        profileId,
+        profileDir,
+        profileMtimeMs: profileStat?.mtimeMs || 0,
+        fingerprintPath,
+        fingerprintMtimeMs: fpStat?.mtimeMs || null,
+        fingerprint
+      });
+    }
+    entries.sort((a, b) => {
+      if (a.profileMtimeMs !== b.profileMtimeMs) return b.profileMtimeMs - a.profileMtimeMs;
+      return a.profileId.localeCompare(b.profileId);
+    });
+    return { ok: true, profilesRoot, fingerprintsRoot, entries };
+  }
+  async function profileCreate(input) {
+    const profileId = validateProfileId(input?.profileId);
+    const { profileDir } = resolveProfileDir(opts, profileId);
+    await fs2.mkdir(profileDir, { recursive: true });
+    return { ok: true, profileId, profileDir };
+  }
+  async function profileDelete(input) {
+    const profileId = validateProfileId(input?.profileId);
+    const { profileDir } = resolveProfileDir(opts, profileId);
+    await fs2.rm(profileDir, { recursive: true, force: true });
+    if (input?.deleteFingerprint) {
+      const { fingerprintPath } = resolveFingerprintPath(opts, profileId);
+      await fs2.rm(fingerprintPath, { force: true });
+    }
+    return { ok: true, profileId };
+  }
+  async function fingerprintDelete(input) {
+    const profileId = validateProfileId(input?.profileId);
+    const { fingerprintPath } = resolveFingerprintPath(opts, profileId);
+    await fs2.rm(fingerprintPath, { force: true });
+    return { ok: true, profileId };
+  }
+  async function fingerprintRegenerate(input) {
+    const profileId = validateProfileId(input?.profileId);
+    const mod = await getFingerprintModule();
+    const platform = input?.platform === "windows" || input?.platform === "macos" ? input.platform : null;
+    const { fingerprintPath } = resolveFingerprintPath(opts, profileId);
+    const fingerprint = mod.generateFingerprint(profileId, { platform });
+    const saved = await mod.saveFingerprint(fingerprintPath, fingerprint);
+    if (!saved) throw new Error("failed to save fingerprint");
+    return {
+      ok: true,
+      profileId,
+      fingerprintPath,
+      fingerprint: {
+        platform: fingerprint?.platform,
+        originalPlatform: fingerprint?.originalPlatform,
+        osVersion: fingerprint?.osVersion,
+        userAgent: fingerprint?.userAgent,
+        viewport: fingerprint?.viewport,
+        fingerprintSalt: fingerprint?.fingerprintSalt
+      }
+    };
+  }
+  return {
+    listProfiles,
+    scanProfiles,
+    profileCreate,
+    profileDelete,
+    fingerprintDelete,
+    fingerprintRegenerate
+  };
+}
+
+// src/main/heartbeat-watchdog.mts
+var DEFAULT_UI_HEARTBEAT_TIMEOUT_MS = 5 * 6e4;
+function resolveUiHeartbeatTimeoutMs(env = process.env) {
+  const raw = Number.parseInt(String(env.WEBAUTO_UI_HEARTBEAT_TIMEOUT_MS || "").trim(), 10);
+  if (Number.isFinite(raw) && raw >= 3e4 && raw <= 60 * 6e4) {
+    return raw;
+  }
+  return DEFAULT_UI_HEARTBEAT_TIMEOUT_MS;
+}
+function decideWatchdogAction(input) {
+  if (input.staleMs <= input.timeoutMs) {
+    return { action: "none", nextHandled: false, reason: "healthy" };
+  }
+  if (input.alreadyHandled) {
+    return { action: "none", nextHandled: true, reason: "already_handled" };
+  }
+  if (input.uiOperational) {
+    return { action: "none", nextHandled: true, reason: "stale_ui_alive" };
+  }
+  if (input.runCount > 0) {
+    return { action: "kill_runs", nextHandled: true, reason: "stale_ui_unavailable_with_runs" };
+  }
+  return { action: "stop_core_services", nextHandled: true, reason: "stale_ui_unavailable_idle" };
+}
+
+// src/main/state-bridge.mts
+import { ipcMain } from "electron";
+import WebSocket from "ws";
+var UNIFIED_API_WS = process.env.WEBAUTO_UNIFIED_WS || "ws://127.0.0.1:7701/ws";
+var API_URL = "http://127.0.0.1:7701";
+var StateBridge = class {
+  ws = null;
+  reconnectTimer = null;
+  win = null;
+  tasks = /* @__PURE__ */ new Map();
+  handlersRegistered = false;
+  start(win2) {
+    this.win = win2;
+    this.connect();
+    this.setupIPCHandlers();
+  }
+  connect() {
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    try {
+      this.ws = new WebSocket(UNIFIED_API_WS);
+      this.ws.on("open", () => {
+        console.log("[StateBridge] connected to", UNIFIED_API_WS);
+        this.ws?.send(JSON.stringify({ type: "subscribe", topic: "task:*" }));
+      });
+      this.ws.on("message", (data) => {
+        try {
+          const msg = JSON.parse(data.toString());
+          if (msg.type === "task:update" && msg.data) {
+            this.handleTaskUpdate(msg.data);
+          }
+        } catch (err) {
+          console.warn("[StateBridge] parse error:", err);
+        }
+      });
+      this.ws.on("close", () => {
+        console.log("[StateBridge] disconnected, reconnecting...");
+        this.scheduleReconnect();
+      });
+      this.ws.on("error", (err) => {
+        console.warn("[StateBridge] error:", err.message);
+      });
+    } catch (err) {
+      console.warn("[StateBridge] connect failed:", err);
+      this.scheduleReconnect();
+    }
+  }
+  scheduleReconnect() {
+    if (this.reconnectTimer) clearTimeout(this.reconnectTimer);
+    this.reconnectTimer = setTimeout(() => this.connect(), 3e3);
+  }
+  handleTaskUpdate(update) {
+    const task = this.tasks.get(update.runId);
+    if (task) {
+      this.tasks.set(update.runId, { ...task, ...update.data });
+    }
+    this.win?.webContents.send("state:update", update);
+  }
+  setupIPCHandlers() {
+    if (this.handlersRegistered) return;
+    this.handlersRegistered = true;
+    const fetchJson = async (url) => {
+      try {
+        const res = await globalThis.fetch(url, { signal: AbortSignal.timeout(5e3) });
+        if (!res.ok) return null;
+        return await res.json().catch(() => null);
+      } catch {
+        return null;
+      }
+    };
+    ipcMain.handle("state:getTasks", async () => {
+      const json = await fetchJson(`${API_URL}/api/v1/tasks`);
+      return json?.data || [];
+    });
+    ipcMain.handle("state:getTask", async (_e, runId) => {
+      const json = await fetchJson(`${API_URL}/api/v1/tasks/${runId}`);
+      return json?.data ?? null;
+    });
+    ipcMain.handle("state:getEvents", async (_e, runId, since) => {
+      let url = `${API_URL}/api/v1/tasks/${runId}/events`;
+      if (since) url += `?since=${since}`;
+      const json = await fetchJson(url);
+      return json?.data || [];
+    });
+  }
+  stop() {
+    if (this.reconnectTimer) clearTimeout(this.reconnectTimer);
+    if (this.ws) this.ws.close();
+    this.ws = null;
+    this.win = null;
+  }
+};
+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 path4 from "node:path";
+import os3 from "node:os";
+var execAsync = promisify(exec);
+function resolveNpxBin2() {
+  return process.platform === "win32" ? "npx.cmd" : "npx";
+}
+function resolveCamoVersionFromText(stdout, stderr) {
+  const merged = `${String(stdout || "")}
+${String(stderr || "")}`.trim();
+  if (!merged) return "unknown";
+  const lines = merged.split(/\r?\n/).map((x) => x.trim()).filter(Boolean);
+  for (let i = lines.length - 1; i >= 0; i -= 1) {
+    if (!/version/i.test(lines[i])) continue;
+    const m = lines[i].match(/\d+\.\d+\.\d+(?:[-+][A-Za-z0-9._-]+)?/);
+    if (m?.[0]) return m[0];
+  }
+  return "unknown";
+}
+function runVersionCheck(command, args, explicitPath) {
+  try {
+    const ret = spawnSync(command, args, {
+      encoding: "utf8",
+      timeout: 8e3,
+      windowsHide: true
+    });
+    if (ret.status !== 0) {
+      return {
+        installed: false,
+        error: String(ret.stderr || ret.stdout || "").trim() || `exit ${ret.status}`
+      };
+    }
+    return {
+      installed: true,
+      path: explicitPath || command,
+      version: resolveCamoVersionFromText(String(ret.stdout || ""), String(ret.stderr || ""))
+    };
+  } catch (err) {
+    return { installed: false, error: String(err) };
+  }
+}
+async function checkCamoCli() {
+  const pathCheck = runVersionCheck(process.platform === "win32" ? "camo.cmd" : "camo", ["help"], "PATH:camo");
+  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)
+  ];
+  for (const candidate of localCandidates) {
+    if (!existsSync(candidate)) continue;
+    const ret = runVersionCheck(candidate, ["help"], candidate);
+    if (ret.installed) return ret;
+  }
+  const npxCheck = runVersionCheck(
+    resolveNpxBin2(),
+    ["--yes", "--package=@web-auto/camo", "camo", "help"],
+    "npx:@web-auto/camo"
+  );
+  if (npxCheck.installed) return npxCheck;
+  return {
+    installed: false,
+    error: "camo not found in PATH/local bin, and npx @web-auto/camo failed"
+  };
+}
+async function checkServices() {
+  const [unifiedApi, browserService, 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 };
+}
+async function checkFirefox() {
+  try {
+    const pythonBin = process.platform === "win32" ? "python" : "python3";
+    const ret = spawnSync(pythonBin, ["-m", "camoufox", "path"], {
+      encoding: "utf8",
+      timeout: 8e3,
+      windowsHide: true
+    });
+    if (ret.status === 0) {
+      const lines = String(ret.stdout || "").split(/\r?\n/).map((x) => x.trim()).filter(Boolean);
+      for (let i = lines.length - 1; i >= 0; i -= 1) {
+        const line = lines[i];
+        if (line && (line.startsWith("/") || /^[A-Z]:\\/.test(line))) return { installed: true, path: line };
+      }
+      return { installed: true };
+    }
+  } catch {
+  }
+  const platform = process.platform;
+  try {
+    if (platform === "win32") {
+      const programFiles = process.env.PROGRAMFILES || "C:\\Program Files";
+      const programFilesX86 = process.env["PROGRAMFILES(X86)"] || "C:\\Program Files (x86)";
+      const localAppData = process.env.LOCALAPPDATA || path4.join(os3.homedir(), "AppData", "Local");
+      const possiblePaths = [
+        path4.join(programFiles, "Mozilla Firefox", "firefox.exe"),
+        path4.join(programFilesX86, "Mozilla Firefox", "firefox.exe"),
+        path4.join(localAppData, "Mozilla Firefox", "firefox.exe")
+      ];
+      for (const firefoxPath2 of possiblePaths) {
+        if (existsSync(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 };
+    const { stdout } = await execAsync("which firefox", { timeout: 3e3 });
+    const firefoxPath = String(stdout || "").trim();
+    return firefoxPath ? { installed: true, path: firefoxPath } : { installed: false };
+  } catch {
+    return { installed: false };
+  }
+}
+async function checkGeoIP() {
+  const geoIpPath = path4.join(os3.homedir(), ".webauto", "geoip", "GeoLite2-City.mmdb");
+  if (existsSync(geoIpPath)) {
+    return { installed: true, path: geoIpPath };
+  }
+  return { installed: false };
+}
+async function checkEnvironment() {
+  const [camo, services, firefox, geoip] = await Promise.all([
+    checkCamoCli(),
+    checkServices(),
+    checkFirefox(),
+    checkGeoIP()
+  ]);
+  const allReady = camo.installed && services.unifiedApi && services.browserService && firefox.installed && geoip.installed;
+  return { camo, services, firefox, geoip, allReady };
+}
+
+// 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(),
+  ".webauto",
+  "run",
+  "desktop-console-heartbeat.json"
+);
+var profileStore = createProfileStore({ repoRoot: REPO_ROOT2 });
+var XHS_SCRIPTS_ROOT = path5.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");
+    try {
+      mkdirSync(cacheRoot, { recursive: true });
+    } catch {
+    }
+    try {
+      mkdirSync(gpuCacheRoot, { recursive: true });
+    } catch {
+    }
+    app.setPath("userData", userDataRoot);
+    app.setPath("cache", cacheRoot);
+    app.commandLine.appendSwitch("disk-cache-dir", cacheRoot);
+    app.commandLine.appendSwitch("gpu-cache-dir", gpuCacheRoot);
+  } catch (err) {
+    console.warn("[desktop-console] failed to configure cache paths", err);
+  }
+}
+function now() {
+  return Date.now();
+}
+var GroupQueue = class {
+  running = false;
+  queue = [];
+  enqueue(job) {
+    this.queue.push(job);
+    void this.pump();
+  }
+  async pump() {
+    if (this.running) return;
+    this.running = true;
+    try {
+      while (this.queue.length > 0) {
+        const job = this.queue.shift();
+        await job();
+      }
+    } finally {
+      this.running = false;
+    }
+  }
+};
+var groupQueues = /* @__PURE__ */ new Map();
+var runs = /* @__PURE__ */ new Map();
+var UI_HEARTBEAT_TIMEOUT_MS = resolveUiHeartbeatTimeoutMs(process.env);
+var lastUiHeartbeatAt = Date.now();
+var heartbeatWatchdog = null;
+var heartbeatTimeoutHandled = false;
+var coreServicesStopRequested = false;
+var coreServiceHeartbeatTimer = null;
+var coreServiceHeartbeatStopped = false;
+async function writeCoreServiceHeartbeat(status) {
+  const filePath = String(process.env.WEBAUTO_HEARTBEAT_FILE || DESKTOP_HEARTBEAT_FILE).trim() || DESKTOP_HEARTBEAT_FILE;
+  const payload = {
+    pid: process.pid,
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    status,
+    source: "desktop-console"
+  };
+  try {
+    await fs3.mkdir(path5.dirname(filePath), { recursive: true });
+    await fs3.writeFile(filePath, JSON.stringify(payload), "utf8");
+  } catch {
+  }
+}
+function startCoreServiceHeartbeat() {
+  const filePath = String(process.env.WEBAUTO_HEARTBEAT_FILE || DESKTOP_HEARTBEAT_FILE).trim() || DESKTOP_HEARTBEAT_FILE;
+  process.env.WEBAUTO_HEARTBEAT_FILE = filePath;
+  if (!process.env.WEBAUTO_HEARTBEAT_INTERVAL_MS) process.env.WEBAUTO_HEARTBEAT_INTERVAL_MS = "5000";
+  if (!process.env.WEBAUTO_HEARTBEAT_STALE_MS) process.env.WEBAUTO_HEARTBEAT_STALE_MS = "45000";
+  coreServiceHeartbeatStopped = false;
+  void writeCoreServiceHeartbeat("running");
+  if (coreServiceHeartbeatTimer) clearInterval(coreServiceHeartbeatTimer);
+  coreServiceHeartbeatTimer = setInterval(() => {
+    if (coreServiceHeartbeatStopped) return;
+    void writeCoreServiceHeartbeat("running");
+  }, 5e3);
+  coreServiceHeartbeatTimer.unref();
+}
+function stopCoreServiceHeartbeat() {
+  if (coreServiceHeartbeatStopped) return;
+  coreServiceHeartbeatStopped = true;
+  if (coreServiceHeartbeatTimer) {
+    clearInterval(coreServiceHeartbeatTimer);
+    coreServiceHeartbeatTimer = null;
+  }
+  void writeCoreServiceHeartbeat("stopped");
+}
+var stateBridgeStarted = false;
+function ensureStateBridge() {
+  if (stateBridgeStarted) return;
+  const w = getWin();
+  if (w) {
+    stateBridge.start(w);
+    stateBridgeStarted = true;
+  }
+}
+var win = null;
+configureElectronPaths();
+function getWin() {
+  if (!win || win.isDestroyed()) return null;
+  return win;
+}
+function isUiOperational() {
+  const w = getWin();
+  if (!w) return false;
+  const wc = w.webContents;
+  if (!wc || wc.isDestroyed()) return false;
+  if (typeof wc.isCrashed === "function" && wc.isCrashed()) return false;
+  return true;
+}
+function sendEvent(evt) {
+  if (!win || win.isDestroyed()) return;
+  win.webContents.send("cmd:event", evt);
+}
+function markUiHeartbeat(source = "renderer") {
+  lastUiHeartbeatAt = Date.now();
+  heartbeatTimeoutHandled = false;
+  return { ok: true, ts: new Date(lastUiHeartbeatAt).toISOString(), source };
+}
+function terminateRunProcess(runId, reason = "manual") {
+  const run = runs.get(runId);
+  if (!run) return false;
+  const child = run.child;
+  const pid = Number(child.pid || 0);
+  try {
+    if (process.platform === "win32") {
+      if (pid > 0) {
+        spawn2("taskkill", ["/PID", String(pid), "/T", "/F"], { stdio: "ignore", windowsHide: true });
+      }
+    } else {
+      if (pid > 0) {
+        spawn2("pkill", ["-TERM", "-P", String(pid)], { stdio: "ignore" }).on("error", () => {
+        });
+      }
+    }
+  } catch {
+  }
+  try {
+    child.kill("SIGTERM");
+  } catch {
+  }
+  sendEvent({ type: "stderr", runId, line: `[watchdog] kill requested (${reason})`, ts: now() });
+  return true;
+}
+async function stopCoreServicesBestEffort(reason) {
+  if (coreServicesStopRequested) return;
+  coreServicesStopRequested = true;
+  try {
+    await stopCoreDaemon();
+  } catch (err) {
+    console.warn(`[desktop-console] core-daemon stop failed (${reason})`, err);
+  }
+}
+function killAllRuns(reason = "ui_heartbeat_timeout") {
+  for (const runId of Array.from(runs.keys())) {
+    terminateRunProcess(runId, reason);
+  }
+  if (reason === "ui_heartbeat_timeout" || reason === "window_closed") {
+    void stopCoreServicesBestEffort(reason);
+  }
+}
+function ensureHeartbeatWatchdog() {
+  if (heartbeatWatchdog) return;
+  heartbeatWatchdog = setInterval(() => {
+    const staleMs = Date.now() - lastUiHeartbeatAt;
+    const decision = decideWatchdogAction({
+      staleMs,
+      timeoutMs: UI_HEARTBEAT_TIMEOUT_MS,
+      alreadyHandled: heartbeatTimeoutHandled,
+      runCount: runs.size,
+      uiOperational: isUiOperational()
+    });
+    heartbeatTimeoutHandled = decision.nextHandled;
+    if (decision.action === "none") {
+      if (decision.reason === "stale_ui_alive") {
+        console.warn(
+          `[desktop-heartbeat] stale ${staleMs}ms > ${UI_HEARTBEAT_TIMEOUT_MS}ms, UI still alive, skip kill (likely timer throttling)`
+        );
+      }
+      return;
+    }
+    if (decision.action === "kill_runs") {
+      console.warn(`[desktop-heartbeat] stale ${staleMs}ms > ${UI_HEARTBEAT_TIMEOUT_MS}ms, killing ${runs.size} run(s)`);
+      killAllRuns("ui_heartbeat_timeout");
+      return;
+    }
+    console.warn(`[desktop-heartbeat] stale ${staleMs}ms > ${UI_HEARTBEAT_TIMEOUT_MS}ms, stopping core services`);
+    void stopCoreServicesBestEffort("heartbeat_stop_only");
+  }, 5e3);
+  heartbeatWatchdog.unref();
+}
+function getQueue(groupKey) {
+  const key = groupKey || "default";
+  let q = groupQueues.get(key);
+  if (!q) {
+    q = new GroupQueue();
+    groupQueues.set(key, q);
+  }
+  return q;
+}
+function generateRunId() {
+  return `run_${Date.now()}_${Math.random().toString(16).slice(2, 8)}`;
+}
+function createLineEmitter(runId, type) {
+  let pending = "";
+  const emit = (line) => {
+    const normalized = String(line || "").replace(/\r$/, "");
+    if (!normalized) return;
+    sendEvent({ type, runId, line: normalized, ts: now() });
+  };
+  return {
+    push(chunk) {
+      pending += chunk.toString("utf8");
+      let idx = pending.indexOf("\n");
+      while (idx >= 0) {
+        const line = pending.slice(0, idx);
+        pending = pending.slice(idx + 1);
+        emit(line);
+        idx = pending.indexOf("\n");
+      }
+    },
+    flush() {
+      if (!pending) return;
+      emit(pending);
+      pending = "";
+    }
+  };
+}
+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;
+  return process.platform === "win32" ? "node.exe" : "node";
+}
+function resolveCwd(input) {
+  const raw = String(input || "").trim();
+  if (!raw) return REPO_ROOT2;
+  return path5.isAbsolute(raw) ? raw : path5.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");
+    cachedStateMod = await import(pathToFileURL3(p).href);
+    return cachedStateMod;
+  } catch {
+    cachedStateMod = null;
+    return null;
+  }
+}
+async function spawnCommand(spec) {
+  const runId = generateRunId();
+  const groupKey = spec.groupKey || "xiaohongshu";
+  const q = getQueue(groupKey);
+  const cwd = resolveCwd(spec.cwd);
+  q.enqueue(
+    () => new Promise((resolve) => {
+      let finished = false;
+      let exitCode = null;
+      let exitSignal = null;
+      const finalize = (code, signal) => {
+        if (finished) return;
+        finished = true;
+        sendEvent({ type: "exit", runId, exitCode: code, signal, ts: now() });
+        runs.delete(runId);
+        resolve();
+      };
+      const child = spawn2(resolveNodeBin2(), spec.args, {
+        cwd,
+        env: {
+          ...process.env,
+          WEBAUTO_DAEMON: "1",
+          WEBAUTO_UI_HEARTBEAT: "1",
+          ...spec.env || {}
+        },
+        stdio: ["ignore", "pipe", "pipe"],
+        windowsHide: true
+      });
+      runs.set(runId, { child, title: spec.title, startedAt: now() });
+      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) => {
+        stdoutLines.flush();
+        stderrLines.flush();
+        finalize(exitCode ?? code ?? null, exitSignal ?? signal ?? null);
+      });
+    })
+  );
+  return { runId };
+}
+async function runJson(spec) {
+  const timeoutMs = typeof spec.timeoutMs === "number" ? spec.timeoutMs : 2e4;
+  const cwd = resolveCwd(spec.cwd);
+  const child = spawn2(resolveNodeBin2(), spec.args, {
+    cwd,
+    env: { ...process.env, ...spec.env || {} },
+    stdio: ["ignore", "pipe", "pipe"],
+    windowsHide: true
+  });
+  const stdout = [];
+  const stderr = [];
+  child.stdout?.on("data", (c) => stdout.push(c));
+  child.stderr?.on("data", (c) => stderr.push(c));
+  const timer = setTimeout(() => {
+    try {
+      child.kill("SIGTERM");
+    } catch {
+    }
+  }, timeoutMs);
+  const { code } = await new Promise((resolve) => {
+    child.on("exit", (c) => resolve({ code: c }));
+  });
+  clearTimeout(timer);
+  const out = Buffer.concat(stdout).toString("utf8").trim();
+  const err = Buffer.concat(stderr).toString("utf8").trim();
+  if (code !== 0) {
+    return { ok: false, code, stdout: out, stderr: err };
+  }
+  try {
+    const json = JSON.parse(out);
+    return { ok: true, code, json };
+  } catch {
+    return { ok: true, code, stdout: out, stderr: err };
+  }
+}
+async function scanResults(input) {
+  const downloadRoot = String(input.downloadRoot || resolveDefaultDownloadRoot());
+  const root = path5.join(downloadRoot, "xiaohongshu");
+  const result = { ok: true, root, entries: [] };
+  try {
+    const stateMod = await getStateModule();
+    const envDirs = await fs3.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 });
+      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);
+        let stateSummary = null;
+        if (stateMod?.loadXhsCollectState) {
+          try {
+            const state = await stateMod.loadXhsCollectState({ keyword, env, downloadRoot });
+            stateSummary = {
+              status: state?.status,
+              links: state?.listCollection?.collectedUrls?.length || 0,
+              target: state?.listCollection?.targetCount || 0,
+              completed: state?.detailCollection?.completed || 0,
+              failed: state?.detailCollection?.failed || 0,
+              updatedAt: state?.lastUpdateTime || null
+            };
+          } catch {
+          }
+        }
+        result.entries.push({ env, keyword, path: kwPath, mtimeMs: stat?.mtimeMs || 0, state: stateSummary });
+      }
+    }
+    result.entries.sort((a, b) => (b.mtimeMs || 0) - (a.mtimeMs || 0));
+  } catch (e) {
+    result.ok = false;
+    result.error = e?.message || String(e);
+  }
+  return result;
+}
+async function listXhsFullCollectScripts() {
+  try {
+    const entries = await fs3.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)
+      };
+    });
+    return { ok: true, scripts };
+  } catch (err) {
+    return { ok: false, error: err?.message || String(err), scripts: [] };
+  }
+}
+async function readTextPreview(input) {
+  const filePath = String(input.path || "");
+  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 clipped = raw.slice(0, maxBytes);
+    const lines = clipped.split(/\r?\n/g).slice(0, maxLines);
+    return { ok: true, path: filePath, text: lines.join("\n") };
+  } catch (err) {
+    if (err?.code === "ENOENT") return { ok: false, path: filePath, error: "not_found" };
+    return { ok: false, path: filePath, error: err?.message || String(err) };
+  }
+}
+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 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");
+  try {
+    const buf = Buffer.allocUnsafe(toRead);
+    const { bytesRead } = await fh.read(buf, 0, toRead, fromOffset);
+    const text = buf.subarray(0, bytesRead).toString("utf8");
+    return {
+      ok: true,
+      path: filePath,
+      text,
+      fromOffset,
+      nextOffset: fromOffset + bytesRead,
+      fileSize: size
+    };
+  } finally {
+    await fh.close();
+  }
+}
+async function readFileBase64(input) {
+  const filePath = String(input.path || "");
+  const maxBytes = typeof input.maxBytes === "number" ? input.maxBytes : 8e6;
+  const buf = await fs3.readFile(filePath);
+  if (buf.byteLength > maxBytes) {
+    return { ok: false, error: `file too large: ${buf.byteLength}` };
+  }
+  return { ok: true, data: buf.toString("base64") };
+}
+async function listDir(input) {
+  const root = String(input?.root || "");
+  const recursive = Boolean(input?.recursive);
+  const maxEntries = typeof input?.maxEntries === "number" ? input.maxEntries : 2e3;
+  const entries = [];
+  const stack = [root];
+  while (stack.length > 0 && entries.length < maxEntries) {
+    const dir = stack.pop();
+    const items = await fs3.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);
+      entries.push({
+        path: full,
+        rel: path5.relative(root, full),
+        name: ent.name,
+        isDir: ent.isDirectory(),
+        size: st?.size || 0,
+        mtimeMs: st?.mtimeMs || 0
+      });
+      if (recursive && ent.isDirectory()) stack.push(full);
+    }
+  }
+  entries.sort((a, b) => {
+    if (a.isDir !== b.isDir) return a.isDir ? -1 : 1;
+    return b.mtimeMs - a.mtimeMs;
+  });
+  return { ok: true, root, entries, truncated: entries.length >= maxEntries };
+}
+function createWindow() {
+  win = new BrowserWindow2({
+    title: "WebAuto Desktop v0.1.1",
+    width: 1280,
+    height: 900,
+    minWidth: 920,
+    minHeight: 800,
+    webPreferences: {
+      preload: path5.join(APP_ROOT, "dist", "main", "preload.mjs"),
+      contextIsolation: true,
+      nodeIntegration: false,
+      sandbox: false,
+      // Prevent renderer timer throttling when app loses focus; heartbeat must remain stable.
+      backgroundThrottling: false
+    }
+  });
+  const htmlPath = path5.join(APP_ROOT, "dist", "renderer", "index.html");
+  void win.loadFile(htmlPath);
+  ensureStateBridge();
+}
+app.on("window-all-closed", () => {
+  killAllRuns("window_closed");
+  app.quit();
+});
+app.on("before-quit", () => {
+  killAllRuns("before_quit");
+  stopCoreServiceHeartbeat();
+  void stopCoreServicesBestEffort("before_quit");
+  if (heartbeatWatchdog) {
+    clearInterval(heartbeatWatchdog);
+    heartbeatWatchdog = null;
+  }
+});
+app.on("will-quit", () => {
+  killAllRuns("will_quit");
+  stopCoreServiceHeartbeat();
+  void stopCoreServicesBestEffort("will_quit");
+  stateBridge.stop();
+});
+app.whenReady().then(async () => {
+  startCoreServiceHeartbeat();
+  const started = await startCoreDaemon().catch(() => false);
+  if (!started) {
+    console.warn("[desktop-console] core services are not healthy at startup");
+  }
+  markUiHeartbeat("main_ready");
+  ensureHeartbeatWatchdog();
+  createWindow();
+});
+ipcMain2.on("preload:test", () => {
+  console.log("[preload-test] window.api OK");
+  setTimeout(() => app.quit(), 200);
+});
+ipcMain2.handle("settings:get", async () => readDesktopConsoleSettings({ appRoot: APP_ROOT, repoRoot: REPO_ROOT2 }));
+ipcMain2.handle("settings:set", async (_evt, next) => {
+  const updated = await writeDesktopConsoleSettings({ appRoot: APP_ROOT, repoRoot: REPO_ROOT2 }, next || {});
+  const w = getWin();
+  if (w) w.webContents.send("settings:changed", updated);
+  return updated;
+});
+ipcMain2.handle("ai:listModels", async (_evt, input) => {
+  try {
+    const baseUrl = String(input?.baseUrl || "").trim().replace(/\/+$/, "");
+    const apiKey = String(input?.apiKey || "").trim();
+    const apiPath = String(input?.path || "/v1/models").trim() || "/v1/models";
+    if (!baseUrl) return { ok: false, models: [], rawCount: 0, error: "baseUrl is required" };
+    const headers = { "Content-Type": "application/json" };
+    if (apiKey) headers.Authorization = `Bearer ${apiKey}`;
+    const res = await fetch(`${baseUrl}${apiPath}`, {
+      method: "GET",
+      headers,
+      signal: AbortSignal.timeout(15e3)
+    });
+    const json = await res.json().catch(() => ({}));
+    if (!res.ok) {
+      return {
+        ok: false,
+        models: [],
+        rawCount: 0,
+        error: json?.error?.message || `HTTP ${res.status}`
+      };
+    }
+    const data = Array.isArray(json?.data) ? json.data : [];
+    const models = data.map((m) => String(m?.id || "")).filter(Boolean);
+    return { ok: true, models, rawCount: data.length };
+  } catch (e) {
+    return { ok: false, models: [], rawCount: 0, error: e?.message || String(e) };
+  }
+});
+ipcMain2.handle(
+  "ai:testChatCompletion",
+  async (_evt, input) => {
+    const startedAt = Date.now();
+    try {
+      const baseUrl = String(input?.baseUrl || "").trim().replace(/\/+$/, "");
+      const apiKey = String(input?.apiKey || "").trim();
+      const model = String(input?.model || "").trim();
+      const timeoutMs = Math.max(5e3, Number(input?.timeoutMs || 25e3));
+      if (!baseUrl) return { ok: false, latencyMs: 0, model, error: "baseUrl is required" };
+      if (!model) return { ok: false, latencyMs: 0, model, error: "model is required" };
+      const headers = { "Content-Type": "application/json" };
+      if (apiKey) headers.Authorization = `Bearer ${apiKey}`;
+      const res = await fetch(`${baseUrl}/v1/chat/completions`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          model,
+          messages: [{ role: "user", content: "ping" }],
+          max_tokens: 8,
+          temperature: 0
+        }),
+        signal: AbortSignal.timeout(timeoutMs)
+      });
+      const json = await res.json().catch(() => ({}));
+      if (!res.ok) {
+        return {
+          ok: false,
+          latencyMs: Date.now() - startedAt,
+          model,
+          error: json?.error?.message || `HTTP ${res.status}`
+        };
+      }
+      return {
+        ok: true,
+        latencyMs: Date.now() - startedAt,
+        model
+      };
+    } catch (e) {
+      return {
+        ok: false,
+        latencyMs: Date.now() - startedAt,
+        model: String(input?.model || ""),
+        error: e?.message || String(e)
+      };
+    }
+  }
+);
+ipcMain2.handle("desktop:heartbeat", async () => markUiHeartbeat());
+ipcMain2.handle("cmd:spawn", async (_evt, spec) => {
+  markUiHeartbeat("cmd_spawn");
+  const title = String(spec?.title || "command");
+  const cwd = String(spec?.cwd || REPO_ROOT2);
+  const args = Array.isArray(spec?.args) ? spec.args : [];
+  return spawnCommand({ title, cwd, args, env: spec.env, groupKey: spec.groupKey });
+});
+ipcMain2.handle("cmd:kill", async (_evt, input) => {
+  const runId = String(input?.runId || "");
+  const r = runs.get(runId);
+  if (!r) return { ok: false, error: "not found" };
+  try {
+    const ok = terminateRunProcess(runId, "manual_stop");
+    return { ok };
+  } catch (e) {
+    return { ok: false, error: e?.message || String(e) };
+  }
+});
+ipcMain2.handle("cmd:runJson", async (_evt, spec) => {
+  const cwd = String(spec?.cwd || REPO_ROOT2);
+  const args = Array.isArray(spec?.args) ? spec.args : [];
+  return runJson({ ...spec, cwd, args });
+});
+ipcMain2.handle("results:scan", async (_evt, spec) => scanResults(spec || {}));
+ipcMain2.handle("fs:listDir", async (_evt, spec) => listDir(spec));
+ipcMain2.handle(
+  "fs:readTextPreview",
+  async (_evt, spec) => readTextPreview(spec)
+);
+ipcMain2.handle(
+  "fs:readTextTail",
+  async (_evt, spec) => readTextTail(spec)
+);
+ipcMain2.handle("fs:readFileBase64", async (_evt, spec) => readFileBase64(spec));
+ipcMain2.handle("profiles:list", async () => profileStore.listProfiles());
+ipcMain2.handle("profiles:scan", async () => profileStore.scanProfiles());
+ipcMain2.handle("scripts:xhsFullCollect", async () => listXhsFullCollectScripts());
+ipcMain2.handle("profile:create", async (_evt, input) => profileStore.profileCreate(input || {}));
+ipcMain2.handle(
+  "profile:delete",
+  async (_evt, input) => profileStore.profileDelete(input || {})
+);
+ipcMain2.handle("fingerprint:delete", async (_evt, input) => profileStore.fingerprintDelete(input || {}));
+ipcMain2.handle(
+  "fingerprint:regenerate",
+  async (_evt, input) => profileStore.fingerprintRegenerate(input || {})
+);
+ipcMain2.handle("os:openPath", async (_evt, input) => {
+  const p = String(input?.path || "");
+  const r = await shell.openPath(p);
+  return { ok: !r, error: r || null };
+});
+ipcMain2.handle("env:checkCamo", async () => checkCamoCli());
+ipcMain2.handle("env:checkServices", async () => checkServices());
+ipcMain2.handle("env:checkFirefox", async () => checkFirefox());
+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 }));
+  return { ok, services };
+});
+ipcMain2.handle("config:saveLast", async (_evt, config) => {
+  await saveCrawlConfig({ appRoot: APP_ROOT, repoRoot: REPO_ROOT2 }, config);
+  return { ok: true };
+});
+ipcMain2.handle("config:loadLast", async () => {
+  const config = await loadCrawlConfig({ appRoot: APP_ROOT, repoRoot: REPO_ROOT2 });
+  return config;
+});
+ipcMain2.handle("config:export", async (_evt, { filePath, config }) => {
+  return await exportConfigToFile(filePath, config);
+});
+ipcMain2.handle("config:import", async (_evt, { filePath }) => {
+  return await importConfigFromFile(filePath);
+});
+ipcMain2.handle("clipboard:writeText", async (_evt, input) => {
+  try {
+    clipboard.writeText(String(input?.text || ""));
+    return { ok: true };
+  } catch (err) {
+    return { ok: false, error: err?.message || String(err) };
+  }
+});
+async function unifiedAction(action, payload) {
+  const base = String((await readDesktopConsoleSettings({ appRoot: APP_ROOT, repoRoot: REPO_ROOT2 }))?.unifiedApiUrl || "http://127.0.0.1:7701");
+  const res = await fetch(`${base}/v1/controller/action`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ action, payload }),
+    signal: AbortSignal.timeout ? AbortSignal.timeout(2e4) : void 0
+  });
+  const json = await res.json().catch(() => ({}));
+  if (!res.ok || json?.success === false || json?.ok === false) throw new Error(json?.error || "unified action failed");
+  return json;
+}
+ipcMain2.handle("runtime:listSessions", async () => {
+  const data = await unifiedAction("session:list", {}).catch(() => null);
+  const sessions = data?.data?.sessions || data?.sessions || [];
+  if (!Array.isArray(sessions)) return [];
+  const now2 = (/* @__PURE__ */ new Date()).toISOString();
+  return sessions.map((s) => ({
+    profileId: String(s?.profileId || s?.profile_id || s?.sessionId || s?.session_id || ""),
+    sessionId: String(s?.sessionId || s?.session_id || s?.profileId || s?.profile_id || ""),
+    currentUrl: String(s?.currentUrl || s?.current_url || ""),
+    lastPhase: String(s?.lastPhase || s?.phase || "phase1"),
+    lastActiveAt: String(s?.lastActiveAt || now2),
+    status: "running"
+  })).filter((s) => s.profileId);
+});
+ipcMain2.handle("runtime:focus", async (_evt, input) => {
+  const profileId = String(input?.profileId || "").trim();
+  if (!profileId) return { ok: false, error: "missing profileId" };
+  const focusRes = await unifiedAction("browser:focus", { profile: profileId }).catch(() => ({ ok: false }));
+  await unifiedAction("browser:execute", {
+    profile: profileId,
+    script: `(() => {
+      try {
+        const id = '__webauto_focus_ring__';
+        let el = document.getElementById(id);
+        if (!el) {
+          el = document.createElement('div');
+          el.id = id;
+          el.style.position = 'fixed';
+          el.style.left = '8px';
+          el.style.top = '8px';
+          el.style.right = '8px';
+          el.style.bottom = '8px';
+          el.style.border = '3px solid #2b67ff';
+          el.style.borderRadius = '10px';
+          el.style.zIndex = '2147483647';
+          el.style.pointerEvents = 'none';
+          document.body.appendChild(el);
+        }
+        el.style.display = 'block';
+        setTimeout(() => { try { el.remove(); } catch {} }, 1500);
+        return true;
+      } catch {
+        return false;
+      }
+    })()`
+  }).catch(() => null);
+  return focusRes;
+});
+ipcMain2.handle("runtime:kill", async (_evt, input) => {
+  const profileId = String(input?.profileId || "").trim();
+  if (!profileId) return { ok: false, error: "missing profileId" };
+  return unifiedAction("session:delete", { profileId }).catch((err) => ({ ok: false, error: err?.message || String(err) }));
+});
+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"];
+  return spawnCommand({ title: `Phase1 restart ${profileId}`, cwd: REPO_ROOT2, args, groupKey: "phase1" });
+});
+ipcMain2.handle("runtime:setBrowserTitle", async (_evt, input) => {
+  const profileId = String(input?.profileId || "").trim();
+  const title = String(input?.title || "").trim();
+  if (!profileId || !title) return { ok: false, error: "missing profileId/title" };
+  return unifiedAction("browser:execute", {
+    profile: profileId,
+    script: `(() => { try { document.title = ${JSON.stringify(title)}; return true; } catch { return false; } })()`
+  }).catch((err) => ({ ok: false, error: err?.message || String(err) }));
+});
+ipcMain2.handle("runtime:setHeaderBar", async (_evt, input) => {
+  const profileId = String(input?.profileId || "").trim();
+  const label = String(input?.label || "").trim();
+  const color = String(input?.color || "").trim();
+  if (!profileId || !label || !color) return { ok: false, error: "missing profileId/label/color" };
+  const safeColor = /^#[0-9a-fA-F]{6}$/.test(color) ? color : "#2b67ff";
+  return unifiedAction("browser:execute", {
+    profile: profileId,
+    script: `(() => {
+      try {
+        const id = '__webauto_header_bar__';
+        let bar = document.getElementById(id);
+        if (!bar) {
+          bar = document.createElement('div');
+          bar.id = id;
+          bar.style.position = 'fixed';
+          bar.style.left = '0';
+          bar.style.top = '0';
+          bar.style.right = '0';
+          bar.style.height = '22px';
+          bar.style.zIndex = '2147483647';
+          bar.style.display = 'flex';
+          bar.style.alignItems = 'center';
+          bar.style.padding = '0 10px';
+          bar.style.fontSize = '12px';
+          bar.style.fontFamily = 'system-ui, sans-serif';
+          bar.style.fontWeight = '600';
+          bar.style.color = '#fff';
+          bar.style.pointerEvents = 'none';
+          document.body.appendChild(bar);
+          const html = document.documentElement;
+          if (html) html.style.scrollPaddingTop = '22px';
+        }
+        bar.style.background = ${JSON.stringify(safeColor)};
+        bar.textContent = ${JSON.stringify(label)};
+        return true;
+      } catch {
+        return false;
+      }
+    })()`
+  }).catch((err) => ({ ok: false, error: err?.message || String(err) }));
+});
+//# sourceMappingURL=index.mjs.map