@oniroproject/oniro-app 0.14.0 → 0.15.0

package/README.md

@@ -221,6 +221,45 @@ Local paths may be relative, or absolute with either slash. A device path that a
 | `--domain <domain>` | hilog domain filter (e.g. `0xD003900`). |
 | `--device <serial>` | Target device serial. |
 
+#### `logs collect` — create a diagnostic bundle
+
+```bash
+oniro-app logs collect --redact --package com.example.app
+```
+
+The command requires exactly one connected device unless `--device` (or
+`ONIRO_DEVICE_SERIAL`) selects one. It captures the current `hilog -x` buffer,
+faultlog evidence, device information, process list, and memory/thread snapshots.
+Because `hilog -x` has no duration argument, `--duration` filters recognized
+HiLog timestamps locally using device clock readings before and after the snapshot.
+If the clock or log format cannot be parsed reliably, the manifest records the
+window as unapplied, the command exits non-zero, and the full snapshot is omitted
+from the redacted archive (it remains only in the local raw bundle).
+`--pid`, `--tag`, and `--level` create an additional filtered HiLog view from the
+time-bounded records when their format can be parsed reliably. `--package`
+targets `hidumper -e --print <bundle> -n 5` for faultlog evidence.
+
+`--redact` creates a sibling `incident-...-redacted` directory and ZIP; the
+archive is built only from that redacted copy. Without `--redact`, the archive
+contains raw sensitive data. Redaction is heuristic, fails closed on binary or
+unknown-encoding files, and does not guarantee that a bundle is safe to publish.
+Collection continues after individual command failures and records each result
+in `manifest.json`; the CLI exits non-zero for a partial bundle. The default
+output is under `~/.oniro/incident-bundles`; bundle files are created with
+owner-only permissions where the host OS supports POSIX modes.
+
+| Flag | Description |
+| --- | --- |
+| `-o, --output <directory>` | Parent directory for bundles (default `~/.oniro/incident-bundles`). |
+| `--device <serial>` | Target device serial. |
+| `--package <bundle>` | Bundle name for package-specific faultlog collection. |
+| `--pid <pid>` | Create an exact-PID filtered HiLog view. |
+| `--tag <tag>` | Create an exact-tag filtered HiLog view. |
+| `--level <level>` | Create a filtered view for `V`, `D`, `I`, `W`, `E`, or `F`. |
+| `--duration <seconds>` | Include HiLog records from the last N seconds (default `600`; maximum `31536000`). |
+| `--redact` | Redact text evidence; create the archive only from the redacted copy. |
+| `--json` | Emit bundle paths and completion status as JSON. |
+
 #### `hdc` — run the bundled hdc
 
 `hdc [args...]` runs the `hdc` binary oniro-app itself uses (the one `cmdtools status` shows), with stdio passed through, so it needs nothing on `PATH`. Device commands are addressed at `--device` or `ONIRO_DEVICE_SERIAL` unless the arguments start with `-t`. `hdc --path` prints the binary's location. The exit code is hdc's own, which is 0 even for a `[Fail]` line.

package/dist/oniro-app.js

@@ -1122,9 +1122,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],
@@ -1337,14 +1337,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 +1882,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 +1921,19 @@ function registerHdcCommand(program) {
 `);
       return;
     }
-    await new Promise((resolve8, reject) => {
+    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;
-        resolve8();
+        resolve9();
       });
     });
   });
 }
 
 // src/bin/oniro-app.ts
-var CLI_VERSION = "0.14.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."