@web-auto/webauto 0.1.8 → 0.1.11

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) {
@@ -73,50 +252,46 @@ function runPackageCommand(packageName, commandArgs) {
   return run(resolveNpmBin(), ['exec', '--yes', `--package=${packageName}`, '--', ...commandArgs]);
 }
 
-function resolveWebautoRoot() {
-  const portableRoot = String(process.env.WEBAUTO_PORTABLE_ROOT || process.env.WEBAUTO_ROOT || '').trim();
-  if (portableRoot) return path.join(portableRoot, '.webauto');
-  return path.join(os.homedir(), '.webauto');
+function normalizePathForPlatform(raw, platform = process.platform) {
+  const input = String(raw || '').trim();
+  const isWinPath = platform === 'win32' || /^[A-Za-z]:[\\/]/.test(input);
+  const pathApi = isWinPath ? path.win32 : path;
+  return isWinPath ? pathApi.normalize(input) : path.resolve(input);
 }
 
-function resolveGeoIPPath() {
-  return path.join(resolveWebautoRoot(), 'geoip', 'GeoLite2-City.mmdb');
+function normalizeLegacyWebautoRoot(raw, platform = process.platform) {
+  const pathApi = platform === 'win32' ? path.win32 : path;
+  const resolved = normalizePathForPlatform(raw, platform);
+  const base = pathApi.basename(resolved).toLowerCase();
+  if (base === '.webauto' || base === 'webauto') return resolved;
+  return pathApi.join(resolved, '.webauto');
 }
 
-function 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 resolveWebautoRoot(options = {}) {
+  const env = options.env || process.env;
+  const platform = String(options.platform || process.platform);
+  const pathApi = platform === 'win32' ? path.win32 : path;
+  const homeDir = String(options.homeDir || os.homedir());
+  const explicitHome = String(env.WEBAUTO_HOME || '').trim();
+  if (explicitHome) return normalizePathForPlatform(explicitHome, platform);
 
-function installCamoufox() {
-  const ret = runPackageCommand('camoufox', ['camoufox', 'fetch']);
-  return ret.status === 0;
-}
+  const legacyRoot = String(env.WEBAUTO_ROOT || env.WEBAUTO_PORTABLE_ROOT || '').trim();
+  if (legacyRoot) return normalizeLegacyWebautoRoot(legacyRoot, platform);
 
-function checkGeoIPInstalled() {
-  return existsSync(resolveGeoIPPath());
+  const hasDDrive = typeof options.hasDDrive === 'boolean'
+    ? options.hasDDrive
+    : (platform === 'win32' && existsSync('D:\\'));
+  if (platform === 'win32') return hasDDrive ? 'D:\\webauto' : pathApi.join(homeDir, '.webauto');
+  return pathApi.join(homeDir, '.webauto');
 }
 
-function installGeoIP() {
-  const ret = runPackageCommand('@web-auto/camo', ['camo', 'init', 'geoip']);
-  return ret.status === 0;
+function resolveGeoIPPath() {
+  return path.join(resolveWebautoRoot(), 'geoip', 'GeoLite2-City.mmdb');
 }
 
+
 function uninstallCamoufox() {
-  const ret = runPackageCommand('camoufox', ['camoufox', 'remove']);
-  return ret.status === 0;
+  return runCamoufoxCommand(['remove']);
 }
 
 function uninstallGeoIP() {
@@ -203,6 +378,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 +387,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 +416,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 +481,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 +511,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);