@web-auto/webauto 0.1.14 → 0.1.16

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

@@ -1,9 +1,58 @@
 #!/usr/bin/env node
-import { execSync } from 'node:child_process';
+import { execSync, spawnSync } from 'node:child_process';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
 import { BROWSER_SERVICE_URL, loadConfig, setRepoRoot } from './config.mjs';
+const requireFromHere = createRequire(import.meta.url);
+const MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
+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.execPath;
+}
+function resolveCamoCliEntry() {
+    try {
+        const resolved = requireFromHere.resolve('@web-auto/camo/bin/camo.mjs');
+        if (resolved && fs.existsSync(resolved))
+            return resolved;
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
+function runCamoCli(args = [], options = {}) {
+    const entry = resolveCamoCliEntry();
+    if (!entry) {
+        return {
+            ok: false,
+            code: null,
+            stdout: '',
+            stderr: '@web-auto/camo/bin/camo.mjs not found',
+            entry: null,
+        };
+    }
+    const ret = spawnSync(resolveNodeBin(), [entry, ...args], {
+        encoding: 'utf8',
+        windowsHide: true,
+        stdio: options.stdio || 'pipe',
+        env: { ...process.env, ...(options.env || {}) },
+    });
+    return {
+        ok: ret.status === 0,
+        code: ret.status,
+        stdout: String(ret.stdout || ''),
+        stderr: String(ret.stderr || ''),
+        entry,
+    };
+}
 export async function callAPI(action, payload = {}) {
     const r = await fetch(`${BROWSER_SERVICE_URL}/command`, {
         method: 'POST',
@@ -319,20 +368,13 @@ function scanCommonRepoRoots() {
 }
 export function findRepoRootCandidate() {
     const cfg = loadConfig();
+    const cwdRoot = walkUpForRepoRoot(process.cwd());
+    const moduleRoot = walkUpForRepoRoot(MODULE_DIR);
     const candidates = [
         process.env.WEBAUTO_REPO_ROOT,
-        process.cwd(),
         cfg.repoRoot,
-        path.join('/Volumes', 'extension', 'code', 'webauto'),
-        path.join('/Volumes', 'extension', 'code', 'WebAuto'),
-        path.join(os.homedir(), 'Documents', 'github', 'webauto'),
-        path.join(os.homedir(), 'Documents', 'github', 'WebAuto'),
-        path.join(os.homedir(), 'github', 'webauto'),
-        path.join(os.homedir(), 'github', 'WebAuto'),
-        path.join('C:', 'code', 'webauto'),
-        path.join('C:', 'code', 'WebAuto'),
-        path.join('C:', 'Users', os.userInfo().username, 'code', 'webauto'),
-        path.join('C:', 'Users', os.userInfo().username, 'code', 'WebAuto'),
+        moduleRoot,
+        cwdRoot,
     ].filter(Boolean);
     for (const root of candidates) {
         if (!hasContainerLibrary(root))
@@ -343,20 +385,6 @@ export function findRepoRootCandidate() {
         }
         return resolved;
     }
-    const walked = walkUpForRepoRoot(process.cwd());
-    if (walked) {
-        if (cfg.repoRoot !== walked) {
-            setRepoRoot(walked);
-        }
-        return walked;
-    }
-    const scanned = scanCommonRepoRoots();
-    if (scanned) {
-        if (cfg.repoRoot !== scanned) {
-            setRepoRoot(scanned);
-        }
-        return scanned;
-    }
     return null;
 }
 export function detectCamoufoxPath() {
@@ -381,12 +409,7 @@ export function detectCamoufoxPath() {
 export function ensureCamoufox() {
     if (detectCamoufoxPath())
         return;
-    console.log('Camoufox is not found. Installing...');
-    execSync('npx --yes --package=camoufox camoufox fetch', { stdio: 'inherit' });
-    if (!detectCamoufoxPath()) {
-        throw new Error('Camoufox install finished but executable was not detected');
-    }
-    console.log('Camoufox installed.');
+    throw new Error('Camoufox is not installed. Run: webauto xhs install --download-browser');
 }
 export async function ensureBrowserService() {
     if (await checkBrowserService())
@@ -398,20 +421,17 @@ export async function ensureBrowserService() {
     }
     if (provider === 'camo') {
         const repoRoot = findRepoRootCandidate();
-        if (repoRoot) {
-            try {
-                execSync(`npx --yes @web-auto/camo config repo-root ${JSON.stringify(repoRoot)}`, { stdio: 'ignore' });
-            }
-            catch {
-                // best-effort only; init will still try using current config
-            }
+        if (!repoRoot) {
+            throw new Error('WEBAUTO_REPO_ROOT is not set and no valid repo root was found');
         }
-        try {
-            console.log('Starting browser backend via camo init...');
-            execSync('npx --yes @web-auto/camo init', { stdio: 'inherit' });
+        const configRet = runCamoCli(['config', 'repo-root', repoRoot], { stdio: 'pipe' });
+        if (!configRet.ok) {
+            throw new Error(`camo config repo-root failed: ${configRet.stderr.trim() || configRet.stdout.trim() || `exit ${configRet.code ?? 'null'}`}`);
         }
-        catch (error) {
-            throw new Error(`camo init failed: ${error?.message || String(error)}`);
+        console.log('Starting browser backend via camo init...');
+        const initRet = runCamoCli(['init'], { stdio: 'inherit' });
+        if (!initRet.ok) {
+            throw new Error(`camo init failed: ${initRet.stderr.trim() || initRet.stdout.trim() || `exit ${initRet.code ?? 'null'}`}`);
         }
         for (let i = 0; i < 20; i += 1) {
             await new Promise((r) => setTimeout(r, 400));

package/modules/camo-runtime/src/autoscript/action-providers/xhs/comments.mjs

@@ -1,7 +1,11 @@
 export function buildCommentsHarvestScript(params = {}) {
   const maxRounds = Math.max(1, Number(params.maxRounds ?? params.maxScrollRounds ?? 14) || 14);
-  const scrollStep = Math.max(120, Number(params.scrollStep ?? 420) || 420);
-  const settleMs = Math.max(80, Number(params.settleMs ?? 180) || 180);
+  const scrollStepMin = Math.max(120, Number(params.scrollStepMin ?? params.scrollStep ?? 420) || 420);
+  const scrollStepMax = Math.max(scrollStepMin, Number(params.scrollStepMax ?? scrollStepMin) || scrollStepMin);
+  const scrollStepBase = Math.max(scrollStepMin, Math.floor((scrollStepMin + scrollStepMax) / 2));
+  const settleMinMs = Math.max(80, Number(params.settleMinMs ?? params.settleMs ?? 180) || 180);
+  const settleMaxMs = Math.max(settleMinMs, Number(params.settleMaxMs ?? settleMinMs) || settleMinMs);
+  const settleMs = settleMinMs;
   const stallRounds = Math.max(1, Number(params.stallRounds ?? 2) || 2);
   const requireBottom = params.requireBottom !== false;
   const includeComments = params.includeComments !== false;
@@ -10,12 +14,12 @@ export function buildCommentsHarvestScript(params = {}) {
   const recoveryUpRounds = Math.max(1, Number(params.recoveryUpRounds ?? 2) || 2);
   const recoveryDownRounds = Math.max(1, Number(params.recoveryDownRounds ?? 3) || 3);
   const maxRecoveries = Math.max(0, Number(params.maxRecoveries ?? 3) || 3);
-  const recoveryUpStep = Math.max(80, Number(params.recoveryUpStep ?? Math.floor(scrollStep * 0.75)) || Math.floor(scrollStep * 0.75));
-  const recoveryDownStep = Math.max(120, Number(params.recoveryDownStep ?? Math.floor(scrollStep * 1.3)) || Math.floor(scrollStep * 1.3));
+  const recoveryUpStep = Math.max(80, Number(params.recoveryUpStep ?? Math.floor(scrollStepBase * 0.75)) || Math.floor(scrollStepBase * 0.75));
+  const recoveryDownStep = Math.max(120, Number(params.recoveryDownStep ?? Math.floor(scrollStepBase * 1.3)) || Math.floor(scrollStepBase * 1.3));
   const recoveryNoProgressRounds = Math.max(1, Number(params.recoveryNoProgressRounds ?? 3) || 3);
   const progressDiffThreshold = Math.max(2, Number(
-    params.progressDiffThreshold ?? Math.max(12, Math.floor(scrollStep * 0.08)),
-  ) || Math.max(12, Math.floor(scrollStep * 0.08)));
+    params.progressDiffThreshold ?? Math.max(12, Math.floor(scrollStepBase * 0.08)),
+  ) || Math.max(12, Math.floor(scrollStepBase * 0.08)));
   const recoveryDownBoostPerAttempt = Math.max(0, Number(params.recoveryDownBoostPerAttempt ?? 1) || 1);
   const maxRecoveryDownBoost = Math.max(0, Number(params.maxRecoveryDownBoost ?? 2) || 2);
   const adaptiveMaxRounds = params.adaptiveMaxRounds !== false;
@@ -165,7 +169,10 @@ export function buildCommentsHarvestScript(params = {}) {
     };
 
     const configuredMaxRounds = Number(${maxRounds});
-    const scrollStep = Number(${scrollStep});
+    const scrollStepMin = Number(${scrollStepMin});
+    const scrollStepMax = Number(${scrollStepMax});
+    const settleMinMs = Number(${settleMinMs});
+    const settleMaxMs = Number(${settleMaxMs});
     const settleMs = Number(${settleMs});
     const stallRounds = Number(${stallRounds});
     const requireBottom = ${requireBottom ? 'true' : 'false'};
@@ -186,6 +193,12 @@ export function buildCommentsHarvestScript(params = {}) {
     const adaptiveBufferRounds = Number(${adaptiveBufferRounds});
     const adaptiveMinBoostRounds = Number(${adaptiveMinBoostRounds});
     const adaptiveMaxRoundsCap = Number(${adaptiveMaxRoundsCap});
+    const randomBetween = (min, max) => {
+      const lo = Math.max(0, Math.floor(Number(min) || 0));
+      const hi = Math.max(lo, Math.floor(Number(max) || 0));
+      if (hi <= lo) return lo;
+      return lo + Math.floor(Math.random() * (hi - lo + 1));
+    };
     let maxRounds = configuredMaxRounds;
     let maxRoundsSource = 'configured';
     let budgetExpectedCommentsCount = null;
@@ -216,10 +229,14 @@ export function buildCommentsHarvestScript(params = {}) {
       no_new_comments: 0,
     };
     const performScroll = async (deltaY, waitMs = settleMs, meta = {}) => {
+      const waitFloor = Math.max(settleMinMs, Math.floor(Number(waitMs) || settleMinMs));
+      const waitCeil = Math.max(waitFloor, Math.max(settleMaxMs, Math.floor(Number(waitMs) || settleMaxMs)));
+      const waitActual = randomBetween(waitFloor, waitCeil);
       pushTrace({
         kind: 'scroll',
         stage: 'xhs_comments_harvest',
         deltaY: Number(deltaY),
+        waitMs: waitActual,
         ...meta,
       });
       if (typeof scroller?.scrollBy === 'function') {
@@ -227,7 +244,7 @@ export function buildCommentsHarvestScript(params = {}) {
       } else {
         window.scrollBy({ top: deltaY, behavior: 'auto' });
       }
-      await new Promise((resolve) => setTimeout(resolve, waitMs));
+      await new Promise((resolve) => setTimeout(resolve, waitActual));
     };
 
     for (let round = 1; round <= maxRounds; round += 1) {
@@ -253,7 +270,8 @@ export function buildCommentsHarvestScript(params = {}) {
       }
 
       const prevTop = beforeMetrics.scrollTop;
-      await performScroll(scrollStep, settleMs, {
+      const roundScrollStep = randomBetween(scrollStepMin, scrollStepMax);
+      await performScroll(roundScrollStep, settleMs, {
         round,
         reason: 'main_scroll',
       });
@@ -261,16 +279,18 @@ export function buildCommentsHarvestScript(params = {}) {
       let afterMetrics = readMetrics();
       let moved = Math.abs(afterMetrics.scrollTop - prevTop) > 1;
       if (!moved && typeof window.scrollBy === 'function') {
-        const fallbackStep = Math.max(120, Math.floor(scrollStep / 2));
+        const fallbackStep = Math.max(120, Math.floor(roundScrollStep / 2));
+        const fallbackWaitMs = randomBetween(settleMinMs, settleMaxMs);
         pushTrace({
           kind: 'scroll',
           stage: 'xhs_comments_harvest',
           round,
           reason: 'fallback_scroll',
           deltaY: Number(fallbackStep),
+          waitMs: fallbackWaitMs,
         });
         window.scrollBy({ top: fallbackStep, behavior: 'auto' });
-        await new Promise((resolve) => setTimeout(resolve, settleMs));
+        await new Promise((resolve) => setTimeout(resolve, fallbackWaitMs));
         collect(round);
         afterMetrics = readMetrics();
         moved = Math.abs(afterMetrics.scrollTop - prevTop) > 1;

package/modules/camo-runtime/src/autoscript/action-providers/xhs/search.mjs

@@ -1,5 +1,10 @@
 export function buildSubmitSearchScript(params = {}) {
   const keyword = String(params.keyword || '').trim();
+  const method = String(params.method || params.submitMethod || 'click').trim().toLowerCase();
+  const actionDelayMinMs = Math.max(20, Number(params.actionDelayMinMs ?? 180) || 180);
+  const actionDelayMaxMs = Math.max(actionDelayMinMs, Number(params.actionDelayMaxMs ?? 620) || 620);
+  const settleMinMs = Math.max(60, Number(params.settleMinMs ?? 1200) || 1200);
+  const settleMaxMs = Math.max(settleMinMs, Number(params.settleMaxMs ?? 2600) || 2600);
   return `(async () => {
     const state = window.__camoXhsState || (window.__camoXhsState = {});
     const metrics = state.metrics && typeof state.metrics === 'object' ? state.metrics : {};
@@ -17,6 +22,18 @@ export function buildSubmitSearchScript(params = {}) {
     if (!(input instanceof HTMLInputElement)) {
       throw new Error('SEARCH_INPUT_NOT_FOUND');
     }
+    const randomBetween = (min, max) => {
+      const lo = Math.max(0, Math.floor(Number(min) || 0));
+      const hi = Math.max(lo, Math.floor(Number(max) || 0));
+      if (hi <= lo) return lo;
+      return lo + Math.floor(Math.random() * (hi - lo + 1));
+    };
+    const waitRandom = async (min, max, stage) => {
+      const waitMs = randomBetween(min, max);
+      pushTrace({ kind: 'wait', stage, waitMs });
+      await new Promise((resolve) => setTimeout(resolve, waitMs));
+      return waitMs;
+    };
     const targetKeyword = ${JSON.stringify(keyword)};
     if (targetKeyword && input.value !== targetKeyword) {
       input.focus();
@@ -24,38 +41,63 @@ export function buildSubmitSearchScript(params = {}) {
       input.dispatchEvent(new Event('input', { bubbles: true }));
       input.dispatchEvent(new Event('change', { bubbles: true }));
     }
-    const enterEvent = { key: 'Enter', code: 'Enter', keyCode: 13, which: 13, bubbles: true, cancelable: true };
+    const requestedMethod = ${JSON.stringify(method)};
+    const normalizedMethod = ['click', 'enter', 'form'].includes(requestedMethod) ? requestedMethod : 'click';
     const beforeUrl = window.location.href;
     input.focus();
-    input.dispatchEvent(new KeyboardEvent('keydown', enterEvent));
-    input.dispatchEvent(new KeyboardEvent('keypress', enterEvent));
-    input.dispatchEvent(new KeyboardEvent('keyup', enterEvent));
     const candidates = ['.input-button .search-icon', '.input-button', 'button.min-width-search-icon'];
+    let methodUsed = normalizedMethod;
     let clickedSelector = null;
-    for (const selector of candidates) {
-      const button = document.querySelector(selector);
-      if (!button) continue;
-      if (button instanceof HTMLElement) {
-        pushTrace({ kind: 'scroll', stage: 'submit_search', selector, via: 'scrollIntoView' });
-        button.scrollIntoView({ behavior: 'auto', block: 'center' });
+    const form = input.closest('form');
+    if (normalizedMethod === 'click') {
+      let clicked = false;
+      for (const selector of candidates) {
+        const button = document.querySelector(selector);
+        if (!button) continue;
+        if (button instanceof HTMLElement) {
+          pushTrace({ kind: 'scroll', stage: 'submit_search', selector, via: 'scrollIntoView' });
+          button.scrollIntoView({ behavior: 'auto', block: 'center' });
+        }
+        await waitRandom(${actionDelayMinMs}, ${actionDelayMaxMs}, 'submit_pre_click');
+        pushTrace({ kind: 'click', stage: 'submit_search', selector });
+        button.click();
+        clickedSelector = selector;
+        clicked = true;
+        break;
+      }
+      if (!clicked) {
+        methodUsed = 'form';
       }
-      await new Promise((resolve) => setTimeout(resolve, 80));
-      pushTrace({ kind: 'click', stage: 'submit_search', selector });
-      button.click();
-      clickedSelector = selector;
-      break;
     }
-    const form = input.closest('form');
-    if (form) {
-      if (typeof form.requestSubmit === 'function') form.requestSubmit();
-      else form.dispatchEvent(new Event('submit', { bubbles: true, cancelable: true }));
+    if (methodUsed === 'enter') {
+      await waitRandom(${actionDelayMinMs}, ${actionDelayMaxMs}, 'submit_pre_enter');
+      const enterEvent = { key: 'Enter', code: 'Enter', keyCode: 13, which: 13, bubbles: true, cancelable: true };
+      pushTrace({ kind: 'key', stage: 'submit_search', key: 'Enter' });
+      input.dispatchEvent(new KeyboardEvent('keydown', enterEvent));
+      input.dispatchEvent(new KeyboardEvent('keypress', enterEvent));
+      input.dispatchEvent(new KeyboardEvent('keyup', enterEvent));
+    } else if (methodUsed === 'form') {
+      await waitRandom(${actionDelayMinMs}, ${actionDelayMaxMs}, 'submit_pre_form');
+      if (form) {
+        pushTrace({ kind: 'submit', stage: 'submit_search', via: 'form' });
+        if (typeof form.requestSubmit === 'function') form.requestSubmit();
+        else form.dispatchEvent(new Event('submit', { bubbles: true, cancelable: true }));
+      } else {
+        methodUsed = 'enter';
+        const enterEvent = { key: 'Enter', code: 'Enter', keyCode: 13, which: 13, bubbles: true, cancelable: true };
+        pushTrace({ kind: 'key', stage: 'submit_search', key: 'Enter', fallback: true });
+        input.dispatchEvent(new KeyboardEvent('keydown', enterEvent));
+        input.dispatchEvent(new KeyboardEvent('keypress', enterEvent));
+        input.dispatchEvent(new KeyboardEvent('keyup', enterEvent));
+      }
     }
-    await new Promise((resolve) => setTimeout(resolve, 320));
+    await waitRandom(${settleMinMs}, ${settleMaxMs}, 'submit_settle');
     return {
       submitted: true,
-      via: clickedSelector || 'enter_or_form_submit',
+      via: clickedSelector || methodUsed,
       beforeUrl,
       afterUrl: window.location.href,
+      method: methodUsed,
       searchCount: metrics.searchCount,
       actionTrace,
     };
@@ -79,9 +121,21 @@ export function buildOpenDetailScript(params = {}) {
   const nextSeekRounds = Math.max(0, Number(params.nextSeekRounds || 8) || 8);
   const nextSeekStep = Math.max(0, Number(params.nextSeekStep || 0) || 0);
   const nextSeekSettleMs = Math.max(120, Number(params.nextSeekSettleMs || 320) || 320);
+  const preClickDelayMinMs = Math.max(60, Number(params.preClickDelayMinMs ?? 220) || 220);
+  const preClickDelayMaxMs = Math.max(preClickDelayMinMs, Number(params.preClickDelayMaxMs ?? 700) || 700);
+  const pollDelayMinMs = Math.max(80, Number(params.pollDelayMinMs ?? 130) || 130);
+  const pollDelayMaxMs = Math.max(pollDelayMinMs, Number(params.pollDelayMaxMs ?? 320) || 320);
+  const postOpenDelayMinMs = Math.max(120, Number(params.postOpenDelayMinMs ?? 420) || 420);
+  const postOpenDelayMaxMs = Math.max(postOpenDelayMinMs, Number(params.postOpenDelayMaxMs ?? 1100) || 1100);
 
   return `(async () => {
     const STATE_KEY = '__camoXhsState';
+    const randomBetween = (min, max) => {
+      const lo = Math.max(0, Math.floor(Number(min) || 0));
+      const hi = Math.max(lo, Math.floor(Number(max) || 0));
+      if (hi <= lo) return lo;
+      return lo + Math.floor(Math.random() * (hi - lo + 1));
+    };
     const normalizeVisited = (value) => {
       if (!Array.isArray(value)) return [];
       return value
@@ -282,7 +336,9 @@ export function buildOpenDetailScript(params = {}) {
       via: 'scrollIntoView',
     });
     next.cover.scrollIntoView({ behavior: 'auto', block: 'center' });
-    await new Promise((resolve) => setTimeout(resolve, 140));
+    const preClickDelay = randomBetween(${preClickDelayMinMs}, ${preClickDelayMaxMs});
+    pushTrace({ kind: 'wait', stage: 'open_detail_pre_click', noteId: next.noteId, waitMs: preClickDelay });
+    await new Promise((resolve) => setTimeout(resolve, preClickDelay));
     const beforeUrl = window.location.href;
     pushTrace({
       kind: 'click',
@@ -298,12 +354,15 @@ export function buildOpenDetailScript(params = {}) {
         detailReady = true;
         break;
       }
-      await new Promise((resolve) => setTimeout(resolve, 120));
+      const pollDelay = randomBetween(${pollDelayMinMs}, ${pollDelayMaxMs});
+      await new Promise((resolve) => setTimeout(resolve, pollDelay));
     }
     if (!detailReady) {
       throw new Error('DETAIL_OPEN_TIMEOUT');
     }
-    await new Promise((resolve) => setTimeout(resolve, 220));
+    const postOpenDelay = randomBetween(${postOpenDelayMinMs}, ${postOpenDelayMaxMs});
+    pushTrace({ kind: 'wait', stage: 'open_detail_post_open', noteId: next.noteId, waitMs: postOpenDelay });
+    await new Promise((resolve) => setTimeout(resolve, postOpenDelay));
     const afterUrl = window.location.href;
 
     if (!state.visitedNoteIds.includes(next.noteId)) state.visitedNoteIds.push(next.noteId);

package/modules/camo-runtime/src/autoscript/xhs-unified-template.mjs

@@ -472,8 +472,28 @@ export function buildXhsUnifiedAutoscript(rawOptions = {}) {
   const env = toTrimmedString(rawOptions.env, 'prod');
   const outputRoot = toTrimmedString(rawOptions.outputRoot, '');
   const throttle = toPositiveInt(rawOptions.throttle, 900, 100);
-  const tabCount = toPositiveInt(rawOptions.tabCount, 4, 1);
+  const tabCount = toPositiveInt(rawOptions.tabCount, 1, 1);
+  const tabOpenDelayMs = toNonNegativeInt(rawOptions.tabOpenDelayMs, 1400);
   const noteIntervalMs = toPositiveInt(rawOptions.noteIntervalMs, 1200, 200);
+  const submitMethod = toTrimmedString(rawOptions.submitMethod, 'click').toLowerCase();
+  const submitActionDelayMinMs = toPositiveInt(rawOptions.submitActionDelayMinMs, 180, 20);
+  const submitActionDelayMaxMs = toPositiveInt(rawOptions.submitActionDelayMaxMs, 620, submitActionDelayMinMs);
+  const submitSettleMinMs = toPositiveInt(rawOptions.submitSettleMinMs, 1200, 60);
+  const submitSettleMaxMs = toPositiveInt(rawOptions.submitSettleMaxMs, 2600, submitSettleMinMs);
+  const openDetailPreClickMinMs = toPositiveInt(rawOptions.openDetailPreClickMinMs, 220, 60);
+  const openDetailPreClickMaxMs = toPositiveInt(rawOptions.openDetailPreClickMaxMs, 700, openDetailPreClickMinMs);
+  const openDetailPollDelayMinMs = toPositiveInt(rawOptions.openDetailPollDelayMinMs, 130, 80);
+  const openDetailPollDelayMaxMs = toPositiveInt(rawOptions.openDetailPollDelayMaxMs, 320, openDetailPollDelayMinMs);
+  const openDetailPostOpenMinMs = toPositiveInt(rawOptions.openDetailPostOpenMinMs, 420, 120);
+  const openDetailPostOpenMaxMs = toPositiveInt(rawOptions.openDetailPostOpenMaxMs, 1100, openDetailPostOpenMinMs);
+  const commentsScrollStepMin = toPositiveInt(rawOptions.commentsScrollStepMin, 280, 120);
+  const commentsScrollStepMax = toPositiveInt(rawOptions.commentsScrollStepMax, 420, commentsScrollStepMin);
+  const commentsSettleMinMs = toPositiveInt(rawOptions.commentsSettleMinMs, 280, 80);
+  const commentsSettleMaxMs = toPositiveInt(rawOptions.commentsSettleMaxMs, 820, commentsSettleMinMs);
+  const defaultOperationMinIntervalMs = toNonNegativeInt(rawOptions.defaultOperationMinIntervalMs, 1200);
+  const defaultEventCooldownMs = toNonNegativeInt(rawOptions.defaultEventCooldownMs, 700);
+  const defaultPacingJitterMs = toNonNegativeInt(rawOptions.defaultPacingJitterMs, 900);
+  const navigationMinIntervalMs = toNonNegativeInt(rawOptions.navigationMinIntervalMs, 2200);
   const maxNotes = toPositiveInt(rawOptions.maxNotes, 30, 1);
   const maxComments = toNonNegativeInt(rawOptions.maxComments, 0);
   const resume = toBoolean(rawOptions.resume, false);
@@ -529,10 +549,10 @@ export function buildXhsUnifiedAutoscript(rawOptions = {}) {
       validationMode: 'none',
       recovery,
       pacing: {
-        operationMinIntervalMs: 700,
-        eventCooldownMs: 300,
-        jitterMs: 220,
-        navigationMinIntervalMs: 1800,
+        operationMinIntervalMs: defaultOperationMinIntervalMs,
+        eventCooldownMs: defaultEventCooldownMs,
+        jitterMs: defaultPacingJitterMs,
+        navigationMinIntervalMs,
         timeoutMs: 0,
       },
       timeoutMs: 0,
@@ -542,7 +562,27 @@ export function buildXhsUnifiedAutoscript(rawOptions = {}) {
       env,
       outputRoot,
       tabCount,
+      tabOpenDelayMs,
       noteIntervalMs,
+      submitMethod,
+      submitActionDelayMinMs,
+      submitActionDelayMaxMs,
+      submitSettleMinMs,
+      submitSettleMaxMs,
+      openDetailPreClickMinMs,
+      openDetailPreClickMaxMs,
+      openDetailPollDelayMinMs,
+      openDetailPollDelayMaxMs,
+      openDetailPostOpenMinMs,
+      openDetailPostOpenMaxMs,
+      commentsScrollStepMin,
+      commentsScrollStepMax,
+      commentsSettleMinMs,
+      commentsSettleMaxMs,
+      defaultOperationMinIntervalMs,
+      defaultEventCooldownMs,
+      defaultPacingJitterMs,
+      navigationMinIntervalMs,
       maxNotes,
       maxComments,
       maxLikesPerRound,
@@ -645,6 +685,11 @@ export function buildXhsUnifiedAutoscript(rawOptions = {}) {
           keyword,
           searchSerialKey,
           sharedHarvestPath,
+          method: submitMethod,
+          actionDelayMinMs: submitActionDelayMinMs,
+          actionDelayMaxMs: submitActionDelayMaxMs,
+          settleMinMs: submitSettleMinMs,
+          settleMaxMs: submitSettleMaxMs,
         },
         trigger: 'home_search_input.exist',
         dependsOn: ['fill_keyword'],
@@ -672,6 +717,12 @@ export function buildXhsUnifiedAutoscript(rawOptions = {}) {
           sharedHarvestPath,
           seedCollectCount,
           seedCollectMaxRounds,
+          preClickDelayMinMs: openDetailPreClickMinMs,
+          preClickDelayMaxMs: openDetailPreClickMaxMs,
+          pollDelayMinMs: openDetailPollDelayMinMs,
+          pollDelayMaxMs: openDetailPollDelayMaxMs,
+          postOpenDelayMinMs: openDetailPostOpenMinMs,
+          postOpenDelayMaxMs: openDetailPostOpenMaxMs,
         },
         trigger: 'search_result_item.exist',
         dependsOn: ['submit_search'],
@@ -732,8 +783,12 @@ export function buildXhsUnifiedAutoscript(rawOptions = {}) {
           persistComments,
           commentsLimit: maxComments,
           maxRounds: 48,
-          scrollStep: 360,
-          settleMs: 260,
+          scrollStep: commentsScrollStepMin,
+          scrollStepMin: commentsScrollStepMin,
+          scrollStepMax: commentsScrollStepMax,
+          settleMs: commentsSettleMinMs,
+          settleMinMs: commentsSettleMinMs,
+          settleMaxMs: commentsSettleMaxMs,
           stallRounds: 8,
           recoveryNoProgressRounds: 3,
           recoveryStuckRounds: 2,
@@ -874,6 +929,12 @@ export function buildXhsUnifiedAutoscript(rawOptions = {}) {
           resume,
           incrementalMax,
           sharedHarvestPath,
+          preClickDelayMinMs: openDetailPreClickMinMs,
+          preClickDelayMaxMs: openDetailPreClickMaxMs,
+          pollDelayMinMs: openDetailPollDelayMinMs,
+          pollDelayMaxMs: openDetailPollDelayMaxMs,
+          postOpenDelayMinMs: openDetailPostOpenMinMs,
+          postOpenDelayMaxMs: openDetailPostOpenMaxMs,
         },
         trigger: 'search_result_item.exist',
         dependsOn: ['switch_tab_round_robin'],
@@ -924,7 +985,7 @@ export function buildXhsUnifiedAutoscript(rawOptions = {}) {
         action: 'ensure_tab_pool',
         params: {
           tabCount,
-          openDelayMs: 1200,
+          openDelayMs: tabOpenDelayMs,
           normalizeTabs: false,
         },
         trigger: 'search_result_item.exist',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@web-auto/webauto",
-  "version": "0.1.14",
+  "version": "0.1.16",
   "type": "module",
   "bin": {
     "webauto": "bin/webauto.mjs"
@@ -50,6 +50,7 @@
   },
   "scripts": {
     "postinstall": "node scripts/postinstall-resources.mjs",
+    "prepack": "npm run build",
     "start:mcp:browser": "npx @browsermcp/mcp@latest",
     "build": "npm run prebuild && npm run build:services && npm run self-check:post-build && npm run ui:test && npm --prefix apps/desktop-console run build",
     "build:services": "tsc -p tsconfig.services.json",