@poe-platform/safe-bash 0.1.801 → 0.1.803

package/dist/safe-bash/chunks/chunk-VBTDHOWC.js

@@ -0,0 +1,55 @@
+import {
+  registerDefaultExecutors
+} from "./chunk-E7OYNDGL.js";
+import {
+  init_platform
+} from "./chunk-B7TAL7S5.js";
+
+// packages/safe-bash/src/commands/metadata/index.ts
+init_platform();
+
+// packages/safe-bash/src/commands/metadata/chmod.ts
+init_platform();
+import { createChmodCommand, evalSyncChmod, modeChange } from "../../safe-bash-command-chmod/command.js";
+
+// packages/safe-bash/src/commands/metadata/stat.ts
+init_platform();
+import { createStatCommand, evalSyncStat } from "../../safe-bash-command-stat/command.js";
+
+// packages/safe-bash/src/commands/metadata/mktemp.ts
+init_platform();
+import { createMktempCommand, evalSyncMktemp } from "../../safe-bash-command-mktemp/command.js";
+
+// packages/safe-bash/src/commands/truncate.ts
+init_platform();
+import {} from "../../safe-bash-command-truncate/index.js";
+import { createTruncateCommand, createTruncateCommands, truncateCommand, truncateCommands, evalSyncTruncate } from "../../safe-bash-command-truncate/index.js";
+
+// packages/safe-bash/src/commands/metadata/internal.ts
+init_platform();
+import { MetadataBudget, metadataCommand, permissionString, settings } from "../../safe-bash-metadata-engine/index.js";
+
+// packages/safe-bash/src/commands/metadata/index.ts
+import { evalSyncTruncate as evalSyncTruncate2 } from "../../safe-bash-command-truncate/index.js";
+function createMetadataCommands(options = {}) {
+  settings(options);
+  return registerDefaultExecutors([createChmodCommand(options), createStatCommand(options), createMktempCommand(options), truncateCommand(options)], options);
+}
+function metadataCommands(options = {}) {
+  const commands = createMetadataCommands(options);
+  return { name: "metadata-commands", setup(host) {
+    if (!options.replace) {
+      for (const command of commands) if (host.commands.has(command.name)) throw new Error(`Command already registered: ${command.name}`);
+    }
+    for (const command of commands) host.commands.register(command, { replace: options.replace ?? false });
+  } };
+}
+
+export {
+  modeChange,
+  evalSyncStat,
+  evalSyncMktemp,
+  createMetadataCommands,
+  metadataCommands,
+  evalSyncTruncate2 as evalSyncTruncate
+};

package/dist/safe-bash/chunks/{chunk-NR3EM4LS.js → chunk-VKNVHEX3.js}

