@poe-platform/safe-bash 0.1.809 → 0.1.810

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

@@ -0,0 +1,326 @@
+// packages/safe-bash-command-patch/src/patch-publication.ts
+import { compareCopyIdentity } from "../../safe-bash-contracts/filesystem-identity.js";
+import { retainFileSystemCleanup } from "@poe-platform/safe-fs/core";
+import { dirname, FsError, isFsError } from "../../safe-bash-contracts/index.js";
+import { host as host2, ToolError as ToolError2 } from "../../safe-bash-diff-engine/shared.js";
+
+// packages/safe-bash-command-patch/src/stored-target.ts
+import { PagedStorage } from "@poe-platform/safe-fs/storage";
+import { IndexedDocument, closeDocumentResources } from "../../safe-bash-diff-engine/document.js";
+import { ToolError, host } from "../../safe-bash-diff-engine/shared.js";
+async function* targetBytes(line) {
+  if (typeof line !== "string") {
+    const range = await line.document.line(line.index);
+    yield* line.document.range(range.start, range.end);
+    return;
+  }
+  for (let start = 0; start < line.length; ) {
+    let end = Math.min(start + 4096, line.length);
+    const last = line.charCodeAt(end - 1);
+    if (end < line.length && last >= 55296 && last <= 56319) end--;
+    yield new TextEncoder().encode(line.slice(start, end));
+    start = end;
+  }
+}
+async function* normalized(line, whitespace) {
+  if (!whitespace) {
+    yield* targetBytes(line);
+    return;
+  }
+  let pending = false, cr = false;
+  let output = [];
+  for await (const block of targetBytes(line)) {
+    for (const byte of block) {
+      if (cr) {
+        if (byte !== 10 && pending) output.push(32);
+        output.push(13);
+        cr = false;
+        pending = false;
+      }
+      if (byte === 32 || byte === 9) pending = true;
+      else if (byte === 13 && pending) cr = true;
+      else {
+        if (pending && byte !== 10) output.push(32);
+        pending = false;
+        output.push(byte);
+      }
+      if (output.length >= 4096) {
+        yield Uint8Array.from(output);
+        output = [];
+      }
+    }
+  }
+  if (cr) output.push(32, 13);
+  if (output.length) yield Uint8Array.from(output);
+}
+async function equalTargetLines(left, right, budget, whitespace = false) {
+  const a = normalized(left, whitespace)[Symbol.asyncIterator]();
+  const b = normalized(right, whitespace)[Symbol.asyncIterator]();
+  try {
+    let x = await a.next(), y = await b.next(), i = 0, j = 0;
+    while (!x.done && !y.done) {
+      const count = Math.min(x.value.length - i, y.value.length - j);
+      budget.step(count);
+      for (let k = 0; k < count; k++) if (x.value[i + k] !== y.value[j + k]) return false;
+      i += count;
+      j += count;
+      if (i === x.value.length) {
+        x = await a.next();
+        i = 0;
+      }
+      if (j === y.value.length) {
+        y = await b.next();
+        j = 0;
+      }
+      const checkpoint = budget.checkpoint();
+      if (checkpoint) await checkpoint;
+    }
+    return !!x.done && !!y.done;
+  } finally {
+    await a.return?.();
+    await b.return?.();
+  }
+}
+var TargetDocuments = class {
+  constructor(budget) {
+    this.budget = budget;
+  }
+  budget;
+  documents = /* @__PURE__ */ new Set();
+  async load(source) {
+    const document = new IndexedDocument(this.budget, 2);
+    this.documents.add(document);
+    await document.load(source);
+    if (document.binary) throw new ToolError("binary input is unsupported (NUL byte)");
+    if (!document.validUtf8) throw new ToolError("binary input is unsupported (invalid UTF-8)");
+    return document;
+  }
+  async read(path) {
+    const iterator = this.budget.diffSource(path);
+    const context = this.budget.context;
+    return this.load({ async *[Symbol.asyncIterator]() {
+      try {
+        for (; ; ) {
+          const next = await host(context, () => iterator.next());
+          if (next.done) break;
+          yield next.value;
+        }
+      } finally {
+        const closed = iterator.return(void 0);
+        if (context.signal.aborted) void closed.catch(() => {
+        });
+        else await closed;
+      }
+    } });
+  }
+  async concat(left, right) {
+    return this.load({ async *[Symbol.asyncIterator]() {
+      yield* left.range(0, left.size);
+      yield* right.range(0, right.size);
+    } });
+  }
+  async release(document) {
+    await document.close();
+    this.documents.delete(document);
+  }
+  close() {
+    return closeDocumentResources([...this.documents]);
+  }
+};
+var TargetOutput = class {
+  constructor(documents) {
+    this.documents = documents;
+    this.data = new PagedStorage(documents.budget.context, 2);
+  }
+  documents;
+  data;
+  size = 0;
+  unterminated = false;
+  length = 0;
+  async append(line) {
+    if (this.unterminated) await this.write(new Uint8Array([10]));
+    this.unterminated = false;
+    for await (const bytes of targetBytes(line)) {
+      await this.write(bytes);
+      this.unterminated = bytes.at(-1) !== 10;
+    }
+    this.length++;
+  }
+  async write(bytes) {
+    this.size += bytes.length;
+    if (this.size > this.documents.budget.limits.maxOutputBytes) throw new ToolError("output byte limit exceeded");
+    await this.data.append(bytes);
+  }
+  async finish() {
+    const data = this.data, size = this.size;
+    this.documents.budget.outputLength(size);
+    return this.documents.load({ async *[Symbol.asyncIterator]() {
+      for (let offset = 0; offset < size; offset += 16384) yield await data.read(8 + offset, Math.min(16384, size - offset));
+    } });
+  }
+  close() {
+    return this.data.close();
+  }
+};
+
+// packages/safe-bash-command-patch/src/patch-publication.ts
+import { readBytes } from "../../safe-bash-contracts/index.js";
+var PatchPublication = class {
+  constructor(context, trusted = false) {
+    this.context = context;
+    this.trusted = trusted;
+  }
+  context;
+  trusted;
+  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 host2(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 ToolError2(`unsafe patch parent: ${parent}`);
+      this.directories.set(parent, stat);
+    }
+    if (this.trusted) return;
+    if (this.directories.has(dirname(path)) && !this.removals.has(path)) {
+      this.removals.set(path, await host2(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 host2(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 validate(path) {
+    const parents = [];
+    for (let parent = dirname(path); ; parent = dirname(parent)) {
+      parents.unshift(parent);
+      if (parent === "/") break;
+    }
+    for (const parent of parents) {
+      const expected = this.directories.get(parent);
+      const current = await host2(this.context, () => this.context.fs.lstat(parent, { signal: this.context.signal }));
+      if (current.type !== "directory" || compareCopyIdentity(current, expected) !== "same") {
+        throw new FsError("EAGAIN", { syscall: "patch", path: parent });
+      }
+    }
+  }
+  async mkdir(path) {
+    await this.capture(path);
+    await this.validate(path);
+    const stat = await host2(this.context, () => this.context.fs.prepareDirectory(path, {
+      parent: this.directories.get(dirname(path)),
+      expected: null,
+      signal: this.context.signal
+    }));
+    this.directories.set(path, stat);
+  }
+  async write(path, source, 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 ToolError2(`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?.cleanup) await staging.cleanup.remove();
+      else 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 ToolError2("patch publication is closed");
+        if (this.trusted) await this.validate(path);
+        staging = await context.fs.createStagedFile(`${dirname(path) === "/" ? "" : dirname(path)}/.patch-${globalThis.crypto.randomUUID()}`, "file", {
+          type: "file",
+          data: new Uint8Array()
+        }, {
+          parent,
+          retainCleanup: true,
+          signal: context.signal,
+          ...mode === void 0 ? {} : { mode },
+          ...mtimeMs === void 0 ? {} : { atimeMs: mtimeMs, mtimeMs }
+        });
+        if (!staging.writer || !staging.cleanup) throw new ToolError2("filesystem does not support retained staging writes");
+        for await (const bytes of readBytes(typeof source === "string" ? targetBytes(source) : source, context.signal)) {
+          if (closed) throw new ToolError2("patch publication is closed");
+          await staging.writer.write(bytes, { signal: context.signal });
+        }
+        const stat = await staging.writer.finish({ signal: context.signal });
+        context.signal.throwIfAborted();
+        if (closed) throw new ToolError2("patch publication is closed");
+        if (this.trusted) await this.validate(path);
+        await context.fs.publishStagedFile({ ...staging, file: { ...staging.file, stat } }, path, {
+          parent,
+          destination: destination ?? null,
+          ...this.trusted ? {} : { ancestors },
+          signal: context.signal
+        });
+      });
+      await host2(context, () => operation);
+    } finally {
+      await cleanup();
+    }
+  }
+  async remove(path, expected) {
+    if (this.trusted) {
+      await this.validate(path);
+      await host2(this.context, () => this.context.fs.removeFileConditional(path, {
+        parent: this.directories.get(dirname(path)),
+        expected,
+        signal: this.context.signal
+      }));
+      return;
+    }
+    const fs = this.removals.get(path);
+    if (!fs) throw new ToolError2(`patch removal was not admitted: ${path}`);
+    await host2(this.context, () => fs.rm(path, { signal: this.context.signal }));
+  }
+  async prune(path) {
+    if (this.trusted) {
+      await this.validate(`${path}/.patch-prune`);
+      if (!this.context.fs.rmdir) throw new FsError("ENOTSUP", { syscall: "rmdir", path });
+      await host2(this.context, () => this.context.fs.rmdir(path, { signal: this.context.signal }));
+      this.directories.delete(path);
+      return;
+    }
+    const fs = this.pruning.get(path);
+    if (!fs) throw new ToolError2(`patch directory pruning was not admitted: ${path}`);
+    if (!fs.rmdir) throw new FsError("ENOTSUP", { syscall: "rmdir", path });
+    await host2(this.context, () => fs.rmdir(path, { signal: this.context.signal }));
+  }
+};
+
+export {
+  targetBytes,
+  equalTargetLines,
+  TargetDocuments,
+  TargetOutput,
+  PatchPublication
+};

package/dist/safe-bash/command-chunks/{chunk-45FI2IPY.js → chunk-WQ6ABTJU.js}

@@ -1,4 +1,5 @@
 // packages/safe-bash-command-media/src/plugin.ts
+import { readFileStream } from "@poe-platform/safe-fs/core";
 import { getCommandArguments } from "../../safe-bash-contracts/command.js";
 import { createFFmpegShims } from "../../safe-bash-media-engine/index.js";
 import { createImageMagickShims } from "../../safe-bash-media-engine/index.js";
@@ -46,12 +47,8 @@ function mediaShims(options) {
                 return void 0;
               }
             },
-            async read(bytes) {
-              try {
-                return await context.fs.readFile(path(bytes), { signal: context.signal });
-              } catch {
-                return void 0;
-              }
+            readStream(bytes) {
+              return readFileStream(context.fs, path(bytes), { signal: context.signal, chunkSize: 65536 });
             }
           };
         }

package/dist/safe-bash/command-chunks/{chunk-NB7JO7FE.js → chunk-YTFWPJ3F.js}

@@ -1,7 +1,7 @@
 import {
   validateXmlPartReplacement,
   validateXmlViewReplacement
-} from "./chunk-6OKH4X67.js";
+} from "./chunk-CAXJ4RLF.js";
 import {
   Slide,
   Slides,