@web-auto/webauto 0.1.8 → 0.1.9

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

@@ -3,34 +3,213 @@ import minimist from 'minimist';
 import { spawnSync } from 'node:child_process';
 import os from 'node:os';
 import path from 'node:path';
-import { existsSync, rmSync } from 'node:fs';
+import { existsSync, rmSync, mkdirSync, writeFileSync, renameSync, statSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 
-function run(cmd, args) {
-  const lower = String(cmd || '').toLowerCase();
+const DEFAULT_COMMAND_TIMEOUT_MS = (() => {
+  const raw = Number(process.env.WEBAUTO_INSTALL_TIMEOUT_MS || 600000);
+  return Number.isFinite(raw) && raw > 0 ? Math.floor(raw) : 600000;
+})();
+
+function run(cmd, args, options = {}) {
+  const command = normalizeCommand(cmd);
+  const timeoutMs = Number.isFinite(Number(options?.timeoutMs))
+    ? Math.max(1000, Number(options.timeoutMs))
+    : DEFAULT_COMMAND_TIMEOUT_MS;
+  const lower = String(command || '').toLowerCase();
   const spawnOptions = {
     encoding: 'utf8',
     windowsHide: true,
-    timeout: 120000,
+    timeout: timeoutMs,
   };
   if (process.platform === 'win32' && (lower.endsWith('.cmd') || lower.endsWith('.bat'))) {
-    const cmdLine = [quoteCmdArg(cmd), ...args.map(quoteCmdArg)].join(' ');
+    const cmdLine = [quoteCmdArg(command), ...args.map(quoteCmdArg)].join(' ');
     return spawnSync('cmd.exe', ['/d', '/s', '/c', cmdLine], spawnOptions);
   }
   if (process.platform === 'win32' && lower.endsWith('.ps1')) {
     return spawnSync(
       'powershell.exe',
-      ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-File', cmd, ...args],
+      ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-File', command, ...args],
       spawnOptions,
     );
   }
-  return spawnSync(cmd, args, spawnOptions);
+  return spawnSync(command, args, spawnOptions);
 }
 
 function quoteCmdArg(value) {
-  if (!value) return '""';
-  if (!/[\s"]/u.test(value)) return value;
-  return `"${String(value).replace(/"/g, '""')}"`;
+  const normalized = normalizeCommand(value);
+  if (!normalized) return '""';
+  if (!/[\s"]/u.test(normalized)) return normalized;
+  return `"${String(normalized).replace(/"/g, '""')}"`;
+}
+
+function normalizeCommand(value) {
+  const text = String(value || '').trim();
+  if (!text) return '';
+  if ((text.startsWith('"') && text.endsWith('"')) || (text.startsWith("'") && text.endsWith("'"))) {
+    return text.slice(1, -1).trim();
+  }
+  return text;
+}
+
+function hasValidGeoIPFile(filePath) {
+  try {
+    if (!existsSync(filePath)) return false;
+    const stat = statSync(filePath);
+    return Number(stat?.size || 0) > 1024;
+  } catch {
+    return false;
+  }
+}
+
+function stripAnsi(input) {
+  return String(input || '').replace(/\x1b\[[0-9;]*m/g, '');
+}
+
+function resolvePathFromOutput(stdout, stderr) {
+  const merged = `${stripAnsi(stdout)}\n${stripAnsi(stderr)}`;
+  const lines = merged
+    .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.startsWith('/') || /^[A-Z]:\\/i.test(line)) return line;
+  }
+  return '';
+}
+
+function commandReportsExistingPath(ret) {
+  if (!ret || ret.status !== 0) return false;
+  const resolvedPath = resolvePathFromOutput(ret.stdout, ret.stderr);
+  if (!resolvedPath) return false;
+  if (!existsSync(resolvedPath)) return false;
+  const executable =
+    process.platform === 'win32'
+      ? path.join(resolvedPath, 'camoufox.exe')
+      : path.join(resolvedPath, 'camoufox');
+  return existsSync(executable);
+}
+
+function summarizeCommand(ret) {
+  if (!ret) return '';
+  const bits = [
+    ret?.error?.message || '',
+    stripAnsi(ret?.stderr || '').trim(),
+    stripAnsi(ret?.stdout || '').trim(),
+  ].filter(Boolean);
+  return bits.length ? bits.join(' | ').slice(0, 900) : '';
+}
+
+function runCamoufoxCommand(args) {
+  const pyArgs = ['-m', 'camoufox', ...args];
+  const candidates =
+    process.platform === 'win32'
+      ? [
+          { cmd: 'camoufox', args },
+          { cmd: 'python', args: pyArgs },
+          { cmd: 'py', args: ['-3', ...pyArgs] },
+        ]
+      : [
+          { cmd: 'camoufox', args },
+          { cmd: 'python3', args: pyArgs },
+        ];
+  const attempts = [];
+  for (const candidate of candidates) {
+    const ret = run(candidate.cmd, candidate.args);
+    attempts.push({
+      command: `${candidate.cmd} ${candidate.args.join(' ')}`.trim(),
+      status: ret?.status ?? null,
+      error: ret?.error?.message || null,
+      detail: summarizeCommand(ret),
+    });
+    if (ret.status === 0) return { ok: true, ret, attempts };
+  }
+  const viaPackage = runPackageCommand('camoufox', ['camoufox', ...args]);
+  attempts.push({
+    command: `npx/npm exec camoufox ${args.join(' ')}`.trim(),
+    status: viaPackage?.status ?? null,
+    error: viaPackage?.error?.message || null,
+    detail: summarizeCommand(viaPackage),
+  });
+  return { ok: viaPackage.status === 0, ret: viaPackage, attempts };
+}
+
+function runCamoCommand(args) {
+  const candidates = [{ cmd: 'camo', args }];
+  const attempts = [];
+  for (const candidate of candidates) {
+    const ret = run(candidate.cmd, candidate.args);
+    attempts.push({
+      command: `${candidate.cmd} ${candidate.args.join(' ')}`.trim(),
+      status: ret?.status ?? null,
+      error: ret?.error?.message || null,
+      detail: summarizeCommand(ret),
+    });
+    if (ret.status === 0) return { ok: true, ret, attempts };
+  }
+  const viaPackage = runPackageCommand('@web-auto/camo', ['camo', ...args]);
+  attempts.push({
+    command: `npx/npm exec camo ${args.join(' ')}`.trim(),
+    status: viaPackage?.status ?? null,
+    error: viaPackage?.error?.message || null,
+    detail: summarizeCommand(viaPackage),
+  });
+  return { ok: viaPackage.status === 0, ret: viaPackage, attempts };
+}
+
+function checkCamoufoxInstalled() {
+  const pathCheck = runCamoufoxCommand(['path']);
+  if (!pathCheck.ok) return false;
+  return commandReportsExistingPath(pathCheck.ret);
+}
+
+function installCamoufox() {
+  return runCamoufoxCommand(['fetch']);
+}
+
+function checkGeoIPInstalled() {
+  return hasValidGeoIPFile(resolveGeoIPPath());
+}
+
+function installGeoIP() {
+  return runCamoCommand(['init', 'geoip']);
+}
+
+async function installGeoIPDirect() {
+  const target = resolveGeoIPPath();
+  const tmp = `${target}.tmp`;
+  const timeoutMs = (() => {
+    const raw = Number(process.env.WEBAUTO_GEOIP_TIMEOUT_MS || 300000);
+    return Number.isFinite(raw) && raw > 0 ? Math.floor(raw) : 300000;
+  })();
+  const url = String(process.env.WEBAUTO_GEOIP_URL || 'https://git.io/GeoLite2-City.mmdb').trim();
+  mkdirSync(path.dirname(target), { recursive: true });
+  const res = await fetch(url, { signal: AbortSignal.timeout(timeoutMs) });
+  if (!res.ok) throw new Error(`geoip_download_http_${res.status}`);
+  const bytes = Buffer.from(await res.arrayBuffer());
+  if (!bytes || bytes.length < 1024) throw new Error('geoip_download_too_small');
+  writeFileSync(tmp, bytes);
+  renameSync(tmp, target);
+  return target;
+}
+
+async function ensureGeoIPInstalled() {
+  const commandResult = installGeoIP();
+  if (checkGeoIPInstalled()) {
+    return { ok: true, source: 'camo', ret: commandResult.ret };
+  }
+  try {
+    await installGeoIPDirect();
+    return { ok: checkGeoIPInstalled(), source: 'direct', ret: commandResult.ret };
+  } catch (error) {
+    return {
+      ok: false,
+      source: 'none',
+      ret: commandResult.ret,
+      detail: error?.message || String(error),
+    };
+  }
 }
 
 function resolveOnPath(candidates, pathEnv = process.env.PATH || process.env.Path || '', delimiter = path.delimiter) {
@@ -83,40 +262,9 @@ function resolveGeoIPPath() {
   return path.join(resolveWebautoRoot(), 'geoip', 'GeoLite2-City.mmdb');
 }
 
-function checkCamoufoxInstalled() {
-  const candidates =
-    process.platform === 'win32'
-      ? [
-          { cmd: 'python', args: ['-m', 'camoufox', 'path'] },
-          { cmd: 'py', args: ['-3', '-m', 'camoufox', 'path'] },
-        ]
-      : [{ cmd: 'python3', args: ['-m', 'camoufox', 'path'] }];
-  for (const candidate of candidates) {
-    const ret = run(candidate.cmd, candidate.args);
-    if (ret.status === 0) return true;
-  }
-  const npxRet = runPackageCommand('camoufox', ['camoufox', 'path']);
-  if (npxRet.status === 0) return true;
-  return false;
-}
-
-function installCamoufox() {
-  const ret = runPackageCommand('camoufox', ['camoufox', 'fetch']);
-  return ret.status === 0;
-}
-
-function checkGeoIPInstalled() {
-  return existsSync(resolveGeoIPPath());
-}
-
-function installGeoIP() {
-  const ret = runPackageCommand('@web-auto/camo', ['camo', 'init', 'geoip']);
-  return ret.status === 0;
-}
 
 function uninstallCamoufox() {
-  const ret = runPackageCommand('camoufox', ['camoufox', 'remove']);
-  return ret.status === 0;
+  return runCamoufoxCommand(['remove']);
 }
 
 function uninstallGeoIP() {
@@ -203,6 +351,7 @@ async function main() {
   let camoufoxInstalled = before.camoufoxInstalled;
   let geoipInstalled = before.geoipInstalled;
   let operationError = null;
+  let operationDetail = '';
 
   if (mode === 'auto' || mode === 'install') {
     if (browser && !camoufoxInstalled) {
@@ -211,17 +360,25 @@ async function main() {
       if (!camoufoxInstalled) operationError = operationError || 'camoufox_install_failed';
     }
     if (geoip && !geoipInstalled) {
-      actions.geoipInstalled = installGeoIP();
+      const geoResult = await ensureGeoIPInstalled();
+      actions.geoipInstalled = geoResult.ok;
       geoipInstalled = checkGeoIPInstalled();
-      if (!geoipInstalled) operationError = operationError || 'geoip_install_failed';
+      if (!geoipInstalled) {
+        operationError = operationError || 'geoip_install_failed';
+        operationDetail = operationDetail || geoResult.detail || summarizeCommand(geoResult.ret);
+      }
     }
   }
 
   if (mode === 'uninstall' || mode === 'reinstall') {
     if (browser) {
-      actions.browserUninstalled = uninstallCamoufox();
+      const removeResult = uninstallCamoufox();
+      actions.browserUninstalled = removeResult.ok;
       camoufoxInstalled = checkCamoufoxInstalled();
-      if (camoufoxInstalled) operationError = operationError || 'camoufox_uninstall_failed';
+      if (camoufoxInstalled) {
+        operationError = operationError || 'camoufox_uninstall_failed';
+        operationDetail = operationDetail || summarizeCommand(removeResult.ret);
+      }
     }
     if (geoip) {
       actions.geoipUninstalled = uninstallGeoIP();
@@ -232,14 +389,22 @@ async function main() {
 
   if (mode === 'reinstall') {
     if (browser) {
-      actions.browserInstalled = installCamoufox();
+      const installResult = installCamoufox();
+      actions.browserInstalled = installResult.ok;
       camoufoxInstalled = checkCamoufoxInstalled();
-      if (!camoufoxInstalled) operationError = operationError || 'camoufox_install_failed';
+      if (!camoufoxInstalled) {
+        operationError = operationError || 'camoufox_install_failed';
+        operationDetail = operationDetail || summarizeCommand(installResult.ret);
+      }
     }
     if (geoip) {
-      actions.geoipInstalled = installGeoIP();
+      const geoResult = await ensureGeoIPInstalled();
+      actions.geoipInstalled = geoResult.ok;
       geoipInstalled = checkGeoIPInstalled();
-      if (!geoipInstalled) operationError = operationError || 'geoip_install_failed';
+      if (!geoipInstalled) {
+        operationError = operationError || 'geoip_install_failed';
+        operationDetail = operationDetail || geoResult.detail || summarizeCommand(geoResult.ret);
+      }
     }
   }
 
@@ -289,10 +454,11 @@ async function main() {
     backendHealthy: after.backendHealthy,
     geoipInstalled: after.geoipInstalled,
     operationError,
+    operationDetail: operationDetail || null,
     message: ok
       ? '资源状态就绪'
       : operationError
-        ? `资源操作失败: ${operationError}`
+        ? `资源操作失败: ${operationError}${operationDetail ? ` (${operationDetail})` : ''}`
         : browser && !after.camoufoxInstalled
           ? 'Camoufox 未安装'
           : geoip && !after.geoipInstalled
@@ -318,4 +484,7 @@ export const __internals = {
   resolveWebautoRoot,
   resolveGeoIPPath,
   resolveModeAndSelection,
+  resolvePathFromOutput,
+  commandReportsExistingPath,
+  runCamoufoxCommand,
 };

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

@@ -9,7 +9,7 @@ import { buildXhsUnifiedAutoscript } from '../../../modules/camo-runtime/src/aut
 import { normalizeAutoscript, validateAutoscript } from '../../../modules/camo-runtime/src/autoscript/schema.mjs';
 import { AutoscriptRunner } from '../../../modules/camo-runtime/src/autoscript/runtime.mjs';
 import { syncXhsAccountsByProfiles } from './lib/account-detect.mjs';
-import { markProfileInvalid } from './lib/account-store.mjs';
+import { listAccountProfiles, markProfileInvalid } from './lib/account-store.mjs';
 import { listProfilesForPool } from './lib/profilepool.mjs';
 import { runCamo } from './lib/camo-cli.mjs';
 import { publishBusEvent } from './lib/bus-publish.mjs';
@@ -60,6 +60,19 @@ function parseProfiles(argv) {
   return [];
 }
 
+function resolveDefaultXhsProfiles() {
+  const rows = listAccountProfiles({ platform: 'xiaohongshu' }).profiles || [];
+  const valid = rows
+    .filter((row) => row?.valid === true && String(row?.accountId || '').trim())
+    .sort((a, b) => {
+      const ta = Date.parse(String(a?.updatedAt || '')) || 0;
+      const tb = Date.parse(String(b?.updatedAt || '')) || 0;
+      if (tb !== ta) return tb - ta;
+      return String(a?.profileId || '').localeCompare(String(b?.profileId || ''));
+    });
+  return Array.from(new Set(valid.map((row) => String(row.profileId || '').trim()).filter(Boolean)));
+}
+
 function sanitizeForPath(name, fallback = 'unknown') {
   const text = String(name || '').trim();
   if (!text) return fallback;
@@ -230,6 +243,7 @@ function createTaskReporter(seed = {}) {
     profileId: String(seed.profileId || 'unknown').trim() || 'unknown',
     keyword: String(seed.keyword || '').trim(),
     phase: 'unified',
+    uiTriggerId: String(seed.uiTriggerId || '').trim(),
   };
   const createdRunIds = new Set();
 
@@ -305,6 +319,7 @@ function buildTemplateOptions(argv, profileId, overrides = {}) {
   const likeKeywords = String(argv['like-keywords'] || '').trim();
   const replyText = String(argv['reply-text'] || '感谢分享，已关注').trim() || '感谢分享，已关注';
   const outputRoot = String(argv['output-root'] || '').trim();
+  const uiTriggerId = String(argv['ui-trigger-id'] || process.env.WEBAUTO_UI_TRIGGER_ID || '').trim();
   const resume = parseBool(argv.resume, false);
   const incrementalMax = parseBool(argv['incremental-max'], true);
   const sharedHarvestPath = String(overrides.sharedHarvestPath ?? argv['shared-harvest-path'] ?? '').trim();
@@ -329,6 +344,7 @@ function buildTemplateOptions(argv, profileId, overrides = {}) {
     inputMode,
     headless,
     ocrCommand,
+    uiTriggerId,
     outputRoot,
     throttle,
     tabCount,
@@ -537,6 +553,7 @@ async function runProfile(spec, argv, baseOverrides = {}) {
   const reporter = createTaskReporter({
     profileId,
     keyword: options.keyword,
+    uiTriggerId: options.uiTriggerId,
   });
   let activeRunId = '';
   const pushTaskSnapshot = (status = 'running') => {
@@ -600,9 +617,9 @@ async function runProfile(spec, argv, baseOverrides = {}) {
       pushTaskSnapshot('running');
     }
     if (
-      merged.event === 'autoscript:event'
-      && merged.subscriptionId === 'login_guard'
-      && (merged.type === 'appear' || merged.type === 'exist')
+      merged.event === 'autoscript:operation_error'
+      && String(merged.operationId || '').trim() === 'abort_on_login_guard'
+      && String(merged.message || '').includes('LOGIN_GUARD_DETECTED')
     ) {
       try {
         markProfileInvalid(profileId, 'login_guard_runtime');
@@ -919,8 +936,18 @@ export async function runUnified(argv, overrides = {}) {
 
   const env = String(argv.env || 'prod').trim() || 'prod';
   const busEnabled = parseBool(argv['bus-events'], false) || process.env.WEBAUTO_BUS_EVENTS === '1';
-  const profiles = parseProfiles(argv);
-  if (profiles.length === 0) throw new Error('missing --profile or --profiles or --profilepool');
+  let profiles = parseProfiles(argv);
+  if (profiles.length === 0) {
+    profiles = resolveDefaultXhsProfiles();
+    if (profiles.length > 0) {
+      console.log(JSON.stringify({
+        event: 'xhs.unified.auto_profiles_selected',
+        platform: 'xiaohongshu',
+        profiles,
+      }));
+    }
+  }
+  if (profiles.length === 0) throw new Error('missing --profile/--profiles/--profilepool and no valid xiaohongshu account profile found');
   await Promise.all(profiles.map((profileId) => ensureProfileSession(profileId)));
   const defaultMaxNotes = parseIntFlag(argv['max-notes'] ?? argv.target, 30, 1);
   const totalNotes = parseNonNegativeInt(argv['total-notes'] ?? argv['total-target'], 0);

package/bin/webauto.mjs

@@ -78,6 +78,17 @@ function uiConsoleScriptPath() {
   return path.join(ROOT, 'apps', 'desktop-console', 'entry', 'ui-console.mjs');
 }
 
+function readRootVersion() {
+  try {
+    const pkg = JSON.parse(readFileSync(path.join(ROOT, 'package.json'), 'utf8'));
+    return String(pkg.version || '').trim() || '0.0.0';
+  } catch {
+    return '0.0.0';
+  }
+}
+
+const ROOT_VERSION = readRootVersion();
+
 function printMainHelp() {
   console.log(`webauto CLI
 
@@ -100,10 +111,14 @@ Core Commands:
   webauto xhs unified [xhs options...]
   webauto xhs status [--run-id <id>] [--json]
   webauto xhs orchestrate [xhs options...]
+  webauto version [--json]
+  webauto version bump [patch|minor|major]
 
 Build & Release:
   webauto build:dev        # Local link mode
-  webauto build:release    # Full release gate (tests/build/pack)
+  webauto build:release    # Full release gate (默认自动 bump patch 版本)
+  webauto build:release -- --bump minor
+  webauto build:release -- --no-bump
   webauto build:release -- --skip-tests
   webauto build:release -- --skip-pack
 
@@ -132,6 +147,7 @@ Tips:
   - account 命令会转发到 apps/webauto/entry/account.mjs
   - schedule 命令会转发到 apps/webauto/entry/schedule.mjs
   - 全量参数请看: webauto xhs --help
+  - 当前 CLI 版本: ${ROOT_VERSION}
 `);
 }
 
@@ -342,6 +358,21 @@ Examples:
 `);
 }
 
+function printVersionHelp() {
+  console.log(`webauto version
+
+Usage:
+  webauto version [--json]
+  webauto version bump [patch|minor|major] [--json]
+
+Examples:
+  webauto version
+  webauto version --json
+  webauto version bump
+  webauto version bump minor
+`);
+}
+
 function exists(p) {
   try {
     return existsSync(p);
@@ -454,6 +485,7 @@ async function ensureDepsAndBuild() {
 }
 
 async function uiConsole({ build, install, checkOnly, noDaemon }) {
+  console.log(`[webauto] version ${ROOT_VERSION}`);
   const okServices = checkServicesBuilt();
   const okDeps = checkDesktopConsoleDeps();
   const okUiBuilt = checkDesktopConsoleBuilt();
@@ -517,12 +549,14 @@ async function uiConsole({ build, install, checkOnly, noDaemon }) {
 async function main() {
   const rawArgv = process.argv.slice(2);
   const args = minimist(process.argv.slice(2), {
-    boolean: ['help', 'build', 'install', 'check', 'full', 'link', 'skip-tests', 'skip-pack', 'no-daemon'],
+    boolean: ['help', 'build', 'install', 'check', 'full', 'link', 'skip-tests', 'skip-pack', 'no-daemon', 'no-bump', 'json'],
+    string: ['bump'],
     alias: { h: 'help' },
   });
 
   const cmd = String(args._[0] || '').trim();
   const sub = String(args._[1] || '').trim();
+  const noDaemon = rawArgv.includes('--no-daemon') || rawArgv.includes('--foreground') || args['no-daemon'] === true;
 
   if (args.help) {
     if (cmd === 'account') {
@@ -551,6 +585,10 @@ async function main() {
       printXhsHelp();
       return;
     }
+    if (cmd === 'version') {
+      printVersionHelp();
+      return;
+    }
     printMainHelp();
     return;
   }
@@ -560,11 +598,37 @@ async function main() {
       build: false,
       install: false,
       checkOnly: false,
-      noDaemon: args['no-daemon'] === true,
+      noDaemon,
     });
     return;
   }
 
+  if (cmd === 'version') {
+    const jsonMode = args.json === true;
+    const action = String(args._[1] || '').trim();
+    if (!action) {
+      const out = { name: '@web-auto/webauto', version: ROOT_VERSION };
+      if (jsonMode) console.log(JSON.stringify(out, null, 2));
+      else console.log(`@web-auto/webauto v${ROOT_VERSION}`);
+      return;
+    }
+    if (action !== 'bump') {
+      console.error(`Unknown version action: ${action}`);
+      printVersionHelp();
+      process.exit(2);
+    }
+    const bumpType = String(args._[2] || args.bump || 'patch').trim().toLowerCase();
+    if (!['patch', 'minor', 'major'].includes(bumpType)) {
+      console.error(`Unsupported bump type: ${bumpType}`);
+      process.exit(2);
+    }
+    const script = path.join(ROOT, 'scripts', 'bump-version.mjs');
+    const cmdArgs = [script, bumpType];
+    if (jsonMode) cmdArgs.push('--json');
+    await run(process.execPath, cmdArgs);
+    return;
+  }
+
   // build:dev - local development mode
   if (cmd === 'build:dev') {
     console.log('[webauto] Running local dev setup...');
@@ -580,8 +644,20 @@ async function main() {
   if (cmd === 'build:release') {
     const skipTests = args['skip-tests'] === true;
     const skipPack = args['skip-pack'] === true;
+    const noBump = args['no-bump'] === true;
+    const bumpType = String(args.bump || 'patch').trim().toLowerCase();
+    if (!['patch', 'minor', 'major'].includes(bumpType)) {
+      console.error(`Unsupported --bump value: ${bumpType}`);
+      process.exit(2);
+    }
     console.log('[webauto] Running release gate...');
     const npm = npmRunner();
+    if (!noBump) {
+      const bumpScript = path.join(ROOT, 'scripts', 'bump-version.mjs');
+      await run(process.execPath, [bumpScript, bumpType]);
+    } else {
+      console.log('[webauto] Skip version bump (--no-bump)');
+    }
     await run(npm.cmd, [...npm.prefix, 'run', 'prebuild']);
     if (!skipTests) {
       await run(npm.cmd, [...npm.prefix, 'run', 'test:ci']);
@@ -608,7 +684,7 @@ async function main() {
       build: args.build === true,
       install: args.install === true,
       checkOnly: args.check === true,
-      noDaemon: args['no-daemon'] === true,
+      noDaemon,
     });
     return;
   }

package/dist/modules/camo-runtime/src/utils/browser-service.mjs

@@ -213,6 +213,7 @@ function buildDomSnapshotScript(maxDepth, maxChildren) {
     const root = collect(document.body || document.documentElement, 0, 'root');
     return {
       dom_tree: root,
+      current_url: String(window.location.href || ''),
       viewport: {
         width: viewportWidth,
         height: viewportHeight,
@@ -235,6 +236,9 @@ export async function getDomSnapshotByProfile(profileId, options = {}) {
             height: Number(payload.viewport.height) || 0,
         };
     }
+    if (tree && payload.current_url) {
+        tree.__url = String(payload.current_url);
+    }
     return tree;
 }
 export async function getViewportByProfile(profileId) {

package/dist/services/unified-api/server.js

@@ -274,11 +274,13 @@ class UnifiedApiServer {
                         return existing;
                     const profileId = String(seed?.profileId || 'unknown').trim() || 'unknown';
                     const keyword = String(seed?.keyword || '').trim();
+                    const uiTriggerId = String(seed?.uiTriggerId || seed?.triggerId || '').trim();
                     const phase = normalizeTaskPhase(seed?.phase);
                     return this.taskRegistry.createTask({
                         runId: normalizedRunId,
                         profileId,
                         keyword,
+                        uiTriggerId,
                         phase,
                     });
                 };
@@ -290,6 +292,7 @@ class UnifiedApiServer {
                     const phase = normalizeTaskPhase(payload?.phase);
                     const profileId = String(payload?.profileId || '').trim();
                     const keyword = String(payload?.keyword || '').trim();
+                    const uiTriggerId = String(payload?.uiTriggerId || payload?.triggerId || '').trim();
                     const details = payload?.details && typeof payload.details === 'object' ? payload.details : undefined;
                     const patch = {};
                     if (phase !== 'unknown')
@@ -298,6 +301,8 @@ class UnifiedApiServer {
                         patch.profileId = profileId;
                     if (keyword)
                         patch.keyword = keyword;
+                    if (uiTriggerId)
+                        patch.uiTriggerId = uiTriggerId;
                     if (details)
                         patch.details = details;
                     if (Object.keys(patch).length > 0) {

package/dist/services/unified-api/task-state.js

@@ -11,6 +11,7 @@ class TaskStateRegistry {
             runId: partial.runId,
             profileId: partial.profileId,
             keyword: partial.keyword,
+            uiTriggerId: partial.uiTriggerId ? String(partial.uiTriggerId).trim() : undefined,
             phase: partial.phase || 'unknown',
             status: 'starting',
             progress: { total: 0, processed: 0, failed: 0 },
@@ -22,6 +23,7 @@ class TaskStateRegistry {
                 imagesDownloaded: 0,
                 ocrProcessed: 0,
             },
+            createdAt: now,
             startedAt: now,
             updatedAt: now,
             details: {