@poe-platform/safe-bash 0.1.798 → 0.1.800

package/dist/safe-bash/command-chunks/chunk-7RGB363W.js

@@ -0,0 +1,362 @@
+import {
+  Extraction
+} from "./chunk-NFGI5IGF.js";
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-unzip/src/unzip.ts
+init_buffer();
+import { collectBytes, dirname, readBytes, resolvePath, writeBytes } from "../../safe-bash-contracts/index.js";
+import { PublicDiagnostic, publicDiagnosticMessage } from "../../safe-bash-contracts/diagnostics.js";
+import { writeFileOutput } from "../../safe-bash-contracts/filesystem-output.js";
+import { createOutputOperation } from "../../safe-bash-contracts/output.js";
+import { byteLength, concatBytes, encodeBytes } from "../../safe-bash-io-engine/byte-encoding.js";
+import { bounded, Budget, checkPath, display, fail, invocationLimits, settings, text, vfsPath } from "../../safe-bash-io-engine/commands/archive/internal.js";
+import { Answers, parseArguments, Selection } from "../../safe-bash-zip-engine/unzip/arguments.js";
+import { decodeZipEntry, readZipArchive } from "../../safe-bash-zip-engine/zip-format.js";
+import { readZipPassword } from "../../safe-bash-zip-engine/zip/crypto.js";
+import { resolveZipVolumes } from "../../safe-bash-zip-engine/zip/volumes.js";
+function filtered(name) {
+  let output = "";
+  for (const character of name) {
+    const code = character.charCodeAt(0);
+    output += code < 32 ? `^${String.fromCharCode(code + 64)}` : character;
+  }
+  return output;
+}
+function padded(name) {
+  return name + " ".repeat(Math.max(0, 22 - byteLength(name)));
+}
+function date(entry) {
+  const modified = entry.modified;
+  const pad = (value) => String(value).padStart(2, "0");
+  return `${modified.getFullYear()}-${pad(modified.getMonth() + 1)}-${pad(modified.getDate())} ${pad(modified.getHours())}:${pad(modified.getMinutes())}`;
+}
+async function comment(bytes, budget) {
+  if (!bytes.length) return;
+  const output = [];
+  let length = 0;
+  for (const byte of bytes) {
+    if (!byte) break;
+    if (byte !== 13 && byte !== 19) length += byte === 27 ? 2 : 1;
+    if (length > budget.limits.maxTextBytes - budget.textBytes) fail("text output limit exceeded");
+  }
+  for (const byte of bytes) {
+    if (!byte) break;
+    if (byte === 13 || byte === 19) continue;
+    if (byte === 27) output.push(94, 91);
+    else output.push(byte);
+  }
+  if (output.length && output.at(-1) !== 10) output.push(10);
+  const value = Uint8Array.from(output);
+  if (value.length > budget.limits.maxTextBytes - budget.textBytes) fail("text output limit exceeded");
+  budget.textBytes += value.length;
+  await writeBytes(budget.context.stdout, value, budget.context.signal);
+}
+function createUnzipCommand(options = {}) {
+  const configured = settings(options);
+  return { name: "unzip", description: "List, stream or safely extract ZIP archives in the virtual filesystem", async execute(original) {
+    const limits = invocationLimits(configured, original);
+    original.signal.throwIfAborted();
+    const controller = new AbortController();
+    const context = { ...original, signal: AbortSignal.any([original.signal, controller.signal]) };
+    const extraction = new Extraction(context, limits);
+    let output;
+    let answers;
+    let closing;
+    const close = () => closing ??= (async () => {
+      controller.abort(new Error("unzip command closed"));
+      await Promise.all([extraction.close(), output?.close()]);
+      await answers?.close().catch(() => {
+      });
+    })();
+    original.registerCleanup?.(close);
+    const budget = new Budget(context, limits);
+    try {
+      const parsed = parseArguments(context, limits);
+      if (parsed.pipe) output = createOutputOperation(context, context.stdout);
+      if (parsed.pipe && parsed.destination !== void 0) await budget.output("caution:  not extracting; -d ignored\n", true);
+      const selection = new Selection(parsed.patterns, limits, context.signal, { caseInsensitive: parsed.caseInsensitive });
+      const exclusions = new Selection(parsed.exclusions, limits, context.signal, { caseInsensitive: parsed.caseInsensitive });
+      let archive = parsed.archive;
+      let archiveStat;
+      for (const candidate of [archive, `${archive}.zip`, `${archive}.ZIP`]) {
+        checkPath(candidate, limits);
+        const candidateStat = await extraction.stat(vfsPath(context.cwd, candidate));
+        if (candidateStat) {
+          archive = candidate;
+          archiveStat = candidateStat;
+          break;
+        }
+      }
+      if (!archiveStat) {
+        if (!parsed.pipe) await budget.output(`unzip:  cannot find or open ${archive}, ${archive}.zip or ${archive}.ZIP.
+`, true);
+        return { exitCode: 9 };
+      }
+      const archivePath = await extraction.operation(() => context.fs.realpath(vfsPath(context.cwd, archive), { signal: context.signal }));
+      archiveStat = await extraction.operation(() => context.fs.stat(archivePath, { signal: context.signal }));
+      if (archiveStat.type !== "file") fail("input archive is not a regular file");
+      if (!Number.isSafeInteger(archiveStat.size) || archiveStat.size < 0 || archiveStat.size > limits.maxArchiveBytes) fail("archive byte limit exceeded");
+      const bytes = await collectBytes(bounded(extraction.input(archivePath), limits.maxArchiveBytes, context.signal, limits.chunkSize), { signal: context.signal, ...Number.isFinite(limits.maxArchiveBytes) ? { maxBytes: limits.maxArchiveBytes } : {}, ...Number.isFinite(limits.maxInputMemoryBytes) ? { maxMemoryBytes: limits.maxInputMemoryBytes } : {} });
+      if ((!parsed.pipe || parsed.pipeHeaders) && !parsed.names && !parsed.quiet) await budget.output(`Archive:  ${filtered(archive)}
+`);
+      const resolved = await resolveZipVolumes({ context, limits, operation: (action) => extraction.operation(async () => action()), stat: (path) => extraction.stat(path), input: (path) => extraction.input(path) }, archivePath, bytes, options.zipHost);
+      extraction.inputVolumes = resolved.volumes ?? [];
+      const zip = await readZipArchive(resolved.bytes, limits, context.signal, resolved.disks ? { disks: resolved.disks } : { prefix: true });
+      if (parsed.archiveComment || (!parsed.pipe || parsed.pipeHeaders) && !parsed.names && !parsed.quiet) await comment(zip.comment, budget);
+      if (parsed.archiveComment) return { exitCode: 0 };
+      if (!zip.entries.length) {
+        await budget.output(`warning [${filtered(archive)}]:  zipfile is empty
+`, true);
+        return { exitCode: 1 };
+      }
+      if (parsed.names) {
+        let selected2 = 0;
+        for (const entry of zip.entries) {
+          await budget.member(entry.size);
+          checkPath(entry.name, limits);
+          if (!await selection.matches(entry.name, true)) continue;
+          if (parsed.exclusions.length && await exclusions.matches(entry.name, true)) continue;
+          await budget.output(`${filtered(entry.name)}
+`);
+          selected2++;
+        }
+        let unmatched = false;
+        for (let index = 0; index < parsed.patterns.length; index++) if (!selection.matched.has(index)) {
+          await budget.output(`caution: filename not matched:  ${filtered(parsed.patterns[index])}
+`, true);
+          unmatched = true;
+        }
+        return { exitCode: selected2 && !unmatched ? 0 : 11 };
+      }
+      if (parsed.list) await budget.output(parsed.verbose ? " Length   Method    Size  Cmpr    Date    Time   CRC-32   Name\n--------  ------  ------- ---- ---------- ----- --------  ----\n" : "  Length      Date    Time    Name\n---------  ---------- -----   ----\n");
+      const rootRaw = parsed.destination === void 0 ? context.cwd : vfsPath(context.cwd, parsed.destination);
+      const root = parsed.list || parsed.pipe || parsed.test ? resolvePath(rootRaw) : await extraction.directory(rootRaw, true);
+      if (!parsed.list && !parsed.pipe && !parsed.test) answers = new Answers(extraction.source(context.stdin), limits, context.signal);
+      let overwrite = parsed.neverOverwrite ? "none" : parsed.overwrite ? "all" : "ask";
+      let exitCode = 0;
+      let selected = 0;
+      let badPasswords = 0;
+      let total = 0;
+      let compressedTotal = 0;
+      let actualTotal = 0;
+      let password = parsed.password;
+      const payload = async function* (entry) {
+        let actual = 0;
+        const signal = output?.signal ?? context.signal;
+        if (entry.flags & 1) {
+          for (let attempt = password !== void 0 && parsed.password === void 0 ? -1 : 0; attempt < 3; attempt++) {
+            if (password === void 0) password = await extraction.operation(() => readZipPassword(options.zipHost, limits.maxArgumentBytes, signal, false));
+            try {
+              const verified = await collectBytes(decodeZipEntry(entry, limits, signal, password), { ...Number.isFinite(Math.min(limits.maxEntryBytes, limits.maxTotalBytes - actualTotal)) ? { maxBytes: Math.min(limits.maxEntryBytes, limits.maxTotalBytes - actualTotal) } : {}, signal });
+              actualTotal += verified.length;
+              yield verified;
+              return;
+            } catch (error) {
+              signal.throwIfAborted();
+              if (parsed.password !== void 0 || !(error instanceof PublicDiagnostic) || error.message !== "ZIP incorrect password") throw error;
+              password = void 0;
+            }
+          }
+          fail("ZIP incorrect password");
+        }
+        for await (const chunk of readBytes(decodeZipEntry(entry, limits, signal, password), signal)) {
+          if (chunk.length > limits.maxEntryBytes - actual || chunk.length > limits.maxTotalBytes - actualTotal) fail("actual decompressed byte limit exceeded");
+          actual += chunk.length;
+          actualTotal += chunk.length;
+          yield chunk;
+        }
+      };
+      const links = [];
+      const directories = [];
+      for (const entry of zip.entries) {
+        await budget.member(entry.size);
+        checkPath(entry.name, limits);
+        if (!await selection.matches(entry.name, true)) continue;
+        if (parsed.exclusions.length && await exclusions.matches(entry.name, true)) continue;
+        selected++;
+        total += entry.size;
+        try {
+          if (parsed.test) {
+            for await (const chunk of payload(entry)) {
+              if (chunk.length) context.signal.throwIfAborted();
+            }
+            if (!parsed.quiet) await budget.output(`    testing: ${padded(filtered(entry.name))} OK
+`);
+            continue;
+          }
+          if (parsed.pipe) {
+            if (parsed.pipeHeaders && !parsed.quiet) await budget.output(`${entry.method === 0 ? " extracting" : "  inflating"}: ${padded(filtered(entry.name))}  
+`);
+            for await (const chunk of payload(entry)) await output.output.write(chunk);
+            if (parsed.pipeHeaders && !parsed.quiet) await budget.output("\n");
+            continue;
+          }
+          if (parsed.list) {
+            const size = entry.compressedSize ?? entry.data.length;
+            compressedTotal += size;
+            const method = entry.method === 0 ? "Stored" : entry.method === 8 ? "Defl:N" : entry.method === 12 ? "BZip2" : entry.method === 14 ? "LZMA" : `m${entry.method}`;
+            const ratio = entry.size ? Math.round(100 * (entry.size - size) / entry.size) : 0;
+            await budget.output(parsed.verbose ? `${String(entry.size).padStart(8)}  ${method.padEnd(6)} ${String(size).padStart(8)} ${String(ratio).padStart(3)}% ${date(entry)} ${entry.crc32.toString(16).padStart(8, "0")}  ${filtered(entry.name)}
+` : `${String(entry.size).padStart(9)}  ${date(entry)}   ${filtered(entry.name)}
+`);
+            if (entry.comment) await comment(entry.comment, budget);
+            continue;
+          }
+          let path = extraction.member(root, entry.name);
+          const fileType = entry.mode & 61440;
+          if (fileType && fileType !== 32768 && fileType !== 16384 && fileType !== 40960 && fileType !== 4096) fail("unsupported special ZIP entry");
+          if (path === root && !entry.directory) fail("entry would replace extraction root");
+          if (parsed.junkPaths && entry.directory) continue;
+          const name = parsed.junkPaths ? entry.name.split("/").at(-1) : entry.name;
+          if (parsed.junkPaths) path = extraction.member(root, name);
+          if (path === root && !entry.directory) fail("entry would replace extraction root");
+          let shown = parsed.destination === void 0 ? name : `${parsed.destination.endsWith("/") ? parsed.destination : `${parsed.destination}/`}${name}`;
+          if (parsed.freshen && !await extraction.stat(path)) continue;
+          await extraction.parents(root, path, true);
+          if (entry.directory) {
+            if (entry.size) fail("directory has nonempty payload");
+            for await (const chunk of payload(entry)) {
+              await writeFileOutput(context, chunk, async () => {
+                if (chunk.length) fail("directory has nonempty payload");
+              });
+            }
+            const parent2 = await extraction.operation(() => context.fs.lstat(dirname(path), { signal: context.signal }));
+            const existing2 = await extraction.stat(path);
+            let identity = existing2;
+            if (existing2 && existing2.type !== "directory") fail("directory destination is not a directory");
+            if (!existing2) {
+              identity = await extraction.createDirectory(path, parent2);
+              if (!parsed.quiet) await budget.output(`   creating: ${filtered(shown)}
+`);
+            }
+            if (!identity || identity.type !== "directory") fail("directory changed during creation");
+            directories.push({ path, entry, identity, parent: parent2 });
+            continue;
+          }
+          let parent = await extraction.operation(() => context.fs.lstat(dirname(path), { signal: context.signal }));
+          let existing = await extraction.destination(path, archivePath, archiveStat);
+          if (parsed.update && existing && Math.ceil(Math.floor(existing.mtimeMs / 1e3) / 2) * 2e3 >= entry.modified.getTime()) continue;
+          let skip = false;
+          let prompting = 0;
+          while (existing && overwrite !== "all") {
+            if (overwrite === "none") {
+              skip = true;
+              break;
+            }
+            if (++prompting > limits.maxMembers) fail("overwrite prompt work limit exceeded");
+            await budget.output(`replace ${filtered(shown)}? [y]es, [n]o, [A]ll, [N]one, [r]ename: `, true);
+            const answer = await answers.read();
+            if (answer === void 0) {
+              await budget.output(' NULL\n(EOF or read error, treating as "[N]one" ...)\n', true);
+              overwrite = "none";
+              exitCode = 1;
+              skip = true;
+              break;
+            }
+            const choice = answer[0];
+            if (choice === "A") {
+              overwrite = "all";
+              break;
+            }
+            if (choice === "y" || choice === "Y") break;
+            if (choice === "n" || choice === "N") {
+              if (choice === "N") overwrite = "none";
+              skip = true;
+              break;
+            }
+            if (choice === "r" || choice === "R") {
+              let renamed = "";
+              while (!renamed) {
+                await budget.output("new name: ", true);
+                const value = await answers.read(limits.maxPathBytes);
+                if (value === void 0) fail("EOF while reading replacement name");
+                renamed = value.endsWith("\n") ? value.slice(0, -1) : value;
+              }
+              path = extraction.member(root, renamed);
+              shown = parsed.destination === void 0 ? renamed : `${parsed.destination.endsWith("/") ? parsed.destination : `${parsed.destination}/`}${renamed}`;
+              await extraction.parents(root, path, true);
+              parent = await extraction.operation(() => context.fs.lstat(dirname(path), { signal: context.signal }));
+              existing = await extraction.destination(path, archivePath, archiveStat);
+              continue;
+            }
+            const response = choice === "\n" || choice === "\r" ? "{ENTER}" : answer.endsWith("\n") ? answer.slice(0, -1) : answer;
+            await budget.output(`error:  invalid response [${response}]
+`, true);
+          }
+          if (skip) continue;
+          const chunks = [];
+          let actual = 0;
+          for await (const chunk of payload(entry)) {
+            actual += chunk.length;
+            await writeFileOutput(context, chunk, async (bytes2) => {
+              chunks.push(Uint8Array.from(bytes2));
+            });
+          }
+          if (entry.symlink) {
+            if (actual > limits.maxPathBytes) fail("symlink target byte limit exceeded");
+            const target = text(concatBytes(chunks));
+            await extraction.target(root, path, target);
+            if (!context.fs.symlink || context.fs.capabilities.symlinks === false) fail("filesystem does not support symlinks");
+            links.push({ path, shown, target, existing, parent, entry });
+            if (!parsed.quiet) await budget.output(`    linking: ${padded(filtered(shown))}  -> ${filtered(target)} 
+`);
+          } else {
+            await extraction.publish(root, path, chunks, existing, parent, entry.mode, entry.modified);
+            if (!parsed.quiet) await budget.output(`${entry.method === 0 ? " extracting" : "  inflating"}: ${padded(filtered(shown))}  
+`);
+          }
+        } catch (error) {
+          context.signal.throwIfAborted();
+          if (!(error instanceof PublicDiagnostic) || error.message !== "ZIP incorrect password") throw error;
+          badPasswords++;
+          await budget.output(`skipping: ${filtered(entry.name)}  incorrect password
+`, true);
+        }
+      }
+      if (parsed.list) await budget.output(parsed.verbose ? `--------          -------  ---                            -------
+${String(total).padStart(8)}         ${String(compressedTotal).padStart(8)} ${String(total ? Math.round(100 * (total - compressedTotal) / total) : 0).padStart(3)}%                            ${selected} file${selected === 1 ? "" : "s"}
+` : `---------                     -------
+${String(total).padStart(9)}                     ${selected} file${selected === 1 ? "" : "s"}
+`);
+      else {
+        if (links.length && !parsed.quiet) await budget.output("finishing deferred symbolic links:\n");
+        for (const link of links) {
+          await extraction.parents(root, link.path, false);
+          await extraction.target(root, link.path, link.target);
+          await extraction.destination(link.path, archivePath, archiveStat);
+          await extraction.publish(root, link.path, [], link.existing, link.parent, link.entry.mode, link.entry.modified, link.target);
+          if (!parsed.quiet) await budget.output(`  ${padded(filtered(link.shown))} -> ${filtered(link.target)}
+`);
+        }
+        for (const { path, entry, identity, parent } of directories.reverse()) {
+          await extraction.metadata(root, path, identity, parent, entry.mode, entry.modified);
+        }
+      }
+      for (let index = 0; index < parsed.patterns.length; index++) if (!selection.matched.has(index)) {
+        await budget.output(`caution: filename not matched:  ${filtered(parsed.patterns[index])}
+`, true);
+        exitCode = 11;
+      }
+      const resultCode = badPasswords ? badPasswords === selected ? 82 : 1 : selected ? exitCode : 11;
+      if (parsed.test && parsed.quiet < 2) await budget.output(resultCode ? `At least one error was detected in ${filtered(archive)}.
+` : `No errors detected in compressed data of ${filtered(archive)}.
+`);
+      return { exitCode: resultCode };
+    } catch (error) {
+      original.signal.throwIfAborted();
+      const message = display(publicDiagnosticMessage(error, original.onInternalError).slice(0, limits.maxDiagnosticBytes));
+      await writeBytes(original.stderr, encodeBytes(`unzip: ${message}
+`).subarray(0, limits.maxDiagnosticBytes), original.signal);
+      return { exitCode: 2 };
+    } finally {
+      await close();
+    }
+  } };
+}
+
+export {
+  createUnzipCommand
+};

