@web-auto/webauto 0.1.13 → 0.1.15

package/apps/desktop-console/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@webauto/desktop-console",
+  "version": "0.1.11",
+  "private": true,
+  "type": "module",
+  "main": "dist/main/index.mjs",
+  "description": "Cross-platform desktop console for WebAuto (scripts runner)",
+  "scripts": {
+    "build": "node scripts/build.mjs",
+    "start": "electron .",
+    "test-preload": "node scripts/test-preload.mjs",
+    "test:renderer": "tsx --test src/renderer/index.test.mts src/renderer/index.runtime.test.mts src/renderer/path-helpers.test.mts src/renderer/tabs/debug.test.mts src/renderer/tabs/logs.test.mts src/renderer/tabs/preflight.test.mts src/renderer/tabs/preflight.runtime.test.mts src/renderer/tabs/run.test.mts src/renderer/tabs/runtime-smoke.test.mts src/renderer/tabs/xiaohongshu.test.mts src/renderer/tabs-new/setup-wizard.test.mts src/renderer/tabs-new/setup-wizard.runtime.test.mts src/renderer/tabs-new/account-manager.test.mts src/renderer/tabs-new/account-manager.runtime.test.mts src/renderer/tabs-new/config-panel.runtime.test.mts src/renderer/tabs-new/dashboard.runtime.test.mts src/renderer/tabs-new/scheduler.test.mts src/renderer/tabs-new/scheduler.runtime.test.mts src/renderer/tabs-new/tasks.runtime.test.mts src/renderer/ui-runtime.test.mts src/renderer/tabs/xiaohongshu/helpers.runtime.test.mts src/renderer/tabs/xiaohongshu-state.runtime.test.mts src/renderer/tabs/xiaohongshu/guide-browser-check.runtime.test.mts src/renderer/tabs/xiaohongshu/live-stats/runtime.test.mts",
+    "test:renderer:coverage": "c8 --all --extension .mts --extension .ts --reporter=text --reporter=text-summary --check-coverage --lines 90 --functions 85 --branches 55 --statements 90 --include src/renderer/index.mts --include src/renderer/account-source.mts --include src/renderer/hooks/use-task-state.mts --include src/renderer/path-helpers.mts --include src/renderer/ui-components.mts --include src/renderer/tabs/preflight.mts --include src/renderer/tabs/logs.mts --include src/renderer/tabs/profile-pool.mts --include src/renderer/tabs/results.mts --include src/renderer/tabs/run.mts --include src/renderer/tabs/runtime.mts --include src/renderer/tabs/settings.mts --include src/renderer/tabs-new/setup-wizard.mts --include src/renderer/tabs-new/account-manager.mts --include src/renderer/tabs-new/config-panel.mts --include src/renderer/tabs-new/dashboard.mts --include src/renderer/tabs-new/scheduler.mts --include src/renderer/tabs-new/tasks.mts --include src/renderer/tabs/xiaohongshu/helpers.mts --include src/renderer/tabs/xiaohongshu-state.mts --include src/renderer/tabs/xiaohongshu/guide-browser-check.mts --include src/renderer/tabs/xiaohongshu/live-stats/state-patch.mts --include src/renderer/tabs/xiaohongshu/live-stats/stdout-parser.mts tsx --test src/renderer/index.test.mts src/renderer/index.runtime.test.mts src/renderer/path-helpers.test.mts src/renderer/tabs/debug.test.mts src/renderer/tabs/logs.test.mts src/renderer/tabs/preflight.test.mts src/renderer/tabs/preflight.runtime.test.mts src/renderer/tabs/run.test.mts src/renderer/tabs/runtime-smoke.test.mts src/renderer/tabs/xiaohongshu.test.mts src/renderer/tabs-new/setup-wizard.test.mts src/renderer/tabs-new/setup-wizard.runtime.test.mts src/renderer/tabs-new/account-manager.test.mts src/renderer/tabs-new/account-manager.runtime.test.mts src/renderer/tabs-new/config-panel.runtime.test.mts src/renderer/tabs-new/dashboard.runtime.test.mts src/renderer/tabs-new/scheduler.test.mts src/renderer/tabs-new/scheduler.runtime.test.mts src/renderer/tabs-new/tasks.runtime.test.mts src/renderer/ui-runtime.test.mts src/renderer/tabs/xiaohongshu/helpers.runtime.test.mts src/renderer/tabs/xiaohongshu-state.runtime.test.mts src/renderer/tabs/xiaohongshu/guide-browser-check.runtime.test.mts src/renderer/tabs/xiaohongshu/live-stats/runtime.test.mts",
+    "clean": "node --input-type=module -e \"import('node:fs').then((fs)=>fs.rmSync('dist',{recursive:true,force:true}))\""
+  },
+  "devDependencies": {
+    "@types/node": "^20.19.33",
+    "c8": "^10.1.3",
+    "jsdom": "^26.1.0"
+  },
+  "dependencies": {
+    "electron": "^39.6.0"
+  }
+}

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

