@web-auto/webauto 0.1.9 → 0.1.11

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

@@ -7,7 +7,7 @@ import { fileURLToPath as fileURLToPath2, pathToFileURL as pathToFileURL3 } from
 import { mkdirSync, readFileSync, promises as fs4 } from "node:fs";
 
 // src/main/desktop-settings.mts
-import { existsSync, promises as fs } from "node:fs";
+import { existsSync as existsSync2, promises as fs } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
@@ -21,7 +21,7 @@ function resolveLegacySettingsPath() {
 }
 function hasWindowsDriveD() {
   try {
-    return existsSync("D:\\");
+    return existsSync2("D:\\");
   } catch {
     return false;
   }
@@ -270,7 +270,7 @@ async function importConfigFromFile(filePath) {
 // src/main/core-daemon-manager.mts
 import { spawn } from "child_process";
 import path2 from "path";
-import { existsSync as existsSync2 } from "fs";
+import { existsSync as existsSync3 } from "fs";
 import { fileURLToPath } from "url";
 var REPO_ROOT = path2.resolve(path2.dirname(fileURLToPath(import.meta.url)), "../../../..");
 var UNIFIED_API_HEALTH_URL = "http://127.0.0.1:7701/health";
@@ -278,6 +278,8 @@ var CAMO_RUNTIME_HEALTH_URL = "http://127.0.0.1:7704/health";
 var CORE_HEALTH_URLS = [UNIFIED_API_HEALTH_URL, CAMO_RUNTIME_HEALTH_URL];
 var START_API_SCRIPT = path2.join(REPO_ROOT, "runtime", "infra", "utils", "scripts", "service", "start-api.mjs");
 var STOP_API_SCRIPT = path2.join(REPO_ROOT, "runtime", "infra", "utils", "scripts", "service", "stop-api.mjs");
+var DIST_UNIFIED_ENTRY = path2.join(REPO_ROOT, "dist", "apps", "webauto", "server.js");
+var fallbackUnifiedApiPid = null;
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -303,7 +305,7 @@ function resolveOnPath(candidates) {
   for (const dir of dirs) {
     for (const name of candidates) {
       const full = path2.join(dir, name);
-      if (existsSync2(full)) return full;
+      if (existsSync3(full)) return full;
     }
   }
   return null;
@@ -358,6 +360,45 @@ async function runNodeScript(scriptPath, timeoutMs) {
     });
   });
 }
