@poe-platform/safe-bash 0.1.799 → 0.1.800

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

@@ -0,0 +1,122 @@
+import {
+  Reader
+} from "./chunk-7K6JYKPJ.js";
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-awk/src/awk-pipes.ts
+init_buffer();
+import { createBytePipe } from "../../safe-bash-contracts/index.js";
+import { shellValueByteLength } from "../../safe-bash-contracts/value.js";
+import { ProgramError, bytes } from "../../safe-bash-io-engine/commands/text-programs/shared.js";
+var AwkPipes = class {
+  constructor(context, budget, retention) {
+    this.context = context;
+    this.budget = budget;
+    this.retention = retention;
+    context.registerCleanup?.(() => this.closeAll(true));
+  }
+  context;
+  budget;
+  retention;
+  reads = /* @__PURE__ */ new Map();
+  writes = /* @__PURE__ */ new Map();
+  cleanup;
+  open(command, reading) {
+    if (this.cleanup) throw new ProgramError("awk pipes are closed");
+    const map = reading ? this.reads : this.writes;
+    const existing = map.get(command);
+    if (existing) return existing;
+    if (!this.context.invoke) throw new ProgramError("command pipes require virtual command invocation");
+    if (!command) throw new ProgramError("empty pipe command");
+    if (this.reads.size + this.writes.size >= (this.budget.options.maxGetlineFiles ?? Infinity)) throw new ProgramError("awk open-pipe limit exceeded");
+    this.budget.check(command);
+    const size = shellValueByteLength(command);
+    this.retention.admit(0, size);
+    const abort = new AbortController();
+    const signal = AbortSignal.any([this.context.signal, abort.signal]);
+    const channel = createBytePipe({ highWaterMark: 1, signal });
+    const invoke = this.context.invoke;
+    const done = Promise.resolve().then(() => invoke("sh", ["-c", command], {
+      signal,
+      stdin: reading ? this.context.stdin : channel.endpoints.read.readable,
+      stdout: reading ? { write: async (chunk) => {
+        this.retention.admit(0, chunk.byteLength);
+        try {
+          await channel.writable.write(chunk);
+        } finally {
+          this.retention.release(chunk.byteLength);
+        }
+      } } : this.context.stdout,
+      stderr: this.context.stderr
+    })).then(async (result) => {
+      if (reading) await channel.close();
+      else await channel.endpoints?.read.close();
+      return { status: result.exitCode };
+    }).catch(async (error) => {
+      await channel.abort(error);
+      return { error };
+    });
+    const pipe = { channel, abort, done, ...reading ? { reader: new Reader(channel.endpoints.read.readable, this.budget, this.retention) } : {} };
+    map.set(command, pipe);
+    return pipe;
+  }
+  async read(command, separator) {
+    const pipe = this.open(command, true);
+    return pipe.reader.read(separator);
+  }
+  async write(command, output) {
+    const pipe = this.open(command, false);
+    this.budget.step(output.length);
+    this.retention.admit(0, output.length);
+    try {
+      await pipe.channel.writable.write(bytes(output));
+    } finally {
+      this.retention.release(output.length);
+    }
+  }
+  async close(command) {
+    let status;
+    for (const map of [this.reads, this.writes]) {
+      const pipe = map.get(command);
+      if (!pipe) continue;
+      status = await (pipe.closing ??= this.finish(pipe).finally(() => {
+        map.delete(command);
+        this.retention.release(shellValueByteLength(command));
+      }));
+    }
+    return status;
+  }
+  async finish(pipe) {
+    let failed = false;
+    let failure;
+    try {
+      if (pipe.reader) {
+        await pipe.channel.endpoints.read.close();
+        await pipe.reader.close();
+      } else await pipe.channel.close();
+    } catch (error) {
+      failed = true;
+      failure = error;
+    }
+    const result = await pipe.done;
+    if (failed && !pipe.abort.signal.aborted) throw failure;
+    if ("error" in result) {
+      if (!pipe.abort.signal.aborted) throw result.error;
+      return -1;
+    }
+    return result.status;
+  }
+  closeAll(cancel = false) {
+    if (cancel) for (const pipe of [...this.reads.values(), ...this.writes.values()]) pipe.abort.abort();
+    return this.cleanup ??= (async () => {
+      const results = await Promise.allSettled([.../* @__PURE__ */ new Set([...this.reads.keys(), ...this.writes.keys()])].map((command) => this.close(command)));
+      for (const result of results) if (result.status === "rejected") throw result.reason;
+    })();
+  }
+};
+
+export {
+  AwkPipes
+};

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