package/dist/safe-bash/command-chunks/{chunk-HBXQWTJR.js → chunk-A5ZAV6DO.js}

@@ -3,7 +3,7 @@ import {
   bytes,
   fileQuote,
   pathText
-} from "./chunk-CZVBYCB5.js";
+} from "./chunk-IL53SJL4.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";

package/dist/safe-bash/command-chunks/{chunk-LW34AKDM.js → chunk-AB4MXHVS.js}

@@ -6,7 +6,7 @@ import {
 init_buffer();
 import { getCommandArguments } from "../../safe-bash-contracts/index.js";
 import { shellValueByteLength, shellValueBytes } from "../../safe-bash-contracts/value.js";
-import { hasYieldCheckpoint, monotonicNow, runYieldCheckpoint, yieldTurn } from "../../safe-bash-contracts/yield.js";
+import { yieldTurn } from "../../safe-bash-contracts/yield.js";
 import { PublicDiagnostic } from "../../safe-bash-contracts/diagnostics.js";
 function settings(options) {
   const limits = {
@@ -67,8 +67,6 @@ var Budget = class {
   admission;
   work = 0;
   checkpoint = 0;
-  checkpointCount = 0;
-  lastYield = monotonicNow();
   retained = 0;
   input = 0;
   output = 0;
@@ -93,17 +91,9 @@ var Budget = class {
     this.assertOpen();
     if (this.work - this.checkpoint < 4096) return;
     this.checkpoint = this.work;
-    const count = ++this.checkpointCount;
-    const now = monotonicNow();
-    if (count === 1 || count % 16 === 0 || now - this.lastYield >= 16 || hasYieldCheckpoint(this.callerSignal)) {
-      this.lastYield = now;
-      return yieldTurn(this.callerSignal).then(() => {
-        this.lastYield = monotonicNow();
-        this.assertOpen();
-      });
-    }
-    runYieldCheckpoint(this.callerSignal);
-    this.assertOpen();
+    return yieldTurn(this.callerSignal).then(() => {
+      this.assertOpen();
+    });
   }
   retain(amount) {
     this.check(this.retained + amount, this.limits.maxBufferedBytes, "buffered bytes");