android2harmony 0.1.4 → 0.1.5

package/skills/hmos-incremental-ui-align/scripts/app_feature_verify.js

@@ -0,0 +1,790 @@
+#!/usr/bin/env node
+import { randomUUID } from "node:crypto";
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+const ACTION_DELAY = Number(process.env.HT_ACTION_DELAY ?? "1") || 1;
+const sleep = (seconds) => new Promise((resolve) => setTimeout(resolve, Math.max(0, seconds) * 1e3));
+function buildSystemPrompt() {
+  const now = /* @__PURE__ */ new Date();
+  const weekdayNames = ["星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"];
+  const formattedDate = `${now.getFullYear()}年${String(now.getMonth() + 1).padStart(2, "0")}月${String(now.getDate()).padStart(2, "0")}日 ${weekdayNames[now.getDay()]}`;
+  return "今天的日期是: " + formattedDate + `
+你是一个智能体分析专家，可以根据操作历史和当前状态图执行一系列操作来完成任务。
+你必须严格按照要求输出以下格式：
+<thinking>{think}</thinking>
+<answer>{action}</answer>
+
+其中：
+- {think} 是对你为什么选择这个操作的简短推理说明。
+- {action} 是本次执行的具体操作指令，必须严格遵循下方定义的指令格式。
+
+操作指令及其作用如下：
+- do(action="Launch", app="xxx")
+    Launch是启动目标app的操作，这比通过主屏幕导航更快。此操作完成后，您将自动收到结果状态的截图。
+- do(action="Tap", element=[x,y])
+    Tap是点击操作，点击屏幕上的特定点。可用此操作点击按钮、选择项目、从主屏幕打开应用程序，或与任何可点击的用户界面元素进行交互。坐标系统从左上角 (0,0) 开始到右下角（999,999)结束。此操作完成后，您将自动收到结果状态的截图。
+- do(action="Tap", element=[x,y], message="重要操作")
+    基本功能同Tap，点击涉及财产、支付、隐私等敏感按钮时触发。
+- do(action="Type", text="xxx")
+    Type是输入操作，在当前聚焦的输入框中输入文本。使用此操作前，请确保输入框已被聚焦（先点击它）。输入的文本将像使用键盘输入一样输入。重要提示：手机可能正在使用 ADB 键盘，该键盘不会像普通键盘那样占用屏幕空间。要确认键盘已激活，请查看屏幕底部是否显示 'ADB Keyboard {ON}' 类似的文本，或者检查输入框是否处于激活/高亮状态。不要仅仅依赖视觉上的键盘显示。自动清除文本：当你使用输入操作时，输入框中现有的任何文本（包括占位符文本和实际输入）都会在输入新文本前自动清除。你无需在输入前手动清除文本——直接使用输入操作输入所需文本即可。操作完成后，你将自动收到结果状态的截图。
+- do(action="Type_Name", text="xxx")
+    Type_Name是输入人名的操作，基本功能同Type。
+- do(action="Interact")
+    Interact是当有多个满足条件的选项时而触发的交互操作，询问用户如何选择。
+- do(action="Swipe", start=[x1,y1], end=[x2,y2])
+    Swipe是滑动操作，通过从起始坐标拖动到结束坐标来执行滑动手势。可用于滚动内容、在屏幕之间导航、下拉通知栏以及项目栏或进行基于手势的导航。坐标系统从左上角 (0,0) 开始到右下角（999,999)结束。滑动持续时间会自动调整以实现自然的移动。此操作完成后，您将自动收到结果状态的截图。
+- do(action="Note", message="True")
+    记录当前页面内容以便后续总结。
+- do(action="Call_API", instruction="xxx")
+    总结或评论当前页面或已记录的内容。
+- do(action="Long Press", element=[x,y])
+    Long Pres是长按操作，在屏幕上的特定点长按指定时间。可用于触发上下文菜单、选择文本或激活长按交互。坐标系统从左上角 (0,0) 开始到右下角（999,999)结束。此操作完成后，您将自动收到结果状态的屏幕截图。
+- do(action="Double Tap", element=[x,y])
+    Double Tap在屏幕上的特定点快速连续点按两次。使用此操作可以激活双击交互，如缩放、选择文本或打开项目。坐标系统从左上角 (0,0) 开始到右下角（999,999)结束。此操作完成后，您将自动收到结果状态的截图。
+- do(action="Back")
+    导航返回到上一个屏幕或关闭当前对话框。相当于按下 Android 的返回按钮。使用此操作可以从更深的屏幕返回、关闭弹出窗口或退出当前上下文。此操作完成后，您将自动收到结果状态的截图。
+- do(action="Home")
+    Home是回到系统桌面的操作，相当于按下 Android 主屏幕按钮。使用此操作可退出当前应用并返回启动器，或从已知状态启动新任务。此操作完成后，您将自动收到结果状态的截图。
+- do(action="Wait", duration="x seconds")
+    等待页面加载，x为需要等待多少秒。
+- finish(message="xxx")
+    finish是结束任务的操作，表示准确完整完成任务，message是终止信息。
+
+必须遵循的规则：
+1. 在执行任何操作前，先检查当前app是否是目标app，如果不是，先执行 Launch。
+2. 如果进入到了无关页面，先执行 Back。如果执行Back后页面没有变化，请点击页面左上角的返回键进行返回，或者右上角的X号关闭。
+3. 如果页面未加载出内容，最多连续 Wait 三次，否则执行 Back重新进入。
+4. 如果页面显示网络问题，需要重新加载，请点击重新加载。
+5. 如果当前页面找不到目标联系人、商品、店铺等信息，可以尝试 Swipe 滑动查找。
+6. 遇到价格区间、时间区间等筛选条件，如果没有完全符合的，可以放宽要求。
+7. 在做小红书总结类任务时一定要筛选图文笔记。
+8. 购物车全选后再点击全选可以把状态设为全不选，在做购物车任务时，如果购物车里已经有商品被选中时，你需要点击全选后再点击取消全选，再去找需要购买或者删除的商品。
+9. 在做外卖任务时，如果相应店铺购物车里已经有其他商品你需要先把购物车清空再去购买用户指定的外卖。
+10. 在做点外卖任务时，如果用户需要点多个外卖，请尽量在同一店铺进行购买，如果无法找到可以下单，并说明某个商品未找到。
+11. 请严格遵循用户意图执行任务，用户的特殊要求可以执行多次搜索，滑动查找。
+12. 在选择日期时，如果原滑动方向与预期日期越来越远，请向反方向滑动查找。
+13. 执行任务过程中如果有多个可选择的项目栏，请逐个查找每个项目栏，直到完成任务，一定不要在同一项目栏多次查找，从而陷入死循环。
+14. 在执行下一步操作前请一定要检查上一步的操作是否生效，如果点击没生效，可能因为app反应较慢，请先稍微等待一下，如果还是不生效请调整一下点击位置重试，如果仍然不生效请跳过这一步继续任务，并在finish message说明点击不生效。
+15. 在执行任务中如果遇到滑动不生效的情况，请调整一下起始点位置，增大滑动距离重试，如果还是不生效，有可能是已经滑到底了，请继续向反方向滑动，直到顶部或底部，如果仍然没有符合要求的结果，请跳过这一步继续任务，并在finish message说明但没找到要求的项目。
+16. 在做游戏任务时如果在战斗页面如果有自动战斗一定要开启自动战斗，如果多轮历史状态相似要检查自动战斗是否开启。
+17. 如果没有合适的搜索结果，可能是因为搜索页面不对，请返回到搜索页面的上一级尝试重新搜索，如果尝试三次返回上一级搜索后仍然没有符合要求的结果，执行 finish(message="原因")。
+18. 在结束任务前请一定要仔细检查任务是否完整准确的完成，如果出现错选、漏选、多选的情况，请返回之前的步骤进行纠正。
+`;
+}
+function runBin(bin, args, opts = {}) {
+  const res = spawnSync(bin, args, {
+    timeout: (opts.timeout ?? 15) * 1e3,
+    maxBuffer: 128 * 1024 * 1024,
+    windowsHide: true
+  });
+  const outBuf = res.stdout ?? Buffer.alloc(0);
+  const errBuf = res.stderr ?? Buffer.alloc(0);
+  if (res.error && res.error.code === "ETIMEDOUT") {
+    console.log(`  [WARN] ${bin} timeout: ${args.join(" ")}`);
+  }
+  return {
+    stdout: outBuf.toString("utf-8"),
+    stdoutBuf: outBuf,
+    stderr: errBuf.toString("utf-8"),
+    code: res.status
+  };
+}
+function imageSize(buf) {
+  if (buf.length >= 24 && buf[0] === 137 && buf[1] === 80 && buf[2] === 78 && buf[3] === 71) {
+    return { width: buf.readUInt32BE(16), height: buf.readUInt32BE(20) };
+  }
+  if (buf.length >= 4 && buf[0] === 255 && buf[1] === 216) {
+    let i = 2;
+    while (i < buf.length - 1) {
+      if (buf[i] !== 255) {
+        i += 1;
+        continue;
+      }
+      const marker = buf[i + 1];
+      if (marker >= 192 && marker <= 207 && marker !== 196 && marker !== 200 && marker !== 204) {
+        const height = buf.readUInt16BE(i + 5);
+        const width = buf.readUInt16BE(i + 7);
+        return { width, height };
+      }
+      if (marker === 216 || marker === 217 || marker >= 208 && marker <= 215) {
+        i += 2;
+        continue;
+      }
+      const segLen = buf.readUInt16BE(i + 2);
+      i += 2 + segLen;
+    }
+  }
+  return { width: 1080, height: 2400 };
+}
+const APP_PACKAGES = /* @__PURE__ */ new Map();
+class HdcDriver {
+  serial;
+  constructor(serial) {
+    this.serial = serial;
+  }
+  prefix() {
+    return this.serial ? ["-t", this.serial] : [];
+  }
+  shell(args, timeout = 15) {
+    return runBin("hdc", [...this.prefix(), "shell", ...args], { timeout });
+  }
+  getScreenshot() {
+    const remote = "/data/local/tmp/tmp_screenshot.jpeg";
+    let out = this.shell(["snapshot_display", "-f", remote], 10);
+    const combined = (out.stdout + out.stderr).toLowerCase();
+    if (combined.includes("fail") || combined.includes("error")) {
+      this.shell(["screenshot", remote], 10);
+    }
+    const localPath = path.join(os.tmpdir(), `ht_shot_${process.pid}_${Date.now()}.jpeg`);
+    runBin("hdc", [...this.prefix(), "file", "recv", remote, localPath], { timeout: 10 });
+    try {
+      const buf = fs.readFileSync(localPath);
+      fs.unlinkSync(localPath);
+      const { width, height } = imageSize(buf);
+      return { base64: buf.toString("base64"), mime: "image/jpeg", width, height };
+    } catch {
+      return fallbackScreenshot();
+    }
+  }
+  getCurrentApp() {
+    const out = this.shell(["aa", "dump", "-l"]).stdout;
+    if (!out) return "System Home";
+    let currentBundle = null;
+    let foreground = null;
+    for (const line of out.split("\n")) {
+      if (line.includes("app name [")) {
+        const m = line.match(/\[([^\]]+)\]/);
+        if (m) currentBundle = m[1];
+      }
+      if (line.toLowerCase().includes("state #foreground")) {
+        if (currentBundle) {
+          foreground = currentBundle;
+          break;
+        }
+      }
+      if (line.includes("Mission ID")) currentBundle = null;
+    }
+    if (foreground) {
+      for (const [name, pkg] of APP_PACKAGES) if (pkg === foreground) return name;
+      return foreground;
+    }
+    return "System Home";
+  }
+  launchApp(appName) {
+    const bundle = APP_PACKAGES.get(appName);
+    if (!bundle) {
+      console.log(`[HDC] App '${appName}' not registered`);
+      return false;
+    }
+    const ability = process.env.HT_HMOS_ABILITY || "EntryAbility";
+    this.shell(["aa", "start", "-b", bundle, "-a", ability]);
+    return true;
+  }
+  tap(x, y) {
+    this.shell(["uitest", "uiInput", "click", String(x), String(y)]);
+  }
+  doubleTap(x, y) {
+    this.shell(["uitest", "uiInput", "doubleClick", String(x), String(y)]);
+  }
+  longPress(x, y) {
+    this.shell(["uitest", "uiInput", "longClick", String(x), String(y)]);
+  }
+  swipe(x1, y1, x2, y2) {
+    const distance = Math.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2);
+    let durationMs = Math.trunc(distance * distance / 1e3);
+    durationMs = Math.max(500, Math.min(durationMs, 1e3));
+    let velocity = Math.trunc(distance / durationMs * 4e3);
+    velocity = Math.max(500, Math.min(velocity, 4e4));
+    this.shell(["uitest", "uiInput", "swipe", String(x1), String(y1), String(x2), String(y2), String(velocity)]);
+  }
+  back() {
+    this.shell(["uitest", "uiInput", "keyEvent", "Back"]);
+  }
+  home() {
+    this.shell(["uitest", "uiInput", "keyEvent", "Home"]);
+  }
+  typeText(text) {
+    const escaped = text.replace(/"/g, '\\"').replace(/\$/g, "\\$");
+    this.shell(["uitest", "uiInput", "text", escaped]);
+  }
+}
+class AdbDriver {
+  serial;
+  constructor(serial) {
+    this.serial = serial;
+  }
+  prefix() {
+    return this.serial ? ["-s", this.serial] : [];
+  }
+  shell(args, timeout = 15) {
+    return runBin("adb", [...this.prefix(), "shell", ...args], { timeout });
+  }
+  getScreenshot() {
+    const { stdoutBuf, code } = runBin("adb", [...this.prefix(), "exec-out", "screencap", "-p"], {
+      timeout: 15,
+      binary: true
+    });
+    if (code !== 0 || stdoutBuf.length === 0) return fallbackScreenshot();
+    const { width, height } = imageSize(stdoutBuf);
+    return { base64: stdoutBuf.toString("base64"), mime: "image/png", width, height };
+  }
+  getCurrentApp() {
+    const out = this.shell(["dumpsys", "window"]).stdout;
+    for (const line of out.split("\n")) {
+      if (line.includes("mCurrentFocus") || line.includes("mFocusedApp")) {
+        for (const [name, pkg] of APP_PACKAGES) if (line.includes(pkg)) return name;
+      }
+    }
+    return "System Home";
+  }
+  launchApp(appName) {
+    const pkg = APP_PACKAGES.get(appName);
+    if (!pkg) {
+      console.log(`[ADB] App '${appName}' not registered`);
+      return false;
+    }
+    this.shell(["monkey", "-p", pkg, "-c", "android.intent.category.LAUNCHER", "1"]);
+    return true;
+  }
+  tap(x, y) {
+    this.shell(["input", "tap", String(x), String(y)]);
+  }
+  doubleTap(x, y) {
+    this.shell(["input", "tap", String(x), String(y)]);
+    this.shell(["input", "tap", String(x), String(y)]);
+  }
+  longPress(x, y) {
+    this.shell(["input", "swipe", String(x), String(y), String(x), String(y), "3000"]);
+  }
+  swipe(x1, y1, x2, y2) {
+    const distSq = (x1 - x2) ** 2 + (y1 - y2) ** 2;
+    let durationMs = Math.trunc(distSq / 1e3);
+    durationMs = Math.max(1e3, Math.min(durationMs, 2e3));
+    this.shell(["input", "swipe", String(x1), String(y1), String(x2), String(y2), String(durationMs)]);
+  }
+  back() {
+    this.shell(["input", "keyevent", "4"]);
+  }
+  home() {
+    this.shell(["input", "keyevent", "KEYCODE_HOME"]);
+  }
+  typeText(text) {
+    const encoded = Buffer.from(text, "utf-8").toString("base64");
+    this.shell(["am", "broadcast", "-a", "ADB_INPUT_B64", "--es", "msg", encoded]);
+  }
+}
+function fallbackScreenshot() {
+  const png = Buffer.from(
+    "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+M8AAAMBAQDJ/pLvAAAAAElFTkSuQmCC",
+    "base64"
+  );
+  return { base64: png.toString("base64"), mime: "image/png", width: 1080, height: 2400 };
+}
+function splitThinkingAction(content) {
+  const thinkM = content.match(/<thinking>(.*?)<\/thinking>/s);
+  const think = thinkM ? thinkM[1].trim() : "";
+  let cleaned = content.replace(/<thinking>.*?<\/thinking>\s*/gs, "");
+  const ansM = cleaned.match(/<answer>\s*(.*?)\s*<\/answer>/s);
+  if (ansM) cleaned = ansM[1];
+  cleaned = cleaned.replace(/<\/answer>/g, "").trim();
+  if (cleaned.includes("finish(message=")) {
+    const idx = cleaned.indexOf("finish(message=");
+    return { thinking: think || cleaned.slice(0, idx).trim(), action: cleaned.slice(idx) };
+  }
+  if (cleaned.includes("do(action=")) {
+    const idx = cleaned.indexOf("do(action=");
+    return { thinking: think || cleaned.slice(0, idx).trim(), action: cleaned.slice(idx) };
+  }
+  return { thinking: think, action: cleaned || content };
+}
+function stripLlmTags(text) {
+  let t = text.replace(/<thinking>.*?<\/thinking>\s*/gs, "");
+  const m = t.match(/<answer>\s*(.*?)\s*<\/answer>/s);
+  if (m) t = m[1];
+  return t.replace(/<\/answer>/g, "").trim();
+}
+function parseDoArgs(inner) {
+  const args = {};
+  const strRe = /(\w+)\s*=\s*"((?:[^"\\]|\\.)*)"/g;
+  let m;
+  while ((m = strRe.exec(inner)) !== null) {
+    args[m[1]] = m[2].replace(/\\n/g, "\n").replace(/\\t/g, "	").replace(/\\r/g, "\r").replace(/\\"/g, '"');
+  }
+  const arrRe = /(\w+)\s*=\s*\[\s*(-?\d+)\s*,\s*(-?\d+)\s*\]/g;
+  while ((m = arrRe.exec(inner)) !== null) {
+    args[m[1]] = [parseInt(m[2], 10), parseInt(m[3], 10)];
+  }
+  return args;
+}
+function parseAction(response) {
+  const cleaned = stripLlmTags(response);
+  for (const text of [cleaned, response.trim()]) {
+    const finishM = text.match(/finish\s*\(\s*message\s*=\s*"((?:[^"\\]|\\.)*)"\s*\)/s);
+    if (finishM) {
+      return { _metadata: "finish", message: finishM[1].replace(/\\"/g, '"').replace(/\\n/g, "\n") };
+    }
+    const doM = text.match(/do\s*\((.*)\)\s*$/s) || text.match(/do\s*\((.*?)\)/s);
+    if (doM) {
+      const args = parseDoArgs(doM[1]);
+      if (args.action) return { _metadata: "do", ...args };
+    }
+  }
+  return null;
+}
+function isDevEcoMaaS(cfg) {
+  return cfg.baseUrl.includes("devecostudio");
+}
+function chatCompletionsUrl(cfg) {
+  return cfg.baseUrl.replace(/\/$/, "") + "/chat/completions";
+}
+function buildHeaders(cfg) {
+  const headers = {
+    "Content-Type": "application/json",
+    Authorization: `Bearer ${cfg.apiKey}`
+  };
+  if (isDevEcoMaaS(cfg)) {
+    headers["Chat-Id"] = randomUUID().replace(/-/g, "");
+  }
+  return headers;
+}
+function buildBody(cfg, messages) {
+  const body = { model: cfg.modelName, messages, stream: false };
+  if (!isDevEcoMaaS(cfg)) {
+    body.max_tokens = 3e3;
+    body.temperature = cfg.temperature;
+    body.top_p = 0.85;
+    body.frequency_penalty = 0.2;
+  }
+  return body;
+}
+function extractContent(data) {
+  return data.choices?.[0]?.message?.content ?? "";
+}
+async function requestModel(cfg, messages) {
+  const resp = await fetch(chatCompletionsUrl(cfg), {
+    method: "POST",
+    headers: buildHeaders(cfg),
+    body: JSON.stringify(buildBody(cfg, messages))
+  });
+  if (!resp.ok) {
+    const text = await resp.text().catch(() => "");
+    throw new Error(`Model HTTP ${resp.status}: ${text.slice(0, 500)}`);
+  }
+  return extractContent(await resp.json());
+}
+function userMessage(text, shot) {
+  const content = [];
+  if (shot) {
+    content.push({ type: "image_url", image_url: { url: `data:${shot.mime};base64,${shot.base64}` } });
+  }
+  content.push({ type: "text", text });
+  return { role: "user", content };
+}
+function stripImages(msg) {
+  if (Array.isArray(msg.content)) {
+    return { ...msg, content: msg.content.filter((c) => c.type === "text") };
+  }
+  return msg;
+}
+class PhoneAgent {
+  cfg;
+  device;
+  maxSteps;
+  verbose;
+  context = [];
+  constructor(cfg, device, maxSteps, verbose) {
+    this.cfg = cfg;
+    this.device = device;
+    this.maxSteps = maxSteps;
+    this.verbose = verbose;
+  }
+  reset() {
+    this.context = [];
+  }
+  async run(task) {
+    this.context = [];
+    let stepCount = 0;
+    let isFirst = true;
+    while (stepCount < this.maxSteps) {
+      stepCount += 1;
+      const shot = this.device.getScreenshot();
+      const currentApp = this.device.getCurrentApp();
+      const screenInfo = JSON.stringify({ current_app: currentApp });
+      if (isFirst) {
+        this.context.push({ role: "system", content: buildSystemPrompt() });
+        this.context.push(userMessage(`${task}
+
+${screenInfo}`, shot));
+        isFirst = false;
+      } else {
+        this.context.push(userMessage(`** Screen Info **
+
+${screenInfo}`, shot));
+      }
+      let content;
+      try {
+        content = await requestModel(this.cfg, this.context);
+      } catch (e) {
+        return `Model error: ${e.message}`;
+      }
+      const { thinking, action: actionStr } = splitThinkingAction(content);
+      if (this.verbose) {
+        console.log(`
+${"=".repeat(50)}
+💭 思考过程:
+${"-".repeat(50)}`);
+        console.log(thinking || "(无)");
+        console.log(`${"-".repeat(50)}
+🎯 执行动作: ${actionStr}
+${"=".repeat(50)}`);
+      }
+      const action = parseAction(actionStr) ?? { _metadata: "finish", message: actionStr };
+      this.context[this.context.length - 1] = stripImages(this.context[this.context.length - 1]);
+      this.context.push({
+        role: "assistant",
+        content: `<thinking>${thinking}</thinking><answer>${actionStr}</answer>`
+      });
+      if (action._metadata === "finish") {
+        return action.message || "Task completed";
+      }
+      await this.execute(action, shot.width, shot.height);
+      await sleep(ACTION_DELAY);
+    }
+    return "Max steps reached";
+  }
+  async execute(action, width, height) {
+    const toPx = (el) => {
+      const [rx, ry] = el;
+      return [Math.trunc(rx / 1e3 * width), Math.trunc(ry / 1e3 * height)];
+    };
+    const name = action.action;
+    try {
+      switch (name) {
+        case "Launch":
+          this.device.launchApp(action.app);
+          break;
+        case "Tap": {
+          const [x, y] = toPx(action.element);
+          this.device.tap(x, y);
+          break;
+        }
+        case "Double Tap": {
+          const [x, y] = toPx(action.element);
+          this.device.doubleTap(x, y);
+          break;
+        }
+        case "Long Press": {
+          const [x, y] = toPx(action.element);
+          this.device.longPress(x, y);
+          break;
+        }
+        case "Swipe": {
+          const [sx, sy] = toPx(action.start);
+          const [ex, ey] = toPx(action.end);
+          this.device.swipe(sx, sy, ex, ey);
+          break;
+        }
+        case "Type":
+        case "Type_Name":
+          this.device.typeText(action.text ?? "");
+          break;
+        case "Back":
+          this.device.back();
+          break;
+        case "Home":
+          this.device.home();
+          break;
+        case "Wait": {
+          const dur = parseFloat(String(action.duration ?? "1").replace("seconds", "").trim());
+          await sleep(Number.isFinite(dur) ? dur : 1);
+          break;
+        }
+        case "Note":
+        case "Call_API":
+        case "Interact":
+        case "Take_over":
+          break;
+        default:
+          console.log(`  [WARN] Unknown action: ${name}`);
+      }
+    } catch (e) {
+      console.log(`  [WARN] Action '${name}' failed: ${e.message}`);
+    }
+  }
+}
+function parseFeatureMd(filePath) {
+  const text = fs.readFileSync(filePath, "utf-8");
+  const results = [];
+  let currentFeature = "";
+  let current = null;
+  let collecting = null;
+  for (const line of text.split(/\r?\n/)) {
+    const stripped = line.trim();
+    const feat = stripped.match(/^##\s+Feature:\s*(.+)$/);
+    if (feat) {
+      if (current) results.push(current);
+      current = null;
+      currentFeature = feat[1].trim();
+      collecting = null;
+      continue;
+    }
+    const scen = stripped.match(/^###\s+Scenario:\s*(.+)$/);
+    if (scen) {
+      if (current) results.push(current);
+      const scenarioName = scen[1].trim();
+      const featureName = currentFeature.replace(/^FEA-\d+\s*/, "");
+      current = {
+        feature: currentFeature,
+        scenario: scenarioName,
+        preconditions: [],
+        actions: [],
+        expectations: [],
+        L1: featureName,
+        L2: scenarioName,
+        L3: ""
+      };
+      collecting = null;
+      continue;
+    }
+    if (!current) continue;
+    if (/^-\s*前置条件[：:]/.test(stripped)) {
+      collecting = "preconditions";
+      continue;
+    }
+    const act = stripped.match(/^-\s*动作[：:]\s*(.+)$/);
+    if (act) {
+      collecting = null;
+      current.actions.push(act[1].trim());
+      continue;
+    }
+    const exp = stripped.match(/^-\s*预期结果[：:]\s*(.+)$/);
+    if (exp) {
+      collecting = null;
+      current.expectations.push(exp[1].trim());
+      continue;
+    }
+    const sub = line.match(/^\s+-\s+(.+)$/);
+    if (sub && collecting === "preconditions") {
+      current.preconditions.push(sub[1].trim());
+      continue;
+    }
+    if (stripped && !stripped.startsWith("-")) collecting = null;
+  }
+  if (current) results.push(current);
+  return results;
+}
+function getFeaturePath(item) {
+  let keys = ["L1", "L2", "L3"].filter((k) => k in item);
+  if (keys.length === 0) keys = ["一级", "二级", "三级"].filter((k) => k in item);
+  if (keys.length === 0) keys = Object.keys(item).slice(0, 3);
+  const parts = [];
+  for (const k of keys) {
+    const v = item[k];
+    if (v != null && String(v).trim()) parts.push(String(v).trim());
+  }
+  if (parts.length === 0) return { pathStr: "", leaf: "" };
+  return { pathStr: parts.join(" > "), leaf: parts[parts.length - 1] };
+}
+function buildNavigatePrompt(appName, pathStr, leaf, hints) {
+  let prompt = `打开${appName}，按照以下路径依次点击导航到目标页面：${pathStr}。最终目标是到达「${leaf}」所在的页面。注意：1. 鸿蒙手机浅色/深色模式切换路径：设置->显示与亮度2. '更多'组件可能表示为 三横 或者 三点。3. '设置'组件可能表示为 齿轮。到达目标页面后请回复'已到达'，无法到达请回复'未找到'。`;
+  if (hints) prompt += `
+补充提示: ${hints}`;
+  return prompt;
+}
+function judgeReached(msg) {
+  if (!msg) return false;
+  const reached = ["已到达", "到达", "存在", "找到", "完成", "成功", "已确认", "已进入", "已打开"];
+  const failed = ["未找到", "不存在", "无法找到", "无法到达", "没有", "失败", "未到达"];
+  const firstLine = msg.split("\n")[0];
+  if (failed.some((k) => firstLine.includes(k))) return false;
+  if (reached.some((k) => firstLine.includes(k))) return true;
+  return false;
+}
+function loadModelConfig(cliApiKey, stdinModel) {
+  if (stdinModel?.apiKey) {
+    return {
+      apiKey: stdinModel.apiKey,
+      baseUrl: stdinModel.baseURL || "http://localhost:8000/v1",
+      modelName: stdinModel.modelName,
+      temperature: 0.1
+    };
+  }
+  let apiKey = (cliApiKey || process.env.HOMETRANS_MODEL_API_KEY || "").trim();
+  let baseUrl = (process.env.HOMETRANS_MODEL_BASE_URL || "").trim();
+  let modelName = (process.env.HOMETRANS_MODEL_NAME || "").trim();
+  let temperature = 0.1;
+  const configPath = path.join(os.homedir(), ".hometrans", "config.json");
+  if (fs.existsSync(configPath)) {
+    try {
+      const cfg = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+      const um = cfg?.autotest?.unified_model ?? {};
+      apiKey = apiKey || String(um.api_key ?? "").trim();
+      baseUrl = baseUrl || String(um.base_url ?? "").trim();
+      modelName = modelName || String(um.name ?? "").trim();
+      if (um.temperature != null) temperature = Number(um.temperature);
+    } catch {
+    }
+  }
+  if (apiKey) {
+    return { baseUrl: baseUrl || "http://localhost:8000/v1", apiKey, modelName, temperature };
+  }
+  const glmKey = (process.env.GLM_API_KEY || "").trim();
+  if (glmKey) {
+    return {
+      baseUrl: "https://open.bigmodel.cn/api/paas/v4",
+      apiKey: glmKey,
+      modelName: "autoglm-phone",
+      temperature: 0.1
+    };
+  }
+  return { baseUrl: "http://localhost:8000/v1", apiKey: "EMPTY", modelName: "", temperature };
+}
+function parseArgs(argv) {
+  const a = {
+    device: "hdc",
+    app: "",
+    package: "",
+    task: null,
+    prompt: null,
+    feature: null,
+    limit: null,
+    offset: 1,
+    apiKey: "",
+    maxSteps: 30,
+    appHints: null,
+    serial: null,
+    quiet: false,
+    modelStdin: false
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    const next = () => argv[++i];
+    switch (arg) {
+      case "--device":
+        a.device = next();
+        break;
+      case "--app":
+        a.app = next();
+        break;
+      case "--package":
+        a.package = next();
+        break;
+      case "--task":
+        a.task = next();
+        break;
+      case "--prompt":
+        a.prompt = next();
+        break;
+      case "--feature":
+        a.feature = next();
+        break;
+      case "--limit":
+        a.limit = parseInt(next(), 10);
+        break;
+      case "--offset":
+        a.offset = parseInt(next(), 10);
+        break;
+      case "--api-key":
+        a.apiKey = next();
+        break;
+      case "--max-steps":
+        a.maxSteps = parseInt(next(), 10);
+        break;
+      case "--app-hints":
+        a.appHints = next();
+        break;
+      case "--serial":
+        a.serial = next();
+        break;
+      case "-q":
+      case "--quiet":
+        a.quiet = true;
+        break;
+      case "--model-stdin":
+        a.modelStdin = true;
+        break;
+      default:
+        console.log(`[WARN] 未知参数: ${arg}`);
+    }
+  }
+  return a;
+}
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (!args.app || !args.package) {
+    console.error("错误: 必须指定 --app 和 --package");
+    return 2;
+  }
+  if (!args.prompt && !args.task && !args.feature) {
+    console.error("错误: 必须指定 --feature、--task 或 --prompt 之一");
+    return 2;
+  }
+  APP_PACKAGES.set(args.app, args.package);
+  let stdinModel = null;
+  if (args.modelStdin) {
+    try {
+      stdinModel = JSON.parse(fs.readFileSync(0, "utf-8"));
+    } catch {
+    }
+  }
+  const model = loadModelConfig(args.apiKey, stdinModel);
+  if (!model.apiKey || model.apiKey === "EMPTY") {
+    if (!args.quiet) {
+      console.log("提示: 未找到可用的模型配置。请运行 `ht init` 配置统一模型，");
+      console.log("或通过 --api-key 传入 API Key。\n");
+    }
+  }
+  const deviceLabel = args.device === "adb" ? "ADB (Android)" : "HDC (HarmonyOS)";
+  console.log(`设备: ${deviceLabel}, 应用: ${args.app} (${args.package})`);
+  console.log("-".repeat(50));
+  const driver = args.device === "adb" ? new AdbDriver(args.serial) : new HdcDriver(args.serial);
+  const agent = new PhoneAgent(model, driver, args.maxSteps, !args.quiet);
+  const tasks = [];
+  if (args.prompt) {
+    tasks.push({ prompt: `打开${args.app}，${args.prompt}`, label: args.prompt });
+  } else if (args.task) {
+    const parts = args.task.split(/(L[123])/);
+    const item = {};
+    for (let j = 1; j < parts.length - 1; j += 2) {
+      const val = parts[j + 1].trim();
+      if (val) item[parts[j]] = val;
+    }
+    const { pathStr, leaf } = getFeaturePath(item);
+    if (pathStr) tasks.push({ prompt: buildNavigatePrompt(args.app, pathStr, leaf, args.appHints ?? void 0), label: pathStr });
+  } else if (args.feature) {
+    if (!args.feature.toLowerCase().endsWith(".md")) {
+      console.error("错误: --feature 仅支持 .md 功能清单，或改用 --prompt / --task。");
+      return 2;
+    }
+    let features = parseFeatureMd(args.feature);
+    if (args.offset > 1) features = features.slice(args.offset - 1);
+    if (args.limit != null) features = features.slice(0, args.limit);
+    for (const item of features) {
+      const { pathStr, leaf } = getFeaturePath(item);
+      if (pathStr) tasks.push({ prompt: buildNavigatePrompt(args.app, pathStr, leaf, args.appHints ?? void 0), label: pathStr });
+    }
+  }
+  for (let i = 0; i < tasks.length; i++) {
+    const { prompt, label } = tasks[i];
+    console.log(tasks.length > 1 ? `
+[${i + 1}/${tasks.length}] 导航: ${label}` : `导航: ${label}`);
+    let reached = false;
+    try {
+      const resultMsg = await agent.run(prompt);
+      reached = judgeReached(resultMsg);
+    } catch {
+      reached = false;
+    }
+    console.log(reached ? "到达目标页面" : "未找到目标页面");
+    if (i < tasks.length - 1) agent.reset();
+  }
+  return 0;
+}
+main().then((code) => {
+  process.exitCode = code;
+}).catch((e) => {
+  console.error(e);
+  process.exitCode = 1;
+});