@oniroproject/oniro-app 0.13.0 → 0.15.0

package/dist/oniro-app.js

@@ -175,7 +175,9 @@ function registerCmdToolsCommand(program) {
     await installCmdTools({ config, progress, logger, localZipPath: opts.fromZip, tmpDir: opts.tmpDir });
     logger.info("Command-line tools installed.");
   });
-  cmdtools.command("status").description("Report whether the command-line tools are installed and their version.").option("--json", "Emit machine-readable JSON.").action((opts) => {
+  cmdtools.command("status").description(
+    "Report whether the command-line tools are installed, their version and flavour (HarmonyOS or OpenHarmony), and the hdc binary every device command uses."
+  ).option("--json", "Emit machine-readable JSON.").action((opts) => {
     const { config } = getRuntime();
     const status = getCmdToolsStatus(config);
     if (opts.json) {
@@ -184,6 +186,12 @@ function registerCmdToolsCommand(program) {
       return;
     }
     process.stdout.write(`${status.status}
+`);
+    process.stdout.write(`path:    ${status.path}
+`);
+    if (status.flavour) process.stdout.write(`flavour: ${status.flavour}
+`);
+    process.stdout.write(`hdc:     ${status.hdc.path}${status.hdc.exists ? "" : " (missing)"}
 `);
     if (!status.installed) process.exit(1);
   });
@@ -197,6 +205,7 @@ function registerCmdToolsCommand(program) {
 // src/commands/emulator.ts
 import {
   attemptHdcConnection,
+  getEmulatorStatus,
   installEmulator,
   isEmulatorInstalled,
   removeEmulator,
@@ -230,6 +239,24 @@ function registerEmulatorCommand(program) {
     });
     logger.info("Emulator start command complete.");
   });
+  emu.command("status").description(
+    "Report whether the Oniro emulator is installed, running, and connected to hdc, without starting it. Exits 1 when it is not installed."
+  ).option("--address <addr>", "hdc address the emulator listens on", "127.0.0.1:55555").option("--json", "Emit machine-readable JSON.").action(async (opts) => {
+    const { config, logger } = getRuntime();
+    const status = await getEmulatorStatus(config, { address: opts.address, logger });
+    if (opts.json) {
+      process.stdout.write(`${JSON.stringify(status, null, 2)}
+`);
+    } else {
+      process.stdout.write(
+        `installed: ${status.installed ? "yes" : "no"} (${status.dir})
+running:   ${status.running ? "yes" : "no"}
+connected: ${status.connected ? "yes" : "no"} (${status.address})
+`
+      );
+    }
+    if (!status.installed) process.exitCode = 1;
+  });
   emu.command("stop").description("Kill running emulator processes.").action(async () => {
     const { logger } = getRuntime();
     await stopEmulator(logger);
@@ -253,15 +280,15 @@ function registerEmulatorCommand(program) {
 
 // src/commands/build.ts
 import * as path2 from "path";
-import { buildHap } from "@oniroproject/core";
+import { SdkNotInstalledError, buildHap, downloadAndInstallSdk as downloadAndInstallSdk2 } from "@oniroproject/core";
 function registerBuildCommand(program) {
   program.command("build [project-dir]").description(
-    'Build an OpenHarmony or HarmonyOS app via hvigorw. Defaults to the current directory. Projects declaring runtimeOS "HarmonyOS" build against the HarmonyOS SDK (ONIRO_HARMONYOS_SDK_PATH or an installed DevEco Studio).'
-  ).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();
+    'Build an OpenHarmony or HarmonyOS app via hvigorw. Defaults to the current directory. Projects declaring runtimeOS "HarmonyOS" build against the HarmonyOS SDK (ONIRO_HARMONYOS_SDK_PATH or an installed DevEco Studio). An OpenHarmony project fails early, naming the release to install, when the SDK for its compileSdkVersion is missing.'
+  ).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("--install-sdk", "install the OpenHarmony SDK the project compiles against when it is missing, then build").option("--json", "emit the build result (discovered HAPs, warnings) as JSON").action(async (projectDir, opts) => {
+    const { config, logger, progress } = getRuntime();
     const dir = path2.resolve(projectDir ?? process.cwd());
     logger.info(`Building project at ${dir}...`);
-    const result = await buildHap({
+    const build = () => buildHap({
       config,
       projectDir: dir,
       product: opts.product,
@@ -275,6 +302,15 @@ function registerBuildCommand(program) {
       onOutput: () => {
       }
     });
+    let result;
+    try {
+      result = await build();
+    } catch (err) {
+      if (!(err instanceof SdkNotInstalledError && err.version && opts.installSdk)) throw err;
+      logger.info(`Installing OpenHarmony SDK ${err.version} (api ${err.api}), which the project compiles against...`);
+      await downloadAndInstallSdk2({ config, version: err.version, api: err.api, progress, logger });
+      result = await build();
+    }
     for (const w of result.warnings) logger.warn(w);
     if (opts.json) {
       process.stdout.write(`${JSON.stringify(result, null, 2)}
@@ -326,6 +362,11 @@ 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)
+  ).addOption(
+    new Option(
+      "--app-privilege-capabilities <list>",
+      `Comma-separated privileges to write into the profile's app-privilege-capabilities. An app that declares a privileged extension ability (e.g. an AccessibilityExtensionAbility) needs AllowAppUsePrivilegeExtension, else install fails with 9568344 "not allow use privilege extension". Others include AllowAppMultiProcess and AllowAppDesktopIconHide.`
+    ).argParser(parseAclsList)
   ).option(
     "--harmonyos",
     "Sign a HarmonyOS project through AppGallery Connect. Needs `oniro-app auth login`, and a connected device unless the team already has devices registered."
@@ -359,6 +400,7 @@ function registerSignCommand(program) {
           apl: opts.apl,
           appFeature: opts.appFeature,
           acls: opts.acls,
+          appPrivilegeCapabilities: opts.appPrivilegeCapabilities,
           passwords,
           logger
         });
@@ -373,6 +415,7 @@ function registerSignCommand(program) {
         apl: opts.apl,
         appFeature: opts.appFeature,
         acls: opts.acls,
+        appPrivilegeCapabilities: opts.appPrivilegeCapabilities,
         passwords,
         logger
       });
@@ -448,12 +491,16 @@ import * as path4 from "path";
 import { installApp, launchApp, uninstallApp, forceStop, applyChanges, getBundleName } from "@oniroproject/core";
 function registerAppCommand(program) {
   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).").option("--device <serial>", "Target device serial.").action(async (projectDir, opts) => {
+  app.command("install [project-dir-or-hap]").description(
+    "Install a built .hap on the connected device/emulator via hdc. Takes a project dir (default: the current one), whose newest signed HAP is installed, else its unsigned one, or a .hap file. Fails when the bundle manager rejects the HAP, and says how to sign when a target refuses an unsigned one."
+  ).option("--hap <path>", "Override the .hap path (relative to project-dir or absolute).").option("--device <serial>", "Target device serial.").action(async (target, opts) => {
     const { config, logger } = getRuntime();
-    const dir = path4.resolve(projectDir ?? process.cwd());
-    logger.info(`Installing app from ${dir}...`);
-    await installApp({ config, projectDir: dir, hapPath: opts.hap, deviceSerial: opts.device, logger });
-    logger.info("App installed.");
+    const isHap = target !== void 0 && /\.hap$/i.test(target);
+    const dir = isHap ? process.cwd() : path4.resolve(target ?? process.cwd());
+    const hapPath = isHap ? path4.resolve(target) : opts.hap;
+    logger.info(`Installing ${hapPath ?? `app from ${dir}`}...`);
+    const result = await installApp({ config, projectDir: dir, hapPath, deviceSerial: opts.device, logger });
+    logger.info(`Installed ${result.hapPath}.`);
   });
   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."
@@ -1071,13 +1118,42 @@ function registerDumpCommand(program) {
 }
 
 // src/commands/devices.ts
-import { listDevices } from "@oniroproject/core";
+import { getDeviceInfo, listDevices } from "@oniroproject/core";
+function formatLongDevice(d, info) {
+  const head = `${d.serial}	${d.connection ?? ""}	${d.status}`;
+  if (!info) return head;
+  const os3 = [info.osFamily, info.osFamily === "HarmonyOS" ? info.osDistVersion : void 0].filter(Boolean).join(" ");
+  const fields = [
+    ["os", os3 || void 0],
+    ["api", info.sdkApiVersion],
+    ["abi", info.abi],
+    ["type", info.deviceType],
+    ["model", info.model],
+    ["fullname", info.osFullName]
+  ];
+  const rest = fields.filter(([, v]) => v).map(([k, v]) => `${k}=${/\s/.test(v) ? JSON.stringify(v) : v}`);
+  return [head, ...rest].join("	");
+}
 function registerDevicesCommand(program) {
-  program.command("devices").description("List connected hdc devices.").option("--json", "Emit machine-readable JSON.").action(async (opts) => {
-    const { config } = getRuntime();
+  program.command("devices").description("List connected hdc devices.").option(
+    "--long",
+    "Also ask each connected device for its OS family (HarmonyOS / OpenHarmony), version, API level, CPU ABI, device type and model."
+  ).option("--json", "Emit machine-readable JSON.").action(async (opts) => {
+    const { config, logger } = getRuntime();
     const devices = await listDevices(config);
+    const infos = /* @__PURE__ */ new Map();
+    if (opts.long) {
+      for (const d of devices.filter((x) => x.status === "Connected")) {
+        try {
+          infos.set(d.serial, await getDeviceInfo({ config, deviceSerial: d.serial, logger }));
+        } catch (err) {
+          logger.warn(`Could not query ${d.serial}: ${err.message}`);
+        }
+      }
+    }
     if (opts.json) {
-      process.stdout.write(`${JSON.stringify(devices, null, 2)}
+      const out = opts.long ? devices.map((d) => ({ ...d, info: infos.get(d.serial) ?? null })) : devices;
+      process.stdout.write(`${JSON.stringify(out, null, 2)}
 `);
       return;
     }
@@ -1086,7 +1162,7 @@ function registerDevicesCommand(program) {
       return;
     }
     for (const d of devices) {
-      process.stdout.write(`${d.serial}	${d.connection ?? ""}	${d.status}
+      process.stdout.write(`${opts.long ? formatLongDevice(d, infos.get(d.serial)) : `${d.serial}	${d.connection ?? ""}	${d.status}`}
 `);
     }
   });
@@ -1096,10 +1172,14 @@ function registerDevicesCommand(program) {
 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) => {
+  file.command("send <local> <remote>").description(
+    "Push a local file to the device. With --bundle, <remote> may be relative to that app's sandbox (files/x is its filesDir, haps/entry/files/x the entry module's), and the file is chowned to the app so it can read it. Prints the device path."
+  ).option("--bundle <bundle>", "Push into this app's sandbox and give the file to the app's user.").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}.`);
+    const written = await sendFile({ config, local, remote, bundle: opts.bundle, deviceSerial: opts.device, logger });
+    logger.info(`Sent ${local} -> ${written}${opts.bundle ? ` (owned by ${opts.bundle})` : ""}.`);
+    process.stdout.write(`${written}
+`);
   });
   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();
@@ -1110,23 +1190,65 @@ function registerFileCommand(program) {
 
 // src/commands/lint.ts
 import * as path8 from "path";
-import { runCodelinter } from "@oniroproject/core";
+import {
+  detectCmdToolsFlavour,
+  detectRuntimeOs as detectRuntimeOs2,
+  getCmdToolsPath,
+  runCodelinter
+} from "@oniroproject/core";
+function lintTotals(result) {
+  if (result.summary) return result.summary;
+  const count = (s) => result.findings.filter((f) => f.severity === s).length;
+  return {
+    defects: result.findings.length,
+    errors: count("error"),
+    warnings: count("warning"),
+    suggestions: count("suggestion")
+  };
+}
+function lintExitCode(result) {
+  if (lintTotals(result).errors > 0) return 1;
+  const noReport = result.summary === null && result.findings.length === 0;
+  return noReport && result.code !== 0 ? result.code : 0;
+}
 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) => {
+  program.command("lint [project-dir]").description(
+    "Run the OpenHarmony codelinter on a project. Defaults to the current directory. Exits 1 on error-severity findings or when codelinter fails to run; warnings alone exit 0."
+  ).option("--files <globs...>", "Specific files/globs to lint (default: the whole project).").option("--json", "Emit the report (findings, summary, notices, incomplete) 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 });
+    const totals = lintTotals(result);
     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}]` : ""}
+        const at = `${f.file}:${f.line}${f.column ? `:${f.column}` : ""}`;
+        process.stdout.write(`${at} ${f.severity} ${f.message}${f.code ? ` [${f.code}]` : ""}
 `);
       }
-      if (result.findings.length === 0) process.stdout.write("No findings.\n");
+      process.stdout.write(
+        totals.defects === 0 ? "No defects found.\n" : `${totals.defects} defects: ${totals.errors} errors, ${totals.warnings} warnings, ${totals.suggestions} suggestions.
+`
+      );
+    }
+    if (result.summary === null && result.findings.length === 0 && result.code !== 0) {
+      logger.error(`codelinter exited ${result.code} without a report:
+${result.raw.trim().split("\n").slice(-15).join("\n")}`);
+    }
+    if (result.incomplete) {
+      for (const n of result.notices) logger.warn(`codelinter: ${n}`);
+      const cmdToolsPath = getCmdToolsPath(config);
+      const flavour = detectCmdToolsFlavour(cmdToolsPath);
+      const projectOs = detectRuntimeOs2(dir);
+      if (flavour !== projectOs) {
+        logger.warn(
+          `The command-line tools at ${cmdToolsPath} are the ${flavour} flavour, but the project targets ${projectOs} (runtimeOS in build-profile.json5), so codelinter skipped part of its checks: treat the counts as a lower bound. For a complete report, point ONIRO_CMD_TOOLS_PATH at ${projectOs} command-line tools. The build's ArkTS compiler checks are not affected.`
+        );
+      }
     }
-    if (result.code !== 0) process.exitCode = result.code;
+    process.exitCode = lintExitCode(result);
   });
 }
 
@@ -1214,12 +1336,608 @@ function registerInputCommand(program) {
   });
 }
 
+// src/commands/logs.ts
+import * as os2 from "os";
+import * as path10 from "path";
+import { captureLog } from "@oniroproject/core";
+
+// src/lib/logBundle.ts
+import * as fs4 from "fs/promises";
+import * as path9 from "path";
+import { deflateRawSync } from "zlib";
+import {
+  VERSION,
+  hdcExec,
+  parseDeviceList,
+  resolveDeviceSerial,
+  shellChecked
+} from "@oniroproject/core";
+var LEVELS = {
+  V: "V",
+  VERBOSE: "V",
+  D: "D",
+  DEBUG: "D",
+  I: "I",
+  INFO: "I",
+  W: "W",
+  WARN: "W",
+  WARNING: "W",
+  E: "E",
+  ERROR: "E",
+  F: "F",
+  FATAL: "F"
+};
+var HILOG_RECORD = /^(?<date>\d{2}-\d{2})[ \t]+(?<time>\d{2}:\d{2}:\d{2}\.\d{3})[ \t]+(?<pid>\d+)[ \t]+\d+[ \t]+(?<level>[VDIWEF])[ \t]+(?<tag>\S+?)(?:[ \t]+[NH](?::(?:[ \t]+.*)?|[ \t]+.*)?|:(?:[ \t]+.*)?)$/;
+var FAILURE_TEXT = /^(?:\s*(?:\[(?:fail|error)\]|(?:error|failed|failure):|permission denied\b|no devices? connected\b|too many arguments\b|unknown option\b|invalid option\b|command not found\b)|\s*(?:hdc|device)\b.*\b(?:error|failed|no device|not connected|offline)\b)/im;
+function validateDate(date, time) {
+  const [, monthText, dayText] = /^(\d{2})-(\d{2})$/.exec(date) ?? [];
+  const [, hourText, minuteText, secondText, millisecondText] = /^(\d{2}):(\d{2}):(\d{2})\.(\d{3})$/.exec(time) ?? [];
+  if (!monthText || !dayText || !hourText || !minuteText || !secondText || !millisecondText) return false;
+  const value = new Date(Date.UTC(2e3, Number(monthText) - 1, Number(dayText), Number(hourText), Number(minuteText), Number(secondText), Number(millisecondText)));
+  return value.getUTCMonth() === Number(monthText) - 1 && value.getUTCDate() === Number(dayText) && Number(hourText) < 24 && Number(minuteText) < 60 && Number(secondText) < 60;
+}
+function filterHilog(input, filters) {
+  const criteria = {};
+  if (filters.pid) criteria.pid = filters.pid.replace(/^0+(?=\d)/, "");
+  if (filters.tag) criteria.tag = filters.tag;
+  if (filters.level) criteria.level = LEVELS[filters.level.toUpperCase()] ?? filters.level.toUpperCase();
+  if (Object.keys(criteria).length === 0) return null;
+  let sawRecord = false;
+  let keep = false;
+  let output = "";
+  for (const line of input.match(/[^\n]*\n|[^\n]+$/g) ?? []) {
+    const content = line.replace(/[\r\n]+$/, "");
+    const match = HILOG_RECORD.exec(content);
+    if (match?.groups) {
+      if (!validateDate(match.groups.date, match.groups.time)) return null;
+      sawRecord = true;
+      keep = Object.entries(criteria).every(([key, value]) => {
+        const field = key === "tag" ? match.groups.tag.slice(match.groups.tag.lastIndexOf("/") + 1) : match.groups[key];
+        return key === "pid" ? field?.replace(/^0+(?=\d)/, "") === value : field === value;
+      });
+    } else if (/^\s*\[?\d{1,4}[-/]/.test(content) || !sawRecord && content.trim()) {
+      return null;
+    }
+    if (keep) output += line;
+  }
+  return sawRecord ? { text: output, applied: Object.keys(criteria) } : null;
+}
+function redactLogText(value, deviceSerials = []) {
+  let result = value.replace(/(\bBearer\s+)[A-Za-z0-9._~+/=-]+/gi, "$1[REDACTED]").replace(/(\bBasic\s+)[A-Za-z0-9+/=]+/gi, "$1[REDACTED]").replace(/((?:token|password|passwd|secret|api[_-]?key)\s*[=:]\s*)[^\s,;]+/gi, "$1[REDACTED]").replace(/(cookie\s*[=:]\s*)[^\r\n]+/gi, "$1[REDACTED]").replace(/\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi, "[REDACTED_EMAIL]").replace(/((?:phone|mobile|telephone|tel)(?:number)?\s*[=:]\s*)\+?[\d ()-]{8,}\d/gi, "$1[REDACTED_PHONE]").replace(/(?<![\w.])(?:\+\d{1,3}[ -]?)?\(?\d{2,4}\)?[ -]\d{3,4}[ -]\d{3,4}(?![\w.])/g, "[REDACTED_PHONE]").replace(/\b(?:[0-9A-Fa-f]{2}:){5}[0-9A-Fa-f]{2}\b/g, "[REDACTED_MAC]").replace(/([A-Z]:\\Users\\)[^\\\r\n "']+/gi, "$1[REDACTED_USER]").replace(/(\/(?:Users|home)\/)[^/\r\n "']+/gi, "$1[REDACTED_USER]").replace(/("(?:target|deviceSerial)"\s*:\s*")[^"]+(")/gi, "$1[REDACTED_DEVICE]$2").replace(/(--device\s+|-t\s+)([A-Za-z0-9._:-]+)/gi, "$1[REDACTED_DEVICE]");
+  for (const serial of deviceSerials) {
+    if (serial) result = result.split(serial).join("[REDACTED_DEVICE]");
+  }
+  const ipv4 = /\b(?:\d{1,3}\.){3}\d{1,3}\b/g;
+  result = result.replace(ipv4, (address, offset, whole) => {
+    const prefix = whole.slice(Math.max(0, offset - 48), offset);
+    const suffix = whole.slice(offset + address.length);
+    const contextual = /(?:ip|addr(?:ess)?|host|peer|remote|local|endpoint|server|client|target|device(?:id)?|serial)[^\r\n]{0,24}$/i.test(prefix);
+    const hasPort = /^:\d{1,5}(?!\d)/.test(suffix);
+    const octets = address.split(".").map(Number);
+    return octets.every((part) => part <= 255) && (contextual || hasPort) ? "[REDACTED_IP]" : address;
+  });
+  return result;
+}
+function decodeText(data, relativePath) {
+  let text;
+  if (data.subarray(0, 2).equals(Buffer.from([255, 254]))) text = data.toString("utf16le").slice(1);
+  else if (data.subarray(0, 2).equals(Buffer.from([254, 255]))) {
+    const swapped = Buffer.from(data.subarray(2));
+    for (let i = 0; i + 1 < swapped.length; i += 2) [swapped[i], swapped[i + 1]] = [swapped[i + 1], swapped[i]];
+    text = swapped.toString("utf16le");
+  } else {
+    const utf8 = data.subarray(0, 3).equals(Buffer.from([239, 187, 191])) ? data.subarray(3) : data;
+    if (utf8.includes(0)) throw new Error(`Binary data cannot be safely redacted: ${relativePath}`);
+    try {
+      text = new TextDecoder("utf-8", { fatal: true }).decode(utf8);
+    } catch {
+      throw new Error(`Non-UTF-8 data cannot be safely redacted: ${relativePath}`);
+    }
+  }
+  if (text.includes("\0")) throw new Error(`Binary data cannot be safely redacted: ${relativePath}`);
+  return text;
+}
+async function redactTree(source, destination, serials, boundedHilog) {
+  await fs4.mkdir(destination, { recursive: false, mode: 448 });
+  try {
+    const visit = async (directory) => {
+      for (const entry of await fs4.readdir(directory, { withFileTypes: true })) {
+        const sourcePath = path9.join(directory, entry.name);
+        const relative2 = path9.relative(source, sourcePath);
+        const portableRelative = relative2.split(path9.sep).join("/");
+        const destinationPath = path9.join(destination, relative2);
+        if (entry.isDirectory()) {
+          await fs4.mkdir(destinationPath, { recursive: true, mode: 448 });
+          await visit(sourcePath);
+        } else if (entry.isFile()) {
+          if (portableRelative === "logs/hilog.txt") {
+            const text2 = boundedHilog ?? "HiLog omitted from this archive because the requested duration could not be reliably applied.\n";
+            await fs4.mkdir(path9.dirname(destinationPath), { recursive: true, mode: 448 });
+            await fs4.writeFile(destinationPath, redactLogText(text2, serials), { encoding: "utf8", mode: 384 });
+            continue;
+          }
+          if (portableRelative === "logs/hilog-filtered.txt" && boundedHilog === null) continue;
+          const text = decodeText(await fs4.readFile(sourcePath), relative2);
+          await fs4.mkdir(path9.dirname(destinationPath), { recursive: true, mode: 448 });
+          await fs4.writeFile(destinationPath, redactLogText(text, serials), { encoding: "utf8", mode: 384 });
+        }
+      }
+    };
+    await visit(source);
+  } catch (error) {
+    await fs4.rm(destination, { recursive: true, force: true });
+    throw error;
+  }
+}
+var CRC_TABLE = new Uint32Array(256);
+for (let i = 0; i < CRC_TABLE.length; i++) {
+  let value = i;
+  for (let bit = 0; bit < 8; bit++) value = value & 1 ? 3988292384 ^ value >>> 1 : value >>> 1;
+  CRC_TABLE[i] = value >>> 0;
+}
+function crc32(data) {
+  let crc = 4294967295;
+  for (const byte of data) crc = CRC_TABLE[(crc ^ byte) & 255] ^ crc >>> 8;
+  return (crc ^ 4294967295) >>> 0;
+}
+function dosDateTime(date) {
+  const year = Math.max(1980, date.getFullYear());
+  return {
+    date: year - 1980 << 9 | date.getMonth() + 1 << 5 | date.getDate(),
+    time: date.getHours() << 11 | date.getMinutes() << 5 | Math.floor(date.getSeconds() / 2)
+  };
+}
+async function writeZip(source, archivePath) {
+  const files = [];
+  const visit = async (directory) => {
+    for (const entry of await fs4.readdir(directory, { withFileTypes: true })) {
+      const filePath = path9.join(directory, entry.name);
+      if (entry.isDirectory()) await visit(filePath);
+      else if (entry.isFile()) files.push(filePath);
+    }
+  };
+  await visit(source);
+  const localParts = [];
+  const centralParts = [];
+  let offset = 0;
+  const stamp = dosDateTime(/* @__PURE__ */ new Date());
+  for (const filePath of files) {
+    const name = Buffer.from(path9.relative(source, filePath).split(path9.sep).join("/"), "utf8");
+    const data = await fs4.readFile(filePath);
+    const compressed = deflateRawSync(data);
+    const checksum = crc32(data);
+    const local = Buffer.alloc(30);
+    local.writeUInt32LE(67324752, 0);
+    local.writeUInt16LE(20, 4);
+    local.writeUInt16LE(2048, 6);
+    local.writeUInt16LE(8, 8);
+    local.writeUInt16LE(stamp.time, 10);
+    local.writeUInt16LE(stamp.date, 12);
+    local.writeUInt32LE(checksum, 14);
+    local.writeUInt32LE(compressed.length, 18);
+    local.writeUInt32LE(data.length, 22);
+    local.writeUInt16LE(name.length, 26);
+    local.writeUInt16LE(0, 28);
+    localParts.push(local, name, compressed);
+    const central = Buffer.alloc(46);
+    central.writeUInt32LE(33639248, 0);
+    central.writeUInt16LE(20, 4);
+    central.writeUInt16LE(20, 6);
+    central.writeUInt16LE(2048, 8);
+    central.writeUInt16LE(8, 10);
+    central.writeUInt16LE(stamp.time, 12);
+    central.writeUInt16LE(stamp.date, 14);
+    central.writeUInt32LE(checksum, 16);
+    central.writeUInt32LE(compressed.length, 20);
+    central.writeUInt32LE(data.length, 24);
+    central.writeUInt16LE(name.length, 28);
+    central.writeUInt16LE(0, 30);
+    central.writeUInt16LE(0, 32);
+    central.writeUInt16LE(0, 34);
+    central.writeUInt16LE(0, 36);
+    central.writeUInt32LE(0, 38);
+    central.writeUInt32LE(offset, 42);
+    centralParts.push(central, name);
+    offset += local.length + name.length + compressed.length;
+  }
+  const centralDirectory = Buffer.concat(centralParts);
+  const end = Buffer.alloc(22);
+  end.writeUInt32LE(101010256, 0);
+  end.writeUInt16LE(0, 4);
+  end.writeUInt16LE(0, 6);
+  end.writeUInt16LE(files.length, 8);
+  end.writeUInt16LE(files.length, 10);
+  end.writeUInt32LE(centralDirectory.length, 12);
+  end.writeUInt32LE(offset, 16);
+  end.writeUInt16LE(0, 20);
+  await fs4.writeFile(archivePath, Buffer.concat([...localParts, centralDirectory, end]), { flag: "wx", mode: 384 });
+}
+function commandFailure(result) {
+  if (result.code !== 0) return `hdc exited with code ${result.code}`;
+  if (result.stderr.trim()) return "hdc wrote to stderr";
+  const contentError = result.stdout.split(/\r?\n/).find((line) => FAILURE_TEXT.test(line))?.trim() ?? null;
+  return contentError ? `command output indicates failure: ${contentError}` : null;
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+async function uniqueBundleDirectory(outputDirectory, stamp) {
+  await fs4.mkdir(outputDirectory, { recursive: true, mode: 448 });
+  for (let suffix = 0; ; suffix++) {
+    const name = `incident-${stamp}${suffix ? `-${suffix}` : ""}`;
+    const directory = path9.join(outputDirectory, name);
+    try {
+      await fs4.mkdir(directory, { mode: 448 });
+      return directory;
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+    }
+  }
+}
+async function collectLogBundle(options) {
+  if (options.packageName && !/^[A-Za-z0-9_]+(?:\.[A-Za-z0-9_]+)+$/.test(options.packageName)) {
+    throw new Error("packageName must be a reverse-DNS bundle name.");
+  }
+  if (options.pid && !/^[1-9]\d*$/.test(options.pid)) throw new Error("pid must be a positive integer.");
+  if (options.tag && !/^[^\s/\x00-\x1f\x7f]+$/.test(options.tag)) throw new Error("tag must be a single HiLog tag.");
+  if (options.level && !LEVELS[options.level.toUpperCase()]) throw new Error("level is not a recognized HiLog level.");
+  const durationSeconds = options.durationSeconds ?? 600;
+  if (!Number.isSafeInteger(durationSeconds) || durationSeconds < 1 || durationSeconds > 31536e3) {
+    throw new Error("durationSeconds must be an integer between 1 and 31536000.");
+  }
+  const started = /* @__PURE__ */ new Date();
+  const stamp = started.toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
+  const bundleDirectory = await uniqueBundleDirectory(path9.resolve(options.outputDirectory), stamp);
+  const records = [];
+  const serials = [];
+  let replacementWarning = false;
+  const execute = options.execute ?? ((args, deviceSerial) => args[0] === "shell" ? shellChecked({ config: options.config, command: args.slice(1).join(" "), deviceSerial }) : hdcExec({ config: options.config, args, deviceSerial }));
+  const manifest = {
+    schemaVersion: "1.0",
+    collectorVersion: VERSION,
+    collectionStartUtc: started.toISOString(),
+    collectionEndUtc: null,
+    host: { os: process.platform },
+    target: null,
+    packageName: options.packageName ?? null,
+    pid: options.pid ?? null,
+    filters: {
+      tag: options.tag ?? null,
+      level: options.level ?? null,
+      pid: options.pid ?? null,
+      packageName: options.packageName ?? null,
+      durationSeconds
+    },
+    filterStatus: {
+      duration: "not-applied",
+      packageName: options.packageName ? "failed" : "not-requested",
+      pid: options.pid ? "not-applied" : "not-requested",
+      tag: options.tag ? "not-applied" : "not-requested",
+      level: options.level ? "not-applied" : "not-requested"
+    },
+    hilogWindowApplied: false,
+    redactionRequested: options.redact,
+    redactionStatus: options.redact ? "pending" : "not-requested",
+    archiveStatus: { status: "pending", path: null },
+    commands: records,
+    files: [],
+    notes: [
+      "Collection is read-only on the target device.",
+      "hilog -x captures the current device buffer; duration is applied locally against device time when log timestamps are recognized.",
+      "Redaction is heuristic and does not guarantee that a bundle is safe to publish."
+    ]
+  };
+  const run = async (name, relativeOutput, args, deviceSerial) => {
+    const outputPath = path9.join(bundleDirectory, relativeOutput);
+    await fs4.mkdir(path9.dirname(outputPath), { recursive: true, mode: 448 });
+    let result = null;
+    let failure = null;
+    try {
+      result = await execute(args, deviceSerial);
+      await fs4.writeFile(outputPath, result.stdout, { encoding: "utf8", mode: 384 });
+      if (result.stderr) await fs4.writeFile(`${outputPath}.stderr.txt`, result.stderr, { encoding: "utf8", mode: 384 });
+      if (result.stdout.includes("\uFFFD") || result.stderr.includes("\uFFFD")) {
+        replacementWarning = true;
+        manifest.notes.push(`${name} output contains Unicode replacement characters; review the redacted evidence before sharing.`);
+      }
+      failure = commandFailure(result);
+    } catch (error) {
+      failure = errorMessage(error);
+      await fs4.writeFile(outputPath, "", { encoding: "utf8", mode: 384 });
+    }
+    const record = {
+      name,
+      status: failure ? "failed" : "success",
+      output: relativeOutput,
+      stderr: result?.stderr ? `${relativeOutput}.stderr.txt` : null,
+      exitCode: result?.code ?? null,
+      error: failure
+    };
+    records.push(record);
+    return record;
+  };
+  const targetRecord = await run("list-targets", "device/targets.txt", ["list", "targets", "-v"]);
+  const targetOutput = await fs4.readFile(path9.join(bundleDirectory, "device/targets.txt"), "utf8").catch(() => "");
+  const targets = parseDeviceList(targetOutput).filter((target) => target.status === "Connected" || target.status === "Unknown");
+  serials.push(...parseDeviceList(targetOutput).map((target) => target.serial));
+  const requestedDevice = resolveDeviceSerial(options.deviceSerial);
+  let selectedDevice = null;
+  let targetError = null;
+  if (targetRecord.status !== "success") targetError = targetRecord.error ?? "hdc target discovery failed";
+  else if (requestedDevice) {
+    selectedDevice = targets.find((target) => target.serial === requestedDevice)?.serial ?? null;
+    if (!selectedDevice) targetError = "selected device was not discovered as connected";
+  } else if (targets.length === 0) targetError = "hdc did not discover a connected device";
+  else if (targets.length > 1) targetError = "multiple devices are connected; specify --device";
+  else selectedDevice = targets[0].serial;
+  let boundedHilog = null;
+  let durationApplied = false;
+  let durationFailureReason = "device clock or HiLog collection failed";
+  if (targetError) {
+    targetRecord.status = "failed";
+    targetRecord.error = targetError;
+    manifest.notes.push("Device collection stopped because target discovery did not identify exactly one selected connected device.");
+  } else {
+    manifest.target = selectedDevice;
+    const shell = (args) => run(args[0], args[1], args.slice(2), selectedDevice);
+    const captureStartedHostMs = Date.now();
+    const deviceTimeBefore = await shell([
+      "device-time-before",
+      "device/device-time-before.txt",
+      "shell",
+      "date",
+      "+%Y-%m-%dT%H:%M:%S"
+    ]);
+    const hilog = await shell(["hilog-snapshot", "logs/hilog.txt", "shell", "hilog", "-x"]);
+    const deviceTimeAfter = await shell([
+      "device-time-after",
+      "device/device-time-after.txt",
+      "shell",
+      "date",
+      "+%Y-%m-%dT%H:%M:%S"
+    ]);
+    const hostElapsedMs = Date.now() - captureStartedHostMs;
+    if (deviceTimeBefore.status === "success" && hilog.status === "success" && deviceTimeAfter.status === "success") {
+      const [beforeText, afterText, fullHilog] = await Promise.all([
+        fs4.readFile(path9.join(bundleDirectory, "device/device-time-before.txt"), "utf8"),
+        fs4.readFile(path9.join(bundleDirectory, "device/device-time-after.txt"), "utf8"),
+        fs4.readFile(path9.join(bundleDirectory, "logs/hilog.txt"), "utf8")
+      ]);
+      const window = filterHilogWindow(fullHilog, beforeText, afterText, durationSeconds, hostElapsedMs);
+      if (window.text === null) durationFailureReason = window.reason;
+      else boundedHilog = window.text;
+    } else if (deviceTimeBefore.status !== "success" || deviceTimeAfter.status !== "success") {
+      durationFailureReason = "device clock could not be read";
+    } else if (hilog.status !== "success") {
+      durationFailureReason = "HiLog snapshot collection failed";
+    }
+    durationApplied = boundedHilog !== null;
+    manifest.hilogWindowApplied = durationApplied;
+    const faultArgs = options.packageName ? ["faultlog", "logs/faultlog.txt", "shell", "hidumper", "-e", "--print", options.packageName, "-n", "5"] : ["faultlog", "logs/faultlog.txt", "shell", "hidumper", "-e", "--list", "-n", "20"];
+    const faultlog = await shell(faultArgs);
+    manifest.filterStatus = {
+      duration: durationApplied ? "applied" : "not-applied",
+      packageName: options.packageName ? faultlog.status === "success" ? "applied" : "failed" : "not-requested",
+      pid: options.pid ? "not-applied" : "not-requested",
+      tag: options.tag ? "not-applied" : "not-requested",
+      level: options.level ? "not-applied" : "not-requested"
+    };
+    if (!durationApplied) {
+      manifest.notes.push(
+        `HiLog duration was not applied (${durationFailureReason}); the full snapshot is kept only in the local raw bundle and omitted from the redacted archive.`
+      );
+    } else if (boundedHilog !== null && (options.pid || options.tag || options.level)) {
+      const filtered = filterHilog(boundedHilog, { pid: options.pid, tag: options.tag, level: options.level });
+      if (filtered) {
+        await fs4.writeFile(path9.join(bundleDirectory, "logs/hilog-filtered.txt"), filtered.text, { encoding: "utf8", mode: 384 });
+        const status = manifest.filterStatus;
+        for (const key of filtered.applied) status[key] = "applied";
+      } else {
+        manifest.notes.push("Requested HiLog PID/tag/level filters were not applied because the windowed snapshot format could not be parsed reliably.");
+      }
+    }
+    await shell(["device-name", "device/device-info.txt", "shell", "param", "get", "const.product.name"]);
+    await shell(["process-list", "device/process-list.txt", "shell", "ps", "-ef"]);
+    await shell(["memory", "device/memory.txt", "shell", "hidumper", "--mem"]);
+    await shell(["threads", "device/threads.txt", "shell", "hidumper", "-p"]);
+  }
+  const ended = /* @__PURE__ */ new Date();
+  manifest.collectionEndUtc = ended.toISOString();
+  const files = records.flatMap((record) => [record.output, record.stderr].filter((file) => Boolean(file)));
+  files.push("manifest.json", "notes.txt");
+  if (await fs4.access(path9.join(bundleDirectory, "logs/hilog-filtered.txt")).then(() => true, () => false)) {
+    files.push("logs/hilog-filtered.txt");
+  }
+  manifest.files = files;
+  await fs4.writeFile(path9.join(bundleDirectory, "notes.txt"), "Add reproduction steps and precise event timestamps here.\n", { encoding: "utf8", mode: 384 });
+  const durationFailure = !durationApplied;
+  const criticalFailure = Boolean(targetError) || records.some((record) => record.name === "hilog-snapshot" && record.status !== "success");
+  const anyCommandFailure = records.some((record) => record.status !== "success");
+  let redactedDirectory = null;
+  let archivePath = null;
+  let bundleError;
+  try {
+    if (options.redact) {
+      redactedDirectory = `${bundleDirectory}-redacted`;
+      manifest.redactionStatus = replacementWarning ? "review-required" : "success";
+      manifest.archiveStatus = { status: "success", path: `${path9.basename(redactedDirectory)}.zip` };
+      await fs4.writeFile(path9.join(bundleDirectory, "manifest.json"), `${JSON.stringify(manifest, null, 2)}
+`, { encoding: "utf8", mode: 384 });
+      await redactTree(bundleDirectory, redactedDirectory, serials, boundedHilog);
+      archivePath = `${redactedDirectory}.zip`;
+      await writeZip(redactedDirectory, archivePath);
+    } else {
+      archivePath = `${bundleDirectory}.zip`;
+      manifest.archiveStatus = { status: "success", path: path9.basename(archivePath) };
+      await fs4.writeFile(path9.join(bundleDirectory, "manifest.json"), `${JSON.stringify(manifest, null, 2)}
+`, { encoding: "utf8", mode: 384 });
+      await writeZip(bundleDirectory, archivePath);
+    }
+  } catch (error) {
+    bundleError = options.redact ? `redaction or archive creation failed: ${errorMessage(error)}` : `archive creation failed: ${errorMessage(error)}`;
+    archivePath = null;
+    manifest.redactionStatus = options.redact ? "failed" : "not-requested";
+    manifest.archiveStatus = { status: "failed", path: null };
+    manifest.notes.push(bundleError);
+    await fs4.rm(`${redactedDirectory ?? bundleDirectory}.zip`, { force: true }).catch(() => void 0);
+    if (redactedDirectory) await fs4.rm(redactedDirectory, { recursive: true, force: true }).catch(() => void 0);
+    await fs4.writeFile(path9.join(bundleDirectory, "manifest.json"), `${JSON.stringify(manifest, null, 2)}
+`, { encoding: "utf8", mode: 384 });
+    redactedDirectory = null;
+  }
+  return {
+    bundleDirectory,
+    archivePath,
+    redactedDirectory,
+    complete: !criticalFailure && !anyCommandFailure && !bundleError && !replacementWarning && !durationFailure,
+    error: bundleError ?? (criticalFailure ? targetError ?? "HiLog collection failed" : replacementWarning ? "Captured output contains Unicode replacement characters; review the manifest before sharing." : durationFailure ? `HiLog duration was not applied (${durationFailureReason}); the redacted archive omits the full snapshot.` : void 0)
+  };
+}
+function parseDeviceClock(value) {
+  const match = /^\s*(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})\s*$/.exec(value);
+  if (!match) return null;
+  const [, year, month, day, hour, minute, second] = match;
+  const timestamp = Date.UTC(Number(year), Number(month) - 1, Number(day), Number(hour), Number(minute), Number(second));
+  const date = new Date(timestamp);
+  return date.getUTCFullYear() === Number(year) && date.getUTCMonth() === Number(month) - 1 && date.getUTCDate() === Number(day) && Number(hour) < 24 && Number(minute) < 60 && Number(second) < 60 ? timestamp : null;
+}
+function parseHilogTimestamp(datePart, timePart, referenceMs) {
+  if (!validateDate(datePart, timePart)) return null;
+  const [month, day] = datePart.split("-").map(Number);
+  const [hour, minute, second, millisecond] = timePart.split(/[:.]/).map(Number);
+  const referenceYear = new Date(referenceMs).getUTCFullYear();
+  const candidates = [referenceYear - 1, referenceYear, referenceYear + 1].map((year) => Date.UTC(year, month - 1, day, hour, minute, second, millisecond)).filter((timestamp) => {
+    const candidate = new Date(timestamp);
+    return candidate.getUTCMonth() === month - 1 && candidate.getUTCDate() === day;
+  }).sort((left, right) => Math.abs(left - referenceMs) - Math.abs(right - referenceMs));
+  const closest = candidates[0];
+  return closest !== void 0 && closest <= referenceMs + 2e3 ? closest : null;
+}
+function filterHilogWindow(input, deviceClockBefore, deviceClockAfter, durationSeconds, hostElapsedMs) {
+  if (!Number.isSafeInteger(durationSeconds) || durationSeconds < 1 || durationSeconds > 31536e3) {
+    return { text: null, reason: "requested duration is invalid" };
+  }
+  const beforeMs = parseDeviceClock(deviceClockBefore);
+  const afterMs = parseDeviceClock(deviceClockAfter);
+  if (beforeMs === null || afterMs === null) return { text: null, reason: "device clock output was not recognized" };
+  const deviceElapsedMs = afterMs - beforeMs;
+  if (deviceElapsedMs < -1e3 || deviceElapsedMs > Math.max(0, hostElapsedMs) + 5e3) {
+    return { text: null, reason: "device clock changed inconsistently during capture" };
+  }
+  const windowEnd = afterMs + 999;
+  const windowStart = windowEnd - durationSeconds * 1e3;
+  let sawRecord = false;
+  let keep = false;
+  let output = "";
+  for (const line of input.match(/[^\n]*\n|[^\n]+$/g) ?? []) {
+    const content = line.replace(/[\r\n]+$/, "");
+    const match = HILOG_RECORD.exec(content);
+    if (match?.groups) {
+      if (!validateDate(match.groups.date, match.groups.time)) {
+        return { text: null, reason: "HiLog contains an invalid timestamp" };
+      }
+      const timestamp = parseHilogTimestamp(match.groups.date, match.groups.time, afterMs);
+      if (timestamp === null || timestamp > windowEnd) {
+        return { text: null, reason: "HiLog timestamps do not agree with the device clock" };
+      }
+      sawRecord = true;
+      keep = timestamp >= windowStart;
+    } else if (/^-{3,}\s*beginning of\b/i.test(content.trim())) {
+      continue;
+    } else if (/^\s*\[?\d{1,4}[-/]/.test(content) || /^\s*\d{2}:\d{2}:\d{2}/.test(content)) {
+      return { text: null, reason: "HiLog contains timestamped lines in an unrecognized format" };
+    } else if (!sawRecord && content.trim()) {
+      return { text: null, reason: "HiLog contains unclassified lines before the first record" };
+    }
+    if (keep) output += line;
+  }
+  return sawRecord ? { text: output } : { text: null, reason: "no recognized timestamped HiLog records were found" };
+}
+
+// src/commands/logs.ts
+function registerLogsCommand(program) {
+  const logs = program.command("logs").description(
+    "Capture hilog to a file for a whole session: the device's small log buffer wraps within seconds under chatty components, so a dump at the end loses lines. Runs until --for elapses or the process is interrupted; start it in the background, e.g. `oniro-app logs --clear -o hilog_full.txt &`. Every line is flushed as it arrives and the stream reconnects after a reboot."
+  ).option("-o, --output <file>", "File to append the lines to (required).").option("--for <ms>", "Stop after this many ms (default: run until interrupted).").option("--grep <regex>", "Keep only lines matching this regex (default: all).").option("--clear", "Clear the device log buffer first (hilog -r), so the file covers only this session.").option("--domain <domain>", "hilog domain filter (e.g. 0xD003900).").option("--device <serial>", "Target device serial.").action(async (opts) => {
+    if (!opts.output) logs.error("error: required option '-o, --output <file>' not specified");
+    const { config, logger } = getRuntime();
+    const file = path10.resolve(opts.output);
+    const abort = new AbortController();
+    const stop = () => abort.abort();
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+    logger.info(`Capturing hilog to ${file}${opts.for ? ` for ${opts.for} ms` : " until interrupted"}...`);
+    const result = await captureLog({
+      config,
+      file,
+      durationMs: opts.for !== void 0 ? Number(opts.for) : void 0,
+      pattern: opts.grep ? new RegExp(opts.grep) : void 0,
+      clear: opts.clear,
+      domain: opts.domain,
+      deviceSerial: opts.device,
+      abortSignal: abort.signal,
+      logger
+    });
+    logger.info(`Wrote ${result.lines} lines to ${result.file} (${result.reconnects} reconnects).`);
+    process.stdout.write(`${result.file}
+`);
+  });
+  logs.command("collect").description("Create a diagnostic bundle from a connected device.").allowExcessArguments(false).option("-o, --output <directory>", "Parent directory for incident bundles.", path10.join(os2.homedir(), ".oniro", "incident-bundles")).option("--device <serial>", "Target device serial.").option("--package <bundle>", "Collect faultlog entries for this application bundle.").option("--pid <pid>", "Create a filtered HiLog view for this process.").option("--tag <tag>", "Create a filtered HiLog view for this tag.").option("--level <level>", "Create a filtered HiLog view for this level (V/D/I/W/E/F).").option("--duration <seconds>", "Keep HiLog records from the last N seconds (default 600).", "600").option("--redact", "Redact sensitive values and archive only the redacted bundle.").option("--json", "Emit bundle paths and status as JSON.").action(async (opts) => {
+    const { config } = getRuntime();
+    const result = await collectLogBundle({
+      config,
+      outputDirectory: opts.output,
+      deviceSerial: opts.device,
+      packageName: opts.package,
+      pid: opts.pid,
+      tag: opts.tag,
+      level: opts.level,
+      durationSeconds: Number(opts.duration),
+      redact: Boolean(opts.redact)
+    });
+    const output = opts.json ? `${JSON.stringify({ ...result, status: result.complete ? "complete" : "partial" }, null, 2)}
+` : `${result.archivePath ?? result.bundleDirectory}
+`;
+    process.stdout.write(output);
+    if (!result.complete) {
+      throw new Error(`Bundle is partial; inspect manifest.json. ${result.error ?? "One or more collectors failed."}`);
+    }
+  });
+}
+
+// src/commands/hdc.ts
+import { getHdcPath, hdcTargetArgsFor, spawnCompat } from "@oniroproject/core";
+function hdcPassthroughArgv(args, device) {
+  return args[0] === "-t" ? [...args] : [...hdcTargetArgsFor(args, device), ...args];
+}
+function registerHdcCommand(program) {
+  program.command("hdc").description(
+    "Run the hdc binary oniro-app itself uses (see `cmdtools status`), addressed at --device or ONIRO_DEVICE_SERIAL, with stdio passed through. Exits with hdc's own code, which is 0 even for a `[Fail]` line. Example: oniro-app hdc shell param get const.ohos.apiversion"
+  ).argument("[args...]", "hdc arguments, passed through verbatim").option("--device <serial>", "Target device serial.").option("--path", "Print the hdc binary path and exit.").passThroughOptions().allowUnknownOption().action(async (args, opts) => {
+    const { config } = getRuntime();
+    const hdc = getHdcPath(config);
+    if (opts.path) {
+      process.stdout.write(`${hdc}
+`);
+      return;
+    }
+    await new Promise((resolve9, reject) => {
+      const child = spawnCompat(hdc, hdcPassthroughArgv(args, opts.device), { stdio: "inherit" });
+      child.on("error", (err) => reject(new Error(`Failed to run ${hdc}: ${err.message}`)));
+      child.on("close", (code) => {
+        process.exitCode = code ?? 1;
+        resolve9();
+      });
+    });
+  });
+}
+
 // src/bin/oniro-app.ts
-var CLI_VERSION = "0.13.0";
+var CLI_VERSION = "0.15.0";
 function buildProgram() {
   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();
+  ).version(CLI_VERSION).showHelpAfterError().enablePositionalOptions();
   registerSdkCommand(program);
   registerCmdToolsCommand(program);
   registerEmulatorCommand(program);
@@ -1238,6 +1956,8 @@ function buildProgram() {
   registerFileCommand(program);
   registerLintCommand(program);
   registerInputCommand(program);
+  registerLogsCommand(program);
+  registerHdcCommand(program);
   return program;
 }
 async function main() {