@@ -6,12 +6,7 @@ import {
 init_platform();
 import { AvailableRecords, RegexExecutionError, RegexExecutor, RegexSession, withRegexSession } from "../../safe-bash-regex-engine/execution/portable.js";
 
-// packages/safe-bash/src/commands/regex-execution/bounded-provider.ts
-init_platform();
-import { createBoundedRegexProvider } from "../../safe-bash-regex-engine/execution/bounded-provider.js";
-
 export {
   RegexExecutor,
-  RegexSession,
-  createBoundedRegexProvider
+  RegexSession
 };

package/dist/safe-bash/chunks/chunk-XAQMU6OY.js

@@ -0,0 +1,14 @@
+import {
+  init_platform
+} from "./chunk-B7TAL7S5.js";
+
+// packages/safe-bash/src/commands/apply-patch/index.ts
+init_platform();
+import { applyPatchCommands, createApplyPatchCommand, createApplyPatchCommands, evalSyncApplyPatch } from "../../safe-bash-command-apply-patch/index.js";
+
+export {
+  applyPatchCommands,
+  createApplyPatchCommand,
+  createApplyPatchCommands,
+  evalSyncApplyPatch
+};

package/dist/safe-bash/chunks/chunk-ZVD5IS4V.js

@@ -0,0 +1,49 @@
+import {
+  registerDefaultExecutors
+} from "./chunk-E7OYNDGL.js";
+import {
+  init_platform
+} from "./chunk-B7TAL7S5.js";
+
+// packages/safe-bash/src/commands/time-env/index.ts
+init_platform();
+
+// packages/safe-bash/src/commands/time-env/printenv.ts
+init_platform();
+import { createPrintenvWithSettings } from "../../safe-bash-command-printenv/printenv.js";
+import { evalSyncPrintenv } from "../../safe-bash-command-printenv/printenv.js";
+
+// packages/safe-bash/src/commands/time-env/date.ts
+init_platform();
+import { createDateWithSettings } from "../../safe-bash-command-date/date.js";
+import { evalSyncDate } from "../../safe-bash-command-date/date.js";
+
+// packages/safe-bash/src/commands/time-env/sleep.ts
+init_platform();
+import { createSleepWithSettings } from "../../safe-bash-command-sleep/sleep.js";
+
+// packages/safe-bash/src/commands/time-env/shared.ts
+init_platform();
+import { CommandFailure, checkSize, command, defaultSleepScheduler, emit, ownEnvironment, settings, timeEnvExecutorSettings } from "../../safe-bash-calendar-engine/time-env/shared.js";
+
+// packages/safe-bash/src/commands/time-env/index.ts
+function createTimeEnvCommands(options = {}) {
+  const configuration = settings(options);
+  return registerDefaultExecutors([createDateWithSettings(configuration), createSleepWithSettings(configuration), createPrintenvWithSettings(configuration)], options);
+}
+function timeEnvCommands(options = {}) {
+  const commands = createTimeEnvCommands(options);
+  return { name: "time-env-commands", setup(host) {
+    if (!options.replace) for (const definition of commands) {
+      if (host.commands.has(definition.name)) throw new Error(`Command already registered: ${definition.name}`);
+    }
+    for (const definition of commands) host.commands.register(definition, { replace: options.replace ?? false });
+  } };
+}
+
+export {
+  evalSyncPrintenv,
+  evalSyncDate,
+  createTimeEnvCommands,
+  timeEnvCommands
+};

package/dist/safe-bash/command-chunks/{chunk-ORYGZYKW.js → chunk-4FEVBOL5.js}

@@ -1,6 +1,6 @@
 import {
   SearchError
-} from "./chunk-VGG2DL5Q.js";
+} from "./chunk-TRR4MYWF.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";

package/dist/safe-bash/command-chunks/{chunk-VXSLJH7G.js → chunk-6JSIFWYT.js}