@@ -0,0 +1,139 @@
+#!/usr/bin/env node
+import minimist from 'minimist';
+import {
+  listPlatformFlowGates,
+  loadFlowGateDoc,
+  patchPlatformFlowGate,
+  resetPlatformFlowGate,
+  resolveFlowGatePath,
+  resolvePlatformFlowGate,
+} from './lib/flow-gate.mjs';
+
+function normalizePlatform(value) {
+  const text = String(value || '').trim().toLowerCase();
+  if (!text) return 'xiaohongshu';
+  if (text === 'xhs') return 'xiaohongshu';
+  return text;
+}
+
+function toJsonMode(argv) {
+  return argv.json === true || argv.j === true;
+}
+
+function printHelp() {
+  console.log([
+    'Usage: node apps/webauto/entry/flow-gate.mjs <get|list|set|reset|path> [options]',
+    'Options:',
+    '  --platform <name>       平台名（默认 xiaohongshu）',
+    '  --patch-json <json>     set 动作补丁 JSON（对象）',
+    '  --json                  输出 JSON',
+    '',
+    'Examples:',
+    '  node apps/webauto/entry/flow-gate.mjs get --platform xiaohongshu --json',
+    '  node apps/webauto/entry/flow-gate.mjs list --json',
+    '  node apps/webauto/entry/flow-gate.mjs set --platform xiaohongshu --patch-json \'{"noteInterval":{"minMs":2600,"maxMs":5200}}\' --json',
+    '  node apps/webauto/entry/flow-gate.mjs reset --platform xiaohongshu --json',
+  ].join('\n'));
+}
+
+function parsePatchJson(raw) {
+  const text = String(raw || '').trim();
+  if (!text) throw new Error('missing --patch-json');
+  let parsed = null;
+  try {
+    parsed = JSON.parse(text);
+  } catch (error) {
+    throw new Error(`invalid --patch-json: ${error?.message || String(error)}`);
+  }
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    throw new Error('--patch-json must be object JSON');
+  }
+  return parsed;
+}
+
+async function main() {
+  const argv = minimist(process.argv.slice(2), {
+    boolean: ['help', 'h', 'json', 'j'],
+    string: ['platform', 'patch-json'],
+  });
+  if (argv.help || argv.h) {
+    printHelp();
+    return;
+  }
+
+  const action = String(argv._[0] || 'get').trim().toLowerCase();
+  const platform = normalizePlatform(argv.platform);
+  const jsonMode = toJsonMode(argv);
+  const path = resolveFlowGatePath();
+
+  if (action === 'path') {
+    if (jsonMode) {
+      console.log(JSON.stringify({ ok: true, path }, null, 2));
+    } else {
+      console.log(path);
+    }
+    return;
+  }
+
+  if (action === 'get') {
+    const gate = await resolvePlatformFlowGate(platform);
+    if (jsonMode) {
+      console.log(JSON.stringify({ ok: true, platform, path, gate }, null, 2));
+    } else {
+      console.log(`[flow-gate] platform=${platform}`);
+      console.log(JSON.stringify(gate, null, 2));
+      console.log(`[flow-gate] file=${path}`);
+    }
+    return;
+  }
+
+  if (action === 'list') {
+    const gates = await listPlatformFlowGates();
+    if (jsonMode) {
+      console.log(JSON.stringify({ ok: true, path, platforms: gates }, null, 2));
+    } else {
+      console.log(JSON.stringify(gates, null, 2));
+      console.log(`[flow-gate] file=${path}`);
+    }
+    return;
+  }
+
+  if (action === 'set') {
+    const patch = parsePatchJson(argv['patch-json']);
+    const gate = await patchPlatformFlowGate(platform, patch);
+    if (jsonMode) {
+      console.log(JSON.stringify({ ok: true, action, platform, path, gate }, null, 2));
+    } else {
+      console.log(`[flow-gate] updated platform=${platform}`);
+      console.log(JSON.stringify(gate, null, 2));
+      console.log(`[flow-gate] file=${path}`);
+    }
+    return;
+  }
+
+  if (action === 'reset') {
+    const gate = await resetPlatformFlowGate(platform);
+    if (jsonMode) {
+      console.log(JSON.stringify({ ok: true, action, platform, path, gate }, null, 2));
+    } else {
+      console.log(`[flow-gate] reset platform=${platform}`);
+      console.log(JSON.stringify(gate, null, 2));
+      console.log(`[flow-gate] file=${path}`);
+    }
+    return;
+  }
+
+  if (action === 'show-doc') {
+    const doc = await loadFlowGateDoc();
+    if (jsonMode) console.log(JSON.stringify({ ok: true, path, doc }, null, 2));
+    else console.log(JSON.stringify(doc, null, 2));
+    return;
+  }
+
+  throw new Error(`unknown action: ${action}`);
+}
+
+main().catch((err) => {
+  console.error(err?.message || String(err));
+  process.exit(1);
+});

