android2harmony 0.1.4 → 0.1.5

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

@@ -0,0 +1,756 @@
+#!/usr/bin/env node
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { pathToFileURL } from "node:url";
+const SCROLL_DURATION_MS = 300;
+const HDC_SWIPE_SPEED = 600;
+const IDLE_POLL_INTERVAL = 0.2;
+const IDLE_TIMEOUT = 5;
+const HMOS_SKIP_TYPES = /* @__PURE__ */ new Set(["WindowScene", "__Common__", "EffectComponent", "metaballNode"]);
+const HMOS_SKIP_BUNDLES = /* @__PURE__ */ new Set([
+  "com.huawei.systemui",
+  "com.ohos.systemui",
+  "com.huawei.android.launcher"
+]);
+const HORIZONTAL_SCROLL_CLASSES = /* @__PURE__ */ new Set([
+  "android.widget.HorizontalScrollView",
+  "HorizontalScrollView"
+]);
+function sleep(seconds) {
+  const end = Date.now() + seconds * 1e3;
+  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()));
+  }
+}
+const XML_ENTITIES = {
+  amp: "&",
+  lt: "<",
+  gt: ">",
+  quot: '"',
+  apos: "'"
+};
+function decodeEntities(s) {
+  return s.replace(/&(#x?[0-9a-fA-F]+|[a-zA-Z]+);/g, (m, ent) => {
+    if (ent[0] === "#") {
+      const code = ent[1] === "x" || ent[1] === "X" ? parseInt(ent.slice(2), 16) : parseInt(ent.slice(1), 10);
+      return Number.isNaN(code) ? m : String.fromCodePoint(code);
+    }
+    return ent in XML_ENTITIES ? XML_ENTITIES[ent] : m;
+  });
+}
+class XmlParseError extends Error {
+}
+function parseXml(xml) {
+  let i = 0;
+  const n = xml.length;
+  const stack = [];
+  let root = null;
+  const readAttrs = (raw) => {
+    const attrs = {};
+    const re = /([^\s=/>]+)\s*=\s*"([^"]*)"|([^\s=/>]+)\s*=\s*'([^']*)'/g;
+    let m;
+    while ((m = re.exec(raw)) !== null) {
+      if (m[1] !== void 0) attrs[m[1]] = decodeEntities(m[2]);
+      else if (m[3] !== void 0) attrs[m[3]] = decodeEntities(m[4]);
+    }
+    return attrs;
+  };
+  while (i < n) {
+    const lt = xml.indexOf("<", i);
+    if (lt < 0) break;
+    i = lt;
+    if (xml.startsWith("<?", i)) {
+      const end = xml.indexOf("?>", i);
+      if (end < 0) throw new XmlParseError("unterminated declaration");
+      i = end + 2;
+      continue;
+    }
+    if (xml.startsWith("<!--", i)) {
+      const end = xml.indexOf("-->", i);
+      if (end < 0) throw new XmlParseError("unterminated comment");
+      i = end + 3;
+      continue;
+    }
+    if (xml.startsWith("<!", i)) {
+      const end = xml.indexOf(">", i);
+      if (end < 0) throw new XmlParseError("unterminated markup declaration");
+      i = end + 1;
+      continue;
+    }
+    let j = i + 1;
+    let quote = null;
+    for (; j < n; j++) {
+      const c = xml[j];
+      if (quote) {
+        if (c === quote) quote = null;
+      } else if (c === '"' || c === "'") {
+        quote = c;
+      } else if (c === ">") {
+        break;
+      }
+    }
+    if (j >= n) throw new XmlParseError("unterminated tag");
+    const inner = xml.slice(i + 1, j);
+    i = j + 1;
+    if (inner[0] === "/") {
+      const closed = stack.pop();
+      if (!closed) throw new XmlParseError("unexpected closing tag");
+      continue;
+    }
+    const selfClosing = inner.endsWith("/");
+    const body = selfClosing ? inner.slice(0, -1) : inner;
+    const spaceIdx = body.search(/[\s/]/);
+    const tag = spaceIdx < 0 ? body : body.slice(0, spaceIdx);
+    const attrRaw = spaceIdx < 0 ? "" : body.slice(spaceIdx);
+    const node = { tag, attrs: readAttrs(attrRaw), children: [] };
+    if (stack.length > 0) {
+      stack[stack.length - 1].children.push(node);
+    } else if (root === null) {
+      root = node;
+    }
+    if (!selfClosing) stack.push(node);
+  }
+  if (root === null) throw new XmlParseError("no root element");
+  return root;
+}
+function* iterNodes(root, tag) {
+  if (root.tag === tag) yield root;
+  for (const child of root.children) {
+    yield* iterNodes(child, tag);
+  }
+}
+function* iterAll(root) {
+  yield root;
+  for (const child of root.children) {
+    yield* iterAll(child);
+  }
+}
+function attr(node, key, dflt = "") {
+  return key in node.attrs ? node.attrs[key] : dflt;
+}
+function runCapture(file, args, opts = {}) {
+  const timeoutMs = (opts.timeout ?? 15) * 1e3;
+  const res = spawnSync(file, args, {
+    timeout: timeoutMs,
+    maxBuffer: 128 * 1024 * 1024,
+    encoding: opts.binary ? "buffer" : void 0,
+    windowsHide: true
+  });
+  if (opts.binary) {
+    const buf = res.stdout ?? Buffer.alloc(0);
+    return { stdout: "", stdoutBuf: buf, stderr: "", code: res.status };
+  }
+  const outBuf = res.stdout ?? Buffer.alloc(0);
+  const errBuf = res.stderr ?? Buffer.alloc(0);
+  return {
+    stdout: outBuf.toString("utf-8"),
+    stdoutBuf: outBuf,
+    stderr: errBuf.toString("utf-8"),
+    code: res.status
+  };
+}
+function adb(args, serial = null, timeout = 15) {
+  const full = [];
+  if (serial) full.push("-s", serial);
+  full.push(...args);
+  const res = spawnSync("adb", full, {
+    timeout: timeout * 1e3,
+    maxBuffer: 128 * 1024 * 1024,
+    windowsHide: true
+  });
+  if (res.error && res.error.code === "ETIMEDOUT") {
+    console.log(`  [WARN] adb timeout: ${args.join(" ")}`);
+    return "";
+  }
+  const out = res.stdout ?? Buffer.alloc(0);
+  return out.toString("utf-8").trim();
+}
+function adbShell(args, serial = null, timeout = 15) {
+  return adb(["shell", ...args], serial, timeout);
+}
+function adbWaitIdle(serial = null) {
+  const deadline = Date.now() + IDLE_TIMEOUT * 1e3;
+  let prevFocus = null;
+  let interval = IDLE_POLL_INTERVAL;
+  while (Date.now() < deadline) {
+    sleep(interval);
+    interval = Math.min(interval * 1.5, 0.5);
+    const focusOut = adbShell(["dumpsys", "window"], serial);
+    let currentFocus = "";
+    for (const line of focusOut.split(/\r?\n/)) {
+      if (line.includes("mCurrentFocus")) {
+        currentFocus = line.trim();
+        break;
+      }
+    }
+    if (currentFocus && currentFocus === prevFocus) return;
+    prevFocus = currentFocus;
+  }
+}
+function hdc(args, timeout = 15) {
+  const res = spawnSync("hdc", args, {
+    timeout: timeout * 1e3,
+    maxBuffer: 128 * 1024 * 1024,
+    windowsHide: true
+  });
+  if (res.error && res.error.code === "ETIMEDOUT") {
+    console.log(`  [WARN] hdc timeout: ${args.join(" ")}`);
+    return "";
+  }
+  const errBuf = res.stderr ?? Buffer.alloc(0);
+  const errStr = errBuf.toString("utf-8").trim();
+  if (res.status !== 0 && errStr) {
+    console.log(`  [WARN] hdc stderr: ${errStr}`);
+  }
+  const out = res.stdout ?? Buffer.alloc(0);
+  return out.toString("utf-8").trim();
+}
+function hdcShell(args, timeout = 15) {
+  return hdc(["shell", ...args], timeout);
+}
+function hdcWaitIdle() {
+  sleep(1);
+}
+function hdcGetDensity() {
+  let dpi = null;
+  const out = hdcShell(["hidumper", "-s", "3601", "-a", "-a"]);
+  const m = out.match(/(?:densityDpi|dpi)\D*(\d{2,4})/i);
+  if (m) {
+    const val = parseInt(m[1], 10);
+    if (val >= 100 && val <= 1e3) dpi = val;
+  }
+  if (dpi === null) {
+    const param = hdcShell(["param", "get", "persist.sys.dpi"]).trim();
+    if (/^\d+$/.test(param)) {
+      const val = parseInt(param, 10);
+      if (val >= 100 && val <= 1e3) dpi = val;
+    }
+  }
+  if (dpi === null) dpi = 480;
+  return { dpi, density_factor: Math.round(dpi / 160 * 1e4) / 1e4 };
+}
+function extractInts(s) {
+  const m = s.match(/\d+/g);
+  return m ? m.map((x) => parseInt(x, 10)) : [];
+}
+function findScrollableContainers(xmlContent) {
+  const containers = [];
+  if (!xmlContent) return containers;
+  let root;
+  try {
+    root = parseXml(xmlContent);
+  } catch {
+    return containers;
+  }
+  for (const node of iterNodes(root, "node")) {
+    if (attr(node, "scrollable") !== "true") continue;
+    const cls = attr(node, "class");
+    if (HORIZONTAL_SCROLL_CLASSES.has(cls)) continue;
+    const nums = extractInts(attr(node, "bounds"));
+    if (nums.length !== 4) continue;
+    const [x1, y1, x2, y2] = nums;
+    if (y2 - y1 < 200) continue;
+    containers.push({ bounds: [x1, y1, x2, y2], class: cls, "resource-id": attr(node, "resource-id") });
+  }
+  containers.sort(
+    (a, b) => (b.bounds[2] - b.bounds[0]) * (b.bounds[3] - b.bounds[1]) - (a.bounds[2] - a.bounds[0]) * (a.bounds[3] - a.bounds[1])
+  );
+  return containers;
+}
+function extractNodeKeys(xmlContent) {
+  const keys = /* @__PURE__ */ new Set();
+  if (!xmlContent) return keys;
+  let root;
+  try {
+    root = parseXml(xmlContent);
+  } catch {
+    return keys;
+  }
+  for (const node of iterNodes(root, "node")) {
+    keys.add(
+      [
+        attr(node, "class"),
+        attr(node, "resource-id"),
+        attr(node, "text"),
+        attr(node, "content-desc"),
+        attr(node, "bounds")
+      ].join("\0")
+    );
+  }
+  return keys;
+}
+function setsEqual(a, b) {
+  if (a.size !== b.size) return false;
+  for (const v of a) if (!b.has(v)) return false;
+  return true;
+}
+function parseBoundsCenter(bounds) {
+  const nums = extractInts(bounds);
+  if (nums.length === 4) {
+    const [x1, y1, x2, y2] = nums;
+    return [Math.trunc((x1 + x2) / 2), Math.trunc((y1 + y2) / 2)];
+  }
+  return null;
+}
+function getClickableElements(xmlContent) {
+  const elements = [];
+  if (!xmlContent) return elements;
+  let root;
+  try {
+    root = parseXml(xmlContent);
+  } catch (e) {
+    console.log(`  [WARN] XML parse error: ${e.message}`);
+    return elements;
+  }
+  const listviewChildSet = /* @__PURE__ */ new Set();
+  for (const node of iterNodes(root, "node")) {
+    const cls = attr(node, "class");
+    if (cls.includes("ListView") || cls.includes("GridView") || cls === "List") {
+      for (const child of node.children) listviewChildSet.add(child);
+    }
+  }
+  const extractText = (node) => {
+    const t = attr(node, "text");
+    if (t) return t;
+    for (const child of iterNodes(node, "node")) {
+      const ct = attr(child, "text");
+      if (ct) return ct;
+    }
+    return "";
+  };
+  for (const node of iterNodes(root, "node")) {
+    if (attr(node, "enabled") !== "true") continue;
+    const isClickable = attr(node, "clickable") === "true";
+    const isLongClickable = attr(node, "long-clickable") === "true";
+    const isListviewItem = listviewChildSet.has(node);
+    const isCheckable = attr(node, "checkable") === "true";
+    if (!(isClickable || isLongClickable || isListviewItem || isCheckable)) continue;
+    const bounds = attr(node, "bounds");
+    let text = attr(node, "text");
+    if (!text) text = extractText(node);
+    const baseInfo = {
+      class: attr(node, "class"),
+      text,
+      "resource-id": attr(node, "resource-id"),
+      "content-desc": attr(node, "content-desc"),
+      bounds,
+      center: parseBoundsCenter(bounds)
+    };
+    if (isClickable || isListviewItem || isCheckable) {
+      elements.push({ ...baseInfo, "long-clickable": false });
+    }
+    if (isLongClickable) {
+      elements.push({ ...baseInfo, "long-clickable": true });
+    }
+  }
+  return elements;
+}
+function hmosToXml(node) {
+  const attrs = node.attributes ?? {};
+  const t = String(attrs["type"] ?? "");
+  const bundle = String(attrs["bundleName"] ?? "");
+  if (HMOS_SKIP_TYPES.has(t)) return null;
+  if (HMOS_SKIP_BUNDLES.has(bundle)) return null;
+  const get = (k, d = "") => attrs[k] === void 0 || attrs[k] === null ? d : String(attrs[k]);
+  const xmlAttrs = {
+    class: t,
+    "resource-id": get("key"),
+    text: get("text"),
+    "content-desc": get("description"),
+    clickable: get("clickable", "false"),
+    "long-clickable": get("longClickable", "false"),
+    scrollable: get("scrollable", "false"),
+    enabled: get("enabled", "true"),
+    focused: get("focused", "false"),
+    bounds: get("bounds"),
+    package: bundle
+  };
+  const el = { tag: "node", attrs: xmlAttrs, children: [] };
+  for (const child of node.children ?? []) {
+    const childEl = hmosToXml(child);
+    if (childEl !== null) el.children.push(childEl);
+  }
+  return el;
+}
+function escapeXmlAttr(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function serializeXml(node) {
+  const attrStr = Object.entries(node.attrs).map(([k, v]) => ` ${k}="${escapeXmlAttr(v)}"`).join("");
+  if (node.children.length === 0) {
+    return `<${node.tag}${attrStr} />`;
+  }
+  const inner = node.children.map((c) => serializeXml(c)).join("");
+  return `<${node.tag}${attrStr}>${inner}</${node.tag}>`;
+}
+function serializeXmlIndented(node, level = 0) {
+  const pad = "  ".repeat(level);
+  const attrStr = Object.entries(node.attrs).map(([k, v]) => ` ${k}="${escapeXmlAttr(v)}"`).join("");
+  if (node.children.length === 0) {
+    return `${pad}<${node.tag}${attrStr} />`;
+  }
+  const inner = node.children.map((c) => serializeXmlIndented(c, level + 1)).join("\n");
+  return `${pad}<${node.tag}${attrStr}>
+${inner}
+${pad}</${node.tag}>`;
+}
+function adbDumpXmlQuick(serial = null) {
+  const remotePath = "/sdcard/ui_dump.xml";
+  adbShell(["rm -f /sdcard/ui_dump.xml && uiautomator dump /sdcard/ui_dump.xml"], serial, 20);
+  for (let k = 0; k < 6; k++) {
+    const check = adbShell(["ls", remotePath], serial);
+    if (check.includes(remotePath)) break;
+    sleep(0.2);
+  }
+  return adbShell(["cat", remotePath], serial, 15);
+}
+function adbDumpXml(outputDir, serial = null) {
+  const xmlContent = adbDumpXmlQuick(serial);
+  if (xmlContent) fs.writeFileSync(path.join(outputDir, "view.xml"), xmlContent, "utf-8");
+  return xmlContent;
+}
+function adbScreenshot(outputDir, filename = "screenshot.png", serial = null) {
+  const localPath = path.join(outputDir, filename);
+  const args = [];
+  if (serial) args.push("-s", serial);
+  args.push("exec-out", "screencap", "-p");
+  const { stdoutBuf, code } = runCapture("adb", args, { timeout: 15, binary: true });
+  if (code === null) {
+    console.log("  [WARN] screenshot timeout");
+    return;
+  }
+  if (stdoutBuf.length > 0) fs.writeFileSync(localPath, stdoutBuf);
+}
+function adbGetDensity(serial = null) {
+  let dpi = null;
+  const out = adbShell(["wm", "density"], serial);
+  const mOver = out.match(/Override density:\s*(\d+)/);
+  const mPhys = out.match(/Physical density:\s*(\d+)/);
+  if (mOver) {
+    dpi = parseInt(mOver[1], 10);
+  } else if (mPhys) {
+    dpi = parseInt(mPhys[1], 10);
+  }
+  if (dpi === null) {
+    const prop = adbShell(["getprop", "ro.sf.lcd_density"], serial).trim();
+    if (/^\d+$/.test(prop)) dpi = parseInt(prop, 10);
+  }
+  if (dpi === null) dpi = 480;
+  return { dpi, density_factor: Math.round(dpi / 160 * 1e4) / 1e4 };
+}
+function adbGetActivity(serial = null) {
+  const info = {};
+  const actOut = adbShell(["dumpsys", "activity", "activities"], serial);
+  const winOut = adbShell(["dumpsys", "window"], serial);
+  for (const line of actOut.split(/\r?\n/)) {
+    if (/ResumedActivity|topActivity/i.test(line)) {
+      info["resumed_activity"] = line.trim();
+      break;
+    }
+  }
+  for (const line of winOut.split(/\r?\n/)) {
+    if (line.includes("mCurrentFocus")) {
+      info["current_focus"] = line.trim();
+      break;
+    }
+    if (line.includes("mFocusedApp") && !("focused_app" in info)) {
+      info["focused_app"] = line.trim();
+    }
+  }
+  return info;
+}
+function adbScrollAndCapture(outputDir, containerBounds, maxScrolls, initialXml, serial = null) {
+  const [x1, y1, x2, y2] = containerBounds;
+  const cx = Math.trunc((x1 + x2) / 2);
+  const height = y2 - y1;
+  const swipeFromY = y1 + Math.trunc(height * 0.7);
+  const swipeToY = y1 + Math.trunc(height * 0.3);
+  const xmlList = [];
+  let prevKeys = initialXml ? extractNodeKeys(initialXml) : null;
+  let scrollCount = 0;
+  for (let i = 0; i < maxScrolls; i++) {
+    adbShell(
+      ["input", "swipe", String(cx), String(swipeFromY), String(cx), String(swipeToY), String(SCROLL_DURATION_MS)],
+      serial
+    );
+    adbWaitIdle(serial);
+    const newXml = adbDumpXmlQuick(serial);
+    const newKeys = extractNodeKeys(newXml);
+    if (prevKeys !== null && setsEqual(newKeys, prevKeys)) {
+      console.log(`  Reached bottom after ${i + 1} scroll(s)`);
+      break;
+    }
+    prevKeys = newKeys;
+    scrollCount += 1;
+    xmlList.push(newXml);
+    fs.writeFileSync(path.join(outputDir, `view_scroll_${i + 1}.xml`), newXml, "utf-8");
+    adbScreenshot(outputDir, `screenshot_scroll_${i + 1}.png`, serial);
+    console.log(`  Scroll ${i + 1}: XML + screenshot saved`);
+  }
+  if (scrollCount > 0) {
+    console.log(`  Restoring initial position: scrolling back ${scrollCount} time(s)...`);
+    for (let i = 0; i < scrollCount; i++) {
+      adbShell(
+        ["input", "swipe", String(cx), String(swipeToY), String(cx), String(swipeFromY), String(SCROLL_DURATION_MS)],
+        serial
+      );
+      adbWaitIdle(serial);
+    }
+  }
+  return xmlList;
+}
+function dedupeClickable(allXmlContents) {
+  const seen = /* @__PURE__ */ new Set();
+  const clickable = [];
+  allXmlContents.forEach((xc, idx) => {
+    for (const elem of getClickableElements(xc)) {
+      const key = [
+        elem["resource-id"],
+        elem.text,
+        elem["content-desc"],
+        elem.class,
+        elem.bounds,
+        String(elem["long-clickable"])
+      ].join("\0");
+      if (!seen.has(key)) {
+        seen.add(key);
+        elem.scroll_index = idx;
+        clickable.push(elem);
+      }
+    }
+  });
+  return clickable;
+}
+function captureAndroid(outputDir, serial = null, maxScrolls = 10) {
+  fs.mkdirSync(outputDir, { recursive: true });
+  console.log("[1/4] Dumping view XML...");
+  const xmlContent = adbDumpXml(outputDir, serial);
+  if (!xmlContent) {
+    console.log("[ERR] Failed to dump XML");
+    return;
+  }
+  console.log("[2/4] Taking screenshot...");
+  adbScreenshot(outputDir, "screenshot.png", serial);
+  console.log("[3/4] Checking scrollable containers...");
+  const containers = findScrollableContainers(xmlContent);
+  const allXmlContents = [xmlContent];
+  if (containers.length > 0) {
+    const container = containers[0];
+    console.log(`  Found scrollable: ${container.class} ${container["resource-id"]}`);
+    const scrollXmls = adbScrollAndCapture(outputDir, container.bounds, maxScrolls, xmlContent, serial);
+    allXmlContents.push(...scrollXmls);
+    console.log(`  Scroll capture done: ${scrollXmls.length} scroll(s)`);
+  } else {
+    console.log("  No scrollable container found");
+  }
+  console.log("[4/4] Building meta.json...");
+  const density = adbGetDensity(serial);
+  console.log(`  Density: ${density.dpi}dpi (${density.density_factor}x)`);
+  const activityInfo = adbGetActivity(serial);
+  const clickable = dedupeClickable(allXmlContents);
+  const meta = {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    device: "adb",
+    dpi: density.dpi,
+    density_factor: density.density_factor,
+    activity_info: activityInfo,
+    clickable_count: clickable.length,
+    clickable_elements: clickable
+  };
+  fs.writeFileSync(path.join(outputDir, "meta.json"), JSON.stringify(meta, null, 2), "utf-8");
+  console.log(`
+Done! Files saved to ${outputDir}`);
+}
+function hdcDumpLayout(outputDir) {
+  const out = hdcShell(["uitest dumpLayout"]);
+  const match = out.match(/saved to:(.+\.json)/);
+  if (!match) throw new Error(`Cannot parse dumpLayout output: ${out}`);
+  const remoteJson = match[1].trim();
+  const localJson = path.join(outputDir, "_tmp_layout.json");
+  hdc(["file", "recv", remoteJson, localJson]);
+  const data = JSON.parse(fs.readFileSync(localJson, "utf-8"));
+  let pageName = "";
+  if (data.children && data.children.length > 0) {
+    const pp = String(data.children[0].attributes?.["pagePath"] ?? "");
+    pageName = pp ? pp.split("/").pop() || "unknown" : "unknown";
+  }
+  const rootEl = hmosToXml(data);
+  const xmlPath = path.join(outputDir, "view.xml");
+  if (rootEl) {
+    const doc = `<?xml version='1.0' encoding='utf-8'?>
+${serializeXmlIndented(rootEl)}`;
+    fs.writeFileSync(xmlPath, doc, "utf-8");
+  }
+  const xmlStr = rootEl ? serializeXml(rootEl) : "";
+  fs.rmSync(localJson, { force: true });
+  return { xml: xmlStr, pageName };
+}
+function hdcDumpLayoutQuick(outputDir) {
+  const out = hdcShell(["uitest dumpLayout"]);
+  const match = out.match(/saved to:(.+\.json)/);
+  if (!match) return "";
+  const remoteJson = match[1].trim();
+  const localJson = path.join(outputDir, "_tmp_layout.json");
+  hdc(["file", "recv", remoteJson, localJson]);
+  try {
+    const data = JSON.parse(fs.readFileSync(localJson, "utf-8"));
+    const rootEl = hmosToXml(data);
+    return rootEl ? serializeXml(rootEl) : "";
+  } finally {
+    if (fs.existsSync(localJson)) fs.rmSync(localJson, { force: true });
+  }
+}
+function hdcScreenshot(outputDir, filename = "screenshot.jpeg") {
+  const remoteImg = "/data/local/tmp/screenshot.jpeg";
+  hdcShell([`snapshot_display -f ${remoteImg}`]);
+  hdc(["file", "recv", remoteImg, path.join(outputDir, filename)]);
+}
+function hdcScrollAndCapture(outputDir, containerBounds, maxScrolls, initialXml) {
+  const [x1, y1, x2, y2] = containerBounds;
+  const cx = Math.trunc((x1 + x2) / 2);
+  const height = y2 - y1;
+  const swipeFromY = y1 + Math.trunc(height * 0.7);
+  const swipeToY = y1 + Math.trunc(height * 0.3);
+  const xmlList = [];
+  let prevKeys = initialXml ? extractNodeKeys(initialXml) : null;
+  let scrollCount = 0;
+  for (let i = 0; i < maxScrolls; i++) {
+    hdcShell(["uitest", "uiInput", "swipe", String(cx), String(swipeFromY), String(cx), String(swipeToY), String(HDC_SWIPE_SPEED)]);
+    hdcWaitIdle();
+    const newXml = hdcDumpLayoutQuick(outputDir);
+    const newKeys = extractNodeKeys(newXml);
+    if (prevKeys !== null && setsEqual(newKeys, prevKeys)) {
+      console.log(`  Reached bottom after ${i + 1} scroll(s)`);
+      break;
+    }
+    prevKeys = newKeys;
+    scrollCount += 1;
+    xmlList.push(newXml);
+    fs.writeFileSync(path.join(outputDir, `view_scroll_${i + 1}.xml`), newXml, "utf-8");
+    hdcScreenshot(outputDir, `screenshot_scroll_${i + 1}.jpeg`);
+    console.log(`  Scroll ${i + 1}: XML + screenshot saved`);
+  }
+  if (scrollCount > 0) {
+    console.log(`  Restoring initial position: scrolling back ${scrollCount} time(s)...`);
+    for (let i = 0; i < scrollCount; i++) {
+      hdcShell(["uitest", "uiInput", "swipe", String(cx), String(swipeToY), String(cx), String(swipeFromY), String(HDC_SWIPE_SPEED)]);
+      hdcWaitIdle();
+    }
+  }
+  return xmlList;
+}
+function captureHdc(outputDir, maxScrolls = 10) {
+  fs.mkdirSync(outputDir, { recursive: true });
+  console.log("[1/3] Dumping layout (JSON -> XML)...");
+  const { xml: xmlContent, pageName } = hdcDumpLayout(outputDir);
+  if (!xmlContent) {
+    console.log("[ERR] Failed to dump layout");
+    return;
+  }
+  console.log(`  Page: ${pageName}`);
+  console.log("[2/3] Taking screenshot...");
+  hdcScreenshot(outputDir);
+  console.log("[3/3] Checking scrollable containers...");
+  const containers = findScrollableContainers(xmlContent);
+  if (containers.length > 0) {
+    const container = containers[0];
+    console.log(`  Found scrollable: ${container.class} ${container["resource-id"]}`);
+    const scrollXmls = hdcScrollAndCapture(outputDir, container.bounds, maxScrolls, xmlContent);
+    console.log(`  Scroll capture done: ${scrollXmls.length} scroll(s)`);
+  } else {
+    console.log("  No scrollable container found");
+  }
+  const density = hdcGetDensity();
+  console.log(`  Density: ${density.dpi}dpi (${density.density_factor}x)`);
+  const meta = {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    device: "hdc",
+    dpi: density.dpi,
+    density_factor: density.density_factor,
+    page_name: pageName
+  };
+  fs.writeFileSync(path.join(outputDir, "meta.json"), JSON.stringify(meta, null, 2), "utf-8");
+  console.log(`
+Done! Files saved to ${outputDir}`);
+}
+function parseArgs(argv) {
+  const args = { device: "hdc", outputDir: "", maxScrolls: 10, serial: null };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    const next = () => {
+      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 !== "hdc" && v !== "adb") {
+        console.error(`--device must be hdc or adb`);
+        process.exit(2);
+      }
+      args.device = v;
+    } else if (a === "--output-dir" || a === "-o") {
+      args.outputDir = next();
+    } else if (a === "--max-scrolls") {
+      args.maxScrolls = 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() {
+  console.log(
+    [
+      "Capture current page: view tree XML + screenshots (Android / HarmonyOS)",
+      "",
+      "Usage: node page_capture.ts --device <hdc|adb> -o <dir> [--max-scrolls N] [--serial S]",
+      "",
+      "  --device        Device type: hdc=HarmonyOS, adb=Android (default: hdc)",
+      "  --output-dir,-o Output directory for captured files (required)",
+      "  --max-scrolls   Max scroll count per container (default: 10)",
+      "  --serial        ADB device serial (optional, for multi-device)"
+    ].join("\n")
+  );
+}
+function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.device === "adb") {
+    captureAndroid(args.outputDir, args.serial, args.maxScrolls);
+  } else {
+    captureHdc(args.outputDir, args.maxScrolls);
+  }
+  return 0;
+}
+const isEntry = process.argv[1] !== void 0 && import.meta.url === pathToFileURL(process.argv[1]).href;
+if (isEntry) {
+  process.exit(main());
+}
+export {
+  dedupeClickable,
+  extractNodeKeys,
+  findScrollableContainers,
+  getClickableElements,
+  hmosToXml,
+  iterAll,
+  iterNodes,
+  parseBoundsCenter,
+  parseXml,
+  serializeXml,
+  serializeXmlIndented
+};