@poe-platform/safe-bash 0.1.826 → 0.1.827

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

@@ -0,0 +1,219 @@
+import {
+  openPythonPackageFile
+} from "./chunk-UCE77LYV.js";
+
+// packages/safe-bash-command-python/src/record-reader.ts
+function createPythonRecordReader(encode) {
+  let source, row;
+  let text = "", previous = "", position = 0, tail = Promise.resolve();
+  return {
+    read(nextRow, offset) {
+      const work = tail.then(async () => {
+        if (row === nextRow && offset === position - 1 && previous) {
+          text = previous + text;
+          position--;
+        }
+        if (row !== nextRow || offset < position) {
+          source = void 0;
+          position = 0;
+          text = previous = "";
+          row = nextRow;
+        }
+        source ??= encode(nextRow)[Symbol.asyncIterator]();
+        const decoder = new TextDecoder();
+        while (true) {
+          if (position < offset) {
+            const skip = Math.min(offset - position, text.length);
+            if (skip) previous = text[skip - 1];
+            text = text.slice(skip);
+            position += skip;
+          }
+          if (text.length >= 8192) break;
+          const next = await source.next();
+          if (next.done) break;
+          text += decoder.decode(next.value);
+        }
+        const result = text.slice(0, 8192);
+        previous = result.at(-1) ?? previous;
+        text = text.slice(result.length);
+        position += result.length;
+        return result;
+      });
+      tail = work.catch(() => {
+      });
+      return work;
+    },
+    async close() {
+      await tail;
+      source = void 0;
+      text = previous = "";
+      row = void 0;
+    }
+  };
+}
+
+// packages/safe-bash-command-python/src/manifest-backed.ts
+import { openLlmJsonDocument } from "../../safe-bash-command-llm/index.js";
+import { IntegerTable, PagedStorage } from "@poe-platform/safe-fs/storage";
+async function readBackedPythonManifest(fs, directory, signal, input, collectInstalled = true) {
+  const document = await openLlmJsonDocument({ fs, directory, signal, maxFileBytes: Number.MAX_SAFE_INTEGER, maxOpenFiles: 1, profile: "javascript", maxControlBytes: Number.MAX_SAFE_INTEGER }, input);
+  const storage = new PagedStorage({ fs, cwd: directory, env: {}, signal }, 4), index = new IntegerTable(storage, 64);
+  const invalid = () => {
+    throw new Error("Invalid Python package environment manifest");
+  };
+  const close = async () => {
+    const results = await Promise.allSettled([document.close(), storage.close()]);
+    for (const result of results) if (result.status === "rejected") throw result.reason;
+  };
+  async function* children(node) {
+    for (let child = await document.child(node.id); child; child = await document.child(node.id, child.position)) yield child;
+  }
+  const string = async (node) => {
+    if (node.type !== "string") invalid();
+    let text = "";
+    for await (const chunk of document.text(node)) text += chunk;
+    return text;
+  };
+  let version = 0, records, installedNode = document.root, recordCount = -1;
+  try {
+    if (document.root.type !== "array") {
+      if (document.root.type !== "object") invalid();
+      let count = 0, found = false;
+      for await (const { node, key } of children(document.root)) {
+        count++;
+        if (key === "version") {
+          const value = Number(node.token);
+          if (node.type !== "number" || ![1, 2, 3].includes(value)) invalid();
+          version = value;
+        } else if (key === "installed") {
+          installedNode = node;
+          found = true;
+        } else if (key === "records") records = node;
+        else invalid();
+      }
+      if (!found || !version || count !== (version === 1 ? 2 : 3) || version !== 1 && !records) invalid();
+    }
+    if (installedNode.type !== "array") invalid();
+    const installed = [];
+    for await (const { node } of children(installedNode)) {
+      if (node.type !== "string") invalid();
+      if (collectInstalled) installed.push(await string(node));
+    }
+    if (records) {
+      if (records.type !== "array") invalid();
+      recordCount = 0;
+      let previous = -1;
+      for await (const entry of children(records)) {
+        const row = entry.node;
+        if (row.type !== "array") invalid();
+        let field = 0;
+        for await (const { node } of children(row)) {
+          if (field === 3 || field === 4) {
+            if (node.type !== "array") invalid();
+            for await (const { node: item } of children(node)) if (item.type !== "string") invalid();
+          } else if (node.type !== "string" && !(field === 5 && node.type === "null")) invalid();
+          field++;
+        }
+        if (field !== version + 3) invalid();
+        await index.set(BigInt(recordCount++), BigInt(previous + 1));
+        previous = entry.position;
+      }
+    }
+    const encoder = new TextEncoder();
+    async function* json(node, legacy = false) {
+      if (!node || node.type === "null") {
+        yield "null";
+        return;
+      }
+      if (node.type === "string") {
+        yield '"';
+        for await (const text of document.text(node)) for (let offset = 0; offset < text.length; offset += 1024) yield JSON.stringify(text.slice(offset, offset + 1024)).slice(1, -1);
+        yield '"';
+        return;
+      }
+      yield "[";
+      let count = 0;
+      for await (const { node: item } of children(node)) {
+        if (count++) yield ",";
+        yield* json(item);
+      }
+      if (legacy) yield ",null";
+      yield "]";
+    }
+    const reader = createPythonRecordReader(async function* (key) {
+      const ordinal = Math.floor(key / 7), field = key % 7 - 1;
+      const previous = await index.get(BigInt(ordinal));
+      if (previous === void 0) invalid();
+      const entry = await document.child(records.id, Number(previous) - 1);
+      if (!entry) invalid();
+      let selected = entry.node;
+      if (field >= 0) {
+        selected = void 0;
+        let position = 0;
+        for await (const { node } of children(entry.node)) if (position++ === field) {
+          selected = node;
+          break;
+        }
+      }
+      for await (const part of json(selected, field < 0 && version === 2)) yield encoder.encode(part);
+    });
+    const read = async (ordinal, offset, field = -1) => {
+      if (!Number.isSafeInteger(ordinal) || ordinal < 0 || ordinal >= recordCount || !Number.isSafeInteger(offset) || offset < 0 || !Number.isInteger(field) || field < -1 || field > 5) invalid();
+      return reader.read(ordinal * 7 + field + 1, offset);
+    };
+    return { installed, version, recordCount, readRecord: read, async readField(ordinal, field, offset) {
+      if (field < 0) invalid();
+      return read(ordinal, offset, field);
+    }, async close() {
+      try {
+        await reader.close();
+      } finally {
+        await close();
+      }
+    } };
+  } catch (error) {
+    await close();
+    throw error;
+  }
+}
+
+// packages/safe-bash-command-python/src/manifest-publication.ts
+var pythonPublicationFile = "publication.json";
+async function withPythonManifestPublication(context, maxBytes, publish) {
+  const { fs, signal, cwd } = context, path = cwd + "/" + pythonPublicationFile, stat = await fs.lstat(path, { signal });
+  if (stat.type !== "file") throw new Error("Invalid Python manifest publication file");
+  if (stat.size > maxBytes) throw new Error("Python package manifest exceeds maxManifestBytes");
+  const file = await openPythonPackageFile(context, path, maxBytes, stat);
+  if (!file) throw new Error("Python manifest publication requires retained caller reads");
+  let consumed = false;
+  async function* source() {
+    for (let offset = 0; offset < file.size; ) {
+      const bytes = await file.read(offset, 65536);
+      offset += bytes.length;
+      yield bytes;
+    }
+    consumed = true;
+  }
+  try {
+    const snapshot = await readBackedPythonManifest(fs, cwd, signal, source(), false);
+    try {
+      if (snapshot.version !== 3) throw new Error("Invalid Python manifest publication version");
+    } finally {
+      await snapshot.close();
+    }
+    consumed = false;
+    const committed = await publish(source());
+    signal.throwIfAborted();
+    if (committed && !consumed) throw new Error("Python manifest store returned before consuming its source");
+    return committed;
+  } finally {
+    await file.close();
+  }
+}
+
+export {
+  createPythonRecordReader,
+  readBackedPythonManifest,
+  pythonPublicationFile,
+  withPythonManifestPublication
+};