package/apps/webauto/entry/lib/camo-cli.mjs

@@ -44,7 +44,6 @@ export function getCamoRunner(rootDir = process.cwd()) {
   const isWin = process.platform === 'win32';
   const localBin = path.join(rootDir, 'node_modules', '.bin');
   const camoNames = isWin ? ['camo.cmd', 'camo.exe', 'camo.bat', 'camo.ps1'] : ['camo'];
-  const npxNames = isWin ? ['npx.cmd', 'npx.exe', 'npx.bat', 'npx.ps1'] : ['npx'];
 
   const local = resolveInDir(localBin, camoNames);
   if (local) return wrapWindowsRunner(local);
@@ -52,8 +51,7 @@ export function getCamoRunner(rootDir = process.cwd()) {
   const global = resolveOnPath(camoNames);
   if (global) return wrapWindowsRunner(global);
 
-  const npx = resolveOnPath(npxNames) || (isWin ? 'npx.cmd' : 'npx');
-  return wrapWindowsRunner(npx, ['--yes', '--package=@web-auto/camo', 'camo']);
+  return null;
 }
 
 function parseLastJson(stdout) {
@@ -74,6 +72,15 @@ export function runCamo(args, options = {}) {
   const rootDir = String(options.rootDir || process.cwd());
   const timeoutMs = Number(options.timeoutMs) > 0 ? Number(options.timeoutMs) : 60000;
   const runner = getCamoRunner(rootDir);
+  if (!runner) {
+    return {
+      ok: false,
+      code: null,
+      stdout: '',
+      stderr: 'camo cli not found in node_modules/.bin or PATH',
+      json: null,
+    };
+  }
   const ret = spawnSync(runner.cmd, [...runner.prefix, ...args], {
     cwd: rootDir,
     env: { ...process.env, ...(options.env || {}) },

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-install.mjs

@@ -172,10 +172,6 @@ function checkGeoIPInstalled() {
   return hasValidGeoIPFile(resolveGeoIPPath());
 }
 
-function installGeoIP() {
-  return runCamoCommand(['init', 'geoip']);
-}
-
 async function installGeoIPDirect() {
   const target = resolveGeoIPPath();
   const tmp = `${target}.tmp`;
@@ -195,18 +191,14 @@ async function installGeoIPDirect() {
 }
 
 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 };
+    return { ok: checkGeoIPInstalled(), source: 'direct', ret: null, detail: '' };
   } catch (error) {
     return {
       ok: false,
-      source: 'none',
-      ret: commandResult.ret,
+      source: 'direct',
+      ret: null,
       detail: error?.message || String(error),
     };
   }