@oniroproject/oniro-app 0.14.0 → 0.16.0

package/dist/oniro-app.js

@@ -2,17 +2,19 @@
 
 // src/bin/oniro-app.ts
 import { Command as Command4 } from "commander";
-import { OniroError as OniroError2 } from "@oniroproject/core";
+import { OniroError as OniroError3 } from "@oniroproject/core";
 
 // src/commands/sdk.ts
 import * as fs from "fs";
 import * as path from "path";
 import {
   ALL_SDKS,
+  OHOS_DAILY_BUILDS_URL,
   downloadAndInstallSdk,
   getOsFolder,
   getSdkRootDir,
   getSupportedSdksForUi,
+  installSdkFromArchive,
   removeSdk
 } from "@oniroproject/core";
 
@@ -104,13 +106,42 @@ function getRuntime() {
 }
 
 // src/commands/sdk.ts
+var FULL_SDK_TIP = `Tip: the full SDK (with system APIs) is not on the release mirror. Download an ohos-sdk-full archive from the OpenHarmony daily builds, ${OHOS_DAILY_BUILDS_URL}, and install it with \`oniro-app sdk install --from-archive <archive>\`.`;
 function registerSdkCommand(program) {
   const sdk = program.command("sdk").description("Manage OpenHarmony SDK installs.");
-  sdk.command("install <version>").description("Download and install an OpenHarmony SDK. Skips if already installed.").option("--force", "Reinstall even if the SDK is already present.").option(
+  sdk.command("install [version]").description(
+    "Download and install an OpenHarmony SDK (skips if already installed), or install one from a local archive with --from-archive."
+  ).option(
+    "--from-archive <path>",
+    "Install from a local SDK .tar.gz instead of downloading, e.g. the full SDK. The API level is read from the archive."
+  ).option("--force", "Reinstall even if the SDK is already present.").option(
     "--tmp-dir <path>",
     "Directory for download/extract temporaries (default: ONIRO_TMP_DIR, else .oniro-tmp next to the install target). Use this when that filesystem is short on space."
-  ).action(async (version, opts) => {
+  ).addHelpText("after", `
+${FULL_SDK_TIP}`).action(async (version, opts) => {
     const { config, logger, progress } = getRuntime();
+    if (opts.fromArchive) {
+      if (version) throw new Error("Pass either a version or --from-archive, not both.");
+      const archivePath = path.resolve(opts.fromArchive);
+      logger.info(`Installing OpenHarmony SDK from ${archivePath}...`);
+      const installed = await installSdkFromArchive({
+        config,
+        archivePath,
+        force: opts.force,
+        progress,
+        logger,
+        tmpDir: opts.tmpDir
+      });
+      const label = installed.version ? `SDK ${installed.version} (api ${installed.api})` : `SDK api ${installed.api}`;
+      logger.info(`${label} installed at ${installed.dir}.`);
+      return;
+    }
+    if (!version) {
+      throw new Error(
+        `Name an SDK version (${ALL_SDKS.map((s) => s.version).join(", ")}) or pass --from-archive <path>.
+` + FULL_SDK_TIP
+      );
+    }
     const release = ALL_SDKS.find((s) => s.version === version);
     if (!release) {
       throw new Error(
@@ -488,7 +519,17 @@ function registerAuthCommand(program) {
 
 // src/commands/app.ts
 import * as path4 from "path";
-import { installApp, launchApp, uninstallApp, forceStop, applyChanges, getBundleName } from "@oniroproject/core";
+import {
+  installApp,
+  launchApp,
+  uninstallApp,
+  forceStop,
+  applyChanges,
+  existingHapOrUnsigned,
+  getBundleName,
+  readHapBundleName,
+  OniroError as OniroError2
+} 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-or-hap]").description(
@@ -516,16 +557,29 @@ function registerAppCommand(program) {
     }
     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) => {
+  app.command("apply [project-dir-or-hap]").description(
+    "Install a HAP (a project dir, default the current one, or a .hap file) and verify the running process took the change. Refuses a HAP of another bundle. 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 .hap file, else 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 (target, opts) => {
     const { config, logger } = getRuntime();
-    const dir = path4.resolve(projectDir ?? process.cwd());
-    const bundle = opts.bundle ?? getBundleName(dir);
+    const isHap = target !== void 0 && /\.hap$/i.test(target);
+    if (isHap && opts.hap) throw new OniroError2("Pass the HAP either as the argument or with --hap, not both.");
+    const dir = isHap ? process.cwd() : path4.resolve(target ?? process.cwd());
+    const hapPath = isHap ? path4.resolve(target) : opts.hap;
+    let bundle = opts.bundle;
+    if (!bundle && isHap) {
+      const hap = existingHapOrUnsigned(hapPath);
+      if (!hap) throw new OniroError2(`HAP not found at ${hapPath}.`);
+      bundle = await readHapBundleName(hap.path).catch(() => null) ?? void 0;
+      if (!bundle) throw new OniroError2(`Could not read the bundle name from ${hap.path}. Pass --bundle.`);
+    }
+    bundle ??= getBundleName(dir);
     const result = await applyChanges({
       config,
       bundle,
-      hapPath: opts.hap,
+      hapPath,
       projectDir: dir,
       module: opts.module,
       installedHapPath: opts.installedHap,
@@ -685,16 +739,31 @@ function targetIndexFrom(opts) {
   return n;
 }
 
+// src/lib/logSince.ts
+function parseSince(value) {
+  if (value === void 0) return void 0;
+  if (value === "all") return Infinity;
+  const seconds = Number(value);
+  if (value.trim() === "" || !Number.isFinite(seconds) || seconds < 0) {
+    throw new Error(`--since takes a number of seconds or "all", not "${value}".`);
+  }
+  return seconds * 1e3;
+}
+
 // src/commands/wait.ts
 function registerWaitCommand(program) {
   const wait = program.command("wait").description(
     "Wait for a device condition: a log line (--log), boot (--boot), a bundle to start (--bundle), or an on-screen element (--target / --target-id / --target-type)."
-  ).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("--log <pattern>", "Resolve when a hilog line (tag: message) logged after the command starts matches this regex.").option(
+    "--since <seconds>",
+    'With --log: also match lines logged up to N seconds before the command started, measured on the device clock; "all" matches everything still in the device log buffer.'
+  ).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).");
   addTargetOptions(wait, "Resolve when", { index: false });
   wait.option("--gone", "With --target*: resolve when no uncovered element matches any more.").option("--interval <ms>", "With --target*: poll interval, ms (each poll is a layout dump).", "500").option("--timeout <ms>", "Max wait, ms.", "30000").option("--device <serial>", "Target device serial.").option("--json", "With --log or --target*: emit the matched entry/element as JSON.").action(async (opts) => {
     const { config, logger } = getRuntime();
     const timeoutMs = Number(opts.timeout);
     const selector = selectorFrom(opts);
+    if (opts.since !== void 0 && !opts.log) throw new Error("--since applies only to --log.");
     if (opts.log) {
       const entry = await waitForLog({
         config,
@@ -703,11 +772,12 @@ function registerWaitCommand(program) {
         bundle: opts.bundle,
         domain: opts.domain,
         deviceSerial: opts.device,
+        lookbackMs: parseSince(opts.since),
         logger
       });
       if (opts.json) process.stdout.write(`${JSON.stringify(entry, null, 2)}
 `);
-      else logger.info(`matched: ${entry.tag}: ${entry.message}`);
+      else logger.info(`matched: ${entry.time}  ${entry.tag}: ${entry.message}`);
       return;
     }
     if (opts.boot) {
@@ -746,7 +816,10 @@ function registerWaitCommand(program) {
 // 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) => {
+  program.command("watch").description("Collect the hilog lines matching a pattern that are logged during a fixed duration.").option("--log <pattern>", "Regex tested against each line (tag: message).").option("--for <ms>", "Duration to watch, ms.", "10000").option(
+    "--since <seconds>",
+    'Also collect lines logged up to N seconds before the command started, measured on the device clock; "all" adds everything still in the device log buffer.'
+  ).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({
@@ -757,6 +830,7 @@ function registerWatchCommand(program) {
       domain: opts.domain,
       dedup: opts.dedup,
       deviceSerial: opts.device,
+      lookbackMs: parseSince(opts.since),
       logger
     });
     if (opts.json) {
@@ -1122,9 +1196,9 @@ import { getDeviceInfo, listDevices } from "@oniroproject/core";
 function formatLongDevice(d, info) {
   const head = `${d.serial}	${d.connection ?? ""}	${d.status}`;
   if (!info) return head;
-  const os2 = [info.osFamily, info.osFamily === "HarmonyOS" ? info.osDistVersion : void 0].filter(Boolean).join(" ");
+  const os3 = [info.osFamily, info.osFamily === "HarmonyOS" ? info.osDistVersion : void 0].filter(Boolean).join(" ");
   const fields = [
-    ["os", os2 || void 0],
+    ["os", os3 || void 0],
     ["api", info.sdkApiVersion],
     ["abi", info.abi],
     ["type", info.deviceType],
@@ -1194,6 +1268,7 @@ import {
   detectCmdToolsFlavour,
   detectRuntimeOs as detectRuntimeOs2,
   getCmdToolsPath,
+  missingProjectRootFiles,
   runCodelinter
 } from "@oniroproject/core";
 function lintTotals(result) {
@@ -1208,8 +1283,10 @@ function lintTotals(result) {
 }
 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;
+  return lintFailed(result) ? result.code : 0;
+}
+function lintFailed(result) {
+  return result.summary === null && result.findings.length === 0 && result.code !== 0;
 }
 function registerLintCommand(program) {
   program.command("lint [project-dir]").description(
@@ -1219,10 +1296,11 @@ function registerLintCommand(program) {
     const dir = path8.resolve(projectDir ?? process.cwd());
     const result = await runCodelinter({ config, projectDir: dir, files: opts.files, logger });
     const totals = lintTotals(result);
+    const failed = lintFailed(result);
     if (opts.json) {
       process.stdout.write(`${JSON.stringify(result, null, 2)}
 `);
-    } else {
+    } else if (!failed) {
       for (const f of result.findings) {
         const at = `${f.file}:${f.line}${f.column ? `:${f.column}` : ""}`;
         process.stdout.write(`${at} ${f.severity} ${f.message}${f.code ? ` [${f.code}]` : ""}
@@ -1233,9 +1311,13 @@ function registerLintCommand(program) {
 `
       );
     }
-    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 (failed) {
+      const missing = missingProjectRootFiles(dir);
+      const why = missing.length ? ` It needs a DevEco project root, and ${dir} has no ${missing.join(", ")}.` : "";
+      logger.error(
+        `codelinter exited ${result.code} without a report, so nothing was linted.${why}
+` + result.raw.trim().split("\n").slice(-15).join("\n")
+      );
     }
     if (result.incomplete) {
       for (const n of result.notices) logger.warn(`codelinter: ${n}`);
@@ -1337,14 +1419,531 @@ function registerInputCommand(program) {
 }
 
 // src/commands/logs.ts
-import * as path9 from "path";
+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) {
-  program.command("logs").description(
+  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."
-  ).requiredOption("-o, --output <file>", "File to append the lines to.").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) => {
+  ).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 = path9.resolve(opts.output);
+    const file = path10.resolve(opts.output);
     const abort = new AbortController();
     const stop = () => abort.abort();
     process.once("SIGINT", stop);
@@ -1365,6 +1964,27 @@ function registerLogsCommand(program) {
     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
@@ -1383,19 +2003,19 @@ function registerHdcCommand(program) {
 `);
       return;
     }
-    await new Promise((resolve8, reject) => {
+    await new Promise((resolve10, 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;
-        resolve8();
+        resolve10();
       });
     });
   });
 }
 
 // src/bin/oniro-app.ts
-var CLI_VERSION = "0.14.0";
+var CLI_VERSION = "0.16.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."
@@ -1427,7 +2047,7 @@ async function main() {
   try {
     await program.parseAsync(process.argv);
   } catch (err) {
-    const message = err instanceof OniroError2 ? err.message : err instanceof Error ? err.message : String(err);
+    const message = err instanceof OniroError3 ? err.message : err instanceof Error ? err.message : String(err);
     process.stderr.write(`[error] ${message}
 `);
     if (process.env.ONIRO_DEBUG === "1" && err instanceof Error && err.stack) {