@poe-platform/safe-bash 0.1.802 → 0.1.803

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