@@ -0,0 +1,87 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-patch/src/patch-path.ts
+init_buffer();
+import { ToolError } from "../../safe-bash-diff-engine/shared.js";
+import { encodeBytes } from "../../safe-bash-io-engine/byte-encoding.js";
+function decodeHeaderPath(value) {
+  if (!value.startsWith('"')) return value.split("	", 1)[0];
+  const bytes = [];
+  const escapes = { a: 7, b: 8, t: 9, n: 10, v: 11, f: 12, r: 13, '"': 34, "\\": 92 };
+  let index = 1;
+  while (index < value.length) {
+    const character = value[index++];
+    if (character === '"') {
+      if (index < value.length && value[index] !== "	") throw new ToolError("unexpected text after quoted filename");
+      try {
+        return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(Uint8Array.from(bytes));
+      } catch {
+        throw new ToolError("invalid UTF-8 in quoted filename");
+      }
+    }
+    if (character === "\\") {
+      const escaped = value[index++];
+      if (/[0-7]/u.test(escaped ?? "")) {
+        const octal = value.slice(index - 1, index + 2);
+        if (!/^[0-7]{3}$/u.test(octal) || parseInt(octal, 8) > 255) throw new ToolError("invalid octal filename escape");
+        bytes.push(parseInt(octal, 8));
+        index += 2;
+      } else {
+        const byte = escapes[escaped];
+        if (byte === void 0) throw new ToolError("invalid quoted filename escape");
+        bytes.push(byte);
+      }
+    } else {
+      const point = value.codePointAt(index - 1);
+      const literal = String.fromCodePoint(point);
+      bytes.push(...encodeBytes(literal));
+      index += literal.length - 1;
+    }
+  }
+  throw new ToolError("unterminated quoted filename");
+}
+function safeTarget(path, strip, allowAbsolute = false) {
+  if (path === "/dev/null") return void 0;
+  if (!path || !allowAbsolute && path.startsWith("/") || /[\\\0-\x08\x0a-\x1f\x7f]/u.test(path)) throw new ToolError(`unsafe patch path: ${JSON.stringify(path)}`);
+  const parts = path.split(/\/+/u);
+  if (parts.some((part) => part === ".." || /^[A-Za-z]:/u.test(part))) throw new ToolError(`unsafe patch path: ${JSON.stringify(path)}`);
+  if (path.endsWith("/") || parts.at(-1) === ".") throw new ToolError(`patch path names a directory: ${JSON.stringify(path)}`);
+  const stripped = parts.filter(Boolean).slice(strip).filter((part) => part !== ".").join("/");
+  if (!stripped) throw new ToolError(`strip count removes entire patch path: ${path}`);
+  return allowAbsolute && path.startsWith("/") && strip === 0 ? `/${stripped}` : stripped;
+}
+function isEpochHeader(line) {
+  const separator = line.lastIndexOf("	");
+  if (separator < 0) return false;
+  let timestamp = line.slice(separator + 1).trim();
+  const traditional = /^(?:Sun|Mon|Tue|Wed|Thu|Fri|Sat) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) +([0-9]{1,2}) (\d{2}:\d{2}:\d{2}) (\d{4})(?: (UTC|GMT|[+-]\d{4}))?$/u.exec(timestamp);
+  if (traditional) {
+    const month = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"].indexOf(traditional[1]) + 1;
+    timestamp = `${traditional[4]}-${String(month).padStart(2, "0")}-${traditional[2].padStart(2, "0")} ${traditional[3]} ${traditional[5] ?? "+0000"}`;
+  }
+  const match = /^(\d{4}-\d{2}-\d{2})[ T](\d{2}:\d{2}:\d{2})(?:\.(\d{1,9}))?(?:\s*(Z|UTC|GMT|[+-]\d{2}:?\d{2}))?$/u.exec(timestamp);
+  if (!match) return false;
+  const iso = `${match[1]}T${match[2]}`;
+  const local = Date.parse(`${iso}Z`);
+  if (!Number.isFinite(local) || new Date(local).toISOString().slice(0, 19) !== iso) return false;
+  const zone = match[4];
+  let offset = 0;
+  if (zone && /^[+-]/u.test(zone)) {
+    const digits = zone.slice(1).replace(":", "");
+    const hours = Number(digits.slice(0, 2));
+    const minutes = Number(digits.slice(2));
+    if (hours > 25 || minutes > 59) return false;
+    offset = (hours * 60 + minutes) * 60 * (zone[0] === "+" ? 1 : -1);
+  }
+  const seconds = local / 1e3 - offset;
+  const fractional = match[3] !== void 0 && /[1-9]/u.test(match[3]);
+  return (seconds > -25 * 3600 || seconds === -25 * 3600 && fractional) && seconds < 26 * 3600;
+}
+
+export {
+  decodeHeaderPath,
+  safeTarget,
+  isEpochHeader
+};

