@web-auto/webauto 0.1.4 → 0.1.7

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

@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+import minimist from 'minimist';
+import { runWorkflowById } from '../../../dist/modules/workflow/src/runner.js';
+import { pathToFileURL } from 'node:url';
+
+const WEIBO_HOME_URL = 'https://www.weibo.com';
+const DEFAULT_PROFILE = 'xiaohongshu-batch-1'; // Use shared profile for now
+
+async function runCommand(argv) {
+  const profile = String(argv.profile || DEFAULT_PROFILE).trim();
+  if (!profile) {
+    throw new Error('Profile ID is required. Use --profile <id>');
+  }
+
+  const workflowId = String(argv.workflow || '').trim();
+  const keyword = String(argv.keyword || '').trim();
+  const targetCount = Number(argv['max-notes'] || argv.target || 50);
+  const maxComments = Number(argv['max-comments'] || 0); // 0 means no limit
+
+  if (!keyword && workflowId === 'weibo-search-v1') {
+    throw new Error('Keyword is required for search tasks. Use --keyword <text>');
+  }
+
+  const env = String(argv.env || 'debug').trim();
+
+  const initialContext = {
+    sessionId: profile,
+    keyword,
+    env,
+    targetCount,
+    maxComments,
+    // Add other common parameters as needed
+  };
+
+  if (!workflowId) {
+    throw new Error('Workflow ID is required. e.g., --workflow weibo-search-v1');
+  }
+
+  console.log(`[Weibo Unified] Running workflow: ${workflowId} with profile: ${profile}`);
+  const result = await runWorkflowById(workflowId, initialContext);
+
+  if (result.success) {
+    console.log(`[Weibo Unified] Workflow ${workflowId} completed successfully.`);
+  } else {
+    console.error(`[Weibo Unified] Workflow ${workflowId} failed: ${result.error}`);
+    process.exit(1);
+  }
+}
+
+async function main() {
+  const argv = minimist(process.argv.slice(2), {
+    string: ['profile', 'keyword', 'env', 'workflow'],
+    boolean: ['help'],
+    alias: { k: 'keyword', t: 'target', h: 'help' },
+    default: {
+      profile: DEFAULT_PROFILE,
+      env: 'debug',
+      target: 50,
+    },
+  });
+
+  if (argv.help) {
+    console.log(`
+Usage: webauto weibo <command> [options]
+
+Commands:
+  search          Perform a Weibo search task.
+
+Options:
+  --profile <id>      Camo profile ID to use (default: ${DEFAULT_PROFILE})
+  --keyword <text>    Keyword to search for (required for search command)
+  --target <n>        Target number of posts to collect (default: 50)
+  --max-comments <n>  Maximum comments to collect per post (default: 0, no limit)
+  --env <debug|prod>  Environment for data storage (default: debug)
+  --help              Show this help message
+
+Examples:
+  webauto weibo search --keyword "AI" --target 100 --profile my-weibo-profile
+  webauto weibo search --keyword "大模型" --env prod
+`);
+    return;
+  }
+
+  const command = argv._[0];
+
+  switch (command) {
+    case 'search':
+      await runCommand({ ...argv, workflow: 'weibo-search-v1' });
+      break;
+    default:
+      console.error(`Unknown command: ${command}`);
+      process.exit(1);
+  }
+}
+
+const isDirectExec =
+  process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href;
+
+if (isDirectExec) {
+  main().catch((error) => {
+    console.error('Error in Weibo Unified:', error.message);
+    process.exit(1);
+  });
+}
+
+export async function runWeiboUnified(argv) {
+  const workflowId = String(argv.workflow || 'weibo-search-v1').trim();
+  const keyword = String(argv.keyword || argv.k || '').trim();
+  const profile = String(argv.profile || 'xiaohongshu-batch-1').trim();
+  const targetCount = Number(argv['max-notes'] || argv.target || argv['max-notes'] || 50);
+  const maxComments = Number(argv['max-comments'] || 0);
+  const env = String(argv.env || 'debug').trim();
+
+  if (!keyword) {
+    throw new Error('Keyword is required for Weibo search tasks. Use --keyword <text>');
+  }
+
+  const initialContext = {
+    sessionId: profile,
+    keyword,
+    env,
+    targetCount,
+    maxComments,
+  };
+
+  const result = await runWorkflowById(workflowId, initialContext);
+
+  return {
+    ok: result.success,
+    runId: `weibo-${Date.now()}`,
+    summaryPath: null,
+    error: result.error,
+  };
+}

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

@@ -3,36 +3,161 @@ import minimist from 'minimist';
 import { spawnSync } from 'node:child_process';
 import os from 'node:os';
 import path from 'node:path';
-import { existsSync } from 'node:fs';
+import { existsSync, rmSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
 
 function run(cmd, args) {
-  return spawnSync(cmd, args, { encoding: 'utf8' });
+  const lower = String(cmd || '').toLowerCase();
+  const spawnOptions = {
+    encoding: 'utf8',
+    windowsHide: true,
+    timeout: 120000,
+  };
+  if (process.platform === 'win32' && (lower.endsWith('.cmd') || lower.endsWith('.bat'))) {
+    const cmdLine = [quoteCmdArg(cmd), ...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],
+      spawnOptions,
+    );
+  }
+  return spawnSync(cmd, args, spawnOptions);
+}
+
+function quoteCmdArg(value) {
+  if (!value) return '""';
+  if (!/[\s"]/u.test(value)) return value;
+  return `"${String(value).replace(/"/g, '""')}"`;
+}
+
+function resolveOnPath(candidates, pathEnv = process.env.PATH || process.env.Path || '', delimiter = path.delimiter) {
+  const dirs = String(pathEnv)
+    .split(delimiter)
+    .map((x) => x.trim())
+    .filter(Boolean);
+  for (const dir of dirs) {
+    for (const name of candidates) {
+      const full = path.join(dir, name);
+      if (existsSync(full)) return full;
+    }
+  }
+  return null;
+}
+
+function resolveNpxBin(platform = process.platform, pathEnv = process.env.PATH || process.env.Path || '') {
+  if (platform !== 'win32') return 'npx';
+  const resolved = resolveOnPath(
+    ['npx.cmd', 'npx.exe', 'npx.bat', 'npx.ps1'],
+    pathEnv,
+    ';',
+  );
+  return resolved || 'npx.cmd';
 }
 
-function resolveNpxBin() {
-  return process.platform === 'win32' ? 'npx.cmd' : 'npx';
+function resolveNpmBin(platform = process.platform, pathEnv = process.env.PATH || process.env.Path || '') {
+  if (platform !== 'win32') return 'npm';
+  const resolved = resolveOnPath(
+    ['npm.cmd', 'npm.exe', 'npm.bat', 'npm.ps1'],
+    pathEnv,
+    ';',
+  );
+  return resolved || 'npm.cmd';
+}
+
+function runPackageCommand(packageName, commandArgs) {
+  const viaNpx = run(resolveNpxBin(), ['--yes', `--package=${packageName}`, ...commandArgs]);
+  if (viaNpx.status === 0) return viaNpx;
+  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 resolveGeoIPPath() {
+  return path.join(resolveWebautoRoot(), 'geoip', 'GeoLite2-City.mmdb');
 }
 
 function checkCamoufoxInstalled() {
-  const cmd = process.platform === 'win32' ? 'python' : 'python3';
-  const ret = run(cmd, ['-m', 'camoufox', 'path']);
-  return ret.status === 0;
+  const candidates =
+    process.platform === 'win32'
+      ? [
+          { cmd: 'python', args: ['-m', 'camoufox', 'path'] },
+          { cmd: 'py', args: ['-3', '-m', 'camoufox', 'path'] },
+        ]
+      : [{ cmd: 'python3', args: ['-m', 'camoufox', 'path'] }];
+  for (const candidate of candidates) {
+    const ret = run(candidate.cmd, candidate.args);
+    if (ret.status === 0) return true;
+  }
+  const npxRet = runPackageCommand('camoufox', ['camoufox', 'path']);
+  if (npxRet.status === 0) return true;
+  return false;
 }
 
 function installCamoufox() {
-  const ret = run(resolveNpxBin(), ['--yes', '--package=camoufox', 'camoufox', 'fetch']);
+  const ret = runPackageCommand('camoufox', ['camoufox', 'fetch']);
   return ret.status === 0;
 }
 
 function checkGeoIPInstalled() {
-  return existsSync(path.join(os.homedir(), '.webauto', 'geoip', 'GeoLite2-City.mmdb'));
+  return existsSync(resolveGeoIPPath());
 }
 
 function installGeoIP() {
-  const ret = run(resolveNpxBin(), ['--yes', '--package=@web-auto/camo', 'camo', 'init', 'geoip']);
+  const ret = runPackageCommand('@web-auto/camo', ['camo', 'init', 'geoip']);
   return ret.status === 0;
 }
 
+function uninstallCamoufox() {
+  const ret = runPackageCommand('camoufox', ['camoufox', 'remove']);
+  return ret.status === 0;
+}
+
+function uninstallGeoIP() {
+  const geoipDir = path.join(resolveWebautoRoot(), 'geoip');
+  try {
+    rmSync(geoipDir, { recursive: true, force: true });
+  } catch {
+    // ignore
+  }
+  return !checkGeoIPInstalled();
+}
+
+function resolveModeAndSelection(argv = {}) {
+  const legacyDownloadBrowser = argv['download-browser'] === true;
+  const legacyDownloadGeoip = argv['download-geoip'] === true;
+  const checkBrowserOnly = argv['check-browser-only'] === true;
+
+  let mode = 'check';
+  if (argv.auto === true) mode = 'auto';
+  else if (argv.reinstall === true) mode = 'reinstall';
+  else if (argv.uninstall === true || argv.remove === true) mode = 'uninstall';
+  else if (argv.install === true || legacyDownloadBrowser || legacyDownloadGeoip) mode = 'install';
+
+  const explicitBrowser = argv.browser === true || legacyDownloadBrowser || checkBrowserOnly;
+  const explicitGeoip = argv.geoip === true || legacyDownloadGeoip;
+  const explicitAll = argv.all === true;
+  const explicitAny = explicitBrowser || explicitGeoip || explicitAll;
+
+  let browser = false;
+  let geoip = false;
+  if (mode === 'check') {
+    browser = explicitBrowser || explicitAll || !explicitAny;
+    geoip = explicitGeoip || explicitAll;
+  } else {
+    browser = explicitBrowser || explicitAll || !explicitAny;
+    geoip = explicitGeoip || explicitAll || !explicitAny;
+  }
+
+  return { mode, browser, geoip };
+}
+
 async function checkBackendHealth() {
   try {
     const res = await fetch('http://127.0.0.1:7704/health', { signal: AbortSignal.timeout(3000) });
@@ -43,19 +168,79 @@ async function checkBackendHealth() {
 }
 
 async function main() {
-  const argv = minimist(process.argv.slice(2));
-  const download = argv['download-browser'] === true;
-  const downloadGeoip = argv['download-geoip'] === true;
+  const argv = minimist(process.argv.slice(2), {
+    boolean: [
+      'auto',
+      'install',
+      'uninstall',
+      'remove',
+      'reinstall',
+      'check-browser-only',
+      'download-browser',
+      'download-geoip',
+      'browser',
+      'geoip',
+      'all',
+      'ensure-backend',
+      'json',
+    ],
+  });
+  const { mode, browser, geoip } = resolveModeAndSelection(argv);
   const ensureBackend = argv['ensure-backend'] === true;
   const provider = String(process.env.WEBAUTO_BROWSER_PROVIDER || 'camo').trim().toLowerCase();
-  let camoufoxInstalled = checkCamoufoxInstalled();
-  let geoipInstalled = checkGeoIPInstalled();
+  const before = {
+    camoufoxInstalled: checkCamoufoxInstalled(),
+    geoipInstalled: checkGeoIPInstalled(),
+    backendHealthy: await checkBackendHealth(),
+  };
+  const actions = {
+    browserInstalled: false,
+    browserUninstalled: false,
+    geoipInstalled: false,
+    geoipUninstalled: false,
+  };
+
+  let camoufoxInstalled = before.camoufoxInstalled;
+  let geoipInstalled = before.geoipInstalled;
+  let operationError = null;
+
+  if (mode === 'auto' || mode === 'install') {
+    if (browser && !camoufoxInstalled) {
+      actions.browserInstalled = installCamoufox();
+      camoufoxInstalled = checkCamoufoxInstalled();
+      if (!camoufoxInstalled) operationError = operationError || 'camoufox_install_failed';
+    }
+    if (geoip && !geoipInstalled) {
+      actions.geoipInstalled = installGeoIP();
+      geoipInstalled = checkGeoIPInstalled();
+      if (!geoipInstalled) operationError = operationError || 'geoip_install_failed';
+    }
+  }
 
-  if (!camoufoxInstalled && download) {
-    camoufoxInstalled = installCamoufox();
+  if (mode === 'uninstall' || mode === 'reinstall') {
+    if (browser) {
+      actions.browserUninstalled = uninstallCamoufox();
+      camoufoxInstalled = checkCamoufoxInstalled();
+      if (camoufoxInstalled) operationError = operationError || 'camoufox_uninstall_failed';
+    }
+    if (geoip) {
+      actions.geoipUninstalled = uninstallGeoIP();
+      geoipInstalled = checkGeoIPInstalled();
+      if (geoipInstalled) operationError = operationError || 'geoip_uninstall_failed';
+    }
   }
-  if (!geoipInstalled && downloadGeoip) {
-    geoipInstalled = installGeoIP();
+
+  if (mode === 'reinstall') {
+    if (browser) {
+      actions.browserInstalled = installCamoufox();
+      camoufoxInstalled = checkCamoufoxInstalled();
+      if (!camoufoxInstalled) operationError = operationError || 'camoufox_install_failed';
+    }
+    if (geoip) {
+      actions.geoipInstalled = installGeoIP();
+      geoipInstalled = checkGeoIPInstalled();
+      if (!geoipInstalled) operationError = operationError || 'geoip_install_failed';
+    }
   }
 
   let backendEnsured = false;
@@ -70,27 +255,67 @@ async function main() {
     }
   }
 
-  const backendHealthy = await checkBackendHealth();
-  const dependencyReady = camoufoxInstalled || backendHealthy;
-  const geoipReady = downloadGeoip ? geoipInstalled : true;
-  const ok = dependencyReady && geoipReady;
+  const after = {
+    camoufoxInstalled,
+    geoipInstalled,
+    backendHealthy: await checkBackendHealth(),
+  };
+  const browserReady =
+    mode === 'uninstall'
+      ? !browser || !after.camoufoxInstalled
+      : !browser || after.camoufoxInstalled || after.backendHealthy;
+  const geoipReady = mode === 'uninstall' ? !geoip || !after.geoipInstalled : !geoip || after.geoipInstalled;
+  const ok =
+    browserReady &&
+    geoipReady &&
+    operationError === null &&
+    (!ensureBackend || backendEnsured || after.backendHealthy);
 
   const result = {
     ok,
-    camoufoxInstalled,
+    mode,
+    selection: {
+      browser,
+      geoip,
+      ensureBackend,
+    },
+    before,
+    actions,
+    after,
+    camoufoxInstalled: after.camoufoxInstalled,
     provider,
     backendEnsured,
     ensureBackendError,
-    backendHealthy,
-    geoipInstalled,
-    message: ok ? 'Camo 后端就绪' : (downloadGeoip && !geoipInstalled ? 'GeoIP 未安装' : 'Camoufox 未安装'),
+    backendHealthy: after.backendHealthy,
+    geoipInstalled: after.geoipInstalled,
+    operationError,
+    message: ok
+      ? '资源状态就绪'
+      : operationError
+        ? `资源操作失败: ${operationError}`
+        : browser && !after.camoufoxInstalled
+          ? 'Camoufox 未安装'
+          : geoip && !after.geoipInstalled
+            ? 'GeoIP 未安装'
+            : '资源状态未就绪',
   };
 
   console.log(JSON.stringify(result));
   if (!ok) process.exit(1);
 }
 
-main().catch((err) => {
-  console.error(JSON.stringify({ ok: false, error: err?.message || String(err) }));
-  process.exit(1);
-});
+const isEntrypoint = process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+if (isEntrypoint) {
+  main().catch((err) => {
+    console.error(JSON.stringify({ ok: false, error: err?.message || String(err) }));
+    process.exit(1);
+  });
+}
+
+export const __internals = {
+  resolveOnPath,
+  resolveNpxBin,
+  resolveWebautoRoot,
+  resolveGeoIPPath,
+  resolveModeAndSelection,
+};

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

@@ -33,6 +33,9 @@ function summarizeTasks(tasks = []) {
   const rows = tasks.map((task) => {
     const runId = asText(task?.runId || task?.id || '');
     const status = asText(task?.status || 'unknown').toLowerCase();
+    const progressPayload = task?.progress && typeof task.progress === 'object' ? task.progress : null;
+    const processed = Number(progressPayload?.processed ?? task?.progress ?? task?.current ?? 0) || 0;
+    const total = Number(progressPayload?.total ?? task?.total ?? 0) || 0;
     if (status === 'running' || status === 'starting') totals.running += 1;
     else if (status === 'queued' || status === 'pending') totals.queued += 1;
     else if (status === 'completed' || status === 'success' || status === 'succeeded') totals.succeeded += 1;
@@ -43,8 +46,8 @@ function summarizeTasks(tasks = []) {
       runId,
       status,
       phase: asText(task?.phase || task?.lastPhase || ''),
-      progress: Number(task?.progress || task?.current || 0) || 0,
-      total: Number(task?.total || 0) || 0,
+      progress: processed,
+      total,
       updatedAt: asText(task?.updatedAt || task?.lastActiveAt || ''),
       error: asText(task?.error || ''),
     };