@web-auto/webauto 0.1.14 → 0.1.16

package/apps/webauto/entry/lib/flow-gate.mjs

@@ -0,0 +1,466 @@
+import { existsSync } from 'node:fs';
+import fsp from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function toInt(value, fallback, min = 0) {
+  if (value === undefined || value === null || value === '') return fallback;
+  const num = Number(value);
+  if (!Number.isFinite(num)) return fallback;
+  return Math.max(min, Math.floor(num));
+}
+
+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');
+}
+
+export function resolveWebautoHome(options = {}) {
+  const env = options.env || process.env;
+  const platform = String(options.platform || process.platform);
+  const homeDir = String(options.homeDir || os.homedir());
+  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);
+  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');
+}
+
+const DEFAULT_PLATFORM_GATES = Object.freeze({
+  xiaohongshu: {
+    throttle: { minMs: 900, maxMs: 1800 },
+    noteInterval: { minMs: 2200, maxMs: 4200 },
+    tabPool: { tabCount: 1, openDelayMinMs: 1400, openDelayMaxMs: 2800 },
+    submitSearch: {
+      method: 'click',
+      actionDelayMinMs: 180,
+      actionDelayMaxMs: 620,
+      settleMinMs: 1200,
+      settleMaxMs: 2600,
+    },
+    openDetail: {
+      preClickMinMs: 220,
+      preClickMaxMs: 700,
+      pollDelayMinMs: 130,
+      pollDelayMaxMs: 320,
+      postOpenMinMs: 420,
+      postOpenMaxMs: 1100,
+    },
+    commentsHarvest: {
+      scrollStepMin: 280,
+      scrollStepMax: 420,
+      settleMinMs: 280,
+      settleMaxMs: 820,
+    },
+    pacing: {
+      defaultOperationMinIntervalMs: 1200,
+      defaultEventCooldownMs: 700,
+      defaultJitterMs: 900,
+      navigationMinIntervalMs: 2200,
+    },
+  },
+  weibo: {
+    throttle: { minMs: 800, maxMs: 1600 },
+    noteInterval: { minMs: 1800, maxMs: 3600 },
+    tabPool: { tabCount: 1, openDelayMinMs: 1200, openDelayMaxMs: 2400 },
+    submitSearch: {
+      method: 'click',
+      actionDelayMinMs: 160,
+      actionDelayMaxMs: 560,
+      settleMinMs: 900,
+      settleMaxMs: 2200,
+    },
+    openDetail: {
+      preClickMinMs: 180,
+      preClickMaxMs: 640,
+      pollDelayMinMs: 120,
+      pollDelayMaxMs: 300,
+      postOpenMinMs: 380,
+      postOpenMaxMs: 980,
+    },
+    commentsHarvest: {
+      scrollStepMin: 260,
+      scrollStepMax: 380,
+      settleMinMs: 260,
+      settleMaxMs: 760,
+    },
+    pacing: {
+      defaultOperationMinIntervalMs: 1000,
+      defaultEventCooldownMs: 600,
+      defaultJitterMs: 800,
+      navigationMinIntervalMs: 2000,
+    },
+  },
+  '1688': {
+    throttle: { minMs: 800, maxMs: 1500 },
+    noteInterval: { minMs: 1800, maxMs: 3200 },
+    tabPool: { tabCount: 1, openDelayMinMs: 1200, openDelayMaxMs: 2200 },
+    submitSearch: {
+      method: 'click',
+      actionDelayMinMs: 140,
+      actionDelayMaxMs: 520,
+      settleMinMs: 900,
+      settleMaxMs: 2000,
+    },
+    openDetail: {
+      preClickMinMs: 180,
+      preClickMaxMs: 620,
+      pollDelayMinMs: 120,
+      pollDelayMaxMs: 280,
+      postOpenMinMs: 320,
+      postOpenMaxMs: 920,
+    },
+    commentsHarvest: {
+      scrollStepMin: 260,
+      scrollStepMax: 360,
+      settleMinMs: 240,
+      settleMaxMs: 700,
+    },
+    pacing: {
+      defaultOperationMinIntervalMs: 900,
+      defaultEventCooldownMs: 500,
+      defaultJitterMs: 700,
+      navigationMinIntervalMs: 1800,
+    },
+  },
+});
+
+function cloneDefaultPlatformGate(platform) {
+  const key = String(platform || '').trim().toLowerCase() || 'xiaohongshu';
+  const fallback = DEFAULT_PLATFORM_GATES[key] || DEFAULT_PLATFORM_GATES.xiaohongshu;
+  return JSON.parse(JSON.stringify(fallback));
+}
+
+function normalizeMethod(value, fallback = 'click') {
+  const method = String(value || '').trim().toLowerCase();
+  if (['click', 'enter', 'form'].includes(method)) return method;
+  return fallback;
+}
+
+function normalizeMinMax(input, defaults, minFloor = 0) {
+  const fallbackMin = toInt(defaults?.minMs, minFloor, minFloor);
+  const fallbackMax = Math.max(fallbackMin, toInt(defaults?.maxMs, fallbackMin, fallbackMin));
+  const minMs = toInt(input?.minMs, fallbackMin, minFloor);
+  const maxMs = Math.max(minMs, toInt(input?.maxMs, fallbackMax, minMs));
+  return { minMs, maxMs };
+}
+
+function normalizePlatformGate(rawGate = {}, defaults = cloneDefaultPlatformGate('xiaohongshu')) {
+  const gate = rawGate && typeof rawGate === 'object' ? rawGate : {};
+  const out = {
+    throttle: normalizeMinMax(gate.throttle, defaults.throttle, 100),
+    noteInterval: normalizeMinMax(gate.noteInterval, defaults.noteInterval, 200),
+    tabPool: {
+      tabCount: toInt(gate?.tabPool?.tabCount, toInt(defaults?.tabPool?.tabCount, 1, 1), 1),
+      openDelayMinMs: 0,
+      openDelayMaxMs: 0,
+    },
+    submitSearch: {
+      method: normalizeMethod(gate?.submitSearch?.method, normalizeMethod(defaults?.submitSearch?.method, 'click')),
+      actionDelayMinMs: 0,
+      actionDelayMaxMs: 0,
+      settleMinMs: 0,
+      settleMaxMs: 0,
+    },
+    openDetail: {
+      preClickMinMs: 0,
+      preClickMaxMs: 0,
+      pollDelayMinMs: 0,
+      pollDelayMaxMs: 0,
+      postOpenMinMs: 0,
+      postOpenMaxMs: 0,
+    },
+    commentsHarvest: {
+      scrollStepMin: 0,
+      scrollStepMax: 0,
+      settleMinMs: 0,
+      settleMaxMs: 0,
+    },
+    pacing: {
+      defaultOperationMinIntervalMs: 0,
+      defaultEventCooldownMs: 0,
+      defaultJitterMs: 0,
+      navigationMinIntervalMs: 0,
+    },
+  };
+
+  const tabDelay = normalizeMinMax(
+    {
+      minMs: gate?.tabPool?.openDelayMinMs,
+      maxMs: gate?.tabPool?.openDelayMaxMs,
+    },
+    {
+      minMs: defaults?.tabPool?.openDelayMinMs,
+      maxMs: defaults?.tabPool?.openDelayMaxMs,
+    },
+    0,
+  );
+  out.tabPool.openDelayMinMs = tabDelay.minMs;
+  out.tabPool.openDelayMaxMs = tabDelay.maxMs;
+
+  const submitActionDelay = normalizeMinMax(
+    {
+      minMs: gate?.submitSearch?.actionDelayMinMs,
+      maxMs: gate?.submitSearch?.actionDelayMaxMs,
+    },
+    {
+      minMs: defaults?.submitSearch?.actionDelayMinMs,
+      maxMs: defaults?.submitSearch?.actionDelayMaxMs,
+    },
+    20,
+  );
+  out.submitSearch.actionDelayMinMs = submitActionDelay.minMs;
+  out.submitSearch.actionDelayMaxMs = submitActionDelay.maxMs;
+
+  const submitSettle = normalizeMinMax(
+    {
+      minMs: gate?.submitSearch?.settleMinMs,
+      maxMs: gate?.submitSearch?.settleMaxMs,
+    },
+    {
+      minMs: defaults?.submitSearch?.settleMinMs,
+      maxMs: defaults?.submitSearch?.settleMaxMs,
+    },
+    60,
+  );
+  out.submitSearch.settleMinMs = submitSettle.minMs;
+  out.submitSearch.settleMaxMs = submitSettle.maxMs;
+
+  const openDetailPreClick = normalizeMinMax(
+    {
+      minMs: gate?.openDetail?.preClickMinMs,
+      maxMs: gate?.openDetail?.preClickMaxMs,
+    },
+    {
+      minMs: defaults?.openDetail?.preClickMinMs,
+      maxMs: defaults?.openDetail?.preClickMaxMs,
+    },
+    60,
+  );
+  out.openDetail.preClickMinMs = openDetailPreClick.minMs;
+  out.openDetail.preClickMaxMs = openDetailPreClick.maxMs;
+
+  const openDetailPoll = normalizeMinMax(
+    {
+      minMs: gate?.openDetail?.pollDelayMinMs,
+      maxMs: gate?.openDetail?.pollDelayMaxMs,
+    },
+    {
+      minMs: defaults?.openDetail?.pollDelayMinMs,
+      maxMs: defaults?.openDetail?.pollDelayMaxMs,
+    },
+    80,
+  );
+  out.openDetail.pollDelayMinMs = openDetailPoll.minMs;
+  out.openDetail.pollDelayMaxMs = openDetailPoll.maxMs;
+
+  const openDetailPost = normalizeMinMax(
+    {
+      minMs: gate?.openDetail?.postOpenMinMs,
+      maxMs: gate?.openDetail?.postOpenMaxMs,
+    },
+    {
+      minMs: defaults?.openDetail?.postOpenMinMs,
+      maxMs: defaults?.openDetail?.postOpenMaxMs,
+    },
+    120,
+  );
+  out.openDetail.postOpenMinMs = openDetailPost.minMs;
+  out.openDetail.postOpenMaxMs = openDetailPost.maxMs;
+
+  const commentsScrollStep = normalizeMinMax(
+    {
+      minMs: gate?.commentsHarvest?.scrollStepMin,
+      maxMs: gate?.commentsHarvest?.scrollStepMax,
+    },
+    {
+      minMs: defaults?.commentsHarvest?.scrollStepMin,
+      maxMs: defaults?.commentsHarvest?.scrollStepMax,
+    },
+    120,
+  );
+  out.commentsHarvest.scrollStepMin = commentsScrollStep.minMs;
+  out.commentsHarvest.scrollStepMax = commentsScrollStep.maxMs;
+
+  const commentsSettle = normalizeMinMax(
+    {
+      minMs: gate?.commentsHarvest?.settleMinMs,
+      maxMs: gate?.commentsHarvest?.settleMaxMs,
+    },
+    {
+      minMs: defaults?.commentsHarvest?.settleMinMs,
+      maxMs: defaults?.commentsHarvest?.settleMaxMs,
+    },
+    80,
+  );
+  out.commentsHarvest.settleMinMs = commentsSettle.minMs;
+  out.commentsHarvest.settleMaxMs = commentsSettle.maxMs;
+
+  out.pacing.defaultOperationMinIntervalMs = toInt(
+    gate?.pacing?.defaultOperationMinIntervalMs,
+    toInt(defaults?.pacing?.defaultOperationMinIntervalMs, 700, 0),
+    0,
+  );
+  out.pacing.defaultEventCooldownMs = toInt(
+    gate?.pacing?.defaultEventCooldownMs,
+    toInt(defaults?.pacing?.defaultEventCooldownMs, 300, 0),
+    0,
+  );
+  out.pacing.defaultJitterMs = toInt(
+    gate?.pacing?.defaultJitterMs,
+    toInt(defaults?.pacing?.defaultJitterMs, 220, 0),
+    0,
+  );
+  out.pacing.navigationMinIntervalMs = toInt(
+    gate?.pacing?.navigationMinIntervalMs,
+    toInt(defaults?.pacing?.navigationMinIntervalMs, 1800, 0),
+    0,
+  );
+
+  return out;
+}
+
+function normalizePlatformKey(value) {
+  const key = String(value || '').trim().toLowerCase();
+  if (!key) return 'xiaohongshu';
+  if (key === 'xhs') return 'xiaohongshu';
+  return key;
+}
+
+function buildDefaultDoc() {
+  return {
+    version: 1,
+    updatedAt: nowIso(),
+    platforms: {
+      xiaohongshu: cloneDefaultPlatformGate('xiaohongshu'),
+      weibo: cloneDefaultPlatformGate('weibo'),
+      '1688': cloneDefaultPlatformGate('1688'),
+    },
+  };
+}
+
+export function resolveFlowGatePath(options = {}) {
+  const home = resolveWebautoHome(options);
+  return path.join(home, 'config', 'flow-gates.json');
+}
+
+function normalizeDoc(raw) {
+  const base = buildDefaultDoc();
+  const input = raw && typeof raw === 'object' ? raw : {};
+  const sourcePlatforms = input.platforms && typeof input.platforms === 'object' ? input.platforms : {};
+  const platforms = {};
+  for (const key of Object.keys(base.platforms)) {
+    const normalizedKey = normalizePlatformKey(key);
+    const defaults = cloneDefaultPlatformGate(normalizedKey);
+    platforms[normalizedKey] = normalizePlatformGate(sourcePlatforms[normalizedKey], defaults);
+  }
+  for (const [rawKey, rawGate] of Object.entries(sourcePlatforms)) {
+    const key = normalizePlatformKey(rawKey);
+    if (platforms[key]) continue;
+    const defaults = cloneDefaultPlatformGate(key);
+    platforms[key] = normalizePlatformGate(rawGate, defaults);
+  }
+  return {
+    version: 1,
+    updatedAt: String(input.updatedAt || nowIso()),
+    platforms,
+  };
+}
+
+export async function loadFlowGateDoc(options = {}) {
+  const filePath = resolveFlowGatePath(options);
+  let parsed = null;
+  try {
+    const raw = await fsp.readFile(filePath, 'utf8');
+    parsed = JSON.parse(raw);
+  } catch {
+    parsed = null;
+  }
+  if (!parsed && options.ensure !== false) {
+    const seeded = buildDefaultDoc();
+    await saveFlowGateDoc(seeded, options);
+    return normalizeDoc(seeded);
+  }
+  return normalizeDoc(parsed);
+}
+
+export async function saveFlowGateDoc(doc, options = {}) {
+  const filePath = resolveFlowGatePath(options);
+  const normalized = normalizeDoc(doc);
+  const payload = {
+    ...normalized,
+    updatedAt: nowIso(),
+  };
+  await fsp.mkdir(path.dirname(filePath), { recursive: true });
+  await fsp.writeFile(filePath, `${JSON.stringify(payload, null, 2)}\n`, 'utf8');
+  return payload;
+}
+
+export async function resolvePlatformFlowGate(platform, options = {}) {
+  const key = normalizePlatformKey(platform);
+  const doc = await loadFlowGateDoc(options);
+  const defaults = cloneDefaultPlatformGate(key);
+  return normalizePlatformGate(doc.platforms[key], defaults);
+}
+
+function deepMerge(base, patch) {
+  const left = base && typeof base === 'object' ? base : {};
+  const right = patch && typeof patch === 'object' ? patch : {};
+  const out = { ...left };
+  for (const [key, value] of Object.entries(right)) {
+    if (
+      value
+      && typeof value === 'object'
+      && !Array.isArray(value)
+      && left[key]
+      && typeof left[key] === 'object'
+      && !Array.isArray(left[key])
+    ) {
+      out[key] = deepMerge(left[key], value);
+    } else {
+      out[key] = value;
+    }
+  }
+  return out;
+}
+
+export async function patchPlatformFlowGate(platform, patch, options = {}) {
+  const key = normalizePlatformKey(platform);
+  const doc = await loadFlowGateDoc(options);
+  const current = doc.platforms[key] || cloneDefaultPlatformGate(key);
+  doc.platforms[key] = deepMerge(current, patch || {});
+  const saved = await saveFlowGateDoc(doc, options);
+  return saved.platforms[key];
+}
+
+export async function resetPlatformFlowGate(platform, options = {}) {
+  const key = normalizePlatformKey(platform);
+  const doc = await loadFlowGateDoc(options);
+  doc.platforms[key] = cloneDefaultPlatformGate(key);
+  const saved = await saveFlowGateDoc(doc, options);
+  return saved.platforms[key];
+}
+
+export async function listPlatformFlowGates(options = {}) {
+  const doc = await loadFlowGateDoc(options);
+  return doc.platforms;
+}

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