package/dist/safe-bash/command-chunks/{chunk-2PX5B7T5.js → chunk-DQAVUDDX.js}

@@ -1,7 +1,7 @@
 import {
   crc32,
   createZipCodec
-} from "./chunk-MKQVQMXO.js";
+} from "./chunk-5LU4UCBR.js";
 import {
   CodecError,
   yieldEventLoop
@@ -13145,7 +13145,7 @@ var PackageView = class {
     if (input == null) throw new InputTypeError("Expected explicit package input.");
     if (settings2.template !== void 0) throw new InputTypeError("A context template conflicts with package input.");
     const admitted2 = await admitDocumentModel(input, settings2);
-    const { ModelStore: ModelStore2 } = await import("./model-store-L35QTZMJ.js");
+    const { ModelStore: ModelStore2 } = await import("./model-store-WPKMRPV4.js");
     const store = new ModelStore2(admitted2.archive, admitted2.settings, admitted2.archive.mainPart, admitted2.source);
     store.package.after_unmarshal();
     return store.package;

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

@@ -0,0 +1,249 @@
+import {
+  parseUnified,
+  parseUnifiedSection
+} from "./chunk-67QKREJK.js";
+import {
+  decodeHeaderPath
+} from "./chunk-DOKKNRRM.js";
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-patch/src/patch-formats.ts
+init_buffer();
+import { ToolError, integer } from "../../safe-bash-diff-engine/shared.js";
+import { byteLength } from "../../safe-bash-io-engine/byte-encoding.js";
+var Reader = class {
+  constructor(text, budget) {
+    this.budget = budget;
+    this.lines = budget.split(text).map((line) => line.slice(0, -1));
+  }
+  budget;
+  lines;
+  index = 0;
+  peek() {
+    return this.lines[this.index];
+  }
+  async take() {
+    this.budget.step();
+    {
+      const c = this.budget.checkpoint();
+      if (c) await c;
+    }
+    const line = this.lines[this.index++];
+    if (line === void 0) throw new ToolError("truncated patch");
+    return line;
+  }
+  number(value) {
+    const result = integer(value, "patch range");
+    if (result > this.budget.limits.maxLines) throw new ToolError("hunk coordinate exceeds line limit");
+    return result;
+  }
+  async content(prefix) {
+    const line = await this.take();
+    if (line !== prefix && !(prefix === " " && line === "") && !line.startsWith(`${prefix} `) && !line.startsWith(`${prefix}	`)) throw new ToolError("malformed patch body prefix");
+    let text = `${line.slice(2)}
+`;
+    if (this.peek() === "\") {
+      await this.take();
+      if (text === "\n") throw new ToolError("empty incomplete line is not a valid text line");
+      text = text.slice(0, -1);
+    }
+    return text;
+  }
+};
+function encoded(line) {
+  return `${line.kind}${line.text}${line.text.endsWith("\n") ? "" : "\n\\n"}`;
+}
+async function normal(reader, target) {
+  const quoted = JSON.stringify(target ?? "/dev/null");
+  const output = [`--- ${quoted}
++++ ${quoted}
+`];
+  while (reader.peek() !== void 0) {
+    if (reader.peek() === "") {
+      await reader.take();
+      continue;
+    }
+    if (!/^\d/u.test(reader.peek())) break;
+    const command = /^(\d+)(?:,(\d+))?([acd])(\d+)(?:,(\d+))?$/u.exec(await reader.take());
+    if (!command) throw new ToolError("malformed normal patch command");
+    const oldStart = reader.number(command[1]);
+    const oldLast = reader.number(command[2] ?? command[1]);
+    const newStart = reader.number(command[4]);
+    const newLast = reader.number(command[5] ?? command[4]);
+    const operation = command[3];
+    if (oldLast < oldStart || newLast < newStart || operation === "a" && command[2] !== void 0 || operation === "d" && command[5] !== void 0) throw new ToolError("invalid normal patch range");
+    const oldCount = operation === "a" ? 0 : oldLast - oldStart + 1;
+    const newCount = operation === "d" ? 0 : newLast - newStart + 1;
+    output.push(`@@ -${oldStart},${oldCount} +${newStart},${newCount} @@
+`);
+    for (let index = 0; index < oldCount; index++) output.push(encoded({ kind: "-", text: await reader.content("<") }));
+    if (operation === "c" && await reader.take() !== "---") throw new ToolError("missing normal change separator");
+    for (let index = 0; index < newCount; index++) output.push(encoded({ kind: "+", text: await reader.content(">") }));
+  }
+  return output.join("");
+}
+async function contextRange(reader, old) {
+  const line = await reader.take();
+  const match = (old ? /^\*\*\* (\d+)(?:,(\d+))? \*\*\*\*$/u : /^--- (\d+)(?:,(\d+))? ----$/u).exec(line);
+  if (!match) throw new ToolError("malformed context range");
+  const start = reader.number(match[1]);
+  const last = reader.number(match[2] ?? match[1]);
+  if (last < start || match[2] !== void 0 && start === 0) throw new ToolError("invalid context range");
+  return { start, last, multiple: match[2] !== void 0 };
+}
+async function contextSide(reader, old, range) {
+  const lines = [];
+  const count = range.start === 0 ? 0 : range.last - range.start + 1;
+  while (reader.peek() !== void 0 && lines.length < count) {
+    const kind = reader.peek() === "" ? " " : reader.peek()[0];
+    if (kind !== " " && kind !== "!" && kind !== (old ? "-" : "+")) break;
+    if (old && /^--- \d+(?:,\d+)? ----$/u.test(reader.peek())) break;
+    lines.push({ kind, text: await reader.content(kind) });
+    if (lines.length > reader.budget.limits.maxLines) throw new ToolError("context body line limit exceeded");
+  }
+  if (!old && lines.length === count && lines.at(-1)?.text.endsWith("\n") === false) {
+    while (reader.peek() === "\") await reader.take();
+  }
+  return lines;
+}
+function contextCount(range, lines) {
+  if (!lines.length) {
+    if (range.multiple) throw new ToolError("empty context side has a nonempty range");
+    return 0;
+  }
+  if (range.start === 0 || lines.length !== range.last - range.start + 1) throw new ToolError("context body count does not match range");
+  return lines.length;
+}
+async function context(reader) {
+  const output = [];
+  while (reader.peek() !== void 0) {
+    const header = await reader.take();
+    if (header === "") continue;
+    if (/^diff -[^ ]+ /u.test(header)) {
+      output.push(`${header}
+`);
+      continue;
+    }
+    if (!header.startsWith("*** ")) throw new ToolError("expected context file header");
+    const next = await reader.take();
+    if (!next.startsWith("--- ")) throw new ToolError("expected new context file header");
+    output.push(`--- ${header.slice(4)}
++++ ${next.slice(4)}
+`);
+    let hunks = 0;
+    while (reader.peek()?.startsWith("***************")) {
+      const delimiter = await reader.take();
+      if (!/^\*{15}(?: .*)?$/u.test(delimiter)) throw new ToolError("malformed context hunk separator");
+      if (++hunks > reader.budget.limits.maxHunks) throw new ToolError("hunk limit exceeded");
+      const oldRange = await contextRange(reader, true);
+      let oldLines = await contextSide(reader, true, oldRange);
+      const newRange = await contextRange(reader, false);
+      let newLines = await contextSide(reader, false, newRange);
+      if (!oldLines.length) {
+        if (newLines.some((line) => line.kind === "!")) throw new ToolError("missing old changed context body");
+        oldLines = newLines.filter((line) => line.kind === " ");
+      }
+      if (!newLines.length) {
+        if (oldLines.some((line) => line.kind === "!")) throw new ToolError("missing new changed context body");
+        newLines = oldLines.filter((line) => line.kind === " ");
+      }
+      const oldCount = contextCount(oldRange, oldLines);
+      const newCount = contextCount(newRange, newLines);
+      output.push(`@@ -${oldRange.start},${oldCount} +${newRange.start},${newCount} @@${delimiter.slice(15)}
+`);
+      let oldIndex = 0;
+      let newIndex = 0;
+      while (oldIndex < oldLines.length || newIndex < newLines.length) {
+        let oldChanged = false;
+        let newChanged = false;
+        while (oldIndex < oldLines.length && oldLines[oldIndex].kind !== " ") {
+          const line = oldLines[oldIndex++];
+          oldChanged ||= line.kind === "!";
+          output.push(encoded({ kind: "-", text: line.text }));
+          reader.budget.step();
+          {
+            const c = reader.budget.checkpoint();
+            if (c) await c;
+          }
+        }
+        while (newIndex < newLines.length && newLines[newIndex].kind !== " ") {
+          const line = newLines[newIndex++];
+          newChanged ||= line.kind === "!";
+          output.push(encoded({ kind: "+", text: line.text }));
+          reader.budget.step();
+          {
+            const c = reader.budget.checkpoint();
+            if (c) await c;
+          }
+        }
+        if (oldChanged !== newChanged) throw new ToolError("unpaired changed context group");
+        if (oldIndex < oldLines.length || newIndex < newLines.length) {
+          const oldLine = oldLines[oldIndex++];
+          const newLine = newLines[newIndex++];
+          if (!oldLine || !newLine || !reader.budget.equal(oldLine.text, newLine.text)) throw new ToolError("context halves disagree");
+          output.push(encoded({ kind: " ", text: oldLine.text }));
+        }
+      }
+    }
+    if (!hunks) throw new ToolError("context file patch has no hunks");
+    break;
+  }
+  return output.join("");
+}
+async function parsePatch(text, budget, format, target, progress) {
+  if (text && !text.endsWith("\n")) throw new ToolError("patch is truncated: missing final LF");
+  const reader = new Reader(text, budget);
+  const patches = [];
+  let convertedBytes = 0;
+  while (reader.peek() !== void 0) {
+    try {
+      if (reader.peek() === "") {
+        await reader.take();
+        continue;
+      }
+      if (!progress && patches.length && reader.peek().startsWith("-") && !reader.peek().startsWith("---")) {
+        throw new ToolError("unexpected deletion outside a patch hunk");
+      }
+      if (patches.length && !/^(?:Index: |diff |index |---|\*\*\*|@@|[+\\<>]|\d)/u.test(reader.peek())) {
+        await reader.take();
+        continue;
+      }
+      let indexPath;
+      if (reader.peek()?.startsWith("Index: ")) {
+        indexPath = decodeHeaderPath((await reader.take()).slice(7));
+        if (/^=+$/u.test(reader.peek() ?? "")) await reader.take();
+      }
+      const start = reader.index;
+      while (/^diff /u.test(reader.peek() ?? "")) await reader.take();
+      const first = reader.peek() ?? "";
+      const detected = first.startsWith("*** ") ? "context" : /^\d/u.test(first) ? "normal" : "unified";
+      if (format && detected !== format) throw new ToolError(`patch format is ${detected}, not requested ${format}`);
+      if (detected === "unified") {
+        reader.index = start;
+        patches.push(...(await parseUnifiedSection(reader, budget)).map((patch) => ({ ...patch, ...indexPath === void 0 ? {} : { indexPath } })));
+      } else {
+        if (detected === "context") reader.index = start;
+        const converted = detected === "normal" ? await normal(reader, target ?? indexPath) : await context(reader);
+        convertedBytes += byteLength(converted);
+        if (convertedBytes > budget.limits.maxInputBytes * 2 + 16384) throw new ToolError("converted patch byte limit exceeded");
+        patches.push(...(await parseUnified(converted, budget)).map((patch) => ({
+          ...patch,
+          format: detected,
+          ...indexPath === void 0 ? {} : { indexPath },
+          ...detected === "normal" && target === void 0 && indexPath === void 0 ? { unlocated: true } : {}
+        })));
+      }
+    } catch (error) {
+      if (!progress || !(error instanceof ToolError) || /limit|budget|filename|path|escape/u.test(error.message)) throw error;
+      progress.error = error;
+      break;
+    }
+  }
+  return patches;
+}
+
+export {
+  parsePatch
+};

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

@@ -0,0 +1,42 @@
+import {
+  CurlError
+} from "./chunk-IYPAQ7PH.js";
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-network-engine/src/form-headers.ts
+init_buffer();
+import { decodeBytes, encodeBytes } from "../../safe-bash-io-engine/byte-encoding.js";
+function validatePartHeader(header) {
+  const colon = header.indexOf(":");
+  if (colon <= 0) throw new CurlError(2, "Invalid multipart part header");
+  for (const character of header.slice(0, colon)) {
+    const code = character.charCodeAt(0);
+    if (!(code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122 || "!#$%&'*+-.^_`|~".includes(character)))
+      throw new CurlError(2, "Invalid multipart part header");
+  }
+  for (const character of header) {
+    const code = character.charCodeAt(0);
+    if (code < 32 && code !== 9 || code === 127)
+      throw new CurlError(2, "Invalid multipart part header");
+  }
+  return header;
+}
+function filePartHeaders(bytes) {
+  const headers = [];
+  for (let line of decodeBytes(encodeBytes(bytes), "utf8").split("\n")) {
+    if (line.endsWith("\r")) line = line.slice(0, -1);
+    if (!line || line.startsWith("#")) continue;
+    if ((line.startsWith(" ") || line.startsWith("	")) && headers.length) {
+      headers[headers.length - 1] += " " + line.trim();
+      validatePartHeader(headers[headers.length - 1]);
+    } else headers.push(validatePartHeader(line));
+  }
+  return headers;
+}
+
+export {
+  validatePartHeader,
+  filePartHeaders
+};