@poe-platform/safe-bash 0.1.799 → 0.1.800

package/dist/safe-bash/command-chunks/{chunk-ZXKW7SJ2.js → chunk-TYCGMRLM.js}

@@ -1,7 +1,7 @@
 import {
   indexValue,
   type
-} from "./chunk-YZ5SVZFD.js";
+} from "./chunk-UMDIOL3O.js";
 import {
   JqError,
   JqLimitError,
@@ -9,7 +9,7 @@ import {
   isObject,
   put,
   remove
-} from "./chunk-VVI4Z73I.js";
+} from "./chunk-QP4R6GLA.js";
 import {
   isNumber,
   numberValue

package/dist/safe-bash/command-chunks/chunk-UG7SMZFF.js

@@ -0,0 +1,178 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-diff/src/diff-options.ts
+init_buffer();
+import { ToolError } from "../../safe-bash-diff-engine/shared.js";
+import { Pattern } from "../../safe-bash-regex-engine/text/regex.js";
+function contextLength(value) {
+  if (!/^(?:[ \t\n\v\f\r]*[+-]?\d+)?$/u.test(value) || Number(value) < 0) {
+    throw new ToolError(`invalid context length: ${value}`);
+  }
+  return Math.min(Number(value), Number.MAX_SAFE_INTEGER);
+}
+function flags(args) {
+  const result = { format: "normal", whitespace: "exact", context: 0, brief: false, recursive: false, newFile: false, unidirectionalNewFile: false, stripTrailingCr: false, ignoreFileNameCase: false, labels: [], files: [], optionArgs: [], ignoreCase: false, ignoreBlank: false, ignoreTrailing: false, ignoreTabs: false, ignorePatterns: [], functions: [], reportSame: false, text: false, paginate: false, excludes: [], excludeFiles: [], width: 130, expand: false, initialTab: false, leftColumn: false, suppressCommon: false, symbol: "" };
+  let selectedFormat;
+  const selectFormat = (format) => {
+    if (selectedFormat !== void 0 && selectedFormat !== format) throw new ToolError("conflicting output format options");
+    selectedFormat = result.format = format;
+  };
+  let explicitWidth;
+  let legacyContext = -1;
+  let previousDigit = false;
+  const selectContext = (format, width, explicit) => {
+    selectFormat(format);
+    if (explicit) {
+      if (explicitWidth !== void 0 && explicitWidth !== width) throw new ToolError("conflicting output style options");
+      explicitWidth = width;
+    }
+    result.context = explicitWidth ?? width;
+  };
+  let operands = false;
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index];
+    const optionStart = index;
+    const isOption = !operands && arg !== "-" && arg.startsWith("-");
+    if (!operands && arg.startsWith("--")) previousDigit = false;
+    const value = (attached, name) => {
+      const next = attached ?? args[++index];
+      if (next === void 0) throw new ToolError(`${name} requires an argument`);
+      return next;
+    };
+    if (operands || arg === "-" || !arg.startsWith("-")) result.files.push(arg);
+    else if (arg === "--") operands = true;
+    else if (arg === "--brief") result.brief = true;
+    else if (arg === "--recursive") result.recursive = true;
+    else if (arg === "--new-file") result.newFile = true;
+    else if (arg === "--unidirectional-new-file") result.unidirectionalNewFile = true;
+    else if (arg === "--strip-trailing-cr") result.stripTrailingCr = true;
+    else if (arg === "--no-dereference") result.noDereference = true;
+    else if (arg === "--ignore-file-name-case") result.ignoreFileNameCase = true;
+    else if (arg === "--no-ignore-file-name-case") result.ignoreFileNameCase = false;
+    else if (arg === "--ignore-case") result.ignoreCase = true;
+    else if (arg === "--ignore-blank-lines") result.ignoreBlank = true;
+    else if (arg === "--ignore-trailing-space") result.ignoreTrailing = true;
+    else if (arg === "--ignore-tab-expansion") result.ignoreTabs = true;
+    else if (arg === "--report-identical-files") result.reportSame = true;
+    else if (arg === "--text") result.text = true;
+    else if (arg === "--minimal") {
+    } else if (arg === "--side-by-side") selectFormat("side");
+    else if (arg === "--ed") selectFormat("ed");
+    else if (arg === "--rcs") selectFormat("rcs");
+    else if (arg === "--expand-tabs") result.expand = true;
+    else if (arg === "--initial-tab") result.initialTab = true;
+    else if (arg === "--left-column") result.leftColumn = true;
+    else if (arg === "--suppress-common-lines") result.suppressCommon = true;
+    else if (arg === "--paginate") result.paginate = true;
+    else if (arg === "--color" || arg.startsWith("--color=")) {
+      const mode = arg === "--color" ? "auto" : arg.slice(8);
+      if (mode !== "auto" && mode !== "always" && mode !== "never") throw new ToolError(`invalid color: ${mode}`);
+      result.color = mode === "always";
+    } else if (arg === "--show-c-function") result.functions.push(new Pattern("^[A-Za-z_$]", false));
+    else if (["--width", "--ifdef", "--ignore-matching-lines", "--show-function-line", "--exclude", "--exclude-from", "--starting-file", "--from-file", "--to-file"].some((name) => arg === name || arg.startsWith(`${name}=`))) {
+      const equal = arg.indexOf("=");
+      const name = equal < 0 ? arg : arg.slice(0, equal);
+      const parameter = value(equal < 0 ? void 0 : arg.slice(equal + 1), name);
+      if (name === "--width") result.width = outputWidth(parameter);
+      else if (name === "--ifdef") {
+        selectFormat("ifdef");
+        result.symbol = parameter;
+      } else if (name === "--ignore-matching-lines") result.ignorePatterns.push(new Pattern(parameter, false));
+      else if (name === "--show-function-line") result.functions.push(new Pattern(parameter, false));
+      else if (name === "--exclude") result.excludes.push({ pattern: parameter, ignoreCase: result.ignoreFileNameCase });
+      else if (name === "--exclude-from") result.excludeFiles.push({ path: parameter, ignoreCase: result.ignoreFileNameCase });
+      else if (name === "--from-file") result.fromFile = parameter;
+      else if (name === "--to-file") result.toFile = parameter;
+      else result.startingFile = parameter;
+    } else if (arg === "--ignore-all-space") result.whitespace = "all";
+    else if (arg === "--ignore-space-change") {
+      if (result.whitespace !== "all") result.whitespace = "change";
+    } else if (arg === "--normal") selectFormat("normal");
+    else if (arg === "--unified") selectContext("unified", 3, false);
+    else if (arg.startsWith("--unified=")) selectContext("unified", contextLength(arg.slice(10)), true);
+    else if (arg === "--context") selectContext("context", 3, false);
+    else if (arg.startsWith("--context=")) selectContext("context", contextLength(arg.slice(10)), true);
+    else if (arg === "--label" || arg.startsWith("--label=")) result.labels.push(value(arg.includes("=") ? arg.slice(8) : void 0, "--label"));
+    else if (arg.startsWith("--")) throw new ToolError(`unsupported option: ${arg}`);
+    else {
+      for (let offset = 1; offset < arg.length; offset++) {
+        const flag = arg[offset];
+        if (/^\d$/u.test(flag)) {
+          legacyContext = Math.min((previousDigit ? legacyContext : 0) * 10 + Number(flag), Number.MAX_SAFE_INTEGER);
+          previousDigit = true;
+          continue;
+        }
+        previousDigit = false;
+        if (flag === "u") selectContext("unified", 3, false);
+        else if (flag === "c") selectContext("context", 3, false);
+        else if (flag === "q") result.brief = true;
+        else if (flag === "r") result.recursive = true;
+        else if (flag === "N") result.newFile = true;
+        else if (flag === "P") result.unidirectionalNewFile = true;
+        else if (flag === "i") result.ignoreCase = true;
+        else if (flag === "B") result.ignoreBlank = true;
+        else if (flag === "Z") result.ignoreTrailing = true;
+        else if (flag === "E") result.ignoreTabs = true;
+        else if (flag === "s") result.reportSame = true;
+        else if (flag === "a") result.text = true;
+        else if (flag === "d") {
+        } else if (flag === "y") selectFormat("side");
+        else if (flag === "e") selectFormat("ed");
+        else if (flag === "n") selectFormat("rcs");
+        else if (flag === "t") result.expand = true;
+        else if (flag === "T") result.initialTab = true;
+        else if (flag === "l") result.paginate = true;
+        else if (flag === "p") result.functions.push(new Pattern("^[A-Za-z_$]", false));
+        else if (flag === "w") result.whitespace = "all";
+        else if (flag === "b") {
+          if (result.whitespace !== "all") result.whitespace = "change";
+        } else if ("UCLWDIFxXS".includes(flag)) {
+          const parameter = value(arg.slice(offset + 1) || void 0, `-${flag}`);
+          if (flag === "U") selectContext("unified", contextLength(parameter), true);
+          else if (flag === "C") selectContext("context", contextLength(parameter), true);
+          else if (flag === "L") result.labels.push(parameter);
+          else if (flag === "W") result.width = outputWidth(parameter);
+          else if (flag === "D") {
+            selectFormat("ifdef");
+            result.symbol = parameter;
+          } else if (flag === "I") result.ignorePatterns.push(new Pattern(parameter, false));
+          else if (flag === "F") result.functions.push(new Pattern(parameter, false));
+          else if (flag === "x") result.excludes.push({ pattern: parameter, ignoreCase: result.ignoreFileNameCase });
+          else if (flag === "X") result.excludeFiles.push({ path: parameter, ignoreCase: result.ignoreFileNameCase });
+          else result.startingFile = parameter;
+          break;
+        } else throw new ToolError(`unsupported option: -${flag}`);
+      }
+    }
+    if (isOption) result.optionArgs.push(...args.slice(optionStart, index + 1));
+  }
+  if (legacyContext >= 0 && (result.format === "unified" || result.format === "context")) {
+    result.context = explicitWidth !== void 0 ? Math.max(result.context, legacyContext) : legacyContext;
+  }
+  if (result.fromFile !== void 0 && result.toFile !== void 0) throw new ToolError("--from-file and --to-file may not both be specified");
+  const multiple = result.fromFile !== void 0 || result.toFile !== void 0;
+  if (multiple ? result.files.length === 0 : result.files.length !== 2) throw new ToolError(multiple ? "expected at least one file or directory" : "expected two files or directories");
+  if (selectedFormat === void 0 && result.functions.length) {
+    result.format = "context";
+    result.context = Math.max(3, result.context);
+  }
+  if (result.labels.length > 2) throw new ToolError("at most two labels are supported");
+  for (const name of [...result.files, ...[result.fromFile, result.toFile].filter((name2) => name2 !== void 0)]) {
+    if (!name || /[\0\r\n\t]/u.test(name)) throw new ToolError("empty names or control characters in filenames/labels are unsupported");
+  }
+  for (const label of result.labels) {
+    if (/[\0\r\n\t]/u.test(label)) throw new ToolError("empty names or control characters in filenames/labels are unsupported");
+  }
+  return result;
+}
+function outputWidth(value) {
+  const width = contextLength(value);
+  if (width < 1) throw new ToolError(`invalid width: ${value}`);
+  return width;
+}
+
+export {
+  flags
+};

