@poe-platform/safe-bash 0.1.812 → 0.1.814

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

@@ -1,333 +0,0 @@
-// 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, PagedStorageCache } 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;
-    this.documentBudget = {
-      context: budget.context,
-      documentCache: new PagedStorageCache(16),
-      step: budget.step.bind(budget),
-      checkpoint: budget.checkpoint.bind(budget)
-    };
-  }
-  budget;
-  documents = /* @__PURE__ */ new Set();
-  documentBudget;
-  async load(source) {
-    const document = new IndexedDocument(this.documentBudget, 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
-};