android2harmony 0.1.2 → 0.1.3

package/skills/hmos-incremental-ui-align/scripts/page_capture_burst.ts

@@ -0,0 +1,188 @@
+#!/usr/bin/env node
+/**
+ * Android 定时连续采集工具 (TypeScript 版) —— 每隔1秒自动采集一次 view tree + 截图，持续 x 秒。
+ *
+ * 用于捕获动态UI效果（动画中间态、Toast、瞬态弹窗等）。
+ * 零第三方依赖，仅使用 Node 内置模块。
+ *
+ * 用法:
+ *   node page_capture_burst.ts --device adb -o ./output --duration 10
+ *   node page_capture_burst.ts --device adb -o ./output --duration 5 --serial emulator-5554
+ *
+ * 等价于原 page_capture_burst.py（functional equivalence，非逐字节一致）。
+ */
+
+import { spawnSync } from 'node:child_process';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+function sleep(seconds: number): void {
+  const end = Date.now() + seconds * 1000;
+  const sab = new SharedArrayBuffer(4);
+  const ia = new Int32Array(sab);
+  while (Date.now() < end) {
+    Atomics.wait(ia, 0, 0, Math.min(50, end - Date.now()));
+  }
+}
+
+function adb(args: string[], serial: string | null = null, timeout = 15): string {
+  const full: string[] = [];
+  if (serial) full.push('-s', serial);
+  full.push(...args);
+  const res = spawnSync('adb', full, {
+    timeout: timeout * 1000,
+    maxBuffer: 128 * 1024 * 1024,
+    windowsHide: true,
+  });
+  if (res.error && (res.error as NodeJS.ErrnoException).code === 'ETIMEDOUT') {
+    console.log(`  [WARN] adb timeout: ${args.join(' ')}`);
+    return '';
+  }
+  const out = (res.stdout as Buffer) ?? Buffer.alloc(0);
+  return out.toString('utf-8').trim();
+}
+
+function adbShell(args: string[], serial: string | null = null, timeout = 15): string {
+  return adb(['shell', ...args], serial, timeout);
+}
+
+function adbScreenshot(outputDir: string, filename: string, serial: string | null = null): boolean {
+  const localPath = path.join(outputDir, filename);
+  const args: string[] = [];
+  if (serial) args.push('-s', serial);
+  args.push('exec-out', 'screencap', '-p');
+  const res = spawnSync('adb', args, {
+    timeout: 15 * 1000,
+    maxBuffer: 128 * 1024 * 1024,
+    windowsHide: true,
+  });
+  if (res.error && (res.error as NodeJS.ErrnoException).code === 'ETIMEDOUT') {
+    console.log('  [WARN] screenshot timeout');
+    return false;
+  }
+  const stdoutBuf = (res.stdout as Buffer) ?? Buffer.alloc(0);
+  if (stdoutBuf.length > 0) {
+    fs.writeFileSync(localPath, stdoutBuf);
+    return true;
+  }
+  return false;
+}
+
+function adbDumpXml(outputDir: string, filename: string, serial: string | null = null): string {
+  const remotePath = '/sdcard/ui_dump.xml';
+  adbShell(['rm', '-f', '/sdcard/ui_dump.xml', '&&', 'uiautomator', 'dump', '/sdcard/ui_dump.xml'], serial, 20);
+  for (let i = 0; i < 6; i++) {
+    const check = adbShell(['ls', remotePath], serial);
+    if (check.includes(remotePath)) break;
+    sleep(0.2);
+  }
+  const xmlContent = adbShell(['cat', remotePath], serial, 15);
+  if (xmlContent) {
+    fs.writeFileSync(path.join(outputDir, filename), xmlContent, 'utf-8');
+  }
+  return xmlContent;
+}
+
+interface CliArgs {
+  device: 'adb';
+  outputDir: string;
+  duration: number;
+  serial: string | null;
+}
+
+function parseArgs(argv: string[]): CliArgs {
+  const args: CliArgs = { device: 'adb', outputDir: '', duration: 10, serial: null };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    const next = (): string => {
+      if (i + 1 >= argv.length) {
+        console.error(`Missing value for ${a}`);
+        process.exit(2);
+      }
+      return argv[++i];
+    };
+    if (a === '--device') {
+      const v = next();
+      if (v !== 'adb') {
+        console.error('--device must be adb (currently adb only)');
+        process.exit(2);
+      }
+      args.device = v;
+    } else if (a === '--output-dir' || a === '-o') {
+      args.outputDir = next();
+    } else if (a === '--duration' || a === '-d') {
+      args.duration = parseInt(next(), 10);
+    } else if (a === '--serial') {
+      args.serial = next();
+    } else if (a === '-h' || a === '--help') {
+      printHelp();
+      process.exit(0);
+    } else {
+      console.error(`Unknown argument: ${a}`);
+      process.exit(2);
+    }
+  }
+  if (!args.outputDir) {
+    console.error('error: --output-dir/-o is required');
+    process.exit(2);
+  }
+  return args;
+}
+
+function printHelp(): void {
+  console.log(
+    [
+      'Burst capture: take view tree + screenshot every 1s for N seconds',
+      '',
+      'Usage: node page_capture_burst.ts --device adb -o <dir> [--duration N] [--serial S]',
+      '',
+      '  --device        Device type (currently adb only)',
+      '  --output-dir,-o Output directory for captured files (required)',
+      '  --duration,-d   Total capture duration in seconds (default: 10)',
+      '  --serial        ADB device serial (optional)',
+    ].join('\n'),
+  );
+}
+
+function main(): number {
+  const args = parseArgs(process.argv.slice(2));
+  fs.mkdirSync(args.outputDir, { recursive: true });
+
+  console.log(`[Burst Capture] duration=${args.duration}s, output=${args.outputDir}`);
+  console.log('[Burst Capture] Starting continuous capture...');
+
+  const startTime = Date.now();
+  let frame = 0;
+
+  while (true) {
+    const elapsed = (Date.now() - startTime) / 1000;
+    if (elapsed >= args.duration) break;
+
+    frame += 1;
+    const frameStart = Date.now();
+    const frameStr = String(frame).padStart(3, '0');
+    process.stdout.write(`  Frame ${frame} (t=${elapsed.toFixed(1)}s)... `);
+
+    const xmlOk = !!adbDumpXml(args.outputDir, `view_${frameStr}.xml`, args.serial);
+    const shotOk = adbScreenshot(args.outputDir, `screenshot_${frameStr}.png`, args.serial);
+
+    console.log(xmlOk && shotOk ? 'OK' : 'partial');
+
+    const frameElapsed = (Date.now() - frameStart) / 1000;
+    const sleepTime = Math.max(0, 1.0 - frameElapsed);
+    if (sleepTime > 0 && (Date.now() - startTime) / 1000 + sleepTime < args.duration) {
+      sleep(sleepTime);
+    }
+  }
+
+  console.log(`\n[Burst Capture] Done. ${frame} frames captured to ${args.outputDir}`);
+  return 0;
+}
+
+const isEntry = process.argv[1] !== undefined && import.meta.url === pathToFileURL(process.argv[1]).href;
+if (isEntry) {
+  process.exit(main());
+}
+
+export { adbDumpXml, adbScreenshot, parseArgs };

package/tools/autotest/engine/batch-launcher.ts

@@ -0,0 +1,326 @@
+/**
+ * Batch launcher — the detached background process that runs the Node.js
+ * `@autotest/agent` engine programmatically via `new AutoTestAgent({...})`.
+ *
+ * Spawned detached by `self-test-runner.ts` `cmdRun` (which writes `batch.pid` +
+ * emits `{status:'RUNNING', pid}` then exits). This process:
+ *
+ *   1. constructs `new AutoTestAgent({ apiKey, modelName, baseUrl, provider,
+ *      deviceSn, ip, port, agentMode })` from the `AUTOTEST_*` env vars that
+ *      `cmdRun` derived from `~/.hometrans/config.json` — so the user's API_KEY
+ *      / model / device flow in through the constructor, no config.yaml needed;
+ *   2. reads the testcases (JSON array or JSONL — same input as the former
+ *      Python `AutoTest.batch`);
+ *   3. runs each case via `agent.runTask(test_steps, { reportDir, taskName })`;
+ *   4. writes `task_results.jsonl` + `summary.json` in the SAME schema the
+ *      Python `AutoTest.batch` produced, so the HomeTrans `status` /
+ *      `report-tool` contract keeps working unchanged.
+ *
+ * STDOUT/STDERR are captured to `batch_stdout.log` by the spawner; this process
+ * exits 0 on completion regardless of per-case pass/fail (a non-zero exit would
+ * be interpreted as a launch failure by `spawnBatch`).
+ */
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { Command } from 'commander';
+import type {
+  AutoTestAgent,
+  AutoTestAgentConfig,
+  RunTaskOptions,
+  TaskResult,
+} from '@autotest/agent';
+
+const require = createRequire(import.meta.url);
+const { AutoTestAgent: AutoTestAgentCtor } = require('@autotest/agent') as {
+  AutoTestAgent: new (config: AutoTestAgentConfig) => AutoTestAgent;
+};
+
+const UTF_8 = 'utf-8';
+const CASE_TIMEOUT_MS = 10 * 60 * 1000;
+const DEFAULT_PROMPT_VERSION = 'v2.0';
+
+interface CaseRow {
+  uuid: string;
+  spec: string;
+  case_name: string;
+  test_steps: string;
+  execute_mode?: string;
+  [k: string]: unknown;
+}
+
+interface ResultRow {
+  exec_index: number;
+  uuid: string;
+  spec: string;
+  case_name: string;
+  category: string;
+  test_steps: string;
+  report_dir: string;
+  start_time: string;
+  end_time: string;
+  duration_seconds: number;
+  status: 'PASS' | 'FAIL' | 'UNKNOWN';
+  return_code: number;
+  reason: string;
+}
+
+interface LauncherArgs {
+  taskDir: string;
+  testcases: string;
+  category: string;
+}
+
+function sanitizeFilename(name: string): string {
+  return name.replace(/[\\/:*?"<>|]/g, '_');
+}
+
+function formatTimestamp(date: Date): string {
+  const pad = (n: number) => String(n).padStart(2, '0');
+  return (
+    `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ` +
+    `${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`
+  );
+}
+
+function readTestCases(filePath: string): CaseRow[] {
+  let content = fs.readFileSync(filePath, UTF_8);
+  if (content.charCodeAt(0) === 0xfeff) content = content.slice(1);
+  try {
+    const parsed = JSON.parse(content);
+    if (Array.isArray(parsed)) return parsed as CaseRow[];
+    throw new Error('not an array');
+  } catch {
+    // Fall back to JSONL.
+    const cases: CaseRow[] = [];
+    for (const line of content.split('\n')) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        cases.push(JSON.parse(trimmed) as CaseRow);
+      } catch {
+        // skip invalid lines
+      }
+    }
+    return cases;
+  }
+}
+
+function parseArgs(argv: string[]): LauncherArgs {
+  const program = new Command();
+  program.exitOverride();
+  program
+    .requiredOption('--task-dir <dir>', '任务目录')
+    .requiredOption('--testcases <path>', '测试用例文件（JSON 数组或 JSONL）')
+    .option('--category <name>', '测试分类名称', 'self_test');
+  try {
+    program.parse(argv, { from: 'user' });
+  } catch (err) {
+    const e = err as { code?: string };
+    if (e.code !== 'commander.helpDisplayed') {
+      console.error('用法: node batch-launcher.js --task-dir <dir> --testcases <path> [--category <name>]');
+      process.exit(2);
+    }
+  }
+  const opts = program.opts() as LauncherArgs;
+  return { taskDir: opts.taskDir, testcases: opts.testcases, category: opts.category };
+}
+
+/** Construct the agent from AUTOTEST_* env vars (set by `cmdRun` from config.json). */
+function createAgent(): AutoTestAgent {
+  const promptVersion = process.env.AUTOTEST_PROMPT_VERSION || DEFAULT_PROMPT_VERSION;
+  const envPort = process.env.AUTOTEST_PORT;
+  const envMaxSteps = process.env.AUTOTEST_MAX_STEPS;
+  const numOrUndef = (raw: string | undefined): number | undefined => {
+    if (!raw) return undefined;
+    const n = Number(raw);
+    return Number.isFinite(n) ? n : undefined;
+  };
+  // Resolve the bundled config.yaml inside @autotest/agent so the agent loads
+  // model/device/agent defaults (base_url, api_key, …) even when AUTOTEST_*
+  // env vars are not set (e.g. running batch-launcher standalone without
+  // HomeTrans's config.json → AUTOTEST_* mapping). The ConfigManager converts
+  // snake_case YAML keys to camelCase before zod validation, so `base_url` in
+  // the YAML becomes `baseUrl` as the schema expects.
+  const agentMain = require.resolve('@autotest/agent');
+  const configPath = path.join(path.dirname(agentMain), 'common', 'config', 'config.yaml');
+  const config: AutoTestAgentConfig = {
+    configPath,
+    apiKey: process.env.AUTOTEST_API_KEY,
+    modelName: process.env.AUTOTEST_MODEL,
+    baseUrl: process.env.AUTOTEST_BASE_URL,
+    provider: process.env.AUTOTEST_PROVIDER,
+    deviceSn: process.env.AUTOTEST_DEVICE_SN || undefined,
+    ip: process.env.AUTOTEST_IP,
+    port: numOrUndef(envPort),
+    agentMode: (process.env.AUTOTEST_MODE || undefined) as AutoTestAgentConfig['agentMode'],
+    maxSteps: numOrUndef(envMaxSteps),
+    // The SingleAgent resolves its prompt version from `model.unified.promptType`
+    // (loadPrompt(SINGLE, config.model.unified.promptType)), whose zod default is
+    // 'default' → 'vdefault' (not a real version). Inject the real version through
+    // configOverrides — the constructor's route for any extra config the user
+    // wants to set through `new`.
+    configOverrides: { model: { unified: { promptType: promptVersion } } },
+  };
+  return new AutoTestAgentCtor(config);
+}
+
+/** Run one task with a hard timeout (mirrors batch_runner.runWithTimeout). */
+function runWithTimeout(
+  agent: AutoTestAgent,
+  task: string,
+  options: RunTaskOptions,
+  timeoutMs: number,
+): Promise<TaskResult> {
+  let timer: NodeJS.Timeout | undefined;
+  const timeout = new Promise<never>((_, reject) => {
+    timer = setTimeout(
+      () => reject(new Error(`Execution timed out (exceeded ${timeoutMs / 1000} seconds)`)),
+      timeoutMs,
+    );
+  });
+  // Promise.race attaches handlers to both promises, so a late runTask
+  // resolution/rejection after timeout is never "unhandled"; finally clears
+  // the timer regardless of which settles first.
+  return Promise.race([agent.runTask(task, options), timeout]).finally(() => {
+    if (timer) clearTimeout(timer);
+  });
+}
+
+async function main(): Promise<void> {
+  const opts = parseArgs(process.argv.slice(2));
+
+  const taskDir = path.resolve(opts.taskDir);
+  fs.mkdirSync(taskDir, { recursive: true });
+  const jsonlFile = path.join(taskDir, 'task_results.jsonl');
+
+  const testCases = readTestCases(opts.testcases);
+  const total = testCases.length;
+  if (total === 0) {
+    console.log('No test cases, exiting');
+    return;
+  }
+
+  const indexWidth = String(total).length;
+
+  console.log(`Total test cases to execute: ${total}`);
+  console.log(`Test category: ${opts.category}`);
+  console.log(`Task directory: ${taskDir}`);
+  console.log('='.repeat(60));
+
+  // promptVersion is injected via the constructor's configOverrides (see
+  // createAgent) because AgentAPIImpl reads it from effectiveConfig, not the
+  // per-call option.
+  const agent = createAgent();
+
+  let pass = 0;
+  let fail = 0;
+  let unknown = 0;
+  const batchStart = new Date();
+
+  for (let idx = 1; idx <= total; idx++) {
+    const tc = testCases[idx - 1];
+    const uuid = String(tc.uuid ?? '');
+    const spec = String(tc.spec ?? '');
+    const caseName = String(tc.case_name ?? '');
+    const testSteps = String(tc.test_steps ?? '');
+    const caseMode = String(tc.execute_mode ?? '');
+
+    const dirname = uuid
+      ? sanitizeFilename(`${uuid}_${caseName}`)
+      : sanitizeFilename(`${String(idx).padStart(indexWidth, '0')}_${caseName}`);
+    const reportDir = path.join(taskDir, dirname).replace(/\\/g, '/');
+    fs.mkdirSync(reportDir, { recursive: true });
+
+    console.log('\n' + '-'.repeat(60));
+    console.log(`[${opts.category}][${String(idx).padStart(indexWidth, '0')}/${total}] Execute: ${caseName}`);
+    console.log('-'.repeat(60));
+
+    const start = new Date();
+    const runOpts: RunTaskOptions = {
+      reportDir,
+      taskName: caseName,
+      ...(caseMode ? { agentMode: caseMode as RunTaskOptions['agentMode'] } : {}),
+    };
+
+    let status: 'PASS' | 'FAIL' | 'UNKNOWN' = 'UNKNOWN';
+    let reason = '';
+    let returnCode = 0;
+
+    try {
+      const taskResult = await runWithTimeout(agent, testSteps, runOpts, CASE_TIMEOUT_MS);
+      returnCode = taskResult.status === 'failed' ? 1 : 0;
+      if (taskResult.status === 'completed') {
+        status = 'PASS';
+        pass += 1;
+      } else if (taskResult.status === 'failed') {
+        status = 'FAIL';
+        reason = taskResult.errorMessage ?? 'Execution failed';
+        fail += 1;
+      } else {
+        status = 'UNKNOWN';
+        reason = `agent status=${taskResult.status}`;
+        unknown += 1;
+      }
+    } catch (e) {
+      returnCode = -1;
+      status = 'FAIL';
+      reason = `Execution error: ${e instanceof Error ? e.message : String(e)}`;
+      fail += 1;
+    }
+
+    const end = new Date();
+    const duration = (end.getTime() - start.getTime()) / 1000;
+
+    const row: ResultRow = {
+      exec_index: idx,
+      uuid,
+      spec,
+      case_name: caseName,
+      category: opts.category,
+      test_steps: testSteps,
+      report_dir: reportDir,
+      start_time: formatTimestamp(start),
+      end_time: formatTimestamp(end),
+      duration_seconds: Math.round(duration * 100) / 100,
+      status,
+      return_code: returnCode,
+      reason,
+    };
+    fs.appendFileSync(jsonlFile, JSON.stringify(row) + '\n', UTF_8);
+
+    const icon = status === 'PASS' ? 'OK' : status === 'FAIL' ? 'X' : '?';
+    console.log(`Result: [${icon}] ${status} | Duration: ${duration.toFixed(2)}s`);
+    if (reason && status === 'FAIL') console.log(`Reason: ${reason.slice(0, 100)}`);
+    console.log(`Report: ${reportDir}`);
+  }
+
+  const summary = {
+    total_cases: total,
+    pass_count: pass,
+    fail_count: fail,
+    unknown_count: unknown,
+    pass_rate: `${total ? ((pass / total) * 100).toFixed(2) : '0.00'}%`,
+    category: opts.category,
+    start_time: formatTimestamp(batchStart),
+    end_time: formatTimestamp(new Date()),
+    task_dir: taskDir.replace(/\\/g, '/'),
+  };
+  fs.writeFileSync(path.join(taskDir, 'summary.json'), JSON.stringify(summary, null, 4), UTF_8);
+
+  console.log('\n' + '='.repeat(60));
+  console.log('Execution complete!');
+  console.log(`Total cases: ${total}`);
+  console.log(`Pass: ${pass}`);
+  console.log(`Fail: ${fail}`);
+  console.log(`Unknown: ${unknown}`);
+  console.log(`Pass rate: ${summary.pass_rate}`);
+  console.log(`Results file: ${jsonlFile}`);
+  console.log('='.repeat(60));
+}
+
+main().catch((err) => {
+  console.error('batch-launcher fatal:', err instanceof Error ? err.stack ?? err.message : String(err));
+  process.exit(1);
+});