+async function runLongLivedNodeScript(scriptPath) {
+  return new Promise((resolve) => {
+    const nodeBin = resolveNodeBin();
+    const child = spawn(nodeBin, [scriptPath], {
+      cwd: REPO_ROOT,
+      stdio: "ignore",
+      windowsHide: true,
+      detached: false,
+      env: {
+        ...process.env,
+        WEBAUTO_RUNTIME_MODE: "unified"
+      }
+    });
+    let settled = false;
+    const timer = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      fallbackUnifiedApiPid = typeof child.pid === "number" ? child.pid : null;
+      resolve(true);
+    }, 200);
+    child.once("error", () => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(false);
+    });
+    child.once("exit", () => {
+      if (!settled) {
+        settled = true;
+        clearTimeout(timer);
+        resolve(false);
+        return;
+      }
+      if (fallbackUnifiedApiPid && child.pid === fallbackUnifiedApiPid) {
+        fallbackUnifiedApiPid = null;
+      }
+    });
+  });
+}
 async function runCommand(command, args, timeoutMs) {
   return new Promise((resolve) => {
     const lower = String(command || "").toLowerCase();
@@ -399,7 +440,7 @@ async function runCommand(command, args, timeoutMs) {
 }
 async function startCoreDaemon() {
   if (await areCoreServicesHealthy()) return true;
-  const startedApi = await runNodeScript(START_API_SCRIPT, 4e4);
+  const startedApi = existsSync3(START_API_SCRIPT) ? await runNodeScript(START_API_SCRIPT, 4e4) : existsSync3(DIST_UNIFIED_ENTRY) ? await runLongLivedNodeScript(DIST_UNIFIED_ENTRY) : false;
   if (!startedApi) {
     console.error("[CoreDaemonManager] Failed to start unified API service");
     return false;
@@ -412,19 +453,27 @@ async function startCoreDaemon() {
   if (!startedBrowser) {
     console.warn("[CoreDaemonManager] Failed to start camo browser backend, continue in degraded mode");
   }
-  for (let i = 0; i < 20; i += 1) {
+  for (let i = 0; i < 60; i += 1) {
     const [allHealthy, unifiedHealthy] = await Promise.all([
       areCoreServicesHealthy(),
       isUnifiedApiHealthy()
     ]);
     if (allHealthy) return true;
     if (unifiedHealthy) return true;
-    await sleep(300);
+    await sleep(500);
   }
   console.error("[CoreDaemonManager] Unified API still unhealthy after start");
   return false;
 }
 async function stopCoreDaemon() {
+  if (fallbackUnifiedApiPid) {
+    try {
+      process.kill(fallbackUnifiedApiPid, "SIGTERM");
+    } catch {
+    }
+    fallbackUnifiedApiPid = null;
+  }
+  if (!existsSync3(STOP_API_SCRIPT)) return true;
   const stoppedApi = await runNodeScript(STOP_API_SCRIPT, 2e4);
   if (!stoppedApi) {
     console.error("[CoreDaemonManager] Failed to stop core services");
@@ -739,12 +788,30 @@ var stateBridge = new StateBridge();
 
 // src/main/env-check.mts
 import { spawnSync } from "node:child_process";
-import { existsSync as existsSync3 } from "node:fs";
+import { existsSync as existsSync4 } from "node:fs";
 import path4 from "node:path";
 import os3 from "node:os";
 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");
+  const normalizePathForPlatform2 = (raw, platform = process.platform) => {
+    const input = String(raw || "").trim();
+    const isWinPath = platform === "win32" || /^[A-Za-z]:[\\/]/.test(input);
+    const pathApi = isWinPath ? path4.win32 : path4;
+    return isWinPath ? pathApi.normalize(input) : path4.resolve(input);
+  };
+  const normalizeLegacyWebautoRoot2 = (raw, platform = process.platform) => {
+    const pathApi = platform === "win32" ? path4.win32 : path4;
+    const resolved = normalizePathForPlatform2(raw, platform);
+    const base = pathApi.basename(resolved).toLowerCase();
+    return base === ".webauto" || base === "webauto" ? resolved : pathApi.join(resolved, ".webauto");
+  };
+  const explicitHome = String(process.env.WEBAUTO_HOME || "").trim();
+  if (explicitHome) return normalizePathForPlatform2(explicitHome);
+  const legacyRoot = String(process.env.WEBAUTO_ROOT || process.env.WEBAUTO_PORTABLE_ROOT || "").trim();
+  if (legacyRoot) return normalizeLegacyWebautoRoot2(legacyRoot);
+  if (process.platform === "win32") {
+    return existsSync4("D:\\") ? "D:\\webauto" : path4.join(os3.homedir(), ".webauto");
+  }
+  return path4.join(os3.homedir(), ".webauto");
 }
 function resolveNpxBin2() {
   if (process.platform !== "win32") return "npx";
@@ -757,7 +824,7 @@ function resolveOnPath2(candidates) {
   for (const dir of dirs) {
     for (const name of candidates) {
       const full = path4.join(dir, name);
-      if (existsSync3(full)) return full;
+      if (existsSync4(full)) return full;
     }
   }
   return null;
@@ -830,8 +897,8 @@ function resolveCamoufoxExecutable(installRoot) {
   return process.platform === "win32" ? path4.join(installRoot, "camoufox.exe") : path4.join(installRoot, "camoufox");
 }
 function isValidCamoufoxInstallRoot(installRoot) {
-  if (!installRoot || !existsSync3(installRoot)) return false;
-  return existsSync3(resolveCamoufoxExecutable(installRoot));
+  if (!installRoot || !existsSync4(installRoot)) return false;
+  return existsSync4(resolveCamoufoxExecutable(installRoot));
 }
 async function checkCamoCli() {
   const camoCandidates = process.platform === "win32" ? ["camo.cmd", "camo.exe", "camo.bat", "camo.ps1"] : ["camo"];
@@ -848,7 +915,7 @@ async function checkCamoCli() {
   for (const localRoot of localRoots) {
     for (const suffix of camoCandidates) {
       const candidate = path4.resolve(localRoot, suffix);
-      if (!existsSync3(candidate)) continue;
+      if (!existsSync4(candidate)) continue;
       const ret = runVersionCheck(candidate, ["help"], candidate);
       if (ret.installed) return ret;
     }
@@ -903,7 +970,7 @@ async function checkFirefox() {
 }
 async function checkGeoIP() {
   const geoIpPath = path4.join(resolveWebautoRoot(), "geoip", "GeoLite2-City.mmdb");
-  if (existsSync3(geoIpPath)) {
+  if (existsSync4(geoIpPath)) {
     return { installed: true, path: geoIpPath };
   }
   return { installed: false };
@@ -934,7 +1001,33 @@ 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 normalizePathForPlatform(raw, platform = process.platform) {
+  const input = String(raw || "").trim();
+  const isWinPath = platform === "win32" || /^[A-Za-z]:[\\/]/.test(input);
+  const pathApi = isWinPath ? path5.win32 : path5;
+  return isWinPath ? pathApi.normalize(input) : path5.resolve(input);
+}
+function normalizeLegacyWebautoRoot(raw, platform = process.platform) {
+  const pathApi = platform === "win32" ? path5.win32 : path5;
+  const resolved = normalizePathForPlatform(raw, platform);
+  const base = pathApi.basename(resolved).toLowerCase();
+  return base === ".webauto" || base === "webauto" ? resolved : pathApi.join(resolved, ".webauto");
+}
+function resolveWebautoRoot2() {
+  const explicitHome = String(process.env.WEBAUTO_HOME || "").trim();
+  if (explicitHome) return normalizePathForPlatform(explicitHome);
+  const legacyRoot = String(process.env.WEBAUTO_ROOT || process.env.WEBAUTO_PORTABLE_ROOT || "").trim();
+  if (legacyRoot) return normalizeLegacyWebautoRoot(legacyRoot);
+  if (process.platform === "win32") {
+    try {
+      if (existsSync("D:\\")) return "D:\\webauto";
+    } catch {
+    }
+    return path5.join(os4.homedir(), ".webauto");
+  }
+  return path5.join(os4.homedir(), ".webauto");
+}
+var CONTROL_FILE = path5.join(resolveWebautoRoot2(), "run", "ui-cli.json");
 function readInt(input, fallback) {
   const n = Number(input);
   return Number.isFinite(n) && n > 0 ? Math.floor(n) : fallback;

package/apps/desktop-console/dist/renderer/index.js

@@ -414,10 +414,13 @@ ${mergedOutput}`);
     if (!createdProfileId) return;
     if (typeof window.api?.cmdSpawn !== "function") return;
     const timeoutSec = Math.max(30, Math.floor(Number(timeoutInput.value || "900")));
+    const idleTimeout = String(window.api?.settings?.idleTimeout || "30m").trim() || "30m";
     const loginArgs = buildArgs([
       window.api.pathJoin("apps", "webauto", "entry", "profilepool.mjs"),
       "login-profile",
       createdProfileId,
+      "--idle-timeout",
+      idleTimeout,
       "--timeout-sec",
       String(timeoutSec),
       "--check-interval-sec",
@@ -1975,10 +1978,13 @@ function renderSetupWizard(root, ctx2) {
       await refreshAccounts();
       setupStatusText.textContent = `\u8D26\u53F7 ${profileId} \u5DF2\u521B\u5EFA\uFF0C\u7B49\u5F85\u767B\u5F55...`;
       const timeoutSec = ctx2.api.settings?.timeouts?.loginTimeoutSec || 900;
+      const idleTimeout = String(ctx2.api?.settings?.idleTimeout || "30m").trim() || "30m";
       const loginArgs = [
         ctx2.api.pathJoin("apps", "webauto", "entry", "profilepool.mjs"),
         "login-profile",
         profileId,
+        "--idle-timeout",
+        idleTimeout,
         "--wait-sync",
         "false",
         "--timeout-sec",
@@ -4357,6 +4363,7 @@ Profile ID: ${acc.profileId}
   async function openAccountLogin(account, options = {}) {
     if (!String(account.profileId || "").trim()) return false;
     const platform = getPlatformInfo(account.platform);
+    const idleTimeout = String(ctx2.api?.settings?.idleTimeout || "30m").trim() || "30m";
     const timeoutSec = Math.max(30, Number(ctx2.api?.settings?.timeouts?.loginTimeoutSec || 900));
     account.status = "pending";
     account.statusView = "pending";
@@ -4372,6 +4379,8 @@ Profile ID: ${acc.profileId}
         account.profileId,
         "--url",
         platform.loginUrl,
+        "--idle-timeout",
+        idleTimeout,
         "--wait-sync",
         "false",
         "--timeout-sec",
@@ -4417,6 +4426,7 @@ Profile ID: ${acc.profileId}
           await ctx2.refreshSettings();
         }
       }
+      const idleTimeout = String(ctx2.api?.settings?.idleTimeout || "30m").trim() || "30m";
       const timeoutSec = ctx2.api.settings?.timeouts?.loginTimeoutSec || 900;
       await ctx2.api.cmdSpawn({
         title: `\u767B\u5F55 ${alias || profileId}`,
@@ -4425,6 +4435,8 @@ Profile ID: ${acc.profileId}
           ctx2.api.pathJoin("apps", "webauto", "entry", "profilepool.mjs"),
           "login-profile",
           profileId,
+          "--idle-timeout",
+          idleTimeout,
           "--wait-sync",
           "false",
           "--timeout-sec",

package/apps/desktop-console/entry/ui-cli.mjs

@@ -9,10 +9,45 @@ import { fileURLToPath } from 'node:url';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const APP_ROOT = path.resolve(__dirname, '..');
 const ROOT = path.resolve(APP_ROOT, '..', '..');
-const CONTROL_FILE = path.join(os.homedir(), '.webauto', 'run', 'ui-cli.json');
 const DEFAULT_HOST = process.env.WEBAUTO_UI_CLI_HOST || '127.0.0.1';
 const DEFAULT_PORT = Number(process.env.WEBAUTO_UI_CLI_PORT || 7716);
 
+function normalizePathForPlatform(raw, platform = process.platform) {
+  const input = String(raw || '').trim();
+  const isWinPath = platform === 'win32' || /^[A-Za-z]:[\\/]/.test(input);
+  const pathApi = isWinPath ? path.win32 : path;
+  return isWinPath ? pathApi.normalize(input) : path.resolve(input);
+}
+
+function normalizeLegacyWebautoRoot(raw, platform = process.platform) {
+  const pathApi = platform === 'win32' ? path.win32 : path;
+  const resolved = normalizePathForPlatform(raw, platform);
+  const base = pathApi.basename(resolved).toLowerCase();
+  return (base === '.webauto' || base === 'webauto')
+    ? resolved
+    : pathApi.join(resolved, '.webauto');
+}
+
+function resolveWebautoRoot() {
+  const explicitHome = String(process.env.WEBAUTO_HOME || '').trim();
+  if (explicitHome) return normalizePathForPlatform(explicitHome);
+
+  const legacyRoot = String(process.env.WEBAUTO_ROOT || process.env.WEBAUTO_PORTABLE_ROOT || '').trim();
+  if (legacyRoot) return normalizeLegacyWebautoRoot(legacyRoot);
+
+  if (process.platform === 'win32') {
+    try {
+      if (existsSync('D:\\')) return 'D:\\webauto';
+    } catch {
+      // ignore drive probing errors
+    }
+    return path.join(os.homedir(), '.webauto');
+  }
+  return path.join(os.homedir(), '.webauto');
+}
+
+const CONTROL_FILE = path.join(resolveWebautoRoot(), 'run', 'ui-cli.json');
+
 const args = minimist(process.argv.slice(2), {
   boolean: ['help', 'json', 'auto-start', 'build', 'install', 'continue-on-error', 'exact', 'keep-open', 'detailed'],
   string: ['host', 'port', 'selector', 'value', 'text', 'key', 'tab', 'label', 'state', 'file', 'output', 'timeout', 'interval', 'nth'],

package/apps/webauto/entry/account.mjs

@@ -169,7 +169,7 @@ Usage:
   webauto account sync <profileId|all> [--pending-while-login] [--resolve-alias] [--json]
 
 Notes:
-  - 账号数据默认保存到 ~/.webauto/accounts（可用 WEBAUTO_PATHS_ACCOUNTS 覆盖）
+  - 账号数据默认保存到 WEBAUTO 根目录下的 accounts（Windows 优先 D:/webauto，缺失时回落 ~/.webauto，可用 WEBAUTO_HOME 覆盖）
   - list 默认按 profile 展示账号有效态（valid/invalid）
   - add 会自动创建并关联 profile/fingerprint（未指定时自动编号）
   - login 会通过 @web-auto/camo 拉起浏览器并绑定账号 profile

package/apps/webauto/entry/lib/account-store.mjs

@@ -1,11 +1,11 @@
 import fs from 'node:fs';
-import os from 'node:os';
 import path from 'node:path';
 import {
   ensureProfile,
   resolveFingerprintsRoot,
   resolveNextProfileId,
   resolveProfilesRoot,
+  resolveWebautoRoot,
 } from './profilepool.mjs';
 
 const INDEX_FILE = 'index.json';
@@ -119,18 +119,6 @@ function ensureSafeName(name, field) {
   return value;
 }
 
-function resolvePortableRoot() {
-  const root = String(process.env.WEBAUTO_PORTABLE_ROOT || process.env.WEBAUTO_ROOT || '').trim();
-  return root ? path.join(root, '.webauto') : '';
-}
-
-export function resolveWebautoRoot() {
-  const portableRoot = resolvePortableRoot();
-  if (portableRoot) return portableRoot;
-  const home = process.env.HOME || process.env.USERPROFILE || os.homedir();
-  return path.join(home, '.webauto');
-}
-
 export function resolveAccountsRoot() {
   const envRoot = String(process.env.WEBAUTO_PATHS_ACCOUNTS || '').trim();
   if (envRoot) return envRoot;

package/apps/webauto/entry/lib/profilepool.mjs

@@ -2,32 +2,64 @@ import os from 'node:os';
 import path from 'node:path';
 import fs from 'node:fs';
 
-function resolvePortableRoot() {
-  const root = String(process.env.WEBAUTO_PORTABLE_ROOT || process.env.WEBAUTO_ROOT || '').trim();
-  return root ? path.join(root, '.webauto') : '';
+function hasDrive(letter) {
+  if (process.platform !== 'win32') return false;
+  try {
+    return fs.existsSync(`${String(letter || '').replace(/[^A-Za-z]/g, '').toUpperCase()}:\\`);
+  } catch {
+    return false;
+  }
 }
 
-function resolveHomeDir() {
-  if (process.platform === 'win32') {
-    return process.env.USERPROFILE || os.homedir();
-  }
+function normalizePathForPlatform(input, platform = process.platform) {
+  const raw = String(input || '').trim();
+  const isWinPath = platform === 'win32' || /^[A-Za-z]:[\\/]/.test(raw);
+  const pathApi = isWinPath ? path.win32 : path;
+  return isWinPath ? pathApi.normalize(raw) : path.resolve(raw);
+}
+
+function normalizeLegacyWebautoRoot(input, platform = process.platform) {
+  const pathApi = platform === 'win32' ? path.win32 : path;
+  const resolved = normalizePathForPlatform(input, platform);
+  const base = pathApi.basename(resolved).toLowerCase();
+  if (base === '.webauto' || base === 'webauto') return resolved;
+  return pathApi.join(resolved, '.webauto');
+}
+
+function resolveHomeDir(platform = process.platform) {
+  if (platform === 'win32') return process.env.USERPROFILE || os.homedir();
   return process.env.HOME || os.homedir();
 }
 
+export function resolveWebautoRoot(options = {}) {
+  const env = options.env || process.env;
+  const platform = String(options.platform || process.platform);
+  const homeDir = String(options.homeDir || resolveHomeDir(platform));
+  const pathApi = platform === 'win32' ? path.win32 : path;
+
+  const explicitHome = String(env.WEBAUTO_HOME || '').trim();
+  if (explicitHome) return normalizePathForPlatform(explicitHome, platform);
+
+  const legacyRoot = String(env.WEBAUTO_ROOT || env.WEBAUTO_PORTABLE_ROOT || '').trim();
+  if (legacyRoot) return normalizeLegacyWebautoRoot(legacyRoot, platform);
+
+  if (platform === 'win32') {
+    const dDriveExists = typeof options.hasDDrive === 'boolean' ? options.hasDDrive : hasDrive('D');
+    return dDriveExists ? 'D:\\webauto' : pathApi.join(homeDir, '.webauto');
+  }
+  return pathApi.join(homeDir, '.webauto');
+}
+
 export function resolveProfilesRoot() {
   const envProfiles = String(process.env.WEBAUTO_PATHS_PROFILES || '').trim();
   if (envProfiles) return envProfiles;
-  const portableRoot = resolvePortableRoot();
-  if (portableRoot) return path.join(portableRoot, 'profiles');
-  return path.join(resolveHomeDir(), '.webauto', 'profiles');
+  return path.join(resolveWebautoRoot(), 'profiles');
 }
 
 export function resolveFingerprintsRoot() {
   const envFps = String(process.env.WEBAUTO_PATHS_FINGERPRINTS || '').trim();
   if (envFps) return envFps;
-  const portableRoot = resolvePortableRoot();
-  if (portableRoot) return path.join(portableRoot, 'fingerprints');
-  return path.join(resolveHomeDir(), '.webauto', 'fingerprints');
+  return path.join(resolveWebautoRoot(), 'fingerprints');
 }
 
 export function listProfiles() {

package/apps/webauto/entry/lib/schedule-store.mjs

@@ -1,6 +1,6 @@
 import fs from 'node:fs';
-import os from 'node:os';
 import path from 'node:path';
+import { resolveWebautoRoot } from './profilepool.mjs';
 
 const INDEX_FILE = 'index.json';
 const DEFAULT_COMMAND_TYPE = 'xhs-unified';
@@ -78,18 +78,6 @@ function normalizeMaxRuns(value, fallback = null) {
   return Math.max(1, Math.floor(n));
 }
 
-function resolvePortableRoot() {
-  const root = String(process.env.WEBAUTO_PORTABLE_ROOT || process.env.WEBAUTO_ROOT || '').trim();
-  return root ? path.join(root, '.webauto') : '';
-}
-
-function resolveWebautoRoot() {
-  const portableRoot = resolvePortableRoot();
-  if (portableRoot) return portableRoot;
-  const home = process.env.HOME || process.env.USERPROFILE || os.homedir();
-  return path.join(home, '.webauto');
-}
-
 export function resolveSchedulesRoot() {
   const explicit = String(process.env.WEBAUTO_PATHS_SCHEDULES || '').trim();
   if (explicit) return explicit;

package/apps/webauto/entry/xhs-install.mjs

@@ -252,10 +252,37 @@ function runPackageCommand(packageName, commandArgs) {
   return run(resolveNpmBin(), ['exec', '--yes', `--package=${packageName}`, '--', ...commandArgs]);
 }
 
-function resolveWebautoRoot() {
-  const portableRoot = String(process.env.WEBAUTO_PORTABLE_ROOT || process.env.WEBAUTO_ROOT || '').trim();
-  if (portableRoot) return path.join(portableRoot, '.webauto');
-  return path.join(os.homedir(), '.webauto');
+function normalizePathForPlatform(raw, platform = process.platform) {
+  const input = String(raw || '').trim();
+  const isWinPath = platform === 'win32' || /^[A-Za-z]:[\\/]/.test(input);
+  const pathApi = isWinPath ? path.win32 : path;
+  return isWinPath ? pathApi.normalize(input) : path.resolve(input);
+}
+
+function normalizeLegacyWebautoRoot(raw, platform = process.platform) {
+  const pathApi = platform === 'win32' ? path.win32 : path;
+  const resolved = normalizePathForPlatform(raw, platform);
+  const base = pathApi.basename(resolved).toLowerCase();
+  if (base === '.webauto' || base === 'webauto') return resolved;
+  return pathApi.join(resolved, '.webauto');
+}
+
+function resolveWebautoRoot(options = {}) {
+  const env = options.env || process.env;
+  const platform = String(options.platform || process.platform);
+  const pathApi = platform === 'win32' ? path.win32 : path;
+  const homeDir = String(options.homeDir || os.homedir());
+  const explicitHome = String(env.WEBAUTO_HOME || '').trim();
+  if (explicitHome) return normalizePathForPlatform(explicitHome, platform);
+
+  const legacyRoot = String(env.WEBAUTO_ROOT || env.WEBAUTO_PORTABLE_ROOT || '').trim();
+  if (legacyRoot) return normalizeLegacyWebautoRoot(legacyRoot, platform);
+
+  const hasDDrive = typeof options.hasDDrive === 'boolean'
+    ? options.hasDDrive
+    : (platform === 'win32' && existsSync('D:\\'));
+  if (platform === 'win32') return hasDDrive ? 'D:\\webauto' : pathApi.join(homeDir, '.webauto');
+  return pathApi.join(homeDir, '.webauto');
 }
 
 function resolveGeoIPPath() {

package/bin/webauto.mjs

@@ -2,11 +2,67 @@
 import minimist from 'minimist';
 import { spawn } from 'node:child_process';
 import { existsSync, writeFileSync, readFileSync, mkdirSync } from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-const STATE_FILE = path.join(process.env.HOME || process.env.USERPROFILE || '.', '.webauto', 'cli-state.json');
+
+function normalizePathForPlatform(raw, platform = process.platform) {
+  const input = String(raw || '').trim();
+  const isWinPath = platform === 'win32' || /^[A-Za-z]:[\\/]/.test(input);
+  const pathApi = isWinPath ? path.win32 : path;
+  return isWinPath ? pathApi.normalize(input) : path.resolve(input);
+}
+
+function normalizeLegacyWebautoRoot(raw, platform = process.platform) {
+  const pathApi = platform === 'win32' ? path.win32 : path;
+  const resolved = normalizePathForPlatform(raw, platform);
+  const base = pathApi.basename(resolved).toLowerCase();
+  return (base === '.webauto' || base === 'webauto')
+    ? resolved
+    : pathApi.join(resolved, '.webauto');
+}
+
+function resolveWebautoHome(env = process.env, platform = process.platform) {
+  const explicitHome = String(env.WEBAUTO_HOME || '').trim();
+  if (explicitHome) return normalizePathForPlatform(explicitHome, platform);
+
+  const legacyRoot = String(env.WEBAUTO_ROOT || env.WEBAUTO_PORTABLE_ROOT || '').trim();
+  if (legacyRoot) return normalizeLegacyWebautoRoot(legacyRoot, platform);
+
+  const homeDir = platform === 'win32'
+    ? (env.USERPROFILE || os.homedir())
+    : (env.HOME || os.homedir());
+  if (platform === 'win32') {
+    try {
+      if (existsSync('D:\\')) return 'D:\\webauto';
+    } catch {
+      // ignore drive detection errors
+    }
+    return path.win32.join(homeDir, '.webauto');
+  }
+  return path.join(homeDir, '.webauto');
+}
+
+function applyDefaultRuntimeEnv() {
+  if (!String(process.env.WEBAUTO_REPO_ROOT || '').trim()) {
+    process.env.WEBAUTO_REPO_ROOT = ROOT;
+  }
+  if (isGlobalInstall() && !String(process.env.WEBAUTO_SKIP_BUILD_CHECK || '').trim()) {
+    process.env.WEBAUTO_SKIP_BUILD_CHECK = '1';
+  }
+  if (
+    !String(process.env.WEBAUTO_HOME || '').trim()
+    && !String(process.env.WEBAUTO_ROOT || process.env.WEBAUTO_PORTABLE_ROOT || '').trim()
+  ) {
+    process.env.WEBAUTO_HOME = resolveWebautoHome();
+  }
+}
+
+applyDefaultRuntimeEnv();
+
+const STATE_FILE = path.join(resolveWebautoHome(), 'cli-state.json');
 
 function loadState() {
   try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@web-auto/webauto",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "type": "module",
   "bin": {
     "webauto": "bin/webauto.mjs"
@@ -9,6 +9,7 @@
     "bin/",
     "dist/",
     "modules/",
+    "runtime/",
     "scripts/",
     "services/",
     "apps/desktop-console/dist/",

package/runtime/infra/utils/README.md

@@ -0,0 +1,13 @@
+# Runtime Utilities
+
+运行时工具统一收敛到 `runtime/infra/utils/scripts/`。
+
+当前保留目录：
+- `scripts/development/`：开发期调试脚本（会话内执行、高亮等）
+- `scripts/service/`：服务启停与端口清理脚本
+- `scripts/` 根脚本：跨场景工具（例如 `test-services.mjs`）
+
+已移除：
+- `local-dev/`
+- `scripts/local-dev/`
+- 其它历史遗留脚本目录

package/runtime/infra/utils/scripts/development/eval-in-session.mjs

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+// Post a local JS file (or inline) to Workflow API /browser/eval for the given session
+import { readFileSync, existsSync } from 'node:fs';
+
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.length < 2) {
+    console.log('Usage: node scripts/dev/eval-in-session.mjs <sessionId> <file.js|--code="JS..."> [--host=http://127.0.0.1:7701]');
+    process.exit(1);
+  }
+  const sessionId = args[0];
+  let codeArg = args[1];
+  let host = 'http://127.0.0.1:7701';
+  for (const a of args.slice(2)) {
+    if (a.startsWith('--host=')) host = a.slice('--host='.length);
+  }
+  let script = '';
+  if (codeArg.startsWith('--code=')) {
+    script = codeArg.slice('--code='.length);
+  } else {
+    if (!existsSync(codeArg)) {
+      console.error('File not found:', codeArg);
+      process.exit(2);
+    }
+    script = readFileSync(codeArg, 'utf8');
+  }
+  const res = await fetch(host + '/browser/eval', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ sessionId, script })
+  }).then(r => r.json()).catch(e => ({ success: false, error: String(e) }));
+  if (!res || !res.success) {
+    console.error('Eval failed:', res?.error || 'unknown');
+    process.exit(1);
+  }
+  console.log('Eval OK:', JSON.stringify(res.value));
+}
+
+main().catch(e => { console.error(e); process.exit(1); });
+

package/runtime/infra/utils/scripts/development/highlight-search-containers.mjs

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+// Highlight search containers for 3 seconds: root -> listContainer -> first item
+const host = process.env.WORKFLOW_HOST || 'http://127.0.0.1:7701';
+
+function arg(k, d){ const a = process.argv.find(x=>x.startsWith(`--${k}=`)); return a ? a.split('=')[1] : d; }
+const sleep = (ms)=>new Promise(r=>setTimeout(r,ms));
+
+async function j(u,opt){ const r = await fetch(host+u, { headers:{'Content-Type':'application/json'}, ...(opt||{}) }); return await r.json(); }
+async function lastSession(){ const s = await j('/v1/sessions'); const arr=s.sessions||[]; return arr[arr.length-1]||null; }
+
+async function highlight({ sessionId, selector, label }){
+  return await j('/v1/containers/highlight', { method:'POST', body: JSON.stringify({ sessionId, containerSelector: selector, label, durationMs: 3000 }) });
+}
+
+async function validate({ sessionId, selector }){ return await j('/v1/containers/validate', { method:'POST', body: JSON.stringify({ sessionId, containerSelector: selector }) }); }
+
+async function main(){
+  const sessionId = arg('sessionId', null) || await lastSession();
+  if (!sessionId) { console.error('No active session.'); process.exit(1); }
+  // container definitions (must match container registry)
+  const rootSel = '.search-ui2024, .search-i18nUi, body';
+  const listSel = '.space-common-offerlist, .offer-list, #offer-list';
+  const itemSel = '.offer-item, .sm-offer, [class*=offer]';
+
+  const out = { sessionId, checks: [] };
+  for (const [label, sel] of [['ROOT', rootSel], ['LIST', listSel], ['ITEM', itemSel]]){
+    const v = await validate({ sessionId, selector: sel });
+    out.checks.push({ label, selector: sel, found: !!v.found });
+    if (v.found) await highlight({ sessionId, selector: sel, label });
+    await sleep(400);
+  }
+  console.log(JSON.stringify({ ok:true, ...out }, null, 2));
+}
+
+main().catch(e=>{ console.error(e); process.exit(1); });

package/runtime/infra/utils/scripts/service/kill-port.mjs

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+// 杀掉占用指定端口的进程（跨平台尽力）
+import { execSync } from 'node:child_process';
+
+const port = Number(process.argv[2] || 0);
+if (!port) { console.error('Usage: node runtime/infra/utils/scripts/service/kill-port.mjs <port>'); process.exit(1); }
+
+try {
+  if (process.platform === 'win32') {
+    const out = execSync(`netstat -ano | findstr :${port}`, { encoding: 'utf8' });
+    const pids = new Set();
+    out.split(/\r?\n/).forEach(line=>{ const m=line.trim().match(/\s(\d+)\s*$/); if (m) pids.add(Number(m[1])); });
+    for (const pid of pids) { try { execSync(`taskkill /F /PID ${pid}`); console.log(`killed pid ${pid}`); } catch {} }
+    if (pids.size===0) console.log('no process found');
+  } else {
+    const out = execSync(`lsof -ti :${port}`, { encoding: 'utf8' });
+    const pids = out.split(/\s+/).map(s=>Number(s.trim())).filter(Boolean);
+    for (const pid of pids) { try { process.kill(pid, 'SIGKILL'); console.log(`killed pid ${pid}`); } catch {} }
+    if (pids.length===0) console.log('no process found');
+  }
+} catch (e) {
+  console.log('nothing to kill or command failed');
+}
+

package/runtime/infra/utils/scripts/service/start-api.mjs

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+import { spawn, spawnSync } from 'node:child_process';
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { setTimeout as wait } from 'node:timers/promises';
+
+const API_PID_FILE = process.env.WEBAUTO_API_PID_FILE
+  ? path.resolve(process.env.WEBAUTO_API_PID_FILE)
+  : path.join(os.tmpdir(), 'webauto-api.pid');
+const DIST_SERVER = path.resolve(process.cwd(), 'dist', 'apps', 'webauto', 'server.js');
+
+function resolveOnPath(candidates) {
+  const pathEnv = process.env.PATH || process.env.Path || '';
+  const dirs = String(pathEnv).split(path.delimiter).map((x) => x.trim()).filter(Boolean);
+  for (const dir of dirs) {
+    for (const name of candidates) {
+      const full = path.join(dir, name);
+      if (existsSync(full)) return full;
+    }
+  }
+  return null;
+}
+
+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;
+  const fromPath = resolveOnPath(process.platform === 'win32' ? ['node.exe', 'node.cmd', 'node'] : ['node']);
+  if (fromPath) return fromPath;
+  return process.execPath;
+}
+
+function resolveNpmBin() {
+  if (process.platform !== 'win32') return 'npm';
+  const fromPath = resolveOnPath(['npm.cmd', 'npm.exe', 'npm.bat', 'npm.ps1']);
+  return fromPath || 'npm.cmd';
+}
+
+function quoteCmdArg(value) {
+  if (!value) return '""';
+  if (!/[\s"]/u.test(value)) return value;
+  return `"${String(value).replace(/"/g, '""')}"`;
+}
+
+function run(command, args) {
+  const lower = String(command || '').toLowerCase();
+  if (process.platform === 'win32' && (lower.endsWith('.cmd') || lower.endsWith('.bat'))) {
+    const cmdLine = [quoteCmdArg(command), ...args.map(quoteCmdArg)].join(' ');
+    return spawnSync('cmd.exe', ['/d', '/s', '/c', cmdLine], { stdio: 'inherit', windowsHide: true });
+  }
+  if (process.platform === 'win32' && lower.endsWith('.ps1')) {
+    return spawnSync(
+      'powershell.exe',
+      ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-File', command, ...args],
+      { stdio: 'inherit', windowsHide: true },
+    );
+  }
+  return spawnSync(command, args, { stdio: 'inherit', windowsHide: true });
+}
+
+async function health(url='http://127.0.0.1:7701/health'){
+  try{
+    const res = await fetch(url);
+    if (!res.ok) return false;
+    const j = await res.json().catch(() => ({}));
+    return Boolean(j?.ok ?? true);
+  }catch{
+    return false;
+  }
+}
+
+async function main(){
+  if (!existsSync(DIST_SERVER)) {
+    const npmBin = resolveNpmBin();
+    const buildRet = run(npmBin, ['run', '-s', 'build:services']);
+    if (buildRet.status !== 0) {
+      console.error('build:services failed');
+      process.exit(1);
+    }
+  }
+  // start
+  const child = spawn(resolveNodeBin(), [DIST_SERVER], {
+    detached: true,
+    stdio: 'ignore',
+    windowsHide: true,
+    env: {
+      ...process.env,
+      WEBAUTO_RUNTIME_MODE: 'unified',
+    },
+  });
+  child.unref();
+  try {
+    mkdirSync(path.dirname(API_PID_FILE), { recursive: true });
+  } catch {}
+  writeFileSync(API_PID_FILE, String(child.pid));
+  // wait for health
+  for(let i=0;i<20;i++){ if (await health()) { console.log('API started. PID', child.pid); return; } await wait(500); }
+  console.error('API did not become healthy in time'); process.exit(1);
+}
+
+main().catch(e=>{ console.error(e); process.exit(1); });

package/runtime/infra/utils/scripts/service/start-browser-service.mjs

@@ -0,0 +1,173 @@
+#!/usr/bin/env node
+import { execSync, spawn } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { setTimeout as wait } from 'node:timers/promises';
+
+function resolveWebautoRoot() {
+  const explicitHome = String(process.env.WEBAUTO_HOME || '').trim();
+  if (explicitHome) return path.resolve(explicitHome);
+
+  const legacyRoot = String(process.env.WEBAUTO_ROOT || process.env.WEBAUTO_PORTABLE_ROOT || '').trim();
+  if (legacyRoot) {
+    const normalized = path.resolve(legacyRoot);
+    const base = path.basename(normalized).toLowerCase();
+    if (base === '.webauto' || base === 'webauto') return normalized;
+    return path.join(normalized, '.webauto');
+  }
+
+  if (process.platform === 'win32') {
+    try {
+      if (fs.existsSync('D:\\')) return 'D:\\webauto';
+    } catch {
+      // ignore probing errors
+    }
+  }
+  return path.join(os.homedir(), '.webauto');
+}
+
+const RUN_DIR = path.join(resolveWebautoRoot(), 'run');
+const PID_FILE = path.join(RUN_DIR, 'browser-service.pid');
+const DEFAULT_HOST = process.env.WEBAUTO_BROWSER_HOST || '127.0.0.1';
+const DEFAULT_PORT = Number(process.env.WEBAUTO_BROWSER_PORT || 7704);
+
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function health(host = DEFAULT_HOST, port = DEFAULT_PORT) {
+  try {
+    const res = await fetch(`http://${host}:${port}/health`);
+    if (!res.ok) return false;
+    const body = await res.json().catch(() => ({}));
+    return Boolean(body?.ok ?? true);
+  } catch {
+    return false;
+  }
+}
+
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const hostIdx = args.findIndex((item) => item === '--host');
+  const portIdx = args.findIndex((item) => item === '--port');
+  const host = hostIdx >= 0 && args[hostIdx + 1] ? String(args[hostIdx + 1]) : DEFAULT_HOST;
+  const port = portIdx >= 0 && args[portIdx + 1] ? Number(args[portIdx + 1]) : DEFAULT_PORT;
+  return {
+    host,
+    port: Number.isFinite(port) && port > 0 ? port : DEFAULT_PORT,
+  };
+}
+
+function latestMtimeMs(targetPath) {
+  if (!fs.existsSync(targetPath)) return 0;
+  const stat = fs.statSync(targetPath);
+  if (stat.isFile()) return Number(stat.mtimeMs || 0);
+  if (!stat.isDirectory()) return 0;
+  let latest = Number(stat.mtimeMs || 0);
+  const stack = [targetPath];
+  while (stack.length) {
+    const current = stack.pop();
+    if (!current) continue;
+    let entries = [];
+    try {
+      entries = fs.readdirSync(current, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const full = path.join(current, entry.name);
+      let entryStat;
+      try {
+        entryStat = fs.statSync(full);
+      } catch {
+        continue;
+      }
+      const mtime = Number(entryStat.mtimeMs || 0);
+      if (mtime > latest) latest = mtime;
+      if (entryStat.isDirectory()) stack.push(full);
+    }
+  }
+  return latest;
+}
+
+function shouldRebuild(distEntry) {
+  if (!fs.existsSync(distEntry)) return true;
+  if (String(process.env.WEBAUTO_SKIP_BUILD_CHECK || '') === '1') return false;
+  if (!fs.existsSync(path.resolve('tsconfig.services.json'))) return false;
+  const distMtime = Number(fs.statSync(distEntry).mtimeMs || 0);
+  const watchRoots = [
+    path.resolve('modules/camo-backend/src'),
+    path.resolve('modules/logging/src'),
+  ];
+  const latestSourceMtime = Math.max(...watchRoots.map((root) => latestMtimeMs(root)));
+  return latestSourceMtime > distMtime;
+}
+
+function ensureBuild() {
+  const distEntry = path.resolve('dist/modules/camo-backend/src/index.js');
+  if (!shouldRebuild(distEntry)) return distEntry;
+  console.log('[browser-service] backend entry missing/stale, running npm run -s build:services');
+  execSync('npm run -s build:services', { stdio: 'inherit' });
+  if (!fs.existsSync(distEntry)) {
+    throw new Error(`backend entry missing after build: ${distEntry}`);
+  }
+  return distEntry;
+}
+
+async function main() {
+  const { host, port } = parseArgs();
+  fs.mkdirSync(RUN_DIR, { recursive: true });
+
+  if (await health(host, port)) {
+    console.log(`Browser service already healthy on http://${host}:${port}`);
+    return;
+  }
+
+  if (fs.existsSync(PID_FILE)) {
+    try {
+      const oldPid = Number(fs.readFileSync(PID_FILE, 'utf8'));
+      if (oldPid && isAlive(oldPid)) {
+        console.log(`Browser service already running (pid=${oldPid}).`);
+        return;
+      }
+    } catch {
+      // stale pid file will be overwritten
+    }
+  }
+
+  const entry = ensureBuild();
+  const child = spawn(process.execPath, [entry], {
+    detached: true,
+    stdio: 'ignore',
+    env: {
+      ...process.env,
+      BROWSER_SERVICE_HOST: host,
+      BROWSER_SERVICE_PORT: String(port),
+      WEBAUTO_BROWSER_HOST: host,
+      WEBAUTO_BROWSER_PORT: String(port),
+    },
+  });
+  child.unref();
+  fs.writeFileSync(PID_FILE, String(child.pid));
+
+  for (let i = 0; i < 30; i += 1) {
+    if (await health(host, port)) {
+      console.log(`Browser service started (pid=${child.pid}) on http://${host}:${port}`);
+      return;
+    }
+    await wait(300);
+  }
+
+  throw new Error('browser service did not become healthy in time');
+}
+
+main().catch((err) => {
+  console.error(`[browser-service] start failed: ${err?.message || String(err)}`);
+  process.exit(1);
+});

package/runtime/infra/utils/scripts/service/stop-api.mjs

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+import { readFileSync, existsSync, unlinkSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import os from 'node:os';
+import path from 'node:path';
+
+const PID_FILE = process.env.WEBAUTO_API_PID_FILE
+  ? path.resolve(process.env.WEBAUTO_API_PID_FILE)
+  : path.join(os.tmpdir(), 'webauto-api.pid');
+
+function killPid(pid){
+  if (process.platform === 'win32') {
+    try {
+      spawnSync('taskkill', ['/PID', String(pid), '/T', '/F'], { stdio: 'ignore', windowsHide: true });
+    } catch {}
+    return;
+  }
+  try { process.kill(pid, 'SIGTERM'); } catch {}
+  setTimeout(() => { try { process.kill(pid, 'SIGKILL'); } catch {} }, 1000);
+}
+
+async function main(){
+  if (!existsSync(PID_FILE)) { console.log('No pid file.'); return; }
+  const pid = Number(readFileSync(PID_FILE,'utf8').trim());
+  if (pid>0) killPid(pid);
+  try { unlinkSync(PID_FILE); } catch {}
+  console.log('API stopped.');
+}
+
+main().catch(e=>{ console.error(e); process.exit(1); });

package/runtime/infra/utils/scripts/service/stop-browser-service.mjs

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+import { execSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { setTimeout as wait } from 'node:timers/promises';
+
+const RUN_DIR = path.join(os.homedir(), '.webauto', 'run');
+const PID_FILE = path.join(RUN_DIR, 'browser-service.pid');
+const DEFAULT_PORT = Number(process.env.WEBAUTO_BROWSER_PORT || 7704);
+
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function killByPort(port) {
+  try {
+    if (process.platform === 'win32') {
+      const out = execSync(`netstat -ano | findstr :${port}`, { encoding: 'utf8' });
+      const pids = new Set();
+      out.split(/\r?\n/).forEach((line) => {
+        const match = line.trim().match(/\s(\d+)\s*$/);
+        if (match) pids.add(Number(match[1]));
+      });
+      for (const pid of pids) {
+        try {
+          execSync(`taskkill /F /PID ${pid}`, { stdio: 'ignore' });
+        } catch {
+          // ignore
+        }
+      }
+      return pids.size > 0;
+    }
+
+    const out = execSync(`lsof -ti :${port} || true`, { encoding: 'utf8' });
+    const pids = out.split(/\s+/).map((item) => Number(item.trim())).filter(Boolean);
+    for (const pid of pids) {
+      try {
+        process.kill(pid, 'SIGKILL');
+      } catch {
+        // ignore
+      }
+    }
+    return pids.length > 0;
+  } catch {
+    return false;
+  }
+}
+
+async function main() {
+  if (!fs.existsSync(PID_FILE)) {
+    const killed = killByPort(DEFAULT_PORT);
+    console.log(killed ? `Killed processes on :${DEFAULT_PORT}` : 'No PID file found. Service may not be running.');
+    return;
+  }
+
+  const pid = Number(fs.readFileSync(PID_FILE, 'utf8'));
+  if (!pid) {
+    fs.rmSync(PID_FILE, { force: true });
+    killByPort(DEFAULT_PORT);
+    console.log('Invalid PID file. Performed port cleanup.');
+    return;
+  }
+
+  if (!isAlive(pid)) {
+    fs.rmSync(PID_FILE, { force: true });
+    killByPort(DEFAULT_PORT);
+    console.log(`Process ${pid} is not running. Cleaned stale PID.`);
+    return;
+  }
+
+  try {
+    process.kill(pid, 'SIGTERM');
+  } catch {
+    // ignore
+  }
+
+  for (let i = 0; i < 15; i += 1) {
+    if (!isAlive(pid)) break;
+    await wait(200);
+  }
+
+  if (isAlive(pid)) {
+    try {
+      process.kill(pid, 'SIGKILL');
+    } catch {
+      // ignore
+    }
+  }
+
+  fs.rmSync(PID_FILE, { force: true });
+  killByPort(DEFAULT_PORT);
+  console.log(`Browser service stopped (pid=${pid}).`);
+}
+
+main().catch((err) => {
+  console.error(`[browser-service] stop failed: ${err?.message || String(err)}`);
+  process.exit(1);
+});

package/runtime/infra/utils/scripts/test-services.mjs

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+// 测试脚本：验证服务是否能正常启动
+import { spawn, execSync } from 'node:child_process';
+import { setTimeout as wait } from 'node:timers/promises';
+
+function log(msg){ console.log(`[test-services] ${msg}`); }
+
+async function testHealth(port, name, timeout = 10000) {
+  const startTime = Date.now();
+  
+  while (Date.now() - startTime < timeout) {
+    try {
+      const response = await fetch(`http://127.0.0.1:${port}/health`);
+      if (response.ok) {
+        const data = await response.json();
+        log(`✅ ${name} (${port}): 健康检查通过 - ${JSON.stringify(data)}`);
+        return true;
+      }
+    } catch (e) {
+      // 继续等待
+    }
+    await wait(500);
+  }
+  
+  log(`❌ ${name} (${port}): 健康检查失败`);
+  return false;
+}
+
+async function main() {
+  log('🧪 测试服务启动...');
+  
+  // 1. 构建服务
+  try {
+    log('构建服务...');
+    execSync('npm run -s build:services', { stdio: 'inherit' });
+    log('✅ 构建完成');
+  } catch (e) {
+    log('❌ 构建失败');
+    process.exit(1);
+  }
+  
+  // 2. 清理端口
+  const ports = [7704, 7705, 7706];
+  for (const port of ports) {
+    try {
+      execSync(`lsof -ti :${port} | xargs kill -9 || true`, { stdio: 'ignore' });
+    } catch {}
+  }
+  
+  // 3. 测试 Unified API
+  log('测试 Unified API...');
+  const unifiedProc = spawn('node', ['dist/apps/webauto/server.js'], {
+    env: { ...process.env, WEBAUTO_RUNTIME_MODE: 'unified', WEBAUTO_UNIFIED_PORT: '7704' },
+    stdio: ['ignore', 'pipe', 'pipe']
+  });
+  
+  unifiedProc.stdout.on('data', (data) => {
+    log(`[Unified API] ${data.toString().trim()}`);
+  });
+  
+  unifiedProc.stderr.on('data', (data) => {
+    log(`[Unified API ERROR] ${data.toString().trim()}`);
+  });
+  
+  unifiedProc.on('error', (err) => {
+    log(`❌ Unified API 启动错误: ${err.message}`);
+  });
+  
+  const unifiedOk = await testHealth(7704, 'Unified API', 15000);
+  
+  if (unifiedOk) {
+    // 4. 测试基本 API
+    try {
+      const response = await fetch('http://127.0.0.1:7704/v1/system/state');
+      const data = await response.json();
+      log(`📋 系统状态: ${JSON.stringify(data)}`);
+    } catch (e) {
+      log(`❌ 系统状态获取失败: ${e.message}`);
+    }
+  }
+  
+  // 5. 清理
+  unifiedProc.kill('SIGTERM');
+  await wait(1000);
+  unifiedProc.kill('SIGKILL');
+  
+  log('🧹 测试完成');
+  process.exit(unifiedOk ? 0 : 1);
+}
+
+main().catch(e => {
+  console.error('❌ 测试失败:', e.message);
+  process.exit(1);
+});