@poe-platform/safe-bash 0.1.622 → 0.1.624

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

@@ -25649,7 +25649,7 @@ var Budget14 = class {
     if (this.members % 128 === 0) await yieldTurn(this.context.signal);
   }
   async output(value2, stderr = false) {
-    const bytes3 = import_buffer.Buffer.from(value2);
+    const bytes3 = typeof value2 === "string" ? import_buffer.Buffer.from(value2, "utf8") : import_buffer.Buffer.from(value2);
     if (bytes3.length > this.limits.maxTextBytes - this.textBytes) fail("text output limit exceeded");
     this.textBytes += bytes3.length;
     await writeBytes(stderr ? this.context.stderr : this.context.stdout, bytes3, this.context.signal);
@@ -26637,6 +26637,8 @@ var longOptions = {
   update: "u",
   freshen: "f",
   filesync: "FS",
+  "archive-comment": "z",
+  "entry-comments": "c",
   delete: "d",
   include: "i",
   exclude: "x",
@@ -26667,7 +26669,6 @@ var longOptions = {
 var reservedOptions = [
   "adjust-sfx",
   "temp-path",
-  "entry-comments",
   "display-bytes",
   "display-counts",
   "display-dots",
@@ -26706,8 +26707,7 @@ var reservedOptions = [
   "show-options",
   "unzip-command",
   "verbose",
-  "version",
-  "archive-comment"
+  "version"
 ];
 function normalizeZipOption(argument2) {
   if (!argument2.startsWith("--") || argument2 === "--") return argument2;
@@ -26822,6 +26822,72 @@ function zipEnvironmentArguments(env, argv, limits) {
   return [...defaults, ...argv];
 }
 
+// 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 = [];
+  let length = 0;
+  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?.();
+  }
+}
+
 // packages/safe-bash/src/commands/archive/zip-format.ts
 init_platform();
 
@@ -27296,6 +27362,46 @@ 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");
@@ -27667,23 +27773,30 @@ function tokenize2(pattern, noWild, stopAtDirectories) {
       const negative = characters[index + 1] === "!" || characters[index + 1] === "^";
       if (negative) index++;
       const ranges = [];
-      let closed = false;
-      while (++index < characters.length) {
-        let first = characters[index];
-        if (first === "]") {
-          closed = true;
-          break;
-        }
-        if (first === "\\") first = characters[++index] ?? "";
-        let last = first;
-        if (characters[index + 1] === "-" && characters[index + 2] && characters[index + 2] !== "]") {
-          index += 2;
-          last = characters[index];
-          if (last === "\\") last = characters[++index] ?? "";
+      const start = index + 1;
+      let closing = start;
+      let escaped3 = false;
+      for (; closing < characters.length; closing++) {
+        const current = characters[closing];
+        if (escaped3) escaped3 = false;
+        else if (current === "\\") escaped3 = true;
+        else if (current === "]") break;
+      }
+      let first;
+      escaped3 = characters[start] === "-";
+      for (let position = start; position < closing; position++) {
+        const current = characters[position];
+        if (!escaped3 && current === "\\") escaped3 = true;
+        else if (!escaped3 && current === "-") first = characters[position - 1].codePointAt(0);
+        else {
+          const last = current.codePointAt(0);
+          if (characters[position + 1] !== "-") ranges.push([first ?? last, last]);
+          first = void 0;
+          escaped3 = false;
         }
-        ranges.push([first.codePointAt(0) ?? -1, last.codePointAt(0) ?? -1]);
       }
-      tokens2.push(closed ? { kind: "class", ranges, negative } : { kind: "never" });
+      index = closing;
+      tokens2.push(closing < characters.length ? { kind: "class", ranges, negative } : { kind: "never" });
     } else tokens2.push({ kind: "literal", value: character });
   }
   return tokens2;
@@ -27824,6 +27937,8 @@ async function parse12(scope, limits) {
   let test = false;
   let mustMatch = false;
   let filesync = false;
+  let archiveComment = false;
+  let entryComments = false;
   let fromDate;
   let beforeDate;
   let descriptors = false;
@@ -27877,6 +27992,8 @@ async function parse12(scope, limits) {
           filesync = true;
           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";
@@ -27995,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, 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");
@@ -28089,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;
@@ -28109,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();
@@ -28144,6 +28263,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) => {
@@ -28177,6 +28297,7 @@ async function prepare(scope, parsed, budget) {
     const sourceName = name2;
     if (parsed.junkPaths) name2 = directory2 ? "" : name2.slice(name2.lastIndexOf("/") + 1);
     const prior = old.get(name2);
+    if (parsed.entryComments && prior && included && !(directory2 && parsed.omitDirectories)) 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);
@@ -28233,6 +28354,9 @@ async function prepare(scope, parsed, budget) {
       }
     }
   };
+  const editComment = parsed.archiveComment && parsed.action !== "delete" && parsed.action !== "copy";
+  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) {
@@ -28242,7 +28366,7 @@ async function prepare(scope, parsed, budget) {
       }
     }
   } else if (parsed.action === "delete") {
-    if (!parsed.quiet && parsed.recursive) 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 });
@@ -28275,8 +28399,8 @@ async function prepare(scope, parsed, budget) {
       return { kind: "current" };
     }
   }
-  if (!selected.size && (parsed.action === "freshen" || parsed.action === "update" && (existing2 || !parsed.includes.length))) return void 0;
-  if (!selected.size && !deleted.size && (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);
   }
@@ -28326,8 +28450,34 @@ async function prepare(scope, parsed, budget) {
     append(entry, false);
   }
   if (!entries2.length) queue("	zip warning: zip file empty\n");
-  if (!publication) return { kind: "stream", archive: { entries: entries2, comment: archive.comment }, progress };
-  const bytes3 = await writeZipArchive({ entries: entries2, comment: archive.comment }, limits, context2.signal, false, parsed.zip64 === true);
+  let comment2 = archive.comment;
+  if (editComment || editEntries && commentNames.size) {
+    for (const message3 of progress) await budget.output(message3);
+    progress.length = 0;
+    progressBytes = 0;
+    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);
+        if (comment2.at(-1) !== 10) await budget.output("\n");
+      }
+      await budget.output("enter new zip file comment (end with .):\n");
+    }
+    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);
   if (parsed.test && parsed.archive !== "-") {
     for (const message3 of progress) await budget.output(message3);
     progress.length = 0;