package/dist/safe-bash/command-chunks/{chunk-YZ5SVZFD.js → chunk-UMDIOL3O.js}

@@ -1,10 +1,10 @@
 import {
   splitString
-} from "./chunk-UI32HWGS.js";
+} from "./chunk-HMOZ6XVJ.js";
 import {
   jsonFragments,
   renderJsonFragment
-} from "./chunk-5ZSM4UFN.js";
+} from "./chunk-YGC6OS5O.js";
 import {
   JqError,
   JqLimitError,
@@ -14,7 +14,7 @@ import {
   objectKeyIterator,
   objectKeys,
   put
-} from "./chunk-VVI4Z73I.js";
+} from "./chunk-QP4R6GLA.js";
 import {
   decoder,
   encoder,

package/dist/safe-bash/command-chunks/chunk-UXSR5BZH.js

@@ -0,0 +1,136 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-zip-engine/src/zip/aes.ts
+init_buffer();
+import { ecb } from "@noble/ciphers/aes.js";
+import { equalBytes } from "@noble/ciphers/utils.js";
+import { hmac } from "@noble/hashes/hmac.js";
+import { sha1 } from "@noble/hashes/legacy.js";
+import { pbkdf2 } from "@noble/hashes/pbkdf2.js";
+import { collectBytes } from "../../safe-bash-contracts/index.js";
+import { yieldTurn } from "../../safe-bash-contracts/yield.js";
+import { fail } from "../../safe-bash-io-engine/commands/archive/internal.js";
+function zipEncryptionProfile(profile) {
+  if (profile === "zipcrypto") return void 0;
+  const [prefix, strength, version, extra] = profile.split("-");
+  if (prefix !== "aes" || extra !== void 0 || !["128", "192", "256"].includes(strength) || !["ae1", "ae2"].includes(version)) fail("ZIP unsupported encryption profile");
+  return { strength: Number(strength), version: version === "ae1" ? 1 : 2 };
+}
+function aesParameters(aes) {
+  if (aes.version !== 1 && aes.version !== 2) fail("ZIP unsupported AES version");
+  if (aes.strength !== 128 && aes.strength !== 192 && aes.strength !== 256) fail("ZIP unsupported AES strength");
+  return { keyBytes: aes.strength / 8, saltBytes: aes.strength / 16 };
+}
+function keys(password, salt, aes, signal) {
+  signal.throwIfAborted();
+  const { keyBytes } = aesParameters(aes);
+  const derived = pbkdf2(sha1, password, salt, { c: 1e3, dkLen: keyBytes * 2 + 2 });
+  if (signal.aborted) {
+    derived.fill(0);
+    signal.throwIfAborted();
+  }
+  return derived;
+}
+async function transform(input, key, signal) {
+  const output = new Uint8Array(input.length);
+  try {
+    for (let offset = 0; offset < input.length; offset += 65536) {
+      signal.throwIfAborted();
+      const length = Math.min(65536, input.length - offset);
+      const counters = new Uint8Array(Math.ceil(length / 16) * 16);
+      const view = new DataView(counters.buffer);
+      for (let block = 0; block < counters.length; block += 16) view.setBigUint64(block, BigInt((offset + block) / 16 + 1), true);
+      const stream = ecb(key, { disablePadding: true }).encrypt(counters);
+      for (let i = 0; i < length; i++) output[offset + i] = input[offset + i] ^ stream[i];
+      stream.fill(0);
+      await yieldTurn(signal);
+    }
+    return output;
+  } catch (error) {
+    output.fill(0);
+    throw error;
+  }
+}
+async function encryptAesPayload(source, encryption, maxBytes, signal) {
+  signal.throwIfAborted();
+  const { keyBytes, saltBytes } = aesParameters(encryption.aes);
+  const aes = { ...encryption.aes };
+  const password = new Uint8Array(encryption.password);
+  let plaintext;
+  let derived;
+  try {
+    plaintext = await collectBytes(source, { ...Number.isFinite(maxBytes) ? { maxBytes } : {}, signal });
+    let supplied;
+    try {
+      supplied = await encryption.entropy(saltBytes, signal);
+    } catch {
+      signal.throwIfAborted();
+      fail("ZIP AES entropy capability failed");
+    }
+    signal.throwIfAborted();
+    if (!(supplied instanceof Uint8Array) || supplied.length !== saltBytes) fail("ZIP invalid AES entropy bytes");
+    const salt = new Uint8Array(supplied);
+    derived = keys(password, salt, aes, signal);
+    const encrypted = await transform(plaintext, derived.subarray(0, keyBytes), signal);
+    const tag = hmac(sha1, derived.subarray(keyBytes, keyBytes * 2), encrypted);
+    const wire = new Uint8Array(saltBytes + 2 + encrypted.length + 10);
+    wire.set(salt);
+    wire.set(derived.subarray(keyBytes * 2), saltBytes);
+    wire.set(encrypted, saltBytes + 2);
+    wire.set(tag.subarray(0, 10), wire.length - 10);
+    encrypted.fill(0);
+    tag.fill(0);
+    return wire;
+  } finally {
+    plaintext?.fill(0);
+    derived?.fill(0);
+    password.fill(0);
+  }
+}
+async function decryptAesPayload(wire, password, aes, maxBytes, signal) {
+  signal.throwIfAborted();
+  const { keyBytes, saltBytes } = aesParameters(aes);
+  aes = { ...aes };
+  if (maxBytes !== Infinity && (!Number.isSafeInteger(maxBytes) || maxBytes < 0)) throw new RangeError("maxBytes must be a nonnegative safe integer");
+  if (wire.length < saltBytes + 12) fail("ZIP truncated AES payload");
+  const size = wire.length - saltBytes - 12;
+  if (size > maxBytes) fail("ZIP AES authenticated staging limit exceeded");
+  const owned = new Uint8Array(wire);
+  const secret = new Uint8Array(password);
+  let derived;
+  try {
+    derived = keys(secret, owned.subarray(0, saltBytes), aes, signal);
+    if (!equalBytes(derived.subarray(keyBytes * 2), owned.subarray(saltBytes, saltBytes + 2))) fail("ZIP incorrect password");
+    const encrypted = owned.subarray(saltBytes + 2, owned.length - 10);
+    const tag = hmac(sha1, derived.subarray(keyBytes, keyBytes * 2), encrypted);
+    const authentic = equalBytes(tag.subarray(0, 10), owned.subarray(owned.length - 10));
+    tag.fill(0);
+    if (!authentic) fail("ZIP AES authentication failed");
+    return await transform(encrypted, derived.subarray(0, keyBytes), signal);
+  } finally {
+    derived?.fill(0);
+    secret.fill(0);
+    owned.fill(0);
+  }
+}
+function aesExtra(aes, method) {
+  aesParameters(aes);
+  const bytes = new Uint8Array(11);
+  const view = new DataView(bytes.buffer);
+  view.setUint16(0, 39169, true);
+  view.setUint16(2, 7, true);
+  view.setUint16(4, aes.version, true);
+  bytes.set([65, 69, aes.strength / 64 - 1], 6);
+  view.setUint16(9, method, true);
+  return bytes;
+}
+
+export {
+  zipEncryptionProfile,
+  aesParameters,
+  encryptAesPayload,
+  decryptAesPayload,
+  aesExtra
+};

package/dist/safe-bash/command-chunks/chunk-V6BEDRMQ.js

@@ -0,0 +1,112 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-patch/src/patch-publication.ts
+init_buffer();
+import { retainFileSystemCleanup } from "@poe-platform/safe-fs/core";
+import { dirname, FsError, isFsError } from "../../safe-bash-contracts/index.js";
+import { host, ToolError } from "../../safe-bash-diff-engine/shared.js";
+import { encodeBytes } from "../../safe-bash-io-engine/byte-encoding.js";
+var PatchPublication = class {
+  constructor(context) {
+    this.context = context;
+  }
+  context;
+  directories = /* @__PURE__ */ new Map();
+  removals = /* @__PURE__ */ new Map();
+  pruning = /* @__PURE__ */ new Map();
+  async capture(path, prune = []) {
+    const paths = [];
+    for (let parent = dirname(path); ; parent = dirname(parent)) {
+      paths.unshift(parent);
+      if (parent === "/") break;
+    }
+    for (const parent of paths) {
+      if (this.directories.has(parent)) continue;
+      let stat;
+      try {
+        stat = await host(this.context, () => this.context.fs.lstat(parent, { signal: this.context.signal }));
+      } catch (error) {
+        if (isFsError(error, "ENOENT")) break;
+        throw error;
+      }
+      if (stat.type !== "directory") throw new ToolError(`unsafe patch parent: ${parent}`);
+      this.directories.set(parent, stat);
+    }
+    if (this.directories.has(dirname(path)) && !this.removals.has(path)) {
+      this.removals.set(path, await host(this.context, () => this.context.fs.confineExtraction([dirname(path)], { signal: this.context.signal })));
+    }
+    const parents = prune.filter((parent) => this.directories.has(parent) && !this.pruning.has(parent));
+    if (this.directories.has(dirname(path)) && parents.length) {
+      const view = await host(this.context, () => this.context.fs.confineExtraction([dirname(path), parents.at(-1)], { signal: this.context.signal }));
+      for (const parent of parents) this.pruning.set(parent, view);
+    }
+  }
+  async write(path, text, destination, mode, mtimeMs) {
+    await this.capture(path);
+    const ancestors = [];
+    for (let parent2 = dirname(path); ; parent2 = dirname(parent2)) {
+      const stat = this.directories.get(parent2);
+      if (!stat) throw new ToolError(`patch parent does not exist: ${parent2}`);
+      ancestors.unshift({ path: parent2, stat });
+      if (parent2 === "/") break;
+    }
+    const context = this.context;
+    const parent = ancestors[ancestors.length - 1].stat;
+    let staging;
+    let operation;
+    let closed = false;
+    const release = retainFileSystemCleanup(context.fs, async (view) => {
+      await operation?.catch(() => {
+      });
+      if (staging) await view.removeStagedFile(staging);
+    }, { maxOperations: 1 });
+    const cleanup = () => {
+      closed = true;
+      return release();
+    };
+    context.registerCleanup?.(cleanup);
+    try {
+      operation = Promise.resolve().then(async () => {
+        context.signal.throwIfAborted();
+        if (closed) throw new ToolError("patch publication is closed");
+        staging = await context.fs.createStagedFile(`${dirname(path) === "/" ? "" : dirname(path)}/.patch-${globalThis.crypto.randomUUID()}`, "file", {
+          type: "file",
+          data: encodeBytes(text)
+        }, {
+          parent,
+          signal: context.signal,
+          ...mode === void 0 ? {} : { mode },
+          ...mtimeMs === void 0 ? {} : { atimeMs: mtimeMs, mtimeMs }
+        });
+        context.signal.throwIfAborted();
+        if (closed) throw new ToolError("patch publication is closed");
+        await context.fs.publishStagedFile(staging, path, {
+          parent,
+          destination: destination ?? null,
+          ancestors,
+          signal: context.signal
+        });
+      });
+      await host(context, () => operation);
+    } finally {
+      await cleanup();
+    }
+  }
+  async remove(path) {
+    const fs = this.removals.get(path);
+    if (!fs) throw new ToolError(`patch removal was not admitted: ${path}`);
+    await host(this.context, () => fs.rm(path, { signal: this.context.signal }));
+  }
+  async prune(path) {
+    const fs = this.pruning.get(path);
+    if (!fs) throw new ToolError(`patch directory pruning was not admitted: ${path}`);
+    if (!fs.rmdir) throw new FsError("ENOTSUP", { syscall: "rmdir", path });
+    await host(this.context, () => fs.rmdir(path, { signal: this.context.signal }));
+  }
+};
+
+export {
+  PatchPublication
+};