@@ -13,6 +13,7 @@ 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';
+import { resolvePlatformFlowGate } from './lib/flow-gate.mjs';
 
 function nowIso() {
   return new Date().toISOString();
@@ -45,6 +46,13 @@ function parseNonNegativeInt(value, fallback = 0) {
   return Math.max(0, Math.floor(num));
 }
 
+function pickRandomInt(min, max) {
+  const floorMin = Math.max(0, Math.floor(Number(min) || 0));
+  const floorMax = Math.max(floorMin, Math.floor(Number(max) || 0));
+  if (floorMax <= floorMin) return floorMin;
+  return floorMin + Math.floor(Math.random() * (floorMax - floorMin + 1));
+}
+
 function parseProfiles(argv) {
   const profile = String(argv.profile || '').trim();
   const profilesRaw = String(argv.profiles || '').trim();
@@ -301,7 +309,7 @@ function createTaskReporter(seed = {}) {
   };
 }
 
-function buildTemplateOptions(argv, profileId, overrides = {}) {
+async function buildTemplateOptions(argv, profileId, overrides = {}) {
   const keyword = String(argv.keyword || argv.k || '').trim();
   const env = String(argv.env || 'prod').trim() || 'prod';
   const inputMode = String(argv['input-mode'] || 'protocol').trim() || 'protocol';
@@ -309,9 +317,63 @@ function buildTemplateOptions(argv, profileId, overrides = {}) {
   const ocrCommand = String(argv['ocr-command'] || '').trim();
   const maxNotes = parseIntFlag(argv['max-notes'] ?? argv.target, 30, 1);
   const maxComments = parseNonNegativeInt(argv['max-comments'], 0);
-  const throttle = parseIntFlag(argv.throttle, 500, 100);
-  const tabCount = parseIntFlag(argv['tab-count'], 4, 1);
-  const noteIntervalMs = parseIntFlag(argv['note-interval'], 900, 200);
+  let flowGate = null;
+  try {
+    flowGate = await resolvePlatformFlowGate('xiaohongshu');
+  } catch {
+    flowGate = null;
+  }
+
+  const throttleMin = parseIntFlag(flowGate?.throttle?.minMs, 900, 100);
+  const throttleMax = parseIntFlag(flowGate?.throttle?.maxMs, 1800, throttleMin);
+  const noteIntervalMin = parseIntFlag(flowGate?.noteInterval?.minMs, 2200, 200);
+  const noteIntervalMax = parseIntFlag(flowGate?.noteInterval?.maxMs, 4200, noteIntervalMin);
+  const tabCountDefault = parseIntFlag(flowGate?.tabPool?.tabCount, 1, 1);
+  const tabOpenDelayMin = parseIntFlag(flowGate?.tabPool?.openDelayMinMs, 1400, 0);
+  const tabOpenDelayMax = parseIntFlag(flowGate?.tabPool?.openDelayMaxMs, 2800, tabOpenDelayMin);
+  const submitMethodDefault = String(flowGate?.submitSearch?.method || 'click').trim().toLowerCase() || 'click';
+  const submitActionDelayMinDefault = parseIntFlag(flowGate?.submitSearch?.actionDelayMinMs, 180, 20);
+  const submitActionDelayMaxDefault = parseIntFlag(flowGate?.submitSearch?.actionDelayMaxMs, 620, submitActionDelayMinDefault);
+  const submitSettleMinDefault = parseIntFlag(flowGate?.submitSearch?.settleMinMs, 1200, 60);
+  const submitSettleMaxDefault = parseIntFlag(flowGate?.submitSearch?.settleMaxMs, 2600, submitSettleMinDefault);
+  const openDetailPreClickMinDefault = parseIntFlag(flowGate?.openDetail?.preClickMinMs, 220, 60);
+  const openDetailPreClickMaxDefault = parseIntFlag(flowGate?.openDetail?.preClickMaxMs, 700, openDetailPreClickMinDefault);
+  const openDetailPollDelayMinDefault = parseIntFlag(flowGate?.openDetail?.pollDelayMinMs, 130, 80);
+  const openDetailPollDelayMaxDefault = parseIntFlag(flowGate?.openDetail?.pollDelayMaxMs, 320, openDetailPollDelayMinDefault);
+  const openDetailPostOpenMinDefault = parseIntFlag(flowGate?.openDetail?.postOpenMinMs, 420, 120);
+  const openDetailPostOpenMaxDefault = parseIntFlag(flowGate?.openDetail?.postOpenMaxMs, 1100, openDetailPostOpenMinDefault);
+  const commentsScrollStepMinDefault = parseIntFlag(flowGate?.commentsHarvest?.scrollStepMin, 280, 120);
+  const commentsScrollStepMaxDefault = parseIntFlag(flowGate?.commentsHarvest?.scrollStepMax, 420, commentsScrollStepMinDefault);
+  const commentsSettleMinDefault = parseIntFlag(flowGate?.commentsHarvest?.settleMinMs, 280, 80);
+  const commentsSettleMaxDefault = parseIntFlag(flowGate?.commentsHarvest?.settleMaxMs, 820, commentsSettleMinDefault);
+  const defaultOperationMinIntervalDefault = parseIntFlag(flowGate?.pacing?.defaultOperationMinIntervalMs, 1200, 0);
+  const defaultEventCooldownDefault = parseIntFlag(flowGate?.pacing?.defaultEventCooldownMs, 700, 0);
+  const defaultPacingJitterDefault = parseIntFlag(flowGate?.pacing?.defaultJitterMs, 900, 0);
+  const navigationMinIntervalDefault = parseIntFlag(flowGate?.pacing?.navigationMinIntervalMs, 2200, 0);
+
+  const throttle = parseIntFlag(argv.throttle, pickRandomInt(throttleMin, throttleMax), 100);
+  const tabCount = parseIntFlag(argv['tab-count'], tabCountDefault, 1);
+  const noteIntervalMs = parseIntFlag(argv['note-interval'], pickRandomInt(noteIntervalMin, noteIntervalMax), 200);
+  const tabOpenDelayMs = parseIntFlag(argv['tab-open-delay'], pickRandomInt(tabOpenDelayMin, tabOpenDelayMax), 0);
+  const submitMethod = String(argv['search-submit-method'] || submitMethodDefault).trim().toLowerCase() || 'click';
+  const submitActionDelayMinMs = parseIntFlag(argv['submit-action-delay-min'], submitActionDelayMinDefault, 20);
+  const submitActionDelayMaxMs = parseIntFlag(argv['submit-action-delay-max'], submitActionDelayMaxDefault, submitActionDelayMinMs);
+  const submitSettleMinMs = parseIntFlag(argv['submit-settle-min'], submitSettleMinDefault, 60);
+  const submitSettleMaxMs = parseIntFlag(argv['submit-settle-max'], submitSettleMaxDefault, submitSettleMinMs);
+  const openDetailPreClickMinMs = parseIntFlag(argv['open-detail-preclick-min'], openDetailPreClickMinDefault, 60);
+  const openDetailPreClickMaxMs = parseIntFlag(argv['open-detail-preclick-max'], openDetailPreClickMaxDefault, openDetailPreClickMinMs);
+  const openDetailPollDelayMinMs = parseIntFlag(argv['open-detail-poll-min'], openDetailPollDelayMinDefault, 80);
+  const openDetailPollDelayMaxMs = parseIntFlag(argv['open-detail-poll-max'], openDetailPollDelayMaxDefault, openDetailPollDelayMinMs);
+  const openDetailPostOpenMinMs = parseIntFlag(argv['open-detail-postopen-min'], openDetailPostOpenMinDefault, 120);
+  const openDetailPostOpenMaxMs = parseIntFlag(argv['open-detail-postopen-max'], openDetailPostOpenMaxDefault, openDetailPostOpenMinMs);
+  const commentsScrollStepMin = parseIntFlag(argv['comments-scroll-step-min'], commentsScrollStepMinDefault, 120);
+  const commentsScrollStepMax = parseIntFlag(argv['comments-scroll-step-max'], commentsScrollStepMaxDefault, commentsScrollStepMin);
+  const commentsSettleMinMs = parseIntFlag(argv['comments-settle-min'], commentsSettleMinDefault, 80);
+  const commentsSettleMaxMs = parseIntFlag(argv['comments-settle-max'], commentsSettleMaxDefault, commentsSettleMinMs);
+  const defaultOperationMinIntervalMs = parseIntFlag(argv['operation-min-interval'], defaultOperationMinIntervalDefault, 0);
+  const defaultEventCooldownMs = parseIntFlag(argv['event-cooldown'], defaultEventCooldownDefault, 0);
+  const defaultPacingJitterMs = parseIntFlag(argv['pacing-jitter'], defaultPacingJitterDefault, 0);
+  const navigationMinIntervalMs = parseIntFlag(argv['navigation-min-interval'], navigationMinIntervalDefault, 0);
   const maxLikesPerRound = parseNonNegativeInt(argv['max-likes'], 0);
   const matchMode = String(argv['match-mode'] || 'any').trim() || 'any';
   const matchMinHits = parseIntFlag(argv['match-min-hits'], 1, 1);
@@ -348,7 +410,27 @@ function buildTemplateOptions(argv, profileId, overrides = {}) {
     outputRoot,
     throttle,
     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,
@@ -543,7 +625,24 @@ async function runProfile(spec, argv, baseOverrides = {}) {
   if (spec.seedCollectMaxRounds !== undefined && spec.seedCollectMaxRounds !== null) {
     overrides.seedCollectMaxRounds = parseNonNegativeInt(spec.seedCollectMaxRounds, 0);
   }
-  const options = buildTemplateOptions(argv, profileId, overrides);
+  const options = await buildTemplateOptions(argv, profileId, overrides);
+  console.log(JSON.stringify({
+    event: 'xhs.unified.flow_gate',
+    profileId,
+    throttle: options.throttle,
+    noteIntervalMs: options.noteIntervalMs,
+    tabCount: options.tabCount,
+    tabOpenDelayMs: options.tabOpenDelayMs,
+    submitMethod: options.submitMethod,
+    submitActionDelayMinMs: options.submitActionDelayMinMs,
+    submitActionDelayMaxMs: options.submitActionDelayMaxMs,
+    submitSettleMinMs: options.submitSettleMinMs,
+    submitSettleMaxMs: options.submitSettleMaxMs,
+    commentsScrollStepMin: options.commentsScrollStepMin,
+    commentsScrollStepMax: options.commentsScrollStepMax,
+    commentsSettleMinMs: options.commentsSettleMinMs,
+    commentsSettleMaxMs: options.commentsSettleMaxMs,
+  }));
   const script = buildXhsUnifiedAutoscript(options);
   const normalized = normalizeAutoscript(script, `xhs-unified:${profileId}`);
   const validation = validateAutoscript(normalized);
@@ -1283,6 +1382,11 @@ async function main() {
       '  --seed-collect-rounds <n>    首账号预采样滚动轮数（默认6）',
       '  --search-serial-key <key>    搜索阶段串行锁key（默认自动生成）',
       '  --shared-harvest-path <path> 共享harvest去重列表路径（默认自动生成）',
+      '  --search-submit-method <m>   搜索提交方式 click|enter|form（默认 flow-gate）',
+      '  --tab-open-delay <ms>        新开 tab 间隔（默认 flow-gate 区间随机）',
+      '  --operation-min-interval <ms> 基础操作最小间隔（默认 flow-gate）',
+      '  --event-cooldown <ms>        基础事件冷却（默认 flow-gate）',
+      '  --pacing-jitter <ms>         基础抖动区间（默认 flow-gate）',
     ].join('\n'));
     return;
   }

package/bin/webauto.mjs

@@ -167,6 +167,7 @@ Core Commands:
   webauto xhs install [--download-browser] [--download-geoip] [--ensure-backend]
   webauto xhs unified [xhs options...]
   webauto xhs status [--run-id <id>] [--json]
+  webauto xhs gate <get|list|set|reset|path> [--platform <name>] [--patch-json <json>] [--json]
   webauto xhs orchestrate [xhs options...]
   webauto version [--json]
   webauto version bump [patch|minor|major]
@@ -266,12 +267,14 @@ Usage:
   webauto xhs install [--download-browser] [--download-geoip] [--ensure-backend] [--install|--reinstall|--uninstall] [--browser|--geoip|--all]
   webauto xhs unified --profile <id> --keyword <kw> [options...]
   webauto xhs status [--run-id <id>] [--json]
+  webauto xhs gate <get|list|set|reset|path> [--platform <name>] [--patch-json <json>] [--json]
   webauto xhs orchestrate --profile <id> --keyword <kw> [options...]
 
 Subcommands:
   install      运行资源管理（兼容旧入口），支持检查/安装/卸载/重装 camoufox、geoip，按需拉起 backend
   unified      运行统一脚本（搜索 + 打开详情 + 评论抓取 + 点赞）
   status       查询当前任务状态与错误摘要（支持 runId 详情）
+  gate         管理平台流控参数（默认配置可修改并自动生效）
   orchestrate  运行编排入口（默认调用 unified 模式）
 
 Unified Required:
@@ -286,8 +289,8 @@ Unified Common Options:
   --concurrency <n>        并行度（默认=账号数）
   --plan-only              仅生成分片计划，不执行
   --tab-count <n>          轮询 tab 数，默认 4
-  --throttle <ms>          操作节流，默认 500
-  --note-interval <ms>     帖子间等待，默认 900
+  --throttle <ms>          操作节流（默认走 flow-gate 平台配置并随机化）
+  --note-interval <ms>     帖子间等待（默认走 flow-gate 平台配置并随机化）
   --env <name>             输出环境目录，默认 debug
   --output-root <path>     自定义输出根目录
   --dry-run                干跑（禁用点赞/回复）
@@ -332,6 +335,10 @@ Standard Workflows:
      webauto xhs status
      webauto xhs status --run-id <runId> --json
 
+  7) 查看/修改流控 gate（按平台隔离）
+     webauto xhs gate get --platform xiaohongshu --json
+     webauto xhs gate set --platform xiaohongshu --patch-json '{"noteInterval":{"minMs":2600,"maxMs":5200}}' --json
+
 Output:
   默认目录: ~/.webauto/download/xiaohongshu/<env>/<keyword>/
   典型产物:
@@ -869,6 +876,12 @@ async function main() {
       return;
     }
 
+    if (sub === 'gate') {
+      const script = path.join(ROOT, 'apps', 'webauto', 'entry', 'flow-gate.mjs');
+      await run(process.execPath, [script, ...rawArgv.slice(2)]);
+      return;
+    }
+
     if (sub === 'orchestrate') {
       const script = path.join(ROOT, 'apps', 'webauto', 'entry', 'xhs-orchestrate.mjs');
       await run(process.execPath, [script, ...rawArgv.slice(2)]);