@poe-platform/safe-bash 0.1.825 → 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-IGXH5W5Z.js

@@ -0,0 +1,111 @@
+import {
+  normalizeEncoding,
+  pythonCodecAliases
+} from "./chunk-VSNVYOK2.js";
+import {
+  unpackCodepage
+} from "./chunk-RUXOFW5G.js";
+
+// packages/safe-bash-csv-engine/src/python-codepages.ts
+var table0 = unpackCodepage("gKwggf//gQOFJiCG//+GCpEYIJEBkxwgkwGVIiCWEyCWAZj//5gHoQEOoTnb///bA98/Dt8c/P///AM=");
+var table1 = unpackCodepage("ghogg5IBhB4ghiAghgGJMCCLOSCZIiGbOiChhQOhAaOjAKMGqv//q6sAqwOvFSCwsACwA7SEA7W1ALUCuIgDuAK7uwC8jAO9vQC+jgO+E9L//9OjA9Mr", table0);
+var table2 = unpackCodepage("iMYCmNwCoaEAoQGkqiCq1wCvrwC0tAC4uAC4Abr3ALy8AL6+AL4BwLAFwAnK///LuwXLCNTwBdQE2f//2Qbg0AXgGvv///sB/Q4g/QE=", table1);
+var table3 = unpackCodepage("imABjFIBmmEBnFMBn3gBpKQAqqoAuroAwMAAwA/QHgHR0QDRC90wAd5eAd/fAN8Q8B8B8fEA8Qv9MQH+XwH//wA=", table2);
+var table4 = unpackCodepage("gX4GinkGjYYGjpgGj4gGkK8GmKkGmpEGnQwgnQGfugahDAaqvga6Gwa/HwbAwQbBIQbBFdg3BtgD3EAG3APhRAbjRQbjA+xJBuwB8EsG8AP1Twb1AfhRBvpSBv0OIP0B/9IG", table3);
+var table5 = unpackCodepage("gAIEgAGDUwSIrCCKCQSMCgSNDASOCwSPDwSQUgSaWQScWgSdXASeWwSfXwShDgSiXgSjCASlkASoAQSqBASvBwSyBgSzVgS0kQS4UQS5FiG6VAS8WAS9BQS+VQS/VwTAEATAPw==", table1);
+var table6 = unpackCodepage("gBAEgC+wkSWwArMCJbQkJbVhJbUBt1YluFUluWMlulElu1clvF0lvVwlvlslvxAlwBQlwTQlwiwlwxwlxAAlxTwlxl4lxgHIWiXJVCXKaSXLZiXMYCXNUCXObCXPZyXPAdFkJdEB01kl1Fgl1VIl1QHXayXYaiXZGCXaDCXbiCXchCXdjCXekCXfgCXgQATgD/ABBPFRBPIEBPNUBPQHBPVXBPYOBPdeBPiwAPkZIvq3APsaIvwWIf2kAP6gJf+gAA==");
+var table7 = unpackCodepage("gJEDgBCRowORBpixA5gQqcMDqsIDq8QDqwTgyQPhrAPhAuTKA+WvA+bMA+YB6MsD6c4D6oYD64gD6wLujAPvjgPvAfGxAPJlIvNkIvSqA/QB9vcA90gi/H8g/bIA", table6);
+var table8 = unpackCodepage("gBAEgB+gICChsACikASkpwClIiCmtgCnBgSorgCqIiGrAgSsUgStYCKuAwSvUwSwHiKyZCKyAbRWBLaRBLcIBLgEBLlUBLoHBLtXBLwJBL1ZBL4KBL9aBMBYBMEFBMKsAMMaIsSSAcVIIsYGIserAMi7AMkmIMqgAMsLBMxbBM0MBM5cBM9VBNATINAB0hwg0gHUGCDUAdb3ANceINgOBNleBNoPBNtfBNwWId0BBN5RBN9PBOAwBOAe/6wg");
+var table9 = unpackCodepage("g///iP//jFoBjWQBjn0Bj3kBmP//nFsBnWUBnn4Bn3oBoccCotgCo0EBpQQBql4Br3sBstsCs0IBuQUBul8BvD0Bvd0Cvj4Bv3wBwFQBwwIBxTkBxgYByAwByhgBzBoBzw4B0BAB0UMB0kcB1VAB2FgB2W4B23AB3d0A3mIB4FUB4wMB5ToB5gcB6A0B6hkB7BsB7w8B8BEB8UQB8kgB9VEB+FkB+W8B+3EB/f0A/mMB/9kC", table3);
+var table10 = unpackCodepage("gMcAgfwAgukAg+IAhOQAheAAhuUAh+cAiOoAiAGK6ACL7wCM7gCN7ACOxACOAZDJAJHmAJLGAJP0AJT2AJXyAJb7AJf5AJj/AJnWAJrcAJuiAJsBnaUAnqcgn5IBoOEAoe0AovMAo/oApPEApdEApqoAp7oAqL8AqRAjqqwAq70ArLwAraEArqsAr7sA4LED4d8A4pMD48AD5KMD5cMD5rUA58QD6KYD6ZgD6qkD67QD7B4i7cYD7rUD7yki8GEi9CAj9AE=", table7);
+var table11 = unpackCodepage("m/gAndgAr6QA", table10);
+var table12 = unpackCodepage("i9AAjPAAjd4Alf4Al90AmP0ApMEApc0AptMAp9oAr7sA", table11);
+var table13 = unpackCodepage("hOMAhsEAicoAi80AjNQAjsMAj8IAkcAAksgAlPUAltoAmMwAmdUAndkAn9MAqdIA", table10);
+var table14 = unpackCodepage("hMIAhrYAjRcgjsAAj6cAkcgAksoAlMsAlc8AmKQAmdQAndkAntsAoKYAobQApKgApbgAprMAp68AqM4Arb4A", table10);
+var table15 = unpackCodepage("ntcAqa4Ar7sAtcEAtQG3wAC4qQC9ogC+pQDG4wDHwwDPpADQ8ADR0ADSygDSAdTIANUxAdbNANYC3aYA3swA4NMA4tQA49IA5PUA5dUA5/4A6N4A6doA6QHr2QDs/QDt3QDurwDvtADwrQDyFyDzvgD0tgD1pwD3uAD5qAD7uQD8swA=", table11);
+var table16 = unpackCodepage("jTEBmDABnl4BngGmHgGmAdC6ANGqANX//+f//+jXAOzsAO3/APL//w==", table15);
+var table17 = unpackCodepage("hW8BhgcBiEIBilABigGNeQGPBgGROQGRAZU9AZUBl1oBlwGbZAGbAZ1BAZ8NAaQEAaQBpn0BpgGoGAGoAat6AawMAa1fAbcaAbheAb17Ab0BxgIBxgHQEQHREAHSDgHUDwHVRwHYGwHdYgHebgHjQwHjAeVIAeZgAeYB6FQB6lUB63AB7mMB8d0C8tsC88cC9NgC+tkC+3EB/FgB/AE=", table15);
+var table18 = unpackCodepage("gMQAgQABgQGDyQCEBAGF1gCG3ACH4QCIBQGJDAGK5ACLDQGMBgGMAY7pAI95AY8BkQ4Bku0Akw8BlBIBlAGWFgGX8wCYFwGZ9ACa9gCb9QCc+gCdGgGdAZ/8AKIYAaffAKsZAayoAK4jAa8uAa8BsSoBtCsBtTYBtgIitxEiuEIBuTsBuQO9OQG9Ab9FAb8BwUMBxEQBxUcBy0gBzFABzdUAzlEBz0wB18ol2E0B2VQB2QHbWAHcOSDcAd5ZAd9WAd8B4WAB4hog4x4g5GEB5VoB5QHnwQDoZAHoAerNAOt9AesB7WoB7tMA7gHwawHxbgHy2gDzbwHzBPjdAPn9APo3Aft7AfxBAf18Af4iAf/HAg==", table8);
+var table19 = unpackCodepage("gcUAgscAhNEAiOAAieIAi+MAjOUAjecAj+gAkOoAkAGT7ACU7gCUAZbxAJjyAJ35AJ77AKKiAKu0AK7GAK/YALAeIrGxALSlALW1ALgPIrnAA7orIruqALy6AL2pA77mAL/4AMC/AMGhAMSSAcVIIsvAAMzDAM5SAc4B2P8A2XgB2kQg26wg3gH73gHgISDhtwDkMCDlwgDmygDoywDpyADrzgDrAe3MAPD/+PHSAPPbAPTZAPUxAfbGAvfcAvivAPnYAvkC/LgA/d0C/tsC", table18);
+var table20 = unpackCodepage("gbkAgrIAhLMAh4UDi4QDjKgAkqMAkyIhliIgl70AmDAgm6YAnKwgoZMDoQGjmAOkmwOlngOmoAOqowOrqgOspwCusACvtwCwkQO1kgO2lQO2ArmZA7kBu5wDvKYDvasDvqgDvgHArAPBnQPDnwPEoQPGpAPLpQPMpwPNhgPOiAPRFSDXiQPXAdmMA9qOA9utA9sC3swD348D4M0D4bED4QHjyAPktAPkAebGA+ezA+i3A+m5A+q+A+u6A+sD778D7wHxzgPywQPzwwPzAfW4A/bJA/fCA/jHA/nFA/q2A/vKA/sB/ZAD/rAD/60A", table19);
+var dbfCodepages = Object.freeze({
+  "cp1250": table9,
+  "cp1251": table5,
+  "cp1253": table1,
+  "cp1254": table3,
+  "cp1255": table2,
+  "cp1256": table4,
+  "cp437": table10,
+  "cp737": table7,
+  "cp850": table15,
+  "cp852": table17,
+  "cp857": table16,
+  "cp860": table13,
+  "cp861": table12,
+  "cp863": table14,
+  "cp865": table11,
+  "cp866": table6,
+  "cp874": table0,
+  "mac_cyrillic": table8,
+  "mac_greek": table20,
+  "mac_latin2": table18,
+  "mac_roman": table19
+});
+var cp1252High = [
+  8364,
+  -1,
+  8218,
+  402,
+  8222,
+  8230,
+  8224,
+  8225,
+  710,
+  8240,
+  352,
+  8249,
+  338,
+  -1,
+  381,
+  -1,
+  -1,
+  8216,
+  8217,
+  8220,
+  8221,
+  8226,
+  8211,
+  8212,
+  732,
+  8482,
+  353,
+  8250,
+  339,
+  -1,
+  382,
+  376
+];
+var PythonTextDecodeError = class extends Error {
+};
+function decodePythonSingleByte(bytes, codepoints, encoding) {
+  let text = "";
+  for (const byte of bytes) {
+    const code = codepoints[byte];
+    if (code < 0) throw new PythonTextDecodeError(`Invalid ${encoding} input`);
+    text += String.fromCodePoint(code);
+  }
+  return text;
+}
+var pythonSingleByteCodepages = Object.freeze({
+  ...Object.fromEntries(Object.entries(dbfCodepages).map(([name, codepoints]) => [pythonCodecAliases[normalizeEncoding(name)], codepoints])),
+  ascii: Object.freeze(Array.from({ length: 256 }, (_, byte) => byte < 128 ? byte : -1)),
+  "iso8859-1": Object.freeze(Array.from({ length: 256 }, (_, byte) => byte)),
+  cp1252: Object.freeze(Array.from({ length: 256 }, (_, byte) => byte >= 128 && byte < 160 ? cp1252High[byte - 128] : byte))
+});
+
+export {
+  dbfCodepages,
+  PythonTextDecodeError,
+  decodePythonSingleByte,
+  pythonSingleByteCodepages
+};

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";