@oniroproject/oniro-app 0.6.2 → 0.8.1

package/dist/oniro-app.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/bin/oniro-app.ts
-import { Command as Command2 } from "commander";
+import { Command as Command4 } from "commander";
 import { OniroError } from "@oniroproject/core";
 
 // src/commands/sdk.ts
@@ -64,12 +64,15 @@ import * as os from "os";
 var ENV_VAR_BY_KEY = {
   sdkRootDir: "ONIRO_SDK_ROOT_DIR",
   cmdToolsPath: "ONIRO_CMD_TOOLS_PATH",
+  hdcPath: "ONIRO_HDC",
   emulatorDir: "ONIRO_EMULATOR_DIR",
   hapPath: "ONIRO_HAP_PATH",
   cmdToolsUrlLinux: "ONIRO_CMD_TOOLS_URL_LINUX",
   cmdToolsUrlWindows: "ONIRO_CMD_TOOLS_URL_WINDOWS",
   cmdToolsUrlMac: "ONIRO_CMD_TOOLS_URL_MAC",
-  emulatorUrl: "ONIRO_EMULATOR_URL"
+  emulatorUrl: "ONIRO_EMULATOR_URL",
+  sdkUrlBase: "ONIRO_SDK_URL_BASE",
+  applicationCertPath: "ONIRO_APPLICATION_CERT_PATH"
 };
 function createEnvConfig(env = process.env) {
   return {
@@ -230,25 +233,31 @@ function registerEmulatorCommand(program) {
 
 // src/commands/build.ts
 import * as path2 from "path";
-import { runHvigorw } from "@oniroproject/core";
+import { buildHap } from "@oniroproject/core";
 function registerBuildCommand(program) {
-  program.command("build [project-dir]").description("Build an OpenHarmony app via hvigorw. Defaults to the current directory.").option("--product <product>", "hvigor product name", "default").option("--module <module>", "restrict the build to a specific module").option("--mode <mode>", "hvigor build mode (e.g. release, debug)").option("--task <task>", "hvigor task to run", "assembleHap").action(async (projectDir, opts) => {
+  program.command("build [project-dir]").description("Build an OpenHarmony app via hvigorw. Defaults to the current directory.").option("--product <product>", "hvigor product name", "default").option("--module <module>", "restrict the build to a specific module").option("--mode <mode>", "hvigor build mode (e.g. release, debug)").option("--task <task>", "hvigor task to run", "assembleHap").option("--no-deps", "skip the automatic `ohpm install --all` when oh_modules/ is missing").option("--no-parallel", "build modules serially (default: parallel)").option("--json", "emit the build result (discovered HAPs, warnings) as JSON").action(async (projectDir, opts) => {
     const { config, logger } = getRuntime();
     const dir = path2.resolve(projectDir ?? process.cwd());
     logger.info(`Building project at ${dir}...`);
-    await runHvigorw({
+    const result = await buildHap({
       config,
       projectDir: dir,
       product: opts.product,
       module: opts.module,
-      buildMode: opts.mode,
+      mode: opts.mode,
       task: opts.task,
+      autoInstallDeps: opts.deps,
+      parallel: opts.parallel,
       logger,
-      // Forward output as it arrives. We don't double-print since the logger
-      // already echoes spawn output; this hook is for streaming to other UIs.
+      // The logger already echoes spawn output; this hook is for streaming to other UIs.
       onOutput: () => {
       }
     });
+    for (const w of result.warnings) logger.warn(w);
+    if (opts.json) {
+      process.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+    }
     logger.info("Build complete.");
   });
 }
@@ -260,6 +269,7 @@ import {
   APL_VALUES,
   APP_FEATURE_VALUES,
   generateSigningConfigs,
+  prepareSigning,
   getOhosBaseSdkHome
 } from "@oniroproject/core";
 function parseAclsList(value) {
@@ -288,10 +298,24 @@ function registerSignCommand(program) {
       "--acls <list>",
       "Comma-separated permission names to write into the profile's acls.allowed-acls. Required for apps that request permissions above their apl (e.g. a system_basic app requesting ohos.permission.CAPTURE_SCREEN). Example: --acls ohos.permission.REBOOT,ohos.permission.INJECT_INPUT_EVENT"
     ).argParser(parseAclsList)
-  ).action(
+  ).option("--bootstrap", "No-op if signing material is already present; otherwise generate it.").option("--store-password <pwd>", "Keystore store password (default 123456 \u2014 the SDK keystore password).").option("--key-password <pwd>", "Keystore key password (default 123456 \u2014 the SDK keystore password).").action(
     (projectDir, opts) => {
       const { config, logger } = getRuntime();
       const dir = path3.resolve(projectDir ?? process.cwd());
+      const passwords = opts.storePassword || opts.keyPassword ? { store: opts.storePassword ?? "123456", key: opts.keyPassword ?? "123456" } : void 0;
+      if (opts.bootstrap) {
+        const result = prepareSigning({
+          config,
+          projectDir: dir,
+          apl: opts.apl,
+          appFeature: opts.appFeature,
+          acls: opts.acls,
+          passwords,
+          logger
+        });
+        logger.info(result.source === "present" ? "Signing material already present." : "Signing configs generated.");
+        return;
+      }
       const sdkHome = getOhosBaseSdkHome(config);
       logger.info(`Generating signing configs in ${dir} using SDK at ${sdkHome}...`);
       generateSigningConfigs({
@@ -300,6 +324,7 @@ function registerSignCommand(program) {
         apl: opts.apl,
         appFeature: opts.appFeature,
         acls: opts.acls,
+        passwords,
         logger
       });
       logger.info("Signing configs generated.");
@@ -309,9 +334,9 @@ function registerSignCommand(program) {
 
 // src/commands/app.ts
 import * as path4 from "path";
-import { installApp, launchApp } from "@oniroproject/core";
+import { installApp, launchApp, uninstallApp, forceStop, applyChanges, getBundleName } from "@oniroproject/core";
 function registerAppCommand(program) {
-  const app = program.command("app").description("Install and launch built apps on a connected device/emulator.");
+  const app = program.command("app").description("Install, launch, and manage built apps on a connected device/emulator.");
   app.command("install [project-dir]").description("Install the signed .hap on the connected device/emulator via hdc.").option("--hap <path>", "Override the .hap path (relative to project-dir or absolute).").action(async (projectDir, opts) => {
     const { config, logger } = getRuntime();
     const dir = path4.resolve(projectDir ?? process.cwd());
@@ -319,13 +344,57 @@ function registerAppCommand(program) {
     await installApp({ config, projectDir: dir, hapPath: opts.hap, logger });
     logger.info("App installed.");
   });
-  app.command("launch [project-dir]").description("Launch the app on the connected device/emulator via hdc.").option("--module <module>", "Module folder name", "entry").action(async (projectDir, opts) => {
+  app.command("launch [project-dir]").description(
+    "Launch an app on the connected device/emulator. Project mode (default): resolves bundle + main ability from the project. Bundle mode (--bundle): launch an already-installed app by bundle name, no project needed."
+  ).option("--bundle <bundle>", "Launch an already-installed app by bundle name (no project needed).").option("--module <module>", "Module folder name (project mode).", "entry").option("--ability <name>", "Explicit ability to launch (defaults to the module mainElement in project mode, or the installed bundle main ability in --bundle mode).").option("--device <serial>", "Target device serial.").action(async (projectDir, opts) => {
     const { config, logger } = getRuntime();
-    const dir = path4.resolve(projectDir ?? process.cwd());
-    logger.info(`Launching app from ${dir}...`);
-    await launchApp({ config, projectDir: dir, moduleName: opts.module, logger });
+    if (opts.bundle) {
+      logger.info(`Launching installed bundle ${opts.bundle}...`);
+      await launchApp({ config, bundleName: opts.bundle, abilityName: opts.ability, deviceSerial: opts.device, logger });
+    } else {
+      const dir = path4.resolve(projectDir ?? process.cwd());
+      logger.info(`Launching app from ${dir}...`);
+      await launchApp({ config, projectDir: dir, moduleName: opts.module, abilityName: opts.ability, deviceSerial: opts.device, logger });
+    }
     logger.info("App launched.");
   });
+  app.command("apply [project-dir]").description(
+    "Install a HAP and verify the running process took the change. Handles sign-info mismatch, asset-cache invalidation, and persistent-bundle restart."
+  ).option("--bundle <bundle>", "Bundle name to apply changes to. Defaults to the bundleName in the project AppScope/app.json5.").option("--module <module>", "Module to resolve the HAP from (multi-module projects).").option("--hap <path>", "Explicit .hap path (relative to project-dir or absolute).").option("--installed-hap <path>", "Local path to the currently-installed HAP, to enable the asset-cache reboot.").option("--system", "Treat as a persistent/system bundle (refuses uninstall on sign-info mismatch).").option("--allow-uninstall", "Permit uninstalling a system bundle on sign-info mismatch (dangerous).").option("--device <serial>", "Target device serial.").option("--json", "Emit the result as JSON.").action(async (projectDir, opts) => {
+    const { config, logger } = getRuntime();
+    const dir = path4.resolve(projectDir ?? process.cwd());
+    const bundle = opts.bundle ?? getBundleName(dir);
+    const result = await applyChanges({
+      config,
+      bundle,
+      hapPath: opts.hap,
+      projectDir: dir,
+      module: opts.module,
+      installedHapPath: opts.installedHap,
+      isSystemBundle: opts.system,
+      allowUninstall: opts.allowUninstall,
+      deviceSerial: opts.device,
+      logger
+    });
+    if (opts.json) {
+      process.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+    } else {
+      logger.info(
+        `apply: method=${result.method} pid ${result.preInstallPid ?? "-"} -> ${result.postInstallPid ?? "-"}${result.cacheCleared ? " (cache cleared)" : ""}`
+      );
+    }
+  });
+  app.command("uninstall <bundle>").description("Uninstall an app by bundle name.").option("--device <serial>", "Target device serial.").action(async (bundle, opts) => {
+    const { config, logger } = getRuntime();
+    await uninstallApp({ config, bundle, deviceSerial: opts.device, logger });
+    logger.info(`Uninstalled ${bundle}.`);
+  });
+  app.command("stop <bundle>").description("Force-stop an app by bundle name.").option("--device <serial>", "Target device serial.").action(async (bundle, opts) => {
+    const { config, logger } = getRuntime();
+    await forceStop({ config, bundle, deviceSerial: opts.device, logger });
+    logger.info(`Stopped ${bundle}.`);
+  });
 }
 
 // src/commands/create.ts
@@ -410,10 +479,414 @@ function registerTemplatesCommand(program) {
   });
 }
 
+// src/commands/reboot.ts
+import { Option as Option2 } from "commander";
+import { reboot } from "@oniroproject/core";
+function registerRebootCommand(program) {
+  program.command("reboot").description("Reboot the connected device/emulator.").addOption(
+    new Option2("--mode <mode>", "Reboot target.").choices(["system", "bootloader", "recovery"]).default("system")
+  ).option("--wait-bundle <bundle>", "After a system reboot, wait until this bundle is running again.").option("--timeout <ms>", "Max time to wait for the bundle, ms.", "180000").option("--device <serial>", "Target device serial.").action(
+    async (opts) => {
+      const { config, logger } = getRuntime();
+      logger.info(`Rebooting device (${opts.mode})...`);
+      await reboot({
+        config,
+        mode: opts.mode,
+        waitForBundle: opts.waitBundle,
+        timeoutMs: Number(opts.timeout),
+        deviceSerial: opts.device,
+        logger
+      });
+      logger.info("Reboot complete.");
+    }
+  );
+}
+
+// src/commands/wait.ts
+import { waitForLog, waitForBoot, waitForBundle } from "@oniroproject/core";
+function registerWaitCommand(program) {
+  program.command("wait").description("Wait for a device condition: a log line (--log), boot (--boot), or a bundle to start (--bundle).").option("--log <pattern>", "Resolve when a hilog line (tag: message) matches this regex.").option("--boot", "Resolve when the device is reachable (optionally also --pid-of).").option("--bundle <bundle>", "With --log: filter to this bundle. Alone: wait until this bundle is running.").option("--pid-of <name>", "With --boot: also require this process to have a pid.").option("--domain <domain>", "With --log: hilog domain filter (e.g. 0xD003900).").option("--timeout <ms>", "Max wait, ms.", "30000").option("--device <serial>", "Target device serial.").option("--json", "With --log: emit the matched entry as JSON.").action(async (opts) => {
+    const { config, logger } = getRuntime();
+    const timeoutMs = Number(opts.timeout);
+    if (opts.log) {
+      const entry = await waitForLog({
+        config,
+        pattern: new RegExp(opts.log),
+        timeoutMs,
+        bundle: opts.bundle,
+        domain: opts.domain,
+        deviceSerial: opts.device,
+        logger
+      });
+      if (opts.json) process.stdout.write(`${JSON.stringify(entry, null, 2)}
+`);
+      else logger.info(`matched: ${entry.tag}: ${entry.message}`);
+      return;
+    }
+    if (opts.boot) {
+      await waitForBoot({ config, untilPidOf: opts.pidOf, timeoutMs, deviceSerial: opts.device, logger });
+      logger.info("Device booted.");
+      return;
+    }
+    if (opts.bundle) {
+      await waitForBundle({ config, bundle: opts.bundle, timeoutMs, deviceSerial: opts.device, logger });
+      logger.info(`Bundle ${opts.bundle} is running.`);
+      return;
+    }
+    throw new Error("Specify one of --log <pattern>, --boot, or --bundle <bundle>.");
+  });
+}
+
+// src/commands/watch.ts
+import { watchLog } from "@oniroproject/core";
+function registerWatchCommand(program) {
+  program.command("watch").description("Collect hilog lines matching a pattern for a fixed duration.").option("--log <pattern>", "Regex tested against each line (tag: message).").option("--for <ms>", "Duration to watch, ms.", "10000").option("--bundle <bundle>", "Filter to this bundle.").option("--domain <domain>", "hilog domain filter (e.g. 0xD003900).").option("--no-dedup", "Do not collapse consecutive duplicate lines.").option("--device <serial>", "Target device serial.").option("--json", "Emit the entries as JSON.").action(async (opts) => {
+    const { config, logger } = getRuntime();
+    if (!opts.log) throw new Error("watch requires --log <pattern>.");
+    const entries = await watchLog({
+      config,
+      pattern: new RegExp(opts.log),
+      durationMs: Number(opts.for),
+      bundle: opts.bundle,
+      domain: opts.domain,
+      dedup: opts.dedup,
+      deviceSerial: opts.device,
+      logger
+    });
+    if (opts.json) {
+      process.stdout.write(`${JSON.stringify(entries, null, 2)}
+`);
+    } else {
+      for (const e of entries) process.stdout.write(`${e.time}  ${e.level}  ${e.tag}: ${e.message}
+`);
+    }
+  });
+}
+
+// src/commands/screenshot.ts
+import * as fs3 from "fs";
+import * as path7 from "path";
+import { takeScreenshot, captureBurst } from "@oniroproject/core";
+
+// src/lib/screenshotImage.ts
+import sharp from "sharp";
+function buildGridSvg(width, height) {
+  const lineColor = "rgba(255,80,80,0.55)";
+  const labelBg = "rgba(0,0,0,0.7)";
+  const labelFg = "#fff";
+  const fontSize = Math.max(10, Math.round(Math.min(width, height) / 60));
+  const padding = Math.round(fontSize * 0.4);
+  const labels = [];
+  const lines = [];
+  for (let i = 0; i <= 10; i++) {
+    const f = i / 10;
+    const x = Math.round(f * (width - 1));
+    const y = Math.round(f * (height - 1));
+    if (i > 0 && i < 10) {
+      lines.push(`<line x1="${x}" y1="0" x2="${x}" y2="${height}" stroke="${lineColor}" stroke-width="1"/>`);
+      lines.push(`<line x1="0" y1="${y}" x2="${width}" y2="${y}" stroke="${lineColor}" stroke-width="1"/>`);
+    }
+    const tag = f.toFixed(1);
+    const tx = i === 0 ? padding : i === 10 ? width - padding : x;
+    const anchorX = i === 0 ? "start" : i === 10 ? "end" : "middle";
+    labels.push(
+      `<text x="${tx}" y="${fontSize + padding}" font-family="monospace" font-size="${fontSize}" font-weight="bold" fill="${labelFg}" stroke="${labelBg}" stroke-width="3" paint-order="stroke" text-anchor="${anchorX}">${tag}</text>`
+    );
+    const ty = i === 0 ? fontSize + padding : i === 10 ? height - padding : y + fontSize / 3;
+    labels.push(
+      `<text x="${padding}" y="${ty}" font-family="monospace" font-size="${fontSize}" font-weight="bold" fill="${labelFg}" stroke="${labelBg}" stroke-width="3" paint-order="stroke" text-anchor="start">${tag}</text>`
+    );
+  }
+  labels.push(
+    `<text x="${width / 2}" y="${fontSize * 2.4 + padding}" font-family="monospace" font-size="${fontSize}" font-weight="bold" fill="${labelFg}" stroke="${labelBg}" stroke-width="3" paint-order="stroke" text-anchor="middle">X \u2192</text>`
+  );
+  labels.push(
+    `<text x="${padding}" y="${fontSize * 2.6 + padding}" font-family="monospace" font-size="${fontSize}" font-weight="bold" fill="${labelFg}" stroke="${labelBg}" stroke-width="3" paint-order="stroke" text-anchor="start">Y \u2193</text>`
+  );
+  return `<svg width="${width}" height="${height}" xmlns="http://www.w3.org/2000/svg">${lines.join("")}${labels.join("")}</svg>`;
+}
+async function renderWithGrid(jpeg, opts) {
+  const meta = await sharp(jpeg).metadata();
+  const originalWidth = meta.width ?? 0;
+  const originalHeight = meta.height ?? 0;
+  const longest = Math.max(originalWidth, originalHeight) || 1;
+  const scale = Math.min(1, opts.maxDim / longest);
+  const width = Math.max(1, Math.round(originalWidth * scale));
+  const height = Math.max(1, Math.round(originalHeight * scale));
+  const resized = await sharp(jpeg).resize(width, height).jpeg({ quality: 80 }).toBuffer();
+  if (!opts.grid) {
+    return { buf: resized, width, height, originalWidth, originalHeight };
+  }
+  const svg = buildGridSvg(width, height);
+  const buf = await sharp(resized).composite([{ input: Buffer.from(svg) }]).jpeg({ quality: 80 }).toBuffer();
+  return { buf, width, height, originalWidth, originalHeight };
+}
+function buildTileLabelSvg(width, height, idx, diff) {
+  const fontSize = Math.max(12, Math.round(Math.min(width, height) / 16));
+  const pad = Math.round(fontSize * 0.4);
+  let label = `#${idx}`;
+  if (typeof diff === "number") label += `  \u0394${diff.toFixed(2)}`;
+  const boxW = Math.round(label.length * fontSize * 0.62) + pad * 2;
+  const boxH = fontSize + pad * 2;
+  return `<svg width="${width}" height="${height}" xmlns="http://www.w3.org/2000/svg"><rect x="0" y="0" width="${boxW}" height="${boxH}" fill="rgba(0,0,0,0.6)"/><text x="${pad}" y="${fontSize + pad - 1}" font-family="monospace" font-size="${fontSize}" font-weight="bold" fill="#fff" stroke="rgba(0,0,0,0.85)" stroke-width="3" paint-order="stroke" text-anchor="start">${label}</text></svg>`;
+}
+async function buildContactSheet(frames, opts) {
+  if (frames.length === 0) throw new Error("buildContactSheet: no frames");
+  const count = frames.length;
+  const cols = Math.max(1, opts.cols ?? Math.ceil(Math.sqrt(count)));
+  const rows = Math.ceil(count / cols);
+  const gap = opts.gap ?? 8;
+  const meta0 = await sharp(frames[0]).metadata();
+  const fw = meta0.width ?? 1;
+  const fh = meta0.height ?? 1;
+  const longest = Math.max(fw, fh) || 1;
+  const tileScale = Math.min(1, opts.maxDim / cols / longest);
+  const tileWidth = Math.max(1, Math.round(fw * tileScale));
+  const tileHeight = Math.max(1, Math.round(fh * tileScale));
+  const tiles = await Promise.all(
+    frames.map((frame, i) => {
+      const label = Buffer.from(buildTileLabelSvg(tileWidth, tileHeight, i, opts.diffs?.[i]));
+      return sharp(frame).resize(tileWidth, tileHeight, { fit: "fill" }).composite([{ input: label, top: 0, left: 0 }]).png().toBuffer();
+    })
+  );
+  const width = cols * tileWidth + (cols + 1) * gap;
+  const height = rows * tileHeight + (rows + 1) * gap;
+  const placements = tiles.map((input, i) => {
+    const r = Math.floor(i / cols);
+    const c = i % cols;
+    return { input, left: gap + c * (tileWidth + gap), top: gap + r * (tileHeight + gap) };
+  });
+  const buf = await sharp({
+    create: { width, height, channels: 3, background: { r: 20, g: 20, b: 20 } }
+  }).composite(placements).jpeg({ quality: 80 }).toBuffer();
+  return { buf, width, height, cols, rows, tileWidth, tileHeight, count };
+}
+async function frameDiffs(frames, opts = {}) {
+  if (frames.length === 0) return [];
+  const sample = opts.sample ?? 32;
+  const thumbs = await Promise.all(
+    frames.map((f) => sharp(f).greyscale().resize(sample, sample, { fit: "fill" }).raw().toBuffer())
+  );
+  const out = [0];
+  for (let i = 1; i < thumbs.length; i++) {
+    const a = thumbs[i - 1];
+    const b = thumbs[i];
+    if (!a || !b) {
+      out.push(0);
+      continue;
+    }
+    const n = Math.min(a.length, b.length) || 1;
+    let s = 0;
+    for (let k = 0; k < n; k++) s += Math.abs((a[k] ?? 0) - (b[k] ?? 0));
+    out.push(+(s / n / 255).toFixed(4));
+  }
+  return out;
+}
+
+// src/commands/screenshot.ts
+var DEFAULT_CONTACT_SHEET_FRAMES = 8;
+function clampMaxDim(raw) {
+  const n = Number(raw);
+  if (!Number.isFinite(n)) return 1024;
+  return Math.max(256, Math.min(4096, Math.round(n)));
+}
+function registerScreenshotCommand(program) {
+  program.command("screenshot").description(
+    "Capture the screen. Default: full-resolution raw JPEG. --grid: downscaled JPEG with a 10x10 grid (axes 0.0-1.0) for picking tap coordinates. --contact-sheet: capture a burst and tile it into one image with per-frame change diffs."
+  ).option("-o, --output <file>", "Output file path.", "screenshot.jpeg").option("--grid", "Downscale (to --max-dim) and overlay a 10x10 coordinate grid.").option("--max-dim <px>", "Longest-side cap for --grid / --contact-sheet (256-4096).", "1024").option("--contact-sheet", "Capture a burst and composite it into one tiled contact sheet.").option("--burst <count>", "Capture N frames; writes <base>-<i><ext> (or feeds --contact-sheet).").option("--interval <ms>", "Delay between burst frames, ms.", "50").option("--json", "Emit the full result object as JSON on stdout (with --contact-sheet).").option("--device <serial>", "Target device serial.").action(async (opts, command) => {
+    const { config, logger } = getRuntime();
+    const maxDim = clampMaxDim(opts.maxDim);
+    const intervalMs = Number(opts.interval) || 50;
+    if (opts.contactSheet) {
+      const count = opts.burst ? Math.max(1, Number(opts.burst)) : DEFAULT_CONTACT_SHEET_FRAMES;
+      const frames = await captureBurst({ config, count, intervalMs, deviceSerial: opts.device, logger });
+      const diffs = await frameDiffs(frames);
+      const sheet = await buildContactSheet(frames, { maxDim, diffs });
+      fs3.writeFileSync(opts.output, sheet.buf);
+      if (opts.burst) {
+        const ext = path7.extname(opts.output) || ".jpeg";
+        const base = opts.output.slice(0, opts.output.length - ext.length);
+        frames.forEach((frame, i) => fs3.writeFileSync(`${base}-${i}${ext}`, frame));
+      }
+      const perFrame = frames.map((_, i) => ({ idx: i, t_ms: i * intervalMs, diffVsPrev: diffs[i] ?? 0 }));
+      if (opts.json) {
+        process.stdout.write(
+          `${JSON.stringify(
+            {
+              sheet: opts.output,
+              frameCount: frames.length,
+              cols: sheet.cols,
+              rows: sheet.rows,
+              intervalMs,
+              note: "t_ms is nominal (idx*interval); diffVsPrev is 0..1 mean greyscale diff vs the previous frame.",
+              frames: perFrame
+            },
+            null,
+            2
+          )}
+`
+        );
+      } else {
+        process.stdout.write(`${JSON.stringify(perFrame)}
+`);
+      }
+      let peak = 0;
+      for (let i = 1; i < diffs.length; i++) if ((diffs[i] ?? 0) > (diffs[peak] ?? 0)) peak = i;
+      logger.info(
+        `Wrote contact sheet ${opts.output} (${sheet.cols}x${sheet.rows}, ${frames.length} frames). Biggest change at frame ${peak} (\u0394${(diffs[peak] ?? 0).toFixed(2)}).`
+      );
+      return;
+    }
+    if (opts.burst) {
+      const frames = await captureBurst({
+        config,
+        count: Number(opts.burst),
+        intervalMs,
+        deviceSerial: opts.device,
+        logger
+      });
+      const ext = path7.extname(opts.output) || ".jpeg";
+      const base = opts.output.slice(0, opts.output.length - ext.length);
+      frames.forEach((frame, i) => fs3.writeFileSync(`${base}-${i}${ext}`, frame));
+      logger.info(`Wrote ${frames.length} frames to ${base}-<0..${frames.length - 1}>${ext}.`);
+      return;
+    }
+    const shot = await takeScreenshot({ config, deviceSerial: opts.device, logger });
+    const maxDimProvided = command.getOptionValueSource("maxDim") === "cli";
+    if (opts.grid || maxDimProvided) {
+      const rendered = await renderWithGrid(shot.pixels, { maxDim, grid: !!opts.grid });
+      fs3.writeFileSync(opts.output, rendered.buf);
+      logger.info(
+        `Wrote ${opts.output} (${rendered.width}x${rendered.height} from ${rendered.originalWidth}x${rendered.originalHeight}${opts.grid ? ", 10x10 grid" : ""}).`
+      );
+      return;
+    }
+    fs3.writeFileSync(opts.output, shot.pixels);
+    logger.info(`Wrote ${opts.output} (${shot.width}x${shot.height}).`);
+  });
+}
+
+// src/commands/dump.ts
+import { dumpLayout } from "@oniroproject/core";
+function registerDumpCommand(program) {
+  program.command("dump [target]").description("Dump device state as JSON. Currently supports `dump layout` (the default target).").option("--bundle <bundle>", "Filter the layout to a single window/bundle.").option("--raw", "Return the unpruned layout tree.").option("--device <serial>", "Target device serial.").action(async (target, opts) => {
+    const { config, logger } = getRuntime();
+    const what = target ?? "layout";
+    if (what !== "layout") throw new Error(`Unknown dump target "${what}". Supported: layout.`);
+    const result = await dumpLayout({
+      config,
+      bundleName: opts.bundle,
+      prune: !opts.raw,
+      deviceSerial: opts.device,
+      logger
+    });
+    process.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+  });
+}
+
+// src/commands/devices.ts
+import { listDevices } from "@oniroproject/core";
+function registerDevicesCommand(program) {
+  program.command("devices").description("List connected hdc devices.").option("--json", "Emit machine-readable JSON.").action(async (opts) => {
+    const { config } = getRuntime();
+    const devices = await listDevices(config);
+    if (opts.json) {
+      process.stdout.write(`${JSON.stringify(devices, null, 2)}
+`);
+      return;
+    }
+    if (devices.length === 0) {
+      process.stdout.write("(no devices)\n");
+      return;
+    }
+    for (const d of devices) {
+      process.stdout.write(`${d.serial}	${d.connection ?? ""}	${d.status}
+`);
+    }
+  });
+}
+
+// src/commands/file.ts
+import { sendFile, recvFile } from "@oniroproject/core";
+function registerFileCommand(program) {
+  const file = program.command("file").description("Transfer files to/from the device (hdc file send/recv).");
+  file.command("send <local> <remote>").description("Push a local file to the device.").option("--device <serial>", "Target device serial.").action(async (local, remote, opts) => {
+    const { config, logger } = getRuntime();
+    await sendFile({ config, local, remote, deviceSerial: opts.device, logger });
+    logger.info(`Sent ${local} -> ${remote}.`);
+  });
+  file.command("recv <remote> <local>").description("Pull a file from the device.").option("--device <serial>", "Target device serial.").action(async (remote, local, opts) => {
+    const { config, logger } = getRuntime();
+    await recvFile({ config, remote, local, deviceSerial: opts.device, logger });
+    logger.info(`Received ${remote} -> ${local}.`);
+  });
+}
+
+// src/commands/lint.ts
+import * as path8 from "path";
+import { runCodelinter } from "@oniroproject/core";
+function registerLintCommand(program) {
+  program.command("lint [project-dir]").description("Run the OpenHarmony codelinter on a project. Defaults to the current directory.").option("--files <globs...>", "Specific files/globs to lint (default: the whole project).").option("--json", "Emit findings as JSON.").action(async (projectDir, opts) => {
+    const { config, logger } = getRuntime();
+    const dir = path8.resolve(projectDir ?? process.cwd());
+    const result = await runCodelinter({ config, projectDir: dir, files: opts.files, logger });
+    if (opts.json) {
+      process.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+    } else {
+      for (const f of result.findings) {
+        process.stdout.write(`${f.file}:${f.line} ${f.severity} ${f.message}${f.code ? ` [${f.code}]` : ""}
+`);
+      }
+      if (result.findings.length === 0) process.stdout.write("No findings.\n");
+    }
+    if (result.code !== 0) process.exitCode = result.code;
+  });
+}
+
+// src/commands/input.ts
+import { Option as Option3 } from "commander";
+import { sendInput, sendGesture } from "@oniroproject/core";
+var INPUT_TYPES = ["click", "doubleClick", "longClick", "swipe", "drag", "fling", "keyEvent", "inputText"];
+var num = (v) => v === void 0 ? void 0 : Number(v);
+function registerInputCommand(program) {
+  program.command("input").description("Inject a UI input event (pixel coordinates) via uitest uiInput.").addOption(new Option3("--type <type>", "Input type.").choices(INPUT_TYPES).makeOptionMandatory()).option("--x <px>", "X pixel (click/swipe start).").option("--y <px>", "Y pixel (click/swipe start).").option("--x2 <px>", "End X pixel (swipe/drag/fling).").option("--y2 <px>", "End Y pixel (swipe/drag/fling).").option("--speed <px-per-s>", "Velocity for swipe/drag/fling.").option("--key <key>", "Key id or symbolic name (Back/Home/Power) for keyEvent.").option("--text <text>", "Text for inputText.").option("--device <serial>", "Target device serial.").action(async (opts) => {
+    const { config, logger } = getRuntime();
+    await sendInput({
+      config,
+      type: opts.type,
+      pxX: num(opts.x),
+      pxY: num(opts.y),
+      pxX2: num(opts.x2),
+      pxY2: num(opts.y2),
+      speed: num(opts.speed),
+      key: opts.key,
+      text: opts.text,
+      deviceSerial: opts.device,
+      logger
+    });
+    logger.info(`Sent ${opts.type}.`);
+  });
+  program.command("gesture").description('Inject a multi-waypoint gesture. Waypoints are pixel JSON: [{"x":..,"y":..,"t":..}].').requiredOption("--waypoints <json>", "JSON array of {x,y,t} pixel waypoints (t = ms from start).").option("--hold-start <ms>", "Leading press-hold before moving (best-effort: uses `uitest drag`).").option("--hold-end <ms>", "Trailing hold before lifting (no uitest equivalent; ignored).").option("--device <serial>", "Target device serial.").action(async (opts) => {
+    const { config, logger } = getRuntime();
+    const waypoints = JSON.parse(opts.waypoints);
+    await sendGesture({
+      config,
+      waypoints,
+      holdStartMs: num(opts.holdStart),
+      holdEndMs: num(opts.holdEnd),
+      deviceSerial: opts.device,
+      logger
+    });
+    logger.info("Gesture sent.");
+  });
+}
+
 // src/bin/oniro-app.ts
-var CLI_VERSION = "0.6.2";
+var CLI_VERSION = "0.8.1";
 function buildProgram() {
-  const program = new Command2().name("oniro-app").description(
+  const program = new Command4().name("oniro-app").description(
     "Cross-platform CLI for Oniro/OpenHarmony app development.\n\nDesigned for non-interactive use (CI, scripts, agents): every command\ntakes explicit flags, results go to stdout, progress/logs go to stderr,\nand a non-zero exit code indicates failure."
   ).version(CLI_VERSION).showHelpAfterError();
   registerSdkCommand(program);
@@ -424,6 +897,15 @@ function buildProgram() {
   registerAppCommand(program);
   registerCreateCommand(program);
   registerTemplatesCommand(program);
+  registerRebootCommand(program);
+  registerWaitCommand(program);
+  registerWatchCommand(program);
+  registerScreenshotCommand(program);
+  registerDumpCommand(program);
+  registerDevicesCommand(program);
+  registerFileCommand(program);
+  registerLintCommand(program);
+  registerInputCommand(program);
   return program;
 }
 async function main() {