package/dist/safe-bash/command-chunks/{chunk-WKS2PAZL.js → chunk-HUGKO4ZE.js}

@@ -1,6 +1,6 @@
 import {
   stringify
-} from "./chunk-HCPEYQKT.js";
+} from "./chunk-N4SH6QY5.js";
 import {
   JqError
 } from "./chunk-3K5FCRUG.js";
@@ -53,6 +53,15 @@ async function formatValue(name, input, budget) {
       }
       break;
     }
+    case "urid": {
+      if (typeof input !== "string") throw new JqError("urid requires a string");
+      try {
+        result = decodeURIComponent(input);
+      } catch {
+        throw new JqError("invalid uri string");
+      }
+      break;
+    }
     case "html": {
       const escapes = { "&": "&amp;", "<": "&lt;", ">": "&gt;", "'": "&apos;", '"': "&quot;" };
       result = "";

package/dist/safe-bash/command-chunks/{chunk-NXZJJM4J.js → chunk-IGXH5W5Z.js}

@@ -1,7 +1,7 @@
 import {
   normalizeEncoding,
   pythonCodecAliases
-} from "./chunk-ZERCTWUI.js";
+} from "./chunk-VSNVYOK2.js";
 import {
   unpackCodepage
 } from "./chunk-RUXOFW5G.js";

package/dist/safe-bash/command-chunks/{chunk-CMJBRGU2.js → chunk-IHQZKUBS.js}

@@ -1,6 +1,6 @@
 import {
   createCodec
-} from "./chunk-ETFJ4L7F.js";
+} from "./chunk-6OLE6CLV.js";
 import {
   CompressedDataError
 } from "./chunk-V7IP2PFT.js";