@@ -10,7 +10,7 @@ import {
 
 // packages/safe-bash-contracts/src/io.ts
 init_buffer();
-import { collectBytes, readBytes } from "@poe-platform/safe-fs/core";
+import { collectBytes, readBytes, retainFileSystemCleanup } from "@poe-platform/safe-fs/core";
 import { collectBytes as collectBytes2, readBytes as readBytes2, toByteSource } from "@poe-platform/safe-fs/core";
 
 // packages/safe-bash-contracts/src/managed-abort.ts
@@ -305,6 +305,7 @@ Object.assign(PipeWriteEndpointImpl.prototype, {
 });
 var BytePipeImpl = class {
   constructor(options) {
+    this.admitWrite = options.admitWrite;
     const highWaterMark = options.highWaterMark ?? 64 * 1024;
     if (!Number.isSafeInteger(highWaterMark) || highWaterMark < 1) {
       throw new RangeError("highWaterMark must be a positive safe integer");
@@ -636,6 +637,7 @@ var BytePipeImpl = class {
       if (!this.readerReferences) throw brokenPipe();
       if (!(chunk instanceof Uint8Array)) throw new TypeError("Byte sinks require Uint8Array chunks");
       if (!chunk.byteLength) return resolvedVoid;
+      this.admitWrite?.(chunk.byteLength);
       const owned = new Uint8Array(chunk);
       if (!this.writes || this.writes.size === 0) {
         const reading = this.reads && this.reads.size > 0 ? this.reads.values().next().value : void 0;
@@ -858,16 +860,21 @@ var InputByteBudget = class _InputByteBudget {
     return value;
   }
   assertOpen() {
-    if (this.#failure) throw this.#failure;
+    if (this.#failure) throw this.#failure.error;
   }
   charge(bytes) {
     this.assertOpen();
     if (!Number.isSafeInteger(bytes) || bytes < 0) throw new RangeError("Invalid input byte charge");
     if (bytes > this.maximum - this.#used) {
-      this.#failure = new FsError("EFBIG", { message: "command input byte limit exceeded" });
-      throw this.#failure;
+      this.#failure = { error: new FsError("EFBIG", { message: "command input byte limit exceeded" }) };
+      throw this.#failure.error;
+    }
+    try {
+      this.host?.check(this.#used + bytes);
+    } catch (error) {
+      this.#failure = { error };
+      throw error;
     }
-    this.host?.check(this.#used + bytes);
     this.#used += bytes;
   }
   async run(context, execute) {
@@ -875,7 +882,7 @@ var InputByteBudget = class _InputByteBudget {
     const limited = {
       ...context,
       stdin: this.read(context.stdin, context.signal),
-      fs: Object.create(fs, {
+      fs: new Proxy(Object.create(fs, {
         readFile: { configurable: true, value: async (...args) => {
           this.assertOpen();
           const bytes = await fs.readFile(...args);
@@ -902,6 +909,12 @@ var InputByteBudget = class _InputByteBudget {
           this.assertOpen();
           return this.read(fs.readStream(...args), context.signal);
         } } } : {}
+      }), {
+        get(target, key) {
+          if (Object.hasOwn(target, key)) return Reflect.get(target, key, target);
+          const value = Reflect.get(fs, key, fs);
+          return typeof value === "function" ? value.bind(fs) : value;
+        }
       }),
       inputBudget: {
         maxBytes: Math.min(this.maximum, context.inputBudget?.maxBytes ?? Infinity),
@@ -912,6 +925,13 @@ var InputByteBudget = class _InputByteBudget {
         }
       }
     };
+    const retain = (filesystem, callback, options) => {
+      if (filesystem !== limited.fs) throw new TypeError("Invalid input-budget cleanup filesystem");
+      return retainFileSystemCleanup(fs, callback, options);
+    };
+    Object.defineProperty(limited.fs, /* @__PURE__ */ Symbol.for("safe-fs.retainedCleanup"), {
+      value: Object.freeze({ filesystem: limited.fs, retain })
+    });
     try {
       return await execute(limited);
     } finally {

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

@@ -0,0 +1,200 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-chmod/src/command.ts
+init_buffer();
+import { modeChange } from "../../safe-bash-io-engine/commands/mode-change.js";
+import { modeChange as modeChange2 } from "../../safe-bash-io-engine/commands/mode-change.js";
+import { bindConditionalMutation } from "@poe-platform/safe-fs/core";
+import { creationUmask } from "../../safe-bash-contracts/runtime-control.js";
+import { FsError } from "../../safe-bash-contracts/index.js";
+import { codeOf, diagnostic, options, pathOf, requireOperands, syncCommandEvaluators, UsageError, value } from "../../safe-bash-io-engine/internal.js";
+import { gnuInformationSync } from "../../safe-bash-io-engine/gnu-information.js";
+import { MetadataBudget, metadataCommand, permissionString, settings } from "../../safe-bash-metadata-engine/index.js";
+function createChmodCommand(configuration = {}) {
+  const configured = settings(configuration);
+  const configuredUmask = configuration.umask === void 0 ? void 0 : configured.umask;
+  return metadataCommand("chmod", async (context) => {
+    const budget = new MetadataBudget(context, configured.limits);
+    const modeOptions = [];
+    let ended = false, referenceValue = false;
+    const args = context.args.flatMap((argument) => {
+      if (referenceValue) {
+        referenceValue = false;
+        return [argument];
+      }
+      if (argument === "--") ended = true;
+      if (ended) return [argument];
+      if (argument === "--reference") referenceValue = true;
+      if (argument.startsWith("-") && argument.length > 1 && "rwxXstugo01234567".includes(argument[1])) {
+        modeOptions.push(argument);
+        return [];
+      }
+      return [argument];
+    });
+    const parsed = options(args, "Rvcf", { recursive: "R", verbose: "v", changes: "c", silent: "f", quiet: "f", reference: "reference:" });
+    const reference = value(parsed, "reference");
+    if (reference !== void 0 && modeOptions.length) throw new UsageError("cannot combine mode and --reference options");
+    requireOperands(parsed.operands, reference === void 0 && !modeOptions.length ? 2 : 1);
+    const mode = modeOptions.length ? modeOptions.join(",") : reference === void 0 ? parsed.operands.shift() : void 0;
+    const mask = configuredUmask ?? Reflect.get(context.fs, creationUmask);
+    const activeUmask = typeof mask === "number" ? mask : configured.umask;
+    const change = mode === void 0 ? void 0 : modeChange(mode, activeUmask);
+    const paths = parsed.operands;
+    if (context.fs.capabilities.readOnly) throw new FsError("EROFS", { syscall: "chmod" });
+    if (!context.fs.chmod || context.fs.capabilities.permissions === false) throw new FsError("ENOTSUP", { syscall: "chmod" });
+    const referenceMode = reference === void 0 ? void 0 : (await context.fs.stat(pathOf(context, reference), { signal: context.signal })).mode & 4095;
+    let exitCode = 0;
+    const visit = async (path, display, depth, top) => {
+      await budget.step(depth);
+      const link = await context.fs.lstat(path, { signal: context.signal });
+      if (link.type === "symlink" && !top) return;
+      const target = link.type === "symlink" ? await context.fs.realpath(path, { signal: context.signal }) : path;
+      const stat = link.type === "symlink" ? await context.fs.stat(target, { signal: context.signal }) : link;
+      const mode2 = referenceMode ?? change(stat);
+      if (parsed.flags.has("R") && stat.type === "directory" && await context.fs.realpath(target, { signal: context.signal }) === "/") throw new FsError("EBUSY", { syscall: "chmod", path, message: "refusing recursive mode changes at virtual root" });
+      const canonicalTarget = await context.fs.realpath(target, { signal: context.signal });
+      const apply = async () => {
+        context.signal.throwIfAborted();
+        const currentCanonical = await context.fs.realpath(target, { signal: context.signal });
+        if (currentCanonical !== canonicalTarget) throw new FsError("EIO", { syscall: "chmod", path, message: "path changed during permission update" });
+        const fresh = await context.fs.lstat(canonicalTarget, { signal: context.signal });
+        if (fresh.type === "symlink" || fresh.type !== stat.type || stat.ino !== void 0 && fresh.ino !== stat.ino || stat.dev !== void 0 && fresh.dev !== stat.dev) throw new FsError("EIO", { syscall: "chmod", path, message: "path changed during permission update" });
+        const capabilities = await context.fs.capabilitiesFor?.(canonicalTarget, { signal: context.signal, conditionalChmod: true }) ?? context.fs.capabilities;
+        context.signal.throwIfAborted();
+        if (capabilities.conditionalChmod !== true) throw new FsError("ENOTSUP", { syscall: "chmod", path, message: "conditional permission updates are not supported" });
+        const parentPath = canonicalTarget.slice(0, canonicalTarget.lastIndexOf("/")) || "/";
+        const ancestorPaths = ["/"];
+        if (parentPath !== "/") {
+          let prefix = "";
+          for (const part of parentPath.split("/").filter(Boolean)) {
+            prefix += `/${part}`;
+            ancestorPaths.push(prefix);
+          }
+        }
+        const ancestors = await Promise.all(ancestorPaths.map(async (entryPath) => ({
+          path: entryPath,
+          stat: await context.fs.lstat(entryPath, { signal: context.signal })
+        })));
+        const parentStat = ancestors.at(-1).stat;
+        const mutation = { signal: context.signal, parent: parentStat, expected: fresh, ancestors };
+        await bindConditionalMutation(
+          fresh.identityScope,
+          { path: canonicalTarget, parent: parentStat, expected: fresh, ancestors },
+          () => context.fs.chmod(canonicalTarget, mode2, mutation)
+        );
+        if (parsed.flags.has("v") || parsed.flags.has("c") && mode2 !== (stat.mode & 4095)) {
+          await budget.output(`mode of '${display}' ${mode2 === (stat.mode & 4095) ? "retained as" : "changed from " + (stat.mode & 4095).toString(8).padStart(4, "0") + " (" + permissionString(stat.mode, stat.type).slice(1) + ") to"} ${mode2.toString(8).padStart(4, "0")} (${permissionString(mode2, stat.type).slice(1)})
+`);
+        }
+      };
+      const deferred = stat.type === "directory" && parsed.flags.has("R") && (stat.mode & 511 & ~mode2) !== 0;
+      if (!deferred) await apply();
+      if (stat.type === "directory" && parsed.flags.has("R")) {
+        const entries = await context.fs.readdir(target, {
+          signal: context.signal,
+          ...Number.isFinite(budget.remainingEntries) ? { maxEntries: budget.remainingEntries } : {}
+        });
+        if (entries.length > budget.remainingEntries) throw new FsError("EFBIG", { message: "metadata traversal limit exceeded" });
+        for (const entry of entries) {
+          if (!entry.name || entry.name === "." || entry.name === ".." || entry.name.includes("/") || entry.name.includes("\0")) throw new FsError("EIO", { message: "invalid directory entry" });
+          try {
+            await visit(`${target.replace(/\/$/u, "")}/${entry.name}`, `${display.replace(/\/$/u, "")}/${entry.name}`, depth + 1, false);
+          } catch (error) {
+            context.signal.throwIfAborted();
+            if (codeOf(error) === "EFBIG") throw error;
+            exitCode = 1;
+            if (!parsed.flags.has("f")) await diagnostic(context, error);
+          }
+        }
+      }
+      if (deferred) await apply();
+    };
+    for (const operand of paths) {
+      try {
+        await visit(pathOf(context, operand), operand, 0, true);
+      } catch (error) {
+        context.signal.throwIfAborted();
+        if (codeOf(error) === "EFBIG") throw error;
+        exitCode = 1;
+        if (!parsed.flags.has("f")) await diagnostic(context, error);
+      }
+    }
+    return { exitCode };
+  });
+}
+function evalSyncChmod(opArgs, umask, chmodNodeSync) {
+  const gnuInfo = gnuInformationSync("chmod", opArgs);
+  if (gnuInfo !== void 0) return gnuInfo;
+  if (!chmodNodeSync) return void 0;
+  try {
+    const modeOptions = [];
+    let ended = false;
+    let referenceValue = false;
+    const args = [];
+    for (const argument of opArgs) {
+      if (referenceValue) {
+        referenceValue = false;
+        args.push(argument);
+        continue;
+      }
+      if (argument === "--") {
+        ended = true;
+        args.push(argument);
+        continue;
+      }
+      if (!ended && argument === "--reference") {
+        referenceValue = true;
+        args.push(argument);
+        continue;
+      }
+      if (!ended && argument.startsWith("-") && argument.length > 1 && "rwxXstugo01234567".includes(argument[1])) {
+        modeOptions.push(argument);
+        continue;
+      }
+      args.push(argument);
+    }
+    const parsed = options(args, "vcf", { verbose: "v", changes: "c", silent: "f", quiet: "f", reference: "reference:" });
+    const reference = value(parsed, "reference");
+    if (reference !== void 0 && modeOptions.length) return void 0;
+    const minOps = reference !== void 0 || modeOptions.length ? 1 : 2;
+    if (parsed.operands.length < minOps) return void 0;
+    let referenceMode;
+    if (reference !== void 0) {
+      if (!chmodNodeSync(reference, (stat) => {
+        referenceMode = stat.mode & 4095;
+        return stat.mode;
+      }) || referenceMode === void 0) {
+        return void 0;
+      }
+    }
+    const mode = modeOptions.length ? modeOptions.join(",") : reference === void 0 ? parsed.operands.shift() : void 0;
+    const change = mode === void 0 ? void 0 : modeChange(mode, umask);
+    let out = "";
+    for (const op of parsed.operands) {
+      let line = "";
+      const ok = chmodNodeSync(op, (stat) => {
+        const oldMode = stat.mode & 4095;
+        const nextMode = (referenceMode ?? change(stat)) & 4095;
+        if (parsed.flags.has("v") || parsed.flags.has("c") && nextMode !== oldMode) {
+          line = `mode of '${op}' ${nextMode === oldMode ? "retained as" : "changed from " + oldMode.toString(8).padStart(4, "0") + " (" + permissionString(oldMode, stat.type).slice(1) + ") to"} ${nextMode.toString(8).padStart(4, "0")} (${permissionString(nextMode, stat.type).slice(1)})
+`;
+        }
+        return nextMode;
+      });
+      if (!ok) return void 0;
+      out += line;
+    }
+    return out;
+  } catch {
+    return void 0;
+  }
+}
+syncCommandEvaluators.evalSyncChmod = evalSyncChmod;
+
+export {
+  createChmodCommand,
+  evalSyncChmod,
+  modeChange2 as modeChange
+};

package/dist/safe-bash/command-chunks/{chunk-KJIMDLBB.js → chunk-BXCXRYVU.js}

@@ -1,6 +1,6 @@
 import {
   formats
-} from "./chunk-5E4WAO4O.js";
+} from "./chunk-JD5QNRNO.js";
 import {
   CompressedDataError
 } from "./chunk-2UQSP2CE.js";

package/dist/safe-bash/command-chunks/{chunk-F4TEEZTL.js → chunk-CQHP3I66.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-Z6UEDK5T.js";
 import {
   boundedCodec
-} from "./chunk-W5DNF4JH.js";
+} from "./chunk-LOICUCHG.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";

package/dist/safe-bash/command-chunks/{chunk-PEF7K3UQ.js → chunk-EARHPPPJ.js}

@@ -1,6 +1,6 @@
 import {
   SearchError
-} from "./chunk-VGG2DL5Q.js";
+} from "./chunk-TRR4MYWF.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";

package/dist/safe-bash/command-chunks/{chunk-QKFSRZGQ.js → chunk-GFC2NTDG.js}

@@ -125,7 +125,7 @@ function syntheticStatFor(type) {
 function createFindDefinitions(execute, maxDirectoryEntries) {
   const readDirectory = createDirectoryReader(maxDirectoryEntries);
   const defs = [define("find", (context) => {
-    if (!context.argumentValues && context.args.length === 3 && (context.args[1] === "-name" || context.args[1] === "-iname") && !sharedFindPrintBufInUse && !context.signal.aborted) {
+    if (context._hasInfiniteFsOpsLimit === true && !context.argumentValues && context.args.length === 3 && (context.args[1] === "-name" || context.args[1] === "-iname") && !sharedFindPrintBufInUse && !context.signal.aborted) {
       const rootDisplay = context.args[0];
       if (rootDisplay && !rootDisplay.startsWith("-") && rootDisplay !== "!" && rootDisplay !== "(") {
         const fastBacking = context._fastMemoryBackingFs;
@@ -658,7 +658,7 @@ ${explicitAction ? tree : `AND(${tree}, implicit -print)`}
       })();
     };
     const canSkipChildStat = !needsStat && !explicitAction && follow !== "-L";
-    const backing = getRuntimeBackingFileSystem(context.fs);
+    const backing = context._hasInfiniteFsOpsLimit === true ? getRuntimeBackingFileSystem(context.fs) : void 0;
     const maxEntriesLimit = maxDirectoryEntries ?? Infinity;
     let uniformDirAdmitted = false;
     const scratchChildEntry = { path: "", display: "", name: "", stat: SYNTHETIC_FILE_STAT, symlink: false, depth: 0, root: "", relative: "", prune: false };