@poe-platform/safe-bash 0.1.623 → 0.1.625

package/dist/safe-bash/core.browser.js

@@ -26638,6 +26638,7 @@ var longOptions = {
   freshen: "f",
   filesync: "FS",
   "archive-comment": "z",
+  "entry-comments": "c",
   delete: "d",
   include: "i",
   exclude: "x",
@@ -26668,7 +26669,6 @@ var longOptions = {
 var reservedOptions = [
   "adjust-sfx",
   "temp-path",
-  "entry-comments",
   "display-bytes",
   "display-counts",
   "display-dots",
@@ -26824,37 +26824,68 @@ function zipEnvironmentArguments(env, argv, limits) {
 
 // packages/safe-bash/src/commands/archive/zip/comments.ts
 init_platform();
+var ZipCommentInput = class {
+  constructor(source2, limits, signal) {
+    this.limits = limits;
+    this.signal = signal;
+    this.iterator = readBytes(source2, signal)[Symbol.asyncIterator]();
+  }
+  limits;
+  signal;
+  iterator;
+  chunk = new Uint8Array();
+  offset = 0;
+  bytes = 0;
+  pulls = 0;
+  ended = false;
+  async readLine() {
+    const line = [];
+    while (line.length < 65535) {
+      this.signal.throwIfAborted();
+      if (this.offset === this.chunk.length) {
+        if (this.ended) break;
+        if (++this.pulls > this.limits.maxPatternSteps) fail("ZIP comment input work limit exceeded");
+        const next = await this.iterator.next();
+        if (next.done) {
+          this.ended = true;
+          break;
+        }
+        if (next.value.length > this.limits.maxFilesFromBytes - this.bytes) fail("ZIP comment input byte limit exceeded");
+        this.chunk = new Uint8Array(next.value);
+        this.offset = 0;
+        if (this.pulls % 64 === 0) await yieldTurn(this.signal);
+        if (!this.chunk.length) continue;
+      }
+      if (++this.bytes > this.limits.maxFilesFromBytes) fail("ZIP comment input byte limit exceeded");
+      const byte = this.chunk[this.offset++];
+      line.push(byte);
+      if (this.bytes % 4096 === 0) await yieldTurn(this.signal);
+      if (byte === 10) break;
+    }
+    if (!line.length) return void 0;
+    const zero2 = line.indexOf(0);
+    return Uint8Array.from(line.slice(0, zero2 < 0 ? void 0 : zero2));
+  }
+};
 async function readZipComment(source2, limits, signal) {
+  const input3 = source2 instanceof ZipCommentInput ? source2 : new ZipCommentInput(source2, limits, signal);
   const parts = [];
-  const line = [];
   let length = 0;
-  let bytes3 = 0;
-  let pulls = 0;
-  const append = () => {
-    const zero2 = line.indexOf(0);
-    const text3 = line.slice(0, zero2 < 0 ? void 0 : zero2);
-    line.length = 0;
-    if (text3.length === 2 && text3[0] === 46 && text3[1] === 10) return false;
-    if (text3.at(-1) === 10) text3.pop();
-    const separator = length || !text3.length ? 2 : 0;
-    if (text3.length + separator > Math.min(limits.maxTextBytes, 65535) - length) fail("ZIP archive comment byte limit exceeded");
-    if (separator) parts.push(import_buffer.Buffer.from("\r\n"));
-    if (text3.length) parts.push(Uint8Array.from(text3));
-    length += separator + text3.length;
-    return true;
-  };
-  for await (const chunk of readBytes(source2, signal)) {
-    if (++pulls > limits.maxPatternSteps) fail("ZIP comment input work limit exceeded");
-    for (const byte of chunk) {
-      if (++bytes3 > limits.maxFilesFromBytes) fail("ZIP comment input byte limit exceeded");
-      line.push(byte);
-      if ((byte === 10 || line.length === 65535) && !append()) return import_buffer.Buffer.concat(parts, length);
-      if (bytes3 % 4096 === 0) await yieldTurn(signal);
-    }
-    if (pulls % 64 === 0) await yieldTurn(signal);
+  try {
+    for (; ; ) {
+      const line = await input3.readLine();
+      if (line === void 0 || line.length === 2 && line[0] === 46 && line[1] === 10) break;
+      const text3 = line.at(-1) === 10 ? line.subarray(0, -1) : line;
+      const separator = length || !text3.length ? 2 : 0;
+      if (text3.length + separator > Math.min(limits.maxTextBytes, 65535) - length) fail("ZIP archive comment byte limit exceeded");
+      if (separator) parts.push(import_buffer.Buffer.from("\r\n"));
+      if (text3.length) parts.push(text3);
+      length += separator + text3.length;
+    }
+    return import_buffer.Buffer.concat(parts, length);
+  } finally {
+    await input3.iterator.return?.();
   }
-  if (line.length) append();
-  return import_buffer.Buffer.concat(parts, length);
 }
 
 // packages/safe-bash/src/commands/archive/zip-format.ts
@@ -26892,7 +26923,7 @@ function zip64Directory(view, end, limits) {
     members = count2;
     centralSize = size;
     centralStart = start;
-  } else if (members === 65535 || centralSize === 4294967295 || centralStart === 4294967295) fail("ZIP64 missing end record and locator");
+  } else if (centralSize === 4294967295 || centralStart === 4294967295) fail("ZIP64 missing end record and locator");
   else if (diskMembers !== members) fail("ZIP inconsistent member count");
   if (members > limits.maxMembers) fail("ZIP member limit exceeded");
   if (centralStart > limits.maxArchiveBytes || centralSize > limits.maxArchiveBytes || centralStart + centralSize !== centralEnd) fail("ZIP invalid central directory span");
@@ -27099,7 +27130,7 @@ async function readZipArchive(bytes3, limits, signal) {
     if (view.getUint32(offset2, true) === 101010256 && offset2 + 22 + view.getUint16(offset2 + 20, true) === bytes3.length) {
       const size = view.getUint32(offset2 + 12, true);
       const start = view.getUint32(offset2 + 16, true);
-      const zip64 = size === 4294967295 || start === 4294967295 || view.getUint16(offset2 + 10, true) === 65535 || offset2 >= 20 && view.getUint32(offset2 - 20, true) === 117853008;
+      const zip64 = size === 4294967295 || start === 4294967295 || offset2 >= 20 && view.getUint32(offset2 - 20, true) === 117853008;
       if (!zip64 && start + size !== offset2) continue;
       if (end !== -1) fail("ZIP ambiguous end records");
       end = offset2;
@@ -27331,11 +27362,51 @@ function updateZipExtras(entry, previous, mode, limits) {
   }
   return { ...entry, localExtra: retained[0], centralExtra: retained[1] };
 }
+function setZipEntryComment(entry, comment2, limits) {
+  number3(comment2.length, Math.min(limits.maxTextBytes, 65535), "entry comment");
+  let flags3 = entry.flags ?? 2048;
+  if (flags3 & 2048) {
+    try {
+      new TextDecoder("utf-8", { fatal: true }).decode(comment2);
+    } catch {
+      flags3 &= ~2048;
+    }
+  }
+  const rawName = entry.rawName ?? pathBytes(entry.name, limits);
+  const needUnicodePath = !(flags3 & 2048) && legacyName(rawName) !== entry.name;
+  const metadata3 = [];
+  for (const [original, central] of [[entry.localExtra ?? timestampExtra(entry.modified), false], [entry.centralExtra ?? timestampExtra(entry.modified), true]]) {
+    extras(original, rawName, entry.comment ?? new Uint8Array(), central, limits);
+    const fields4 = [];
+    const view = new DataView(original.buffer, original.byteOffset, original.byteLength);
+    for (let offset = 0; offset < original.length; ) {
+      const identifier = view.getUint16(offset, true);
+      const next = offset + 4 + view.getUint16(offset + 2, true);
+      if (identifier !== 25461 && !(needUnicodePath && identifier === 28789)) fields4.push(original.subarray(offset, next));
+      offset = next;
+    }
+    if (needUnicodePath) {
+      const name2 = pathBytes(entry.name, limits);
+      const field2 = new Uint8Array(9 + name2.length);
+      const header3 = new DataView(field2.buffer);
+      header3.setUint16(0, 28789, true);
+      header3.setUint16(2, 5 + name2.length, true);
+      field2[4] = 1;
+      header3.setUint32(5, crc322(rawName), true);
+      field2.set(name2, 9);
+      fields4.push(field2);
+    }
+    const rebuilt = import_buffer.Buffer.concat(fields4);
+    number3(rebuilt.length, Math.min(limits.maxPaxBytes, 65535), "extra field");
+    metadata3.push(rebuilt);
+  }
+  return { ...entry, comment: new Uint8Array(comment2), flags: flags3, localExtra: metadata3[0], centralExtra: metadata3[1] };
+}
 async function* streamZipArchive(archive, limits, signal, descriptors = false, forceZip64 = false) {
   const chunkSize2 = admit(limits, signal);
-  number3(archive.entries.length, Math.min(limits.maxMembers, 65534), "member");
+  number3(archive.entries.length, limits.maxMembers, "member");
   number3(archive.comment.length, Math.min(limits.maxTextBytes, 65535), "archive comment");
-  const wideArchive = forceZip64 || archive.entries.some((entry) => entry.zip64);
+  const wideArchive = forceZip64 || archive.entries.length > 65535 || archive.entries.some((entry) => entry.zip64);
   let length = 22 + archive.comment.length + (wideArchive ? 76 : 0);
   let localLength = 0;
   let total = 0;
@@ -27459,8 +27530,8 @@ async function* streamZipArchive(archive, limits, signal, descriptors = false, f
   const view = new DataView(bytes3.buffer);
   const central = wideArchive ? writeZip64End(view, 0, encoded2.length, centralSize, localLength, localLength + centralSize) : 0;
   view.setUint32(central, 101010256, true);
-  view.setUint16(central + 8, encoded2.length, true);
-  view.setUint16(central + 10, encoded2.length, true);
+  view.setUint16(central + 8, Math.min(encoded2.length, 65535), true);
+  view.setUint16(central + 10, Math.min(encoded2.length, 65535), true);
   view.setUint32(central + 12, centralSize, true);
   view.setUint32(central + 16, wideArchive ? 4294967295 : localLength, true);
   view.setUint16(central + 20, archive.comment.length, true);
@@ -27867,6 +27938,7 @@ async function parse12(scope, limits) {
   let mustMatch = false;
   let filesync = false;
   let archiveComment = false;
+  let entryComments = false;
   let fromDate;
   let beforeDate;
   let descriptors = false;
@@ -27921,6 +27993,7 @@ async function parse12(scope, limits) {
           offset++;
         } else if (flag === "q") quiet = true;
         else if (flag === "z") archiveComment = true;
+        else if (flag === "c") entryComments = true;
         else if (flag === "j") junkPaths = true;
         else if (flag === "X") {
           metadata3 = argument2[offset + 1] === "-" ? "all" : "strip";
@@ -28039,7 +28112,7 @@ async function parse12(scope, limits) {
   }
   if (recursivePatterns && !names.length && !operands.length) throw new ZipFailure(16, "Invalid command arguments", "nothing to select from");
   if (filesync && action !== "add") throw new ZipFailure(16, "Invalid command arguments", "can't use -d, -f, -u, -U, or -g with filesync -FS\n");
-  return { args, action, archive, output: output2, recursive, recursivePatterns, noWild, stopAtDirectories, quiet, junkPaths, omitDirectories, storeLinks, test, mustMatch, filesync, archiveComment, fromDate, beforeDate, descriptors, zip64, metadata: metadata3, includes, excludes, level, method, suffixes, operands: [...names, ...operands], firstOperand };
+  return { args, action, archive, output: output2, recursive, recursivePatterns, noWild, stopAtDirectories, quiet, junkPaths, omitDirectories, storeLinks, test, mustMatch, filesync, archiveComment, entryComments, fromDate, beforeDate, descriptors, zip64, metadata: metadata3, includes, excludes, level, method, suffixes, operands: [...names, ...operands], firstOperand };
 }
 function memberName(path, limits) {
   if (path.startsWith("//") && !path.startsWith("///")) fail("UNC source paths are unsupported");
@@ -28133,6 +28206,7 @@ async function prepare(scope, parsed, budget) {
   const selected = /* @__PURE__ */ new Map();
   const deleted = /* @__PURE__ */ new Set();
   const synchronized = /* @__PURE__ */ new Map();
+  const commentNames = /* @__PURE__ */ new Set();
   const selection = new Selection([...parsed.includes, ...parsed.excludes], limits, context2.signal, { noWild: parsed.noWild, stopAtDirectories: parsed.stopAtDirectories });
   const recursiveSelection = parsed.recursivePatterns ? new Selection(parsed.operands, limits, context2.signal, { noWild: parsed.noWild, stopAtDirectories: parsed.stopAtDirectories, trailingComponents: true }) : void 0;
   let archiveOperandMatches;
@@ -28153,6 +28227,7 @@ async function prepare(scope, parsed, budget) {
     if (entry.data.length > limits.maxArchiveBytes - compressedBytes) fail("archive byte limit exceeded");
     compressedBytes += entry.data.length;
     selected.set(name2, { entry, source: source2 });
+    if (parsed.entryComments) commentNames.add(name2);
   };
   const visit = async (source2, name2, depth) => {
     context2.signal.throwIfAborted();
@@ -28166,6 +28241,7 @@ async function prepare(scope, parsed, budget) {
       if (previous || !await filterName(name2, selection, parsed.includes.length)) return;
       const prior2 = old.get(name2);
       const modified = /* @__PURE__ */ new Date();
+      if (parsed.entryComments && prior2) commentNames.add(name2);
       if (!zipDateMatches(modified, parsed.fromDate, parsed.beforeDate)) return;
       if (parsed.filesync) {
         if (synchronized.has(name2) && synchronized.get(name2) !== source2) throw new ZipFailure(16, "Invalid command arguments", "cannot repeat names in zip file");
@@ -28188,6 +28264,7 @@ async function prepare(scope, parsed, budget) {
       if (typeof error !== "object" || error === null || !("code" in error)) throw error;
       if (parsed.mustMatch && error.code === "EACCES") throw new ZipFailure(18, "File not found or no read permission", source2);
       if (error.code !== "ENOENT") throw error;
+      if (parsed.entryComments && old.has(name2) && await filterName(name2, selection, parsed.includes.length)) commentNames.add(name2);
       if (parsed.mustMatch && !old.has(name2)) {
         if (!archiveOperandMatches) {
           const fallback = new Selection(parsed.operands.map((operand) => {
@@ -28217,10 +28294,13 @@ async function prepare(scope, parsed, budget) {
     if ((existing2 || publication?.existing) && !hasIdentity(stat)) fail("cannot exclude archive aliases when source backing identity is unknown");
     const directory2 = stat.type === "directory";
     if (directory2 && name2 && !name2.endsWith("/")) name2 += "/";
-    const included = zipDateMatches(new Date(stat.mtimeMs), parsed.fromDate, parsed.beforeDate) && await filterName(name2, selection, parsed.includes.length) && (!recursiveSelection || await recursiveSelection.matches(name2, true));
+    const dateIncluded = zipDateMatches(new Date(stat.mtimeMs), parsed.fromDate, parsed.beforeDate);
+    const nameIncluded = (dateIncluded || parsed.entryComments) && await filterName(name2, selection, parsed.includes.length) && (!recursiveSelection || await recursiveSelection.matches(name2, true));
+    const included = dateIncluded && nameIncluded;
     const sourceName = name2;
     if (parsed.junkPaths) name2 = directory2 ? "" : name2.slice(name2.lastIndexOf("/") + 1);
     const prior = old.get(name2);
+    if (parsed.entryComments && prior && nameIncluded) commentNames.add(name2);
     if (parsed.filesync && name2 && included && !(directory2 && parsed.omitDirectories)) {
       if (synchronized.has(name2) && synchronized.get(name2) !== source2) throw new ZipFailure(16, "Invalid command arguments", "cannot repeat names in zip file");
       synchronized.set(name2, source2);
@@ -28278,7 +28358,8 @@ async function prepare(scope, parsed, budget) {
     }
   };
   const editComment = parsed.archiveComment && parsed.action !== "delete" && parsed.action !== "copy";
-  if (parsed.archiveComment && parsed.action === "copy" && !parsed.quiet) await budget.output("	zip warning: can't set method, move, recurse, or comments with copy mode.\n");
+  const editEntries = parsed.entryComments && parsed.action !== "delete" && parsed.action !== "copy";
+  if ((parsed.archiveComment || parsed.entryComments) && parsed.action === "copy" && !parsed.quiet) await budget.output("	zip warning: can't set method, move, recurse, or comments with copy mode.\n");
   if (parsed.action === "copy") {
     const operands = new Selection(parsed.operands, limits, context2.signal, { noWild: parsed.noWild, stopAtDirectories: parsed.stopAtDirectories });
     for (const entry of archive.entries) {
@@ -28288,7 +28369,7 @@ async function prepare(scope, parsed, budget) {
       }
     }
   } else if (parsed.action === "delete") {
-    if (!parsed.quiet && (parsed.recursive || parsed.archiveComment)) await budget.output("	zip warning: invalid option(s) used with -d; ignored.\n");
+    if (!parsed.quiet && (parsed.recursive || parsed.archiveComment || parsed.entryComments)) await budget.output("	zip warning: invalid option(s) used with -d; ignored.\n");
     if (!parsed.quiet && !archive.entries.length) await budget.output(`	zip warning: ${parsed.archive} not found or empty
 `);
     const operands = new Selection(parsed.recursivePatterns ? [] : parsed.operands, limits, context2.signal, { noWild: parsed.noWild, stopAtDirectories: parsed.stopAtDirectories });
@@ -28321,8 +28402,8 @@ async function prepare(scope, parsed, budget) {
       return { kind: "current" };
     }
   }
-  if (!selected.size && !(editComment && archive.entries.length) && (parsed.action === "freshen" || parsed.action === "update" && (existing2 || !parsed.includes.length))) return void 0;
-  if (!selected.size && !deleted.size && !(editComment && archive.entries.length) && (parsed.action === "delete" || parsed.action === "copy" || parsed.recursivePatterns || parsed.fromDate !== void 0 || parsed.beforeDate !== void 0 || !parsed.includes.length)) {
+  if (!selected.size && !((editComment || editEntries) && archive.entries.length) && (parsed.action === "freshen" || parsed.action === "update" && (existing2 || !parsed.includes.length))) return void 0;
+  if (!selected.size && !deleted.size && !((editComment || editEntries) && archive.entries.length) && (parsed.action === "delete" || parsed.action === "copy" || parsed.recursivePatterns || parsed.fromDate !== void 0 || parsed.beforeDate !== void 0 || !parsed.includes.length)) {
     const detail = parsed.action !== "delete" && parsed.recursive && parsed.firstOperand >= 0 ? `try: zip ${parsed.args.slice(0, parsed.firstOperand).join(" ")} . -i ${parsed.args.slice(parsed.firstOperand).join(" ")}` : parsed.archive;
     throw new ZipFailure(12, "Nothing to do!", detail);
   }
@@ -28373,11 +28454,22 @@ async function prepare(scope, parsed, budget) {
   }
   if (!entries2.length) queue("	zip warning: zip file empty\n");
   let comment2 = archive.comment;
-  if (editComment) {
+  if (editComment || editEntries && commentNames.size) {
     for (const message3 of progress) await budget.output(message3);
     progress.length = 0;
     progressBytes = 0;
-    if (!parsed.quiet) {
+    const commentInput = new ZipCommentInput(scope.stdin, limits, context2.signal);
+    if (editEntries) {
+      for (let index = 0; index < entries2.length; index++) {
+        const entry = entries2[index];
+        if (!commentNames.has(entry.name)) continue;
+        if (!parsed.quiet) await budget.output(`Enter comment for ${entry.name}:
+`);
+        const line = await commentInput.readLine();
+        if (line !== void 0) entries2[index] = setZipEntryComment(entry, line.at(-1) === 10 ? line.subarray(0, -1) : line, limits);
+      }
+    }
+    if (editComment && !parsed.quiet) {
       if (comment2.length) {
         await budget.output("current zip file comment is:\n");
         await budget.output(comment2);
@@ -28385,7 +28477,7 @@ async function prepare(scope, parsed, budget) {
       }
       await budget.output("enter new zip file comment (end with .):\n");
     }
-    comment2 = await readZipComment(scope.stdin, limits, context2.signal);
+    if (editComment) comment2 = await readZipComment(commentInput, limits, context2.signal);
   }
   if (!publication) return { kind: "stream", archive: { entries: entries2, comment: comment2 }, progress };
   const bytes3 = await writeZipArchive({ entries: entries2, comment: comment2 }, limits, context2.signal, false, parsed.zip64 === true);