@web-auto/webauto 0.1.1 → 0.1.3

package/apps/desktop-console/entry/ui-console.mjs

@@ -0,0 +1,299 @@
+#!/usr/bin/env node
+import minimist from 'minimist';
+import { spawn } from 'node:child_process';
+import { existsSync, writeFileSync, readFileSync, mkdirSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const APP_ROOT = path.resolve(__dirname, '../..');
+const DIST_MAIN = path.join(APP_ROOT, 'dist', 'main', 'index.mjs');
+
+const args = minimist(process.argv.slice(2), {
+  boolean: ['build', 'install', 'check', 'help', 'headless', 'no-daemon'],
+  string: ['profile', 'keyword', 'target', 'scenario', 'output'],
+  alias: { h: 'help', p: 'profile', k: 'keyword', t: 'target', o: 'output' }
+});
+
+function printHelp() {
+  console.log(`webauto ui console
+
+Usage:
+  webauto ui console [--build] [--install] [--check] [--no-daemon]
+  webauto ui test <scenario> [options]
+
+Test Scenarios:
+  env-check    - Environment check automation test
+  account-flow - Account creation/login flow test
+  config-save  - Config save/load test
+  crawl-run    - Full crawl flow test
+
+Options:
+  --check      Check build/dep status only
+  --build      Auto-build if missing
+  --install    Auto-install if missing deps
+  --no-daemon  Run in foreground mode
+  --scenario   Test scenario name
+  --profile    Test profile ID
+  --keyword    Test keyword
+  --target     Target count
+  --headless   Headless mode
+  --output     Output report path
+`);
+}
+
+function checkBuildStatus() {
+  return existsSync(DIST_MAIN);
+}
+
+async function build() {
+  return new Promise((resolve, reject) => {
+    console.log('[ui-console] Building...');
+    const child = spawn('npm', ['run', 'build'], {
+      cwd: APP_ROOT,
+      stdio: 'inherit',
+      shell: true
+    });
+    child.on('close', (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`Build failed with code ${code}`));
+    });
+  });
+}
+
+async function install() {
+  return new Promise((resolve, reject) => {
+    console.log('[ui-console] Installing dependencies...');
+    const child = spawn('npm', ['install'], {
+      cwd: APP_ROOT,
+      stdio: 'inherit',
+      shell: true
+    });
+    child.on('close', (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`Install failed with code ${code}`));
+    });
+  });
+}
+
+async function startConsole(noDaemon = false) {
+  if (!checkBuildStatus()) {
+    console.log('[ui-console] Build not found, building...');
+    await build();
+  }
+
+  console.log('[ui-console] Starting Desktop Console...');
+  const env = { ...process.env };
+  if (noDaemon) env.WEBAUTO_NO_DAEMON = '1';
+
+  const child = spawn('npx', ['electron', DIST_MAIN], {
+    cwd: APP_ROOT,
+    env,
+    stdio: 'inherit',
+    detached: !noDaemon
+  });
+
+  if (noDaemon) {
+    child.on('close', (code) => {
+      console.log(`[ui-console] Exited with code ${code}`);
+      process.exit(code);
+    });
+  } else {
+    child.unref();
+    console.log(`[ui-console] Started (PID: ${child.pid})`);
+  }
+}
+
+class UITestRunner {
+  constructor(options = {}) {
+    this.profile = options.profile || 'test-profile';
+    this.keyword = options.keyword || '自动化测试';
+    this.target = options.target || 5;
+    this.headless = options.headless || false;
+    this.output = options.output || null;
+    this.results = [];
+    this.startTime = Date.now();
+  }
+
+  log(message, type = 'info') {
+    const ts = new Date().toISOString();
+    const line = `[${ts}] [${type}] ${message}`;
+    console.log(line);
+    this.results.push({ ts, type, message });
+  }
+
+  async runCommand(cmd, args, timeoutMs = 30000) {
+    return new Promise((resolve, reject) => {
+      const child = spawn(cmd, args, { shell: true, stdio: 'pipe' });
+      let stdout = '';
+      let stderr = '';
+      const timer = setTimeout(() => {
+        child.kill('SIGTERM');
+        reject(new Error(`Command timeout: ${cmd}`));
+      }, timeoutMs);
+      child.stdout.on('data', (data) => { stdout += data.toString(); });
+      child.stderr.on('data', (data) => { stderr += data.toString(); });
+      child.on('close', (code) => {
+        clearTimeout(timer);
+        if (code === 0) resolve({ ok: true, stdout, stderr });
+        else reject(new Error(stderr || `Exit code: ${code}`));
+      });
+    });
+  }
+
+  async testEnvCheck() {
+    this.log('Starting environment check test', 'test');
+    try {
+      this.log('Testing: camo CLI');
+      await this.runCommand('which camo');
+      this.log('PASS: camo CLI found', 'pass');
+
+      this.log('Testing: Unified API');
+      const apiRes = await fetch('http://127.0.0.1:7701/health');
+      if (!apiRes.ok) throw new Error('Unified API not responding');
+      this.log('PASS: Unified API running', 'pass');
+
+      this.log('Testing: Browser Service');
+      const bsRes = await fetch('http://127.0.0.1:7704/health');
+      if (!bsRes.ok) throw new Error('Browser Service not responding');
+      this.log('PASS: Browser Service running', 'pass');
+
+      this.log('Environment check PASSED', 'success');
+      return { passed: true };
+    } catch (err) {
+      this.log(`FAILED: ${err.message}`, 'fail');
+      return { passed: false, error: err.message };
+    }
+  }
+
+  async testAccountFlow() {
+    this.log('Starting account flow test', 'test');
+    try {
+      this.log(`Testing: Create profile ${this.profile}`);
+      const result = await this.runCommand('node', [
+        path.join(process.cwd(), 'apps/webauto/entry/profilepool.mjs'),
+        'add', 'test', '--json'
+      ], 60000);
+      const json = JSON.parse(result.stdout);
+      if (json.ok && json.profileId) {
+        this.log(`PASS: Profile created: ${json.profileId}`, 'pass');
+      } else {
+        throw new Error('Failed to create profile');
+      }
+      this.log('Account flow PASSED', 'success');
+      return { passed: true, profileId: json.profileId };
+    } catch (err) {
+      this.log(`FAILED: ${err.message}`, 'fail');
+      return { passed: false, error: err.message };
+    }
+  }
+
+  async testConfigSave() {
+    this.log('Starting config save test', 'test');
+    try {
+      const testConfig = {
+        keyword: this.keyword, target: this.target, env: 'debug',
+        fetchBody: true, fetchComments: true, maxComments: 50,
+        autoLike: false, likeKeywords: '', headless: this.headless, dryRun: true
+      };
+      const configPath = path.join(process.cwd(), 'test-config.json');
+      writeFileSync(configPath, JSON.stringify(testConfig, null, 2));
+      this.log(`PASS: Config exported`, 'pass');
+      const imported = JSON.parse(readFileSync(configPath, 'utf8'));
+      if (imported.keyword === this.keyword) {
+        this.log('PASS: Config imported', 'pass');
+      }
+      import('node:fs').then(fs => fs.unlinkSync(configPath));
+      this.log('Config save PASSED', 'success');
+      return { passed: true };
+    } catch (err) {
+      this.log(`FAILED: ${err.message}`, 'fail');
+      return { passed: false, error: err.message };
+    }
+  }
+
+  async testCrawlRun() {
+    this.log('Starting crawl run test', 'test');
+    try {
+      this.log(`Testing: Dry-run crawl (keyword=${this.keyword}, target=${this.target})`);
+      const args = [
+        path.join(process.cwd(), 'apps/webauto/entry/xhs-unified.mjs'),
+        '--profile', this.profile,
+        '--keyword', this.keyword,
+        '--target', String(this.target),
+        '--env', 'debug',
+        '--dry-run', 'true'
+      ];
+      if (this.headless) args.push('--headless', 'true');
+      await this.runCommand('node', args, 120000);
+      this.log('PASS: Crawl run completed', 'pass');
+      this.log('Crawl run PASSED', 'success');
+      return { passed: true };
+    } catch (err) {
+      this.log(`FAILED: ${err.message}`, 'fail');
+      return { passed: false, error: err.message };
+    }
+  }
+
+  async runScenario(scenario) {
+    this.log(`Running test scenario: ${scenario}`, 'info');
+    let result;
+    switch (scenario) {
+      case 'env-check': result = await this.testEnvCheck(); break;
+      case 'account-flow': result = await this.testAccountFlow(); break;
+      case 'config-save': result = await this.testConfigSave(); break;
+      case 'crawl-run': result = await this.testCrawlRun(); break;
+      default: throw new Error(`Unknown scenario: ${scenario}`);
+    }
+    result.duration = Date.now() - this.startTime;
+    if (this.output) {
+      const report = { scenario, ...result, results: this.results };
+      mkdirSync(path.dirname(this.output), { recursive: true });
+      writeFileSync(this.output, JSON.stringify(report, null, 2));
+      this.log(`Report saved to ${this.output}`, 'info');
+    }
+    return result;
+  }
+}
+
+async function main() {
+  if (args.help || args.h) { printHelp(); process.exit(0); }
+  if (args.check) {
+    const buildOk = checkBuildStatus();
+    console.log(`Build: ${buildOk ? 'OK' : 'MISSING'}`);
+    process.exit(buildOk ? 0 : 1);
+  }
+  if (args.build) { await build(); process.exit(0); }
+  if (args.install) { await install(); process.exit(0); }
+
+  const testIndex = process.argv.indexOf('test');
+  if (testIndex !== -1 && process.argv[testIndex + 1]) {
+    const scenario = process.argv[testIndex + 1];
+    const runner = new UITestRunner({
+      profile: args.profile, keyword: args.keyword,
+      target: parseInt(args.target) || 5,
+      headless: args.headless, output: args.output
+    });
+    try {
+      const result = await runner.runScenario(scenario);
+      if (result.passed) {
+        console.log(`\n✅ Test PASSED (${result.duration}ms)`);
+        process.exit(0);
+      } else {
+        console.log(`\n❌ Test FAILED: ${result.error}`);
+        process.exit(1);
+      }
+    } catch (err) {
+      console.log(`\n❌ Test ERROR: ${err.message}`);
+      process.exit(1);
+    }
+    return;
+  }
+
+  await startConsole(args['no-daemon']);
+}
+
+main().catch((err) => {
+  console.error('[ui-console] Error:', err.message);
+  process.exit(1);
+});

package/apps/webauto/entry/account.mjs

@@ -0,0 +1,356 @@
+#!/usr/bin/env node
+import minimist from 'minimist';
+import path from 'node:path';
+import { existsSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import {
+  addAccount,
+  getAccount,
+  listAccountProfiles,
+  listAccounts,
+  removeAccount,
+  updateAccount,
+} from './lib/account-store.mjs';
+import { ensureProfile } from './lib/profilepool.mjs';
+import { syncXhsAccountByProfile, syncXhsAccountsByProfiles } from './lib/account-detect.mjs';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../..');
+const XHS_HOME_URL = 'https://www.xiaohongshu.com';
+
+function output(payload, jsonMode) {
+  if (jsonMode) {
+    console.log(JSON.stringify(payload));
+    return;
+  }
+  console.log(JSON.stringify(payload, null, 2));
+}
+
+function parseBoolean(value, fallback = false) {
+  if (value === undefined || value === null) return fallback;
+  const normalized = String(value).trim().toLowerCase();
+  if (!normalized) return fallback;
+  if (normalized === '1' || normalized === 'true' || normalized === 'yes') return true;
+  if (normalized === '0' || normalized === 'false' || normalized === 'no') return false;
+  return fallback;
+}
+
+function getCamoRunner() {
+  const local = path.join(ROOT, 'node_modules', '.bin', process.platform === 'win32' ? 'camo.cmd' : 'camo');
+  if (existsSync(local)) return { cmd: local, prefix: [] };
+  return { cmd: process.platform === 'win32' ? 'npx.cmd' : 'npx', prefix: ['@web-auto/camo'] };
+}
+
+function runCamo(args) {
+  const runner = getCamoRunner();
+  const ret = spawnSync(runner.cmd, [...runner.prefix, ...args], {
+    cwd: ROOT,
+    env: process.env,
+    encoding: 'utf8',
+  });
+  const stdout = String(ret.stdout || '').trim();
+  const stderr = String(ret.stderr || '').trim();
+  let parsed = null;
+  if (stdout) {
+    const lines = stdout.split('\n').map((line) => line.trim()).filter(Boolean).reverse();
+    for (const line of lines) {
+      try {
+        parsed = JSON.parse(line);
+        break;
+      } catch {
+        continue;
+      }
+    }
+  }
+  return {
+    ok: ret.status === 0,
+    code: ret.status,
+    stdout,
+    stderr,
+    json: parsed,
+  };
+}
+
+function inferLoginUrl(platform) {
+  const value = String(platform || '').trim().toLowerCase();
+  if (!value || value === 'xiaohongshu' || value === 'xhs') return XHS_HOME_URL;
+  return 'https://example.com';
+}
+
+function normalizeAlias(input) {
+  const value = String(input ?? '').trim();
+  return value || null;
+}
+
+async function detectAliasFromActivePage(profileId, selector) {
+  const { callAPI } = await import('../../../modules/camo-runtime/src/utils/browser-service.mjs');
+  const script = `(() => {
+    const requested = ${JSON.stringify(String(selector || '').trim())};
+    const defaultSelectors = [
+      '[class*="user"] [class*="name"]',
+      '[class*="nickname"]',
+      '[class*="account"] [class*="name"]',
+      'a[href*="/user/profile"] span',
+      'header a[href*="/user"] span',
+      'nav a[href*="/user"] span'
+    ];
+    const selectors = requested ? [requested] : defaultSelectors;
+    const clean = (value) => String(value || '').replace(/\\s+/g, ' ').trim();
+    const candidates = [];
+    for (const sel of selectors) {
+      const nodes = Array.from(document.querySelectorAll(sel)).slice(0, 6);
+      for (const node of nodes) {
+        const text = clean(node.textContent || '');
+        if (!text) continue;
+        candidates.push({ text, selector: sel });
+      }
+    }
+    const title = clean(document.title || '');
+    if (title) candidates.push({ text: title, selector: 'document.title' });
+    const bad = ['小红书', '登录', '注册', '搜索'];
+    const picked = candidates.find((item) => {
+      if (!item?.text) return false;
+      if (item.text.length < 2) return false;
+      return bad.every((word) => !item.text.includes(word));
+    }) || null;
+    return {
+      alias: picked?.text || null,
+      source: picked?.selector || null,
+      candidates
+    };
+  })()`;
+
+  const result = await callAPI('evaluate', { profileId, script });
+  const payload = result?.result || result || {};
+  const alias = normalizeAlias(payload.alias);
+  if (!alias) {
+    throw new Error('unable to detect alias from current page');
+  }
+  return {
+    alias,
+    source: String(payload.source || 'page').trim() || 'page',
+    candidates: Array.isArray(payload.candidates) ? payload.candidates : [],
+  };
+}
+
+function printHelp() {
+  console.log(`webauto account
+
+Usage:
+  webauto account --help
+  webauto account list [--json]
+  webauto account list --records [--json]
+  webauto account add [--platform <name>] [--alias <alias>] [--name <name>] [--username <username>] [--profile <id>] [--fingerprint <id>] [--json]
+  webauto account get <id|alias> [--json]
+  webauto account update <id|alias> [--alias <alias>|--clear-alias] [--name <name>] [--username <name>] [--profile <id>] [--fingerprint <id>] [--status active|disabled|archived] [--json]
+  webauto account delete <id|alias> [--delete-profile] [--delete-fingerprint] [--json]
+  webauto account login <id|alias> [--url <url>] [--sync-alias] [--json]
+  webauto account sync-alias <id|alias> [--selector <css>] [--alias <value>] [--json]
+  webauto account sync <profileId|all> [--json]
+
+Notes:
+  - 账号数据默认保存到 ~/.webauto/accounts（可用 WEBAUTO_PATHS_ACCOUNTS 覆盖）
+  - list 默认按 profile 展示账号有效态（valid/invalid）
+  - add 会自动创建并关联 profile/fingerprint（未指定时自动编号）
+  - login 会通过 @web-auto/camo 拉起浏览器并绑定账号 profile
+  - 只有识别到账号 id 的 profile 才会进入 valid 状态
+
+Examples:
+  webauto account add --platform xiaohongshu --alias 主号
+  webauto account list
+  webauto account sync all
+  webauto account login xhs-0001 --url https://www.xiaohongshu.com
+  webauto account sync-alias xhs-0001
+  webauto account update xhs-0001 --alias 运营1号
+  webauto account delete xhs-0001 --delete-profile --delete-fingerprint
+`);
+}
+
+async function cmdList(jsonMode) {
+  const result = listAccountProfiles();
+  output({ ok: true, ...result }, jsonMode);
+}
+
+async function cmdListRecords(jsonMode) {
+  const result = listAccounts();
+  output({ ok: true, ...result }, jsonMode);
+}
+
+async function cmdAdd(argv, jsonMode) {
+  const result = await addAccount({
+    id: argv.id,
+    platform: argv.platform,
+    alias: argv.alias,
+    name: argv.name,
+    username: argv.username,
+    profileId: argv.profile || argv['profile-id'],
+    fingerprintId: argv.fingerprint || argv['fingerprint-id'],
+    status: argv.status,
+  });
+  output({ ok: true, ...result }, jsonMode);
+}
+
+async function cmdGet(idOrAlias, jsonMode) {
+  const account = getAccount(idOrAlias);
+  output({ ok: true, account }, jsonMode);
+}
+
+async function cmdUpdate(idOrAlias, argv, jsonMode) {
+  const patch = {};
+  if (argv.platform !== undefined) patch.platform = argv.platform;
+  if (argv.name !== undefined) patch.name = argv.name;
+  if (argv.username !== undefined) patch.username = argv.username;
+  if (argv.status !== undefined) patch.status = argv.status;
+  if (argv.profile !== undefined || argv['profile-id'] !== undefined) {
+    patch.profileId = argv.profile || argv['profile-id'];
+  }
+  if (argv.fingerprint !== undefined || argv['fingerprint-id'] !== undefined) {
+    patch.fingerprintId = argv.fingerprint || argv['fingerprint-id'];
+  }
+  if (argv['clear-alias']) {
+    patch.alias = null;
+    patch.aliasSource = 'manual';
+  } else if (argv.alias !== undefined) {
+    patch.alias = argv.alias;
+    patch.aliasSource = 'manual';
+  }
+  if (!Object.keys(patch).length) {
+    throw new Error('no update fields provided');
+  }
+  const account = await updateAccount(idOrAlias, patch);
+  output({ ok: true, account }, jsonMode);
+}
+
+async function cmdDelete(idOrAlias, argv, jsonMode) {
+  const result = removeAccount(idOrAlias, {
+    deleteProfile: argv['delete-profile'] === true,
+    deleteFingerprint: argv['delete-fingerprint'] === true,
+  });
+  output({ ok: true, ...result }, jsonMode);
+}
+
+async function cmdLogin(idOrAlias, argv, jsonMode) {
+  const account = getAccount(idOrAlias);
+  await ensureProfile(account.profileId);
+  const url = String(argv.url || inferLoginUrl(account.platform)).trim();
+
+  const initResult = runCamo(['init']);
+  if (!initResult.ok) {
+    output({
+      ok: false,
+      step: 'init',
+      code: initResult.code,
+      error: initResult.stderr || initResult.stdout || 'camo init failed',
+    }, jsonMode);
+    process.exit(1);
+  }
+
+  const startResult = runCamo(['start', account.profileId, '--url', url]);
+  if (!startResult.ok) {
+    output({
+      ok: false,
+      step: 'start',
+      code: startResult.code,
+      error: startResult.stderr || startResult.stdout || 'camo start failed',
+      account,
+    }, jsonMode);
+    process.exit(1);
+  }
+
+  let aliasSync = null;
+  if (parseBoolean(argv['sync-alias'], false)) {
+    try {
+      const detected = await detectAliasFromActivePage(account.profileId, argv.selector);
+      const updated = await updateAccount(account.id, {
+        alias: detected.alias,
+        aliasSource: `auto:${detected.source}`,
+      });
+      aliasSync = { ok: true, alias: updated.alias, source: detected.source };
+    } catch (error) {
+      aliasSync = { ok: false, error: error?.message || String(error) };
+    }
+  }
+
+  const accountSync = await syncXhsAccountByProfile(account.profileId).catch((error) => ({
+    profileId: account.profileId,
+    valid: false,
+    status: 'invalid',
+    reason: error?.message || String(error),
+  }));
+
+  output({
+    ok: true,
+    account,
+    profileId: account.profileId,
+    url,
+    camo: startResult.json || startResult.stdout || null,
+    aliasSync,
+    accountSync,
+  }, jsonMode);
+}
+
+async function cmdSyncAlias(idOrAlias, argv, jsonMode) {
+  const account = getAccount(idOrAlias);
+  let alias = normalizeAlias(argv.alias);
+  let source = 'manual';
+  let candidates = [];
+  if (!alias) {
+    const detected = await detectAliasFromActivePage(account.profileId, argv.selector);
+    alias = detected.alias;
+    source = `auto:${detected.source}`;
+    candidates = detected.candidates;
+  }
+  const updated = await updateAccount(account.id, { alias, aliasSource: source });
+  output({
+    ok: true,
+    account: updated,
+    alias,
+    source,
+    candidates,
+  }, jsonMode);
+}
+
+async function cmdSync(target, jsonMode) {
+  const value = String(target || '').trim().toLowerCase();
+  if (!value || value === 'all') {
+    const rows = listAccountProfiles().profiles;
+    const profileIds = rows.map((item) => item.profileId);
+    const synced = await syncXhsAccountsByProfiles(profileIds);
+    output({ ok: true, count: synced.length, profiles: synced }, jsonMode);
+    return;
+  }
+  const synced = await syncXhsAccountByProfile(target);
+  output({ ok: true, profile: synced }, jsonMode);
+}
+
+async function main() {
+  const argv = minimist(process.argv.slice(2), {
+    boolean: ['help', 'json', 'clear-alias', 'delete-profile', 'delete-fingerprint', 'sync-alias', 'records'],
+    alias: { h: 'help' },
+  });
+  const cmd = String(argv._[0] || '').trim();
+  const arg1 = String(argv._[1] || '').trim();
+  const jsonMode = argv.json === true;
+
+  if (!cmd || cmd === 'help' || argv.help) {
+    printHelp();
+    return;
+  }
+
+  if (cmd === 'list') return argv.records ? cmdListRecords(jsonMode) : cmdList(jsonMode);
+  if (cmd === 'add') return cmdAdd(argv, jsonMode);
+  if (cmd === 'get') return cmdGet(arg1, jsonMode);
+  if (cmd === 'update') return cmdUpdate(arg1, argv, jsonMode);
+  if (cmd === 'delete' || cmd === 'remove' || cmd === 'rm') return cmdDelete(arg1, argv, jsonMode);
+  if (cmd === 'login') return cmdLogin(arg1, argv, jsonMode);
+  if (cmd === 'sync-alias') return cmdSyncAlias(arg1, argv, jsonMode);
+  if (cmd === 'sync') return cmdSync(arg1, jsonMode);
+
+  throw new Error(`unknown account command: ${cmd}`);
+}
+
+main().catch((error) => {
+  const message = error?.message || String(error);
+  console.error(message);
+  process.exit(1);
+});