android2harmony 0.1.5 → 0.1.6

package/skills/hmos-integration-test/scripts/self-test-runner.mjs

@@ -0,0 +1,1006 @@
+#!/usr/bin/env node
+/**
+ * Self-Test Runner — orchestrates HAP install/uninstall + batch test execution.
+ *
+ * Mode (selected by flags, NOT subcommands):
+ *   default (run)  — hdc uninstall + hdc install + spawn batch_runner + poll until done.
+ *   --status      — report state from output files (summary.json / task_results.jsonl).
+ *
+ * STDOUT carries strict JSON; all logging goes to stderr / the log file.
+ */
+import { execFileSync, spawn, spawnSync } from 'node:child_process';
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const HAP_INSTALL_WAIT = 3;
+const INSTALL_TIMEOUT = 120;
+const DEFAULT_CATEGORY = 'self_test';
+const PER_CASE_TIMEOUT_SEC = 720;
+// ---- logging ----
+let logStream = null;
+function log(level, msg) {
+    const pad = (n) => String(n).padStart(2, '0');
+    const d = new Date();
+    const ts = `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
+    const line = `[${ts}] ${level} ${msg}`;
+    if (logStream)
+        logStream.write(line + '\n');
+    process.stderr.write(line + '\n');
+}
+const logger = {
+    info: (m) => log('INFO', m),
+    warning: (m) => log('WARNING', m),
+    error: (m) => log('ERROR', m),
+};
+// Emit a terminal {status:'FAILED',error} JSON to stdout (the SKILL.md contract:
+// the caller parses the last stdout line as terminal status JSON), then exit 1.
+// Use for every fatal error path so the caller always gets a parseable status.
+function failJson(msg) {
+    logger.error(msg);
+    console.log(JSON.stringify({ status: 'FAILED', error: msg }));
+    process.exit(1);
+}
+function setupLogging(outputDir) {
+    const pad = (n) => String(n).padStart(2, '0');
+    const d = new Date();
+    const ts = `${d.getFullYear()}${pad(d.getMonth() + 1)}${pad(d.getDate())}_${pad(d.getHours())}${pad(d.getMinutes())}${pad(d.getSeconds())}`;
+    const logPath = path.join(outputDir, `self_test_${ts}.log`);
+    fs.mkdirSync(path.dirname(logPath), { recursive: true });
+    logStream = fs.createWriteStream(logPath, { encoding: 'utf-8' });
+    logger.info(`日志文件: ${logPath}`);
+}
+// ---- helpers ----
+function timestampForFile(d) {
+    const pad = (n) => String(n).padStart(2, '0');
+    return `${d.getFullYear()}${pad(d.getMonth() + 1)}${pad(d.getDate())}_${pad(d.getHours())}${pad(d.getMinutes())}${pad(d.getSeconds())}`;
+}
+function sleep(sec) {
+    if (sec <= 0)
+        return;
+    if (process.platform === 'win32') {
+        spawnSync('powershell.exe', ['-NoProfile', '-Command', `Start-Sleep -Seconds ${sec}`], { stdio: 'ignore', timeout: sec * 1000 + 5000, windowsHide: true });
+    }
+    else {
+        spawnSync('sleep', [String(sec)], { stdio: 'ignore', timeout: sec * 1000 + 5000 });
+    }
+}
+function sleepAsync(sec) {
+    return new Promise((resolve) => setTimeout(resolve, sec * 1000));
+}
+function findOnPath(name) {
+    const finder = process.platform === 'win32' ? 'where' : 'which';
+    try {
+        const out = execFileSync(finder, [name], { encoding: 'utf-8', windowsHide: true, timeout: 5000 });
+        const first = out.split(/\r?\n/).find((l) => l.trim());
+        return first ? first.trim() : null;
+    }
+    catch {
+        return null;
+    }
+}
+function isProcessAlive(pid) {
+    if (pid === undefined)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function killProcessTree(pid) {
+    if (!pid)
+        return;
+    if (process.platform === 'win32') {
+        // /T kills the whole descendant tree, /F forces termination
+        try {
+            spawnSync('taskkill', ['/PID', String(pid), '/T', '/F'], { windowsHide: true, stdio: 'ignore' });
+        }
+        catch { /* already dead */ }
+        return;
+    }
+    // POSIX: a detached child is a process-group leader, so -pid targets the whole group
+    try {
+        process.kill(-pid, 'SIGKILL');
+        return;
+    }
+    catch { /* group gone */ }
+    try {
+        process.kill(pid, 'SIGKILL');
+    }
+    catch { /* already dead */ }
+}
+function getHdc() {
+    const found = findOnPath('hdc');
+    if (!found)
+        failJson('hdc 未找到 (不在 PATH；装 DevEco 或设 DEVECO_SDK_HOME)');
+    return found;
+}
+// Dependency-free scan of a top-level YAML block (e.g. `agent:` / `device:`)
+// for a direct-child scalar key. Only matches the key at the block's
+// direct-child indent, so a deeper-nested same-named key (e.g. agent.unified.mode)
+// is never misread as the top-level value. Best-effort — batch_runner re-reads
+// the yaml itself, so this only needs to forward the common flat form.
+function readYamlDirectChild(yamlPath, block, key) {
+    try {
+        let text = fs.readFileSync(yamlPath, 'utf-8');
+        if (text.charCodeAt(0) === 0xfeff)
+            text = text.slice(1);
+        const lines = text.split(/\r?\n/);
+        let i = 0;
+        const blockRe = new RegExp(`^${block}:\\s*(#.*)?$`);
+        for (; i < lines.length; i++)
+            if (blockRe.test(lines[i]))
+                break;
+        if (i >= lines.length)
+            return '';
+        // The first non-blank/non-comment line after `block:` defines the direct-child indent.
+        let childIndent = -1;
+        for (i++; i < lines.length; i++) {
+            const ln = lines[i];
+            if (ln.trim() === '' || /^\s*#/.test(ln))
+                continue;
+            childIndent = ln.match(/^(\s+)/)?.[1].length ?? 0;
+            break;
+        }
+        if (childIndent <= 0)
+            return '';
+        const keyRe = new RegExp(`^ {${childIndent}}${key}:\\s*["']?([A-Za-z0-9_-]+)["']?\\s*(#.*)?$`);
+        for (; i < lines.length; i++) {
+            const ln = lines[i];
+            if (ln.trim() === '' || /^\s*#/.test(ln))
+                continue;
+            const indent = ln.match(/^(\s+)/)?.[1].length ?? 0;
+            if (indent < childIndent)
+                break; // dedented → block ended
+            if (indent === childIndent) {
+                const m = ln.match(keyRe);
+                if (m)
+                    return m[1];
+            }
+        }
+        return '';
+    }
+    catch {
+        return '';
+    }
+}
+// Read `agent.mode` to forward to batch_runner via --mode. batch_runner 0.0.3+
+// also reads the nested `agent.unified.mode` itself; this forwarding is
+// belt-and-suspenders so the flat `agent.mode` form is honored even if that read regresses.
+function readAgentModeFromYaml(yamlPath) {
+    return readYamlDirectChild(yamlPath, 'agent', 'mode');
+}
+// Read `device.device_sn` so `hdc install`/`uninstall` can target a specific device
+// (-t <sn>). Without it, bare `hdc install` fails with "need connect-key" when
+// more than one device is connected.
+function readDeviceSnFromYaml(yamlPath) {
+    return readYamlDirectChild(yamlPath, 'device', 'device_sn');
+}
+// Refresh model.unified.api_key in autotest.yaml from the HOMETRANS_MODEL_API_KEY
+// env var if it's set and differs — so api_key rotation takes effect immediately
+// without regenerating the yaml. Only touches the unified block (not
+// execute/decision slots, which may carry different keys for layered mode).
+function refreshApiKeyFromEnv(yamlPath) {
+    const envKey = process.env.HOMETRANS_MODEL_API_KEY;
+    if (!envKey || envKey.includes('placeholder'))
+        return;
+    try {
+        let text = fs.readFileSync(yamlPath, 'utf-8');
+        if (text.charCodeAt(0) === 0xfeff)
+            text = text.slice(1);
+        const lines = text.split(/\r?\n/);
+        let inModel = false, inUnified = false, unifiedIndent = -1, replaced = false;
+        for (let i = 0; i < lines.length; i++) {
+            const ln = lines[i];
+            if (/^model:\s*(#.*)?$/.test(ln)) {
+                inModel = true;
+                inUnified = false;
+                continue;
+            }
+            if (inModel && !/^\s/.test(ln) && ln.trim() && !/^#/.test(ln)) {
+                inModel = false;
+                inUnified = false;
+                continue;
+            }
+            if (inModel && /^\s+unified:\s*(#.*)?$/.test(ln)) {
+                inUnified = true;
+                unifiedIndent = (ln.match(/^(\s+)/)?.[1]?.length ?? 2) + 1;
+                continue;
+            }
+            if (inUnified) {
+                const indent = (ln.match(/^(\s+)/)?.[1]?.length ?? 0);
+                if (indent <= unifiedIndent - 1 && ln.trim() && !/^#/.test(ln)) {
+                    inUnified = false;
+                    continue;
+                }
+                const m = ln.match(/^(\s+)api_key:\s*["']?([^"'\s#]+)["']?\s*(#.*)?$/);
+                if (m && m[2] !== envKey) {
+                    lines[i] = `${m[1]}api_key: "${envKey}"`;
+                    replaced = true;
+                }
+            }
+        }
+        if (replaced) {
+            fs.writeFileSync(yamlPath, lines.join('\n'), 'utf-8');
+            logger.info('autotest.yaml model.unified.api_key 已从 HOMETRANS_MODEL_API_KEY 环境变量刷新');
+        }
+    }
+    catch { /* yaml read/parse failure is non-fatal — batch_runner will report config errors */ }
+}
+function parseRunArgs(argv) {
+    const args = { category: DEFAULT_CATEGORY, taskDir: 'task' };
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        const next = () => { if (i + 1 >= argv.length)
+            failJson(`Missing value for ${a}`); return argv[++i]; };
+        switch (a) {
+            case '--testcases':
+                args.testcases = next();
+                break;
+            case '--hap':
+                args.hap = next();
+                break;
+            case '--bundle-name':
+                args.bundleName = next();
+                break;
+            case '--task-dir':
+                args.taskDir = next();
+                break;
+            case '--output-dir':
+                args.outputDir = next();
+                break;
+            case '--category':
+                args.category = next();
+                break;
+            case '--config':
+                args.config = next();
+                break;
+            case '--api-key':
+                args.apiKey = next();
+                break;
+            case '--model-name':
+                args.modelName = next();
+                break;
+            case '--model-base-url':
+                args.modelBaseUrl = next();
+                break;
+            case '--provider':
+                args.provider = next();
+                break;
+            case '--mode':
+                args.agentMode = next();
+                break;
+            case '--timeout': {
+                const v = next();
+                args.timeout = v === 'auto' ? 'auto' : Number(v);
+                break;
+            }
+            case '--model-stdin':
+                args.modelStdin = true;
+                break;
+            case '-h':
+            case '--help':
+                console.log(`Usage: self-test-runner [options]
+
+Options:
+  --testcases <path>        测试用例文件，JSON 数组或 JSONL
+  --hap <path>              签名包：单个 .hap/.hsp 文件、目录，或逗号分隔
+  --bundle-name <name>      包名
+  --task-dir <dir>          任务目录 (default: "task")
+  --output-dir <dir>        日志目录
+  --category <name>         测试分类名称 (default: "self_test")
+  --config <path>           autotest.yaml 路径（有 yaml 文件时用）
+  --api-key <key>           模型 API Key（无 yaml 时从 CLI/env 生成临时 yaml）
+  --model-name <name>       模型名称（如 qwen3.7-plus）
+  --model-base-url <url>    模型 API base URL
+  --provider <name>         模型 provider (default: "openai")
+  --mode <single|layered>   agent 模式（default: single；layered 时从同一组参数生成 execute/decision 槽位）
+  --timeout <sec>           阻塞直到终态或超时（秒），或 auto
+  --model-stdin             从 stdin 读取模型配置（a2h 工具注入；优先级最高）
+  -h, --help                display this help
+
+Model config priority: --model-stdin (a2h 工具, 最高) > --config (yaml file) > --api-key/--model-name/--model-base-url (CLI) > HOMETRANS_MODEL_* (env from ht init).
+When --config is absent, the runner auto-generates a temp autotest.yaml from CLI params or env vars. --model-stdin forces a temp yaml from stdin, ignoring --config / default yaml.
+`);
+                process.exit(0);
+            default:
+                failJson(`Unknown option: ${a}`);
+        }
+    }
+    for (const req of ['testcases', 'hap', 'bundleName']) {
+        if (!args[req])
+            failJson(`Missing required option: --${req.replace(/([A-Z])/g, '-$1').toLowerCase()}`);
+    }
+    return args;
+}
+// ---- HAP install ----
+function runCmd(cmd, opts = {}) {
+    const { check = true, timeout } = opts;
+    logger.info(`>>> ${cmd.join(' ')}`);
+    const result = spawnSync(cmd[0], cmd.slice(1), {
+        encoding: 'utf-8',
+        timeout: timeout ? timeout * 1000 : undefined,
+        maxBuffer: 1024 * 1024 * 1024,
+        windowsHide: true,
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    if (result.error) {
+        logger.error(`命令异常: ${result.error.message}`);
+        throw result.error;
+    }
+    const status = result.status ?? 0;
+    if (status !== 0) {
+        logger.warning(`退出码=${status}`);
+        if (result.stdout)
+            logger.warning(`  stdout: ${result.stdout.trim()}`);
+        if (result.stderr)
+            logger.warning(`  stderr: ${result.stderr.trim()}`);
+        if (check)
+            failJson(`命令退出码非零 (${status}): ${cmd.join(' ')}`);
+    }
+    return { returncode: status, stdout: result.stdout ?? '', stderr: result.stderr ?? '' };
+}
+function installHaps(hapArg, hdcCmd) {
+    const entries = hapArg.split(',').map((s) => s.trim()).filter(Boolean);
+    if (entries.length === 0)
+        failJson('hap-path 为空');
+    const pkgs = [];
+    for (const e of entries) {
+        if (!fs.existsSync(e))
+            failJson(`hap 路径不存在: ${e}`);
+        const stat = fs.statSync(e);
+        const lower = e.toLowerCase();
+        if (stat.isDirectory()) {
+            const found = fs.readdirSync(e).filter((f) => f.toLowerCase().endsWith('.hap') || f.toLowerCase().endsWith('.hsp')).sort().map((f) => path.join(e, f));
+            if (found.length === 0)
+                failJson(`目录内无 .hap/.hsp 包: ${e}`);
+            pkgs.push(...found);
+        }
+        else if (lower.endsWith('.hap') || lower.endsWith('.hsp')) {
+            pkgs.push(e);
+        }
+        else {
+            failJson(`既不是目录也不是 .hap/.hsp 文件: ${e}`);
+        }
+    }
+    const seen = new Set();
+    const deduped = pkgs.map((p) => path.resolve(p)).filter((p) => (seen.has(p) ? false : (seen.add(p), true)));
+    if (!deduped.some((p) => p.toLowerCase().endsWith('.hap')))
+        failJson(`缺少 entry HAP: ${hapArg}`);
+    logger.info(`安装 ${deduped.length} 个包: ${deduped.map((p) => path.basename(p)).join(', ')}`);
+    const result = runCmd([...hdcCmd, 'install', '-r', ...deduped], { timeout: INSTALL_TIMEOUT, check: false });
+    const combined = `${result.stdout.trim()}\n${result.stderr.trim()}`;
+    const combinedLower = combined.toLowerCase();
+    const hasError = combined.includes('msg:error') || combinedLower.includes('failed to install') || (combined.includes('code:') && combinedLower.includes('error:'));
+    const hasSuccess = combinedLower.includes('successfully');
+    if (result.returncode === 0 && !hasError && hasSuccess) {
+        logger.info('安装成功');
+        sleep(HAP_INSTALL_WAIT);
+    }
+    else if (result.returncode === 0 && !hasError) {
+        logger.warning(`安装结果不确定: ${combined}`);
+        sleep(HAP_INSTALL_WAIT);
+    }
+    else {
+        failJson(`安装失败: rc=${result.returncode}, output=${combined}`);
+    }
+}
+// ---- testcases JSONL normalizer ----
+function prepareTestcasesJsonl(inputPath, taskSubdir) {
+    if (!fs.existsSync(inputPath))
+        failJson(`测试用例文件不存在: ${inputPath}`);
+    let text = fs.readFileSync(inputPath, 'utf-8');
+    if (text.charCodeAt(0) === 0xfeff)
+        text = text.slice(1);
+    const stripped = text.trimStart();
+    if (!stripped)
+        failJson(`测试用例文件为空: ${inputPath}`);
+    if (stripped[0] === '[') {
+        let arr;
+        try {
+            arr = JSON.parse(text);
+        }
+        catch (e) {
+            failJson(`JSON 解析失败: ${e instanceof Error ? e.message : e}`);
+        }
+        if (!Array.isArray(arr))
+            failJson('testcases 根不是数组');
+        const outPath = path.join(taskSubdir, 'testcases.jsonl');
+        const { createHash } = crypto;
+        const lines = arr.map((entry, idx) => {
+            if (!entry || typeof entry !== 'object')
+                failJson(`用例 #${idx + 1} 不是 JSON 对象`);
+            if (!entry.uuid) {
+                const seed = typeof entry.case_name === 'string' && entry.case_name ? entry.case_name : `case_${idx + 1}`;
+                entry.uuid = createHash('md5').update(seed, 'utf-8').digest('hex').slice(0, 8);
+            }
+            if (!('spec' in entry))
+                entry.spec = '';
+            return JSON.stringify(entry);
+        });
+        fs.writeFileSync(outPath, lines.join('\n') + '\n', 'utf-8');
+        logger.info(`已将 JSON 数组转换为 JSONL: ${outPath}（${arr.length} 条用例）`);
+        return outPath;
+    }
+    const lines = text.split(/\r?\n/).filter((l) => l.trim());
+    lines.forEach((line, i) => {
+        try {
+            JSON.parse(line);
+        }
+        catch (e) {
+            failJson(`JSONL 第 ${i + 1} 行解析失败: ${e instanceof Error ? e.message : e}`);
+        }
+    });
+    logger.info(`测试用例文件已为 JSONL: ${inputPath}（${lines.length} 条用例）`);
+    return inputPath;
+}
+// ---- batch runner path ----
+// Resolve the global npm root(s) where `npm install -g` places packages.
+// Used as a fallback when the script runs from a location with no
+// node_modules ancestor (e.g. the opencode skill dir), so the skill's own
+// self-test-runner.mjs can still locate @autotest/agent installed globally
+// as a dependency of @buaa_smat/hometrans.
+let _globalRootsCache = null;
+function globalNodeModulesRoots() {
+    if (_globalRootsCache)
+        return _globalRootsCache;
+    const roots = new Set();
+    // `npm root -g` is the most reliable source.
+    try {
+        const out = execFileSync('npm', ['root', '-g'], { encoding: 'utf-8', timeout: 15000, windowsHide: true, shell: true });
+        const p = out.trim();
+        if (p)
+            roots.add(p);
+    }
+    catch { /* npm not on PATH or timed out */ }
+    // Heuristic fallbacks (cross-platform) in case `npm root -g` is unavailable.
+    const home = os.homedir();
+    if (process.platform === 'win32') {
+        if (process.env.APPDATA)
+            roots.add(path.join(process.env.APPDATA, 'npm', 'node_modules'));
+    }
+    else {
+        roots.add('/usr/local/lib/node_modules');
+        roots.add('/usr/lib/node_modules');
+        roots.add(path.join(home, '.npm-global', 'lib', 'node_modules'));
+        roots.add(path.join(home, '.npm', 'lib', 'node_modules'));
+    }
+    _globalRootsCache = [...roots].filter((r) => r);
+    return _globalRootsCache;
+}
+function batchRunnerPath() {
+    const rel = path.join('@autotest', 'agent', 'dist', 'tools', 'batch_runner.js');
+    // 1. Walk up from the script's own location (works when the script lives
+    //    inside a project that has @autotest/agent in its node_modules tree,
+    //    e.g. the HomeTrans repo during development).
+    const here = path.dirname(fileURLToPath(import.meta.url));
+    let dir = here;
+    for (let i = 0; i < 20 && dir; i++) {
+        const candidate = path.join(dir, 'node_modules', rel);
+        if (fs.existsSync(candidate))
+            return candidate;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    // 2. Fallback: global npm root. @autotest/agent is either hoisted to the
+    //    global root itself, or nested under the globally-installed
+    //    @buaa_smat/hometrans package.
+    for (const root of globalNodeModulesRoots()) {
+        const hoisted = path.join(root, rel);
+        if (fs.existsSync(hoisted))
+            return hoisted;
+        const nested = path.join(root, '@buaa_smat', 'hometrans', 'node_modules', rel);
+        if (fs.existsSync(nested))
+            return nested;
+    }
+    return '';
+}
+// Locate the @buaa_smat/hometrans package.json (repo dev copy or installed
+// copy, local or global) so we can read the exact @autotest/agent version
+// hometrans depends on — auto-install then pins that version instead of
+// "latest" (which could pull a version without the required fixes).
+function findHometransPackageJson() {
+    const tryRead = (p) => {
+        if (!fs.existsSync(p))
+            return null;
+        try {
+            const pkg = JSON.parse(fs.readFileSync(p, 'utf-8'));
+            if (pkg && pkg.name === '@buaa_smat/hometrans')
+                return p;
+        }
+        catch { /* not a valid package.json */ }
+        return null;
+    };
+    // 1. repo dev context: walk up from the script dir; the repo root itself is
+    //    the hometrans package.
+    const here = path.dirname(fileURLToPath(import.meta.url));
+    let dir = here;
+    for (let i = 0; i < 20 && dir; i++) {
+        const self = tryRead(path.join(dir, 'package.json'));
+        if (self)
+            return self;
+        const nested = tryRead(path.join(dir, 'node_modules', '@buaa_smat', 'hometrans', 'package.json'));
+        if (nested)
+            return nested;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    // 2. global npm root: <root>/@buaa_smat/hometrans/package.json
+    for (const root of globalNodeModulesRoots()) {
+        const g = tryRead(path.join(root, '@buaa_smat', 'hometrans', 'package.json'));
+        if (g)
+            return g;
+    }
+    return null;
+}
+// Ensure @autotest/agent's batch_runner.js is available and up-to-date.
+// Runs `npm install -g @autotest/agent` (latest) every time — npm install only
+// touches the package files (dist/), NEVER the user's ~/.hometrans/autotest.yaml.
+// The yaml is read at runtime via --config, not modified by the install.
+function ensureAutotestAgent() {
+    logger.info('确保 @autotest/agent 最新（npm install -g @autotest/agent）...');
+    let installOk = false;
+    try {
+        const result = spawnSync('npm', ['install', '-g', '@autotest/agent'], {
+            encoding: 'utf-8', timeout: 180000, windowsHide: true, shell: true, stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        installOk = result.status === 0;
+        if (!installOk) {
+            const tail = ((result.stderr || '') + (result.stdout || '')).trim().slice(-400);
+            logger.warning(`npm install 退出码=${result.status}: ${tail}`);
+        }
+        else {
+            logger.info('@autotest/agent 已安装/更新到最新');
+        }
+    }
+    catch (e) {
+        logger.warning(`npm install 异常: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    // Drop the global-roots cache (install may have changed the layout) and locate batch_runner.js.
+    _globalRootsCache = null;
+    const found = batchRunnerPath();
+    if (found) {
+        logger.info(`batch_runner.js → ${found}`);
+        return found;
+    }
+    if (!installOk) {
+        logger.error('@autotest/agent 安装失败（可能网络问题）。' +
+            '请手动安装：`npm install -g @autotest/agent`。');
+    }
+    else {
+        logger.error('npm install 报告成功但 batch_runner.js 仍未找到；请检查 npm 全局目录权限或路径。');
+    }
+    return '';
+}
+// ---- status probe ----
+function findTaskSubdir(taskDir) {
+    if (!fs.existsSync(taskDir))
+        return null;
+    try {
+        const candidates = fs.readdirSync(taskDir, { withFileTypes: true }).filter((e) => e.isDirectory() && e.name.startsWith('task_')).map((e) => e.name).sort().reverse();
+        return candidates.length ? path.join(taskDir, candidates[0]) : null;
+    }
+    catch {
+        return null;
+    }
+}
+function findLatestLog(outputDir, taskDir) {
+    if (!fs.existsSync(outputDir))
+        return null;
+    try {
+        const entries = fs.readdirSync(outputDir, { withFileTypes: true });
+        const selfTest = entries.filter((e) => e.isFile() && e.name.startsWith('self_test_') && e.name.endsWith('.log')).map((e) => e.name).sort().reverse();
+        if (selfTest.length)
+            return path.join(outputDir, selfTest[0]);
+        // batch_stdout.log lives in taskDir (where the runner writes it), not outputDir
+        const batchLogDir = taskDir && fs.existsSync(taskDir) ? taskDir : outputDir;
+        const batchLogPath = path.join(batchLogDir, 'batch_stdout.log');
+        if (fs.existsSync(batchLogPath))
+            return batchLogPath;
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+// Escape a string for a double-quoted YAML scalar (model name / base URL /
+// api key). Without this, a value containing `"`, `\`, or a newline produces a
+// malformed autotest.yaml → batch_runner ConfigManager parse failure (CRASHED)
+// while the key has already landed on disk.
+function yamlScalar(s) {
+    return String(s).replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\r?\n/g, '\\n');
+}
+
+// Best-effort delete of the temp autotest.yaml (the only place the apiKey sits
+// on disk) from taskSubdir. Only ever touches task_subdir/autotest.yaml -- never
+// the user's persistent ~/.hometrans/autotest.yaml passed via --config. Called on
+// every terminal state (COMPLETED/CRASHED/TIMEOUT/NOT_STARTED) so the key never
+// lingers even when the run is killed externally.
+function deleteTempYaml(taskSubdir) {
+    if (!taskSubdir) return;
+    try { fs.unlinkSync(path.join(taskSubdir, 'autotest.yaml')); } catch { /* not generated / already removed */ }
+}
+
+function probeStatus(taskDir, outputDir) {
+    const taskSubdir = findTaskSubdir(taskDir);
+    if (!taskSubdir)
+        return { status: 'NOT_STARTED', taskSubdir: null, casesDone: 0, lastCase: '', logTail: '' };
+    let casesDone = 0;
+    let lastCase = '';
+    const jsonlFile = path.join(taskSubdir, 'task_results.jsonl');
+    if (fs.existsSync(jsonlFile)) {
+        const text = fs.readFileSync(jsonlFile, 'utf-8').trim();
+        const lines = text ? text.split(/\r?\n/) : [];
+        casesDone = lines.length;
+        if (lines.length) {
+            try {
+                const last = JSON.parse(lines[lines.length - 1]);
+                if (typeof last.case_name === 'string')
+                    lastCase = last.case_name;
+            }
+            catch { }
+        }
+    }
+    let logTail = '';
+    const logFile = findLatestLog(outputDir, taskDir);
+    if (logFile && fs.existsSync(logFile)) {
+        const text = fs.readFileSync(logFile, 'utf-8').trim();
+        logTail = (text ? text.split(/\r?\n/) : []).slice(-5).join('\n');
+    }
+    const summaryFile = path.join(taskSubdir, 'summary.json');
+    if (fs.existsSync(summaryFile)) {
+        let summary = {};
+        try {
+            summary = JSON.parse(fs.readFileSync(summaryFile, 'utf-8'));
+        }
+        catch { }
+        const num = (v, f) => (typeof v === 'number' ? v : f);
+        return {
+            status: 'COMPLETED', taskSubdir, casesDone: num(summary.total_cases, casesDone), lastCase,
+            passCount: num(summary.pass_count, 0), failCount: num(summary.fail_count, 0),
+            unknownCount: num(summary.unknown_count, 0), passRate: summary.pass_rate ?? 0, logTail,
+        };
+    }
+    // Immediate CRASHED detection via the batch pid file: if batch.pid exists
+    // and the process is no longer alive (crashed, or externally killed -- e.g.
+    // the agent's timeout-kill), return CRASHED at once instead of waiting 3 min
+    // for stale-log detection. This also lets cmdStatus delete the temp
+    // autotest.yaml (apiKey) right after a timeout-kill -- otherwise the
+    // post-kill poll still sees RUNNING (fresh log mtime) and the key lingers.
+    const pidFile = path.join(taskSubdir, 'batch.pid');
+    if (fs.existsSync(pidFile)) {
+        const pid = parseInt(fs.readFileSync(pidFile, 'utf-8').trim(), 10);
+        if (pid && !isProcessAlive(pid)) {
+            return { status: 'CRASHED', taskSubdir, casesDone, lastCase, logTail };
+        }
+    }
+    // CRASHED detection via log mtime: if no summary.json and the latest log
+    // hasn't been written to in 3+ minutes, the batch process likely crashed.
+    // This catches crashes even when --status is called (no PID context).
+    if (logFile && fs.existsSync(logFile)) {
+        const mtime = fs.statSync(logFile).mtime.getTime();
+        if (Date.now() - mtime > 3 * 60 * 1000) {
+            return { status: 'CRASHED', taskSubdir, casesDone, lastCase, logTail };
+        }
+    }
+    return { status: 'RUNNING', taskSubdir, casesDone, lastCase, logTail };
+}
+// ---- run command ----
+async function cmdRun(args) {
+    const taskDir = path.resolve(args.taskDir);
+    fs.mkdirSync(taskDir, { recursive: true });
+    const outputDir = args.outputDir ? path.resolve(args.outputDir) : taskDir;
+    fs.mkdirSync(outputDir, { recursive: true });
+    setupLogging(outputDir);
+    logger.info(`参数: testcases=${args.testcases}, hap=${args.hap}, bundle=${args.bundleName}, config=${args.config ?? '(default)'}`);
+    const taskSubdir = path.join(taskDir, `task_${timestampForFile(new Date())}`);
+    fs.mkdirSync(taskSubdir, { recursive: true });
+    // Read model config from stdin (--model-stdin, injected by the a2h_self_test
+    // tool). Must happen before config resolution and before batch_runner spawn
+    // (batch_runner stdio is ['ignore', logFd, logFd], so fd0 is free to read here).
+    let stdinModel = null;
+    if (args.modelStdin) {
+        try {
+            stdinModel = JSON.parse(fs.readFileSync(0, 'utf-8'));
+        }
+        catch {
+            failJson('--model-stdin set but failed to read/parse stdin JSON');
+        }
+    }
+    // Resolve autotest.yaml config.
+    // Priority: --model-stdin (a2h tool, highest) > --config (explicit yaml) > CLI params (--api-key etc.) > env vars (HOMETRANS_MODEL_*) > default yaml.
+    // --model-stdin forces a temp yaml from stdin, ignoring --config / default yaml.
+    let configPath;
+    if (args.modelStdin && stdinModel?.apiKey) {
+        // Stdin path (a2h_self_test tool): always generate a temp yaml from the
+        // stdin-injected model config. Ignore --config and the default
+        // ~/.hometrans/autotest.yaml so the host-provided key is authoritative
+        // (the on-disk default may carry a stale key or none). Written 0o600 and
+        // deleted by --status once batch_runner reaches a terminal state.
+        configPath = path.join(taskSubdir, 'autotest.yaml');
+        const apiKey = stdinModel.apiKey;
+        const modelName = stdinModel.modelName || '';
+        const modelBaseUrl = stdinModel.baseURL || '';
+        const provider = args.provider || 'openai';
+        const mode = args.agentMode || 'single';
+        const slot = `    name: "${yamlScalar(modelName)}"\n    base_url: "${yamlScalar(modelBaseUrl)}"\n    api_key: "${yamlScalar(apiKey)}"\n    provider: "${yamlScalar(provider)}"`;
+        let yaml;
+        if (mode === 'layered') {
+            yaml = `model:\n  unified:\n${slot}\n  execute:\n${slot}\n  decision:\n${slot}\nagent:\n  mode: "layered"\n`;
+        }
+        else {
+            yaml = `model:\n  unified:\n${slot}\nagent:\n  mode: "single"\n`;
+        }
+        fs.writeFileSync(configPath, yaml, { encoding: 'utf-8', mode: 0o600 });
+        logger.info(`Generated autotest.yaml (mode=${mode}) from stdin model config → ${configPath}`);
+    }
+    else if (args.config) {
+        configPath = args.config;
+        if (!fs.existsSync(configPath))
+            failJson(`autotest.yaml not found: ${configPath}`);
+    }
+    else {
+        const defaultYaml = path.join(os.homedir(), '.hometrans', 'autotest.yaml');
+        if (fs.existsSync(defaultYaml)) {
+            configPath = defaultYaml;
+        }
+        else {
+            // Auto-generate from CLI params or env vars
+            const apiKey = args.apiKey || process.env.HOMETRANS_MODEL_API_KEY || '';
+            const modelName = args.modelName || process.env.HOMETRANS_MODEL_NAME || '';
+            const modelBaseUrl = args.modelBaseUrl || process.env.HOMETRANS_MODEL_BASE_URL || '';
+            const provider = args.provider || 'openai';
+            if (apiKey && modelName && modelBaseUrl) {
+                configPath = path.join(taskSubdir, 'autotest.yaml');
+                const mode = args.agentMode || 'single';
+                const slot = `    name: "${yamlScalar(modelName)}"\n    base_url: "${yamlScalar(modelBaseUrl)}"\n    api_key: "${yamlScalar(apiKey)}"\n    provider: "${yamlScalar(provider)}"`;
+                let yaml;
+                if (mode === 'layered') {
+                    yaml = `model:
+  unified:
+${slot}
+  execute:
+${slot}
+  decision:
+${slot}
+agent:
+  mode: "layered"
+`;
+                }
+                else {
+                    yaml = `model:
+  unified:
+${slot}
+agent:
+  mode: "single"
+`;
+                }
+                fs.writeFileSync(configPath, yaml, 'utf-8');
+                logger.info(`Generated autotest.yaml (mode=${mode}) from ${args.apiKey ? 'CLI params' : 'HOMETRANS_MODEL_* env'} → ${configPath}`);
+            }
+            else {
+                failJson(`No model config: pass --config <yaml>, or --api-key + --model-name + --model-base-url, or run ht init to set HOMETRANS_MODEL_* env vars`);
+            }
+        }
+    }
+    logger.info(`Config: ${configPath}`);
+    // Read agent.mode from autotest.yaml and forward it to batch_runner via
+    // --mode. Without this, batch_runner (<= 0.0.2) defaults to "single" even
+    // when the yaml says "layered", so Planner+Executor never activates.
+    const agentMode = args.agentMode || readAgentModeFromYaml(configPath);
+    if (agentMode)
+        logger.info(`autotest.yaml agent.mode = "${agentMode}" → --mode ${agentMode}`);
+    else
+        logger.info('autotest.yaml agent.mode not set → batch_runner defaults to "single"');
+    // HAP install/uninstall
+    const hdc = getHdc();
+    // Read device_sn from autotest.yaml so hdc install/uninstall can target a
+    // specific device (-t <sn>). Without it, bare `hdc install` fails with
+    // "need connect-key" when ≥2 devices are connected — and worse, install could
+    // land on device A while batch_runner auto-detects device B, testing the
+    // wrong (stale) app. So when device_sn is unset AND ≥2 devices are connected,
+    // fail fast and tell the user to pin a device in autotest.yaml. With exactly
+    // one device, bare hdc auto-detects it correctly.
+    const deviceSn = readDeviceSnFromYaml(configPath);
+    let hdcCmd;
+    if (deviceSn) {
+        hdcCmd = [hdc, '-t', deviceSn];
+        logger.info(`autotest.yaml device.device_sn = "${deviceSn}" → hdc -t ${deviceSn}`);
+    }
+    else {
+        const targets = runCmd([hdc, 'list', 'targets'], { check: false, timeout: 15 }).stdout
+            .split(/\r?\n/).map((s) => s.trim()).filter((s) => s && !/^\[|empty/i.test(s));
+        if (targets.length > 1) {
+            logger.error(`autotest.yaml 未设 device.device_sn，但连了 ${targets.length} 台设备（${targets.join(', ')}）。` +
+                `请在 ~/.hometrans/autotest.yaml 的 device.device_sn 指定目标设备，` +
+                `避免 install 与 batch_runner 跑在不同设备上。`);
+            failJson(`device.device_sn not set in autotest.yaml; ${targets.length} devices connected (${targets.join(', ')}); set device.device_sn to pin the target`);
+        }
+        hdcCmd = [hdc];
+        logger.info(`autotest.yaml device.device_sn not set; ${targets.length} device(s) connected → hdc auto-detect`);
+    }
+    logger.info(`=== Step 2a: uninstall ${args.bundleName} ===`);
+    runCmd([...hdcCmd, 'uninstall', args.bundleName], { timeout: INSTALL_TIMEOUT, check: false });
+    logger.info(`=== Step 2b: install ${args.hap} ===`);
+    installHaps(args.hap, hdcCmd);
+    // Prepare testcases
+    const testcasesJsonl = prepareTestcasesJsonl(path.resolve(args.testcases), taskSubdir);
+    // Resolve timeout
+    let effectiveTimeout;
+    if (args.timeout === 'auto') {
+        const caseCount = fs.readFileSync(testcasesJsonl, 'utf-8').split(/\r?\n/).filter((l) => l.trim()).length;
+        effectiveTimeout = Math.max(caseCount, 1) * PER_CASE_TIMEOUT_SEC;
+        logger.info(`--timeout auto: ${caseCount} 条用例 × ${PER_CASE_TIMEOUT_SEC}s = ${effectiveTimeout}s`);
+    }
+    else if (args.timeout && typeof args.timeout === 'number') {
+        effectiveTimeout = args.timeout;
+    }
+    // Refresh model.unified.api_key from HOMETRANS_MODEL_API_KEY env if it has
+    // been rotated since the yaml was last generated. Skipped on the stdin path
+    // (a2h_self_test tool): the key came from the host via stdin, not env, so a
+    // possibly-stale HOMETRANS_MODEL_API_KEY (from a prior `ht init`) must not
+    // overwrite the stdin-injected key.
+    if (!args.modelStdin)
+        refreshApiKeyFromEnv(configPath);
+    // Build batch command — ensure @autotest/agent is installed (auto-install if missing)
+    const runnerJs = ensureAutotestAgent();
+    if (!runnerJs) {
+        failJson('batch_runner.js not found; @autotest/agent auto-install failed');
+    }
+    const cmd = ['node', runnerJs, '--task-dir', taskSubdir, '--testcases', testcasesJsonl, '--category', args.category, '--config', configPath];
+    if (agentMode)
+        cmd.push('--mode', agentMode);
+    logger.info('=== Step 3: 启动 AutoTest batch_runner ===');
+    // Spawn detached; write stdout/stderr to batch_stdout.log (file-based, not
+    // pipe-forward). This ensures batch_runner survives a parent-process kill
+    // (no EPIPE from broken pipe), and --status can detect CRASHED via log mtime.
+    const stdoutLog = path.join(taskDir, 'batch_stdout.log');
+    const logFd = fs.openSync(stdoutLog, 'w');
+    const proc = spawn(cmd[0], cmd.slice(1), {
+        cwd: taskSubdir,
+        stdio: ['ignore', logFd, logFd],
+        env: process.env,
+        detached: true,
+        windowsHide: true,
+    });
+    proc.unref();
+    logger.info(`后台进程 PID=${proc.pid}`);
+    fs.closeSync(logFd);
+    // Record the batch pid in task_subdir so --status (which has no spawn
+    // context) can detect a dead/killed process immediately (see probeStatus).
+    // Without it, an agent timeout-kill leaves the temp autotest.yaml (apiKey) on
+    // disk: the post-kill poll still sees RUNNING (fresh log mtime).
+    try { fs.writeFileSync(path.join(taskSubdir, 'batch.pid'), String(proc.pid), 'utf-8'); } catch { /* best-effort */ }
+    // No timeout: return immediately
+    if (!effectiveTimeout) {
+        console.log(JSON.stringify({ status: 'RUNNING', pid: proc.pid, task_dir: taskDir, task_subdir: taskSubdir }));
+        return;
+    }
+    // Poll until terminal
+    const start = Date.now();
+    while (true) {
+        const r = probeStatus(taskDir, outputDir);
+        if (r.status === 'COMPLETED') {
+            console.log(JSON.stringify({
+                status: 'COMPLETED', task_subdir: r.taskSubdir, cases_done: r.casesDone,
+                pass_count: r.passCount ?? 0, fail_count: r.failCount ?? 0, unknown_count: r.unknownCount ?? 0,
+                pass_rate: r.passRate ?? 0, log_tail: r.logTail,
+            }));
+            process.exit(0);
+        }
+        // CRASHED detection: batch process died without producing summary.json.
+        // Without this, a spawn-time crash (ConfigManager error, missing dep, JS
+        // exception) would be misreported as TIMEOUT after waiting the full budget.
+        const procAlive = isProcessAlive(proc.pid);
+        if (!procAlive) {
+            logger.error(`batch_runner 进程 PID=${proc.pid} 已退出但无 summary.json → CRASHED`);
+            deleteTempYaml(r.taskSubdir);
+            console.log(JSON.stringify({
+                status: 'CRASHED', task_subdir: r.taskSubdir, cases_done: r.casesDone,
+                last_case: r.lastCase, log_tail: r.logTail,
+            }));
+            process.exit(3);
+        }
+        const elapsed = (Date.now() - start) / 1000;
+        if (elapsed >= effectiveTimeout) {
+            killProcessTree(proc.pid);
+            deleteTempYaml(r.taskSubdir);
+            console.log(JSON.stringify({
+                status: 'TIMEOUT', task_subdir: r.taskSubdir, cases_done: r.casesDone,
+                last_case: r.lastCase, log_tail: r.logTail,
+            }));
+            process.exit(5);
+        }
+        await sleepAsync(60);
+    }
+}
+// ---- status command ----
+function cmdStatus(taskDir, outputDir) {
+    const r = probeStatus(path.resolve(taskDir), outputDir ? path.resolve(outputDir) : path.resolve(taskDir));
+    // Delete the temp autotest.yaml (apiKey) on ANY terminal state -- not just
+    // COMPLETED/CRASHED. NOT_STARTED has taskSubdir null (no-op). CRASHED here
+    // also covers the post-timeout-kill case: probeStatus returns CRASHED once
+    // batch.pid shows the process is dead, so this deletes the key right after
+    // the agent kills the run and polls once more.
+    if (r.status !== 'RUNNING') {
+        deleteTempYaml(r.taskSubdir);
+    }
+    if (r.status === 'NOT_STARTED') {
+        console.log(JSON.stringify({ status: 'NOT_STARTED' }));
+        process.exit(4);
+    }
+    if (r.status === 'COMPLETED') {
+        console.log(JSON.stringify({
+            status: 'COMPLETED', task_subdir: r.taskSubdir, cases_done: r.casesDone,
+            pass_count: r.passCount ?? 0, fail_count: r.failCount ?? 0, unknown_count: r.unknownCount ?? 0,
+            pass_rate: r.passRate ?? 0, log_tail: r.logTail,
+        }));
+        process.exit(0);
+    }
+    console.log(JSON.stringify({ status: r.status, cases_done: r.casesDone, last_case: r.lastCase, task_subdir: r.taskSubdir, log_tail: r.logTail }));
+    process.exit(r.status === 'RUNNING' ? 2 : 3);
+}
+// ---- entry ----
+const args = process.argv.slice(2);
+// Parse args: --status flag switches to status mode, otherwise run mode
+const isStatus = args.includes('--status');
+const filtered = args.filter((a) => a !== '--status');
+if (filtered.includes('-h') || filtered.includes('--help')) {
+    if (isStatus) {
+        console.log('Usage: self-test-runner --status --task-dir <dir> [--output-dir <dir>]');
+    }
+    else {
+        console.log(`Usage: self-test-runner [options]
+
+Options:
+  --testcases <path>        测试用例文件，JSON 数组或 JSONL
+  --hap <path>              签名包：单个 .hap/.hsp 文件、目录，或逗号分隔
+  --bundle-name <name>      包名
+  --task-dir <dir>          任务目录 (default: "task")
+  --output-dir <dir>        日志目录
+  --category <name>         测试分类名称 (default: "self_test")
+  --config <path>           autotest.yaml 路径（有 yaml 文件时用）
+  --api-key <key>           模型 API Key（无 yaml 时从 CLI/env 生成临时 yaml）
+  --model-name <name>       模型名称（如 qwen3.7-plus）
+  --model-base-url <url>    模型 API base URL
+  --provider <name>         模型 provider (default: "openai")
+  --mode <single|layered>   agent 模式（default: single；layered 时从同一组参数生成 execute/decision 槽位）
+  --timeout <sec>           阻塞直到终态或超时（秒），或 auto
+  --model-stdin             从 stdin 读取模型配置（a2h 工具注入；优先级最高）
+  --status                  查询执行状态（而非运行）
+  -h, --help                display this help
+
+Model config priority: --model-stdin (a2h 工具, 最高) > --config (yaml file) > --api-key/--model-name/--model-base-url (CLI) > HOMETRANS_MODEL_* (env from ht init).
+When --config is absent, the runner auto-generates a temp autotest.yaml from CLI params or env vars. --model-stdin forces a temp yaml from stdin, ignoring --config / default yaml.
+`);
+    }
+    process.exit(0);
+}
+if (isStatus) {
+    // Status mode: only need --task-dir and --output-dir
+    let taskDir = '';
+    let outputDir;
+    for (let i = 0; i < filtered.length; i++) {
+        if (filtered[i] === '--task-dir')
+            taskDir = filtered[++i];
+        else if (filtered[i] === '--output-dir')
+            outputDir = filtered[++i];
+    }
+    if (!taskDir)
+        failJson('Missing required option: --task-dir');
+    cmdStatus(taskDir, outputDir);
+}
+else {
+    // Run mode (default)
+    cmdRun(parseRunArgs(filtered)).catch((e) => {
+        failJson(`cmdRun 未捕获异常: ${e instanceof Error ? e.message : e}`);
+    });
+}