@poe-platform/safe-bash 0.1.801 → 0.1.803

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

@@ -0,0 +1,168 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-mktemp/src/command.ts
+init_buffer();
+import { creationUmask } from "../../safe-bash-contracts/runtime-control.js";
+import { randomInteger } from "../../safe-bash-metadata-engine/random.js";
+import { FsError, validatePath } from "../../safe-bash-contracts/index.js";
+import { codeOf, diagnostic, pathOf, syncCommandEvaluators, UsageError } from "../../safe-bash-io-engine/internal.js";
+import { gnuInformationSync } from "../../safe-bash-io-engine/gnu-information.js";
+import { MetadataBudget, metadataCommand, settings } from "../../safe-bash-metadata-engine/index.js";
+var mktempEncoder = new TextEncoder();
+function parse(args) {
+  let directory = false;
+  let dryRun = false;
+  let quiet = false;
+  let useTmpdir = false;
+  let deprecatedTmpdir = false;
+  let tmpdir;
+  let suffix;
+  let literal = false;
+  const operands = [];
+  for (let index = 0; index < args.length; index++) {
+    const argument = args[index];
+    if (literal || argument === "-" || !argument.startsWith("-")) operands.push(argument);
+    else if (argument === "--") literal = true;
+    else if (argument === "--directory") directory = true;
+    else if (argument === "--dry-run") dryRun = true;
+    else if (argument === "--quiet") quiet = true;
+    else if (argument === "--tmpdir" || argument.startsWith("--tmpdir=")) {
+      useTmpdir = true;
+      tmpdir = argument.includes("=") ? argument.slice(argument.indexOf("=") + 1) : "";
+    } else if (argument === "--suffix" || argument.startsWith("--suffix=")) {
+      suffix = argument.includes("=") ? argument.slice(argument.indexOf("=") + 1) : args[++index];
+      if (suffix === void 0) throw new UsageError("--suffix requires an argument");
+    } else if (!argument.startsWith("--")) {
+      for (let offset = 1; offset < argument.length; offset++) {
+        const option = argument[offset];
+        if (option === "d") directory = true;
+        else if (option === "u") dryRun = true;
+        else if (option === "q") quiet = true;
+        else if (option === "t") {
+          useTmpdir = true;
+          deprecatedTmpdir = true;
+        } else if (option === "p") {
+          tmpdir = argument.slice(offset + 1) || args[++index];
+          if (tmpdir === void 0) throw new UsageError("-p requires an argument");
+          useTmpdir = true;
+          break;
+        } else throw new UsageError(`unrecognized option '${argument}'`);
+      }
+    } else throw new UsageError(`unrecognized option '${argument}'`);
+  }
+  if (operands.length > 1) throw new UsageError("too many templates");
+  const template = operands[0] ?? "tmp.XXXXXXXXXX";
+  if (operands.length === 0) useTmpdir = true;
+  validatePath(template);
+  if (deprecatedTmpdir && template.includes("/")) throw new UsageError("template contains directory separator");
+  validatePath(suffix ?? "");
+  if (suffix?.includes("/") || suffix !== void 0 && !template.endsWith("X")) throw new UsageError("suffix requires a template ending in X and cannot contain '/'");
+  const name = template.slice(template.lastIndexOf("/") + 1);
+  if (name.length + (suffix?.length ?? 0) > 255 || mktempEncoder.encode(name).byteLength + mktempEncoder.encode(suffix ?? "").byteLength > 255) throw new FsError("ENAMETOOLONG", { path: template });
+  const end = name.lastIndexOf("X") + 1;
+  let start = end;
+  while (start > 0 && name[start - 1] === "X") start--;
+  if (end - start < 3) throw new UsageError("template must contain at least three consecutive X characters in its last component");
+  if (useTmpdir && template.startsWith("/")) throw new UsageError("template must be relative with --tmpdir/-p");
+  const tail = suffix ?? name.slice(end);
+  return { directory, dryRun, quiet, useTmpdir, deprecatedTmpdir, tmpdir, template, prefix: template.slice(0, template.length - name.length + start), count: end - start, tail };
+}
+var alphabet = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+function sampleTemplateChars(count) {
+  let out = "";
+  for (let index = 0; index < count; index++) out += alphabet[randomInteger(alphabet.length)];
+  return out;
+}
+function evalSyncMktemp(opArgs, env, statTypeSync, writeFileSync, mkdirSync) {
+  const gnuInfo = gnuInformationSync("mktemp", opArgs);
+  if (gnuInfo !== void 0) return gnuInfo;
+  try {
+    const parsed = parse(opArgs);
+    const parent = parsed.deprecatedTmpdir && env.TMPDIR || parsed.tmpdir || env.TMPDIR || "/tmp";
+    validatePath(parent);
+    if (!statTypeSync) return void 0;
+    if (parsed.useTmpdir && !parsed.dryRun && statTypeSync(parent || ".") !== "directory") return void 0;
+    for (let attempt = 0; attempt < 32; attempt++) {
+      const random = sampleTemplateChars(parsed.count);
+      const generated = `${parsed.prefix}${random}${parsed.tail}`;
+      const display = parsed.useTmpdir ? `${parent.replace(/\/+$/u, "")}/${generated}` : generated;
+      const st = statTypeSync(display);
+      if (st !== "missing") continue;
+      if (!parsed.dryRun) {
+        if (parsed.directory) {
+          if (!mkdirSync || !mkdirSync(display)) return void 0;
+        } else {
+          if (!writeFileSync || !writeFileSync(display, new Uint8Array(0))) return void 0;
+        }
+      }
+      return `${display}
+`;
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+syncCommandEvaluators.evalSyncMktemp = evalSyncMktemp;
+function createMktempCommand(configuration = {}) {
+  const configured = settings(configuration);
+  const configuredUmask = configuration.umask === void 0 ? void 0 : configured.umask;
+  return metadataCommand("mktemp", async (context) => {
+    const budget = new MetadataBudget(context, configured.limits);
+    const parsed = parse(context.args);
+    const parent = parsed.deprecatedTmpdir && context.env.TMPDIR || parsed.tmpdir || context.env.TMPDIR || "/tmp";
+    validatePath(parent);
+    try {
+      if (!parsed.dryRun) {
+        if (context.fs.capabilities.readOnly) throw new FsError("EROFS", { syscall: "mktemp" });
+      }
+      for (let attempt = 0; attempt < configured.limits.maxAttempts; attempt++) {
+        await budget.step();
+        const random = sampleTemplateChars(parsed.count);
+        const generated = `${parsed.prefix}${random}${parsed.tail}`;
+        const display = parsed.useTmpdir ? `${parent.replace(/\/+$/u, "")}/${generated}` : generated;
+        const path = pathOf(context, display);
+        if (mktempEncoder.encode(display).byteLength + 1 > configured.limits.maxOutputBytes) throw new FsError("EFBIG", { message: "temporary pathname output exceeds limit" });
+        if (parsed.dryRun) {
+          try {
+            await context.fs.lstat(path, { signal: context.signal });
+            continue;
+          } catch (error) {
+            context.signal.throwIfAborted();
+            if (codeOf(error) !== "ENOENT") throw error;
+          }
+        } else {
+          const capabilities = await context.fs.capabilitiesFor?.(path, { signal: context.signal }) ?? context.fs.capabilities;
+          if (capabilities.readOnly === true) throw new FsError("EROFS", { syscall: "mktemp" });
+          if (capabilities.permissions !== true) throw new FsError("ENOTSUP", { syscall: "mktemp", message: "private temporary creation requires declared permission support" });
+          try {
+            const mask = configuredUmask ?? Reflect.get(context.fs, creationUmask);
+            const activeUmask = typeof mask === "number" ? mask : configured.umask;
+            const mode = (parsed.directory ? 448 : 384) & ~activeUmask;
+            if (parsed.directory) await context.fs.mkdir(path, { mode, recursive: false, signal: context.signal });
+            else await context.fs.writeFile(path, new Uint8Array(), { mode, flag: "wx", signal: context.signal });
+          } catch (error) {
+            context.signal.throwIfAborted();
+            if (codeOf(error) !== "EEXIST") throw error;
+            continue;
+          }
+        }
+        await budget.output(`${display}
+`);
+        return { exitCode: 0 };
+      }
+      throw new FsError("EEXIST", { syscall: "mktemp", message: "temporary name collision limit exceeded" });
+    } catch (error) {
+      context.signal.throwIfAborted();
+      if (!parsed.quiet) await diagnostic(context, error);
+      return { exitCode: 1 };
+    }
+  });
+}
+
+export {
+  evalSyncMktemp,
+  createMktempCommand
+};

package/dist/safe-bash/commands/apply-patch/index.browser.js

@@ -0,0 +1,14 @@
+import {
+  applyPatchCommands,
+  createApplyPatchCommand,
+  createApplyPatchCommands,
+  evalSyncApplyPatch
+} from "../../chunks/chunk-XAQMU6OY.js";
+import "../../chunks/chunk-IWDICZVK.js";
+import "../../chunks/chunk-B7TAL7S5.js";
+export {
+  applyPatchCommands,
+  createApplyPatchCommand,
+  createApplyPatchCommands,
+  evalSyncApplyPatch
+};

package/dist/safe-bash/commands/archive/index.browser.js

@@ -0,0 +1,36 @@
+import {
+  DEFAULT_ARCHIVE_LIMITS,
+  archiveCommands,
+  createArchiveCommands,
+  createTarCommand,
+  createTarCommands,
+  createUnzipCommand,
+  createUnzipCommands,
+  createZipCommand,
+  createZipCommands,
+  evalSyncTar,
+  evalSyncUnzip,
+  evalSyncZip,
+  tarCommands,
+  unzipCommands,
+  zipCommands
+} from "../../chunks/chunk-QGUV42T5.js";
+import "../../chunks/chunk-IWDICZVK.js";
+import "../../chunks/chunk-B7TAL7S5.js";
+export {
+  DEFAULT_ARCHIVE_LIMITS,
+  archiveCommands,
+  createArchiveCommands,
+  createTarCommand,
+  createTarCommands,
+  createUnzipCommand,
+  createUnzipCommands,
+  createZipCommand,
+  createZipCommands,
+  evalSyncTar,
+  evalSyncUnzip,
+  evalSyncZip,
+  tarCommands,
+  unzipCommands,
+  zipCommands
+};

package/dist/safe-bash/commands/bytes/compression/index.js

@@ -23,65 +23,68 @@ export function createCompressionCommands(config = {}) {
     if (maxDecodedBytes !== undefined && maxDecodedBytes !== Infinity && (!Number.isSafeInteger(maxDecodedBytes) || maxDecodedBytes < 0)) {
         throw new RangeError("maxDecodedBytes must be a nonnegative safe integer or Infinity");
     }
-    const commands = profiles.flatMap(profile => profile.format === "gzip" ? createGzipCommands(config) : profile.format === "bzip2" ? createBzip2Commands(config) : profile.names.map((name) => define(name, withInputByteBudget(async (context) => {
-        const options = parseOptions(name, context.args);
-        if (options.help) {
-            await output(context, `Usage: ${name} [OPTION]... [FILE]...\n-c, --stdout, --to-stdout\n-d, --decompress, --uncompress\n-k, --keep\n-f, --force\n-t, --test\n${options.format === "zstd" ? "-1..-9, --best\nHigher levels and --fast[=NUM] are unsupported by the bounded codec.\n" : "-1..-9, --fast, --best\n"}${options.format === "zstd" ? "-q, --quiet (repeat to suppress errors)\n" : ""}${options.format === "gzip" ? "-q, --quiet (suppress warnings)\n-r, --recursive (traverse directories without following symlinks)\n-n, --no-name (always enabled)\n" : `Default compression level: ${options.level}.\n`}-h, --help\nNo FILE or FILE '-' uses stdin; file output uses private VFS staging.\n`);
-            return { exitCode: 0 };
-        }
-        let plans;
-        let planningFailed = false;
-        try {
-            if (options.operands.length > 1) {
-                plans = [];
-                for (const name of options.operands) {
-                    try {
-                        plans.push(...await planOperands(context, { ...options, operands: [name] }));
-                    }
-                    catch (error) {
-                        context.signal.throwIfAborted();
-                        if (codeOf(error) === "EROFS")
-                            throw error;
-                        planningFailed = true;
-                        if (options.quiet < 2)
-                            await diagnostic(context, error);
-                    }
-                }
-                if (plans.length > 1)
-                    await verifyOperandDestinations(context, plans);
+    const commands = profiles.flatMap(profile => profile.format === "gzip" ? createGzipCommands(config) : profile.format === "bzip2" ? createBzip2Commands(config) : profile.names.map((name) => {
+        const command = define(name, async (context) => {
+            const options = parseOptions(name, context.args);
+            if (options.help) {
+                await output(context, `Usage: ${name} [OPTION]... [FILE]...\n-c, --stdout, --to-stdout\n-d, --decompress, --uncompress\n-k, --keep\n-f, --force\n-t, --test\n${options.format === "zstd" ? "-1..-9, --best\nHigher levels and --fast[=NUM] are unsupported by the bounded codec.\n" : "-1..-9, --fast, --best\n"}${options.format === "zstd" ? "-q, --quiet (repeat to suppress errors)\n" : ""}${options.format === "gzip" ? "-q, --quiet (suppress warnings)\n-r, --recursive (traverse directories without following symlinks)\n-n, --no-name (always enabled)\n" : `Default compression level: ${options.level}.\n`}-h, --help\nNo FILE or FILE '-' uses stdin; file output uses private VFS staging.\n`);
+                return { exitCode: 0 };
             }
-            else
-                plans = await planOperands(context, options);
-        }
-        catch (error) {
-            context.signal.throwIfAborted();
-            if (options.quiet < 2)
-                throw error;
-            return { exitCode: 1 };
-        }
-        const decodedBudget = new DecodedBudget(maxDecodedBytes);
-        let exitCode = planningFailed ? 1 : 0;
-        for (const plan of plans) {
+            let plans;
+            let planningFailed = false;
             try {
-                const warned = await runOperand(context, plan, options, decodedBudget);
-                if (warned) {
-                    if (!options.quiet)
-                        await diagnostic(context, new PublicDiagnostic(`${plan.source}: decompression OK, trailing garbage ignored`));
-                    if (exitCode === 0)
-                        exitCode = 2;
+                if (options.operands.length > 1) {
+                    plans = [];
+                    for (const name of options.operands) {
+                        try {
+                            plans.push(...await planOperands(context, { ...options, operands: [name] }));
+                        }
+                        catch (error) {
+                            context.signal.throwIfAborted();
+                            if (codeOf(error) === "EROFS")
+                                throw error;
+                            planningFailed = true;
+                            if (options.quiet < 2)
+                                await diagnostic(context, error);
+                        }
+                    }
+                    if (plans.length > 1)
+                        await verifyOperandDestinations(context, plans);
                 }
+                else
+                    plans = await planOperands(context, options);
             }
             catch (error) {
                 context.signal.throwIfAborted();
                 if (options.quiet < 2)
-                    await diagnostic(context, error);
-                exitCode = 1;
-                if (decodedBudget.exceeded)
-                    break;
+                    throw error;
+                return { exitCode: 1 };
             }
-        }
-        return { exitCode };
-    }))));
+            const decodedBudget = new DecodedBudget(maxDecodedBytes);
+            let exitCode = planningFailed ? 1 : 0;
+            for (const plan of plans) {
+                try {
+                    const warned = await runOperand(context, plan, options, decodedBudget);
+                    if (warned) {
+                        if (!options.quiet)
+                            await diagnostic(context, new PublicDiagnostic(`${plan.source}: decompression OK, trailing garbage ignored`));
+                        if (exitCode === 0)
+                            exitCode = 2;
+                    }
+                }
+                catch (error) {
+                    context.signal.throwIfAborted();
+                    if (options.quiet < 2)
+                        await diagnostic(context, error);
+                    exitCode = 1;
+                    if (decodedBudget.exceeded)
+                        break;
+                }
+            }
+            return { exitCode };
+        });
+        return { ...command, execute: withInputByteBudget(async (context) => command.execute(context)) };
+    }));
     const xzCmds = createXzCommands(config);
     if (maxDecodedBytes === undefined || maxDecodedBytes === Infinity) {
         for (const c of [...commands, ...xzCmds])

package/dist/safe-bash/commands/chmod/index.browser.js

@@ -0,0 +1,14 @@
+import {
+  init_platform
+} from "../../chunks/chunk-B7TAL7S5.js";
+
+// packages/safe-bash/src/commands/chmod/index.ts
+init_platform();
+import { chmodCommands, createChmodCommand, createChmodCommands, evalSyncChmod, modeChange } from "../../../safe-bash-command-chmod/index.js";
+export {
+  chmodCommands,
+  createChmodCommand,
+  createChmodCommands,
+  evalSyncChmod,
+  modeChange
+};

package/dist/safe-bash/commands/chmod/index.d.ts

@@ -0,0 +1,2 @@
+export * from "../../../safe-bash-command-chmod/index.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/safe-bash/commands/chmod/index.js

@@ -0,0 +1,2 @@
+export * from "../../../safe-bash-command-chmod/index.js";
+//# sourceMappingURL=index.js.map

package/dist/safe-bash/commands/column/index.browser.js

@@ -0,0 +1,12 @@
+import {
+  columnCommands,
+  createColumnCommand,
+  createColumnCommands
+} from "../../chunks/chunk-3HQU4OJO.js";
+import "../../chunks/chunk-IWDICZVK.js";
+import "../../chunks/chunk-B7TAL7S5.js";
+export {
+  columnCommands,
+  createColumnCommand,
+  createColumnCommands
+};

package/dist/safe-bash/commands/du/index.browser.js

@@ -0,0 +1,14 @@
+import {
+  createDuCommand,
+  createDuCommands,
+  duCommands,
+  evalSyncDu
+} from "../../chunks/chunk-GEG3BWGE.js";
+import "../../chunks/chunk-IWDICZVK.js";
+import "../../chunks/chunk-B7TAL7S5.js";
+export {
+  createDuCommand,
+  createDuCommands,
+  duCommands,
+  evalSyncDu
+};

package/dist/safe-bash/commands/expr/index.browser.js

@@ -0,0 +1,12 @@
+import {
+  createExprCommand,
+  createExprCommands,
+  exprCommands
+} from "../../chunks/chunk-HZ7BWKQ3.js";
+import "../../chunks/chunk-IWDICZVK.js";
+import "../../chunks/chunk-B7TAL7S5.js";
+export {
+  createExprCommand,
+  createExprCommands,
+  exprCommands
+};

package/dist/safe-bash/commands/file/index.browser.js

@@ -0,0 +1,14 @@
+import {
+  createFileCommand,
+  createFileCommands,
+  evalSyncFile,
+  fileCommands
+} from "../../chunks/chunk-4BSJLKNM.js";
+import "../../chunks/chunk-IWDICZVK.js";
+import "../../chunks/chunk-B7TAL7S5.js";
+export {
+  createFileCommand,
+  createFileCommands,
+  evalSyncFile,
+  fileCommands
+};

package/dist/safe-bash/commands/filesystem.js

@@ -577,10 +577,17 @@ export function filesystemCommands(maxDirectoryEntries, maxRecursiveDirectoryDep
                         if (admitted) {
                             const effectiveMode = backingMem.capabilities.permissions !== false ? 0o777 & ~umask : undefined;
                             let allCreated = true;
+                            ended = false;
                             for (let i = 0; i < rawArgs.length; i++) {
                                 const a = rawArgs[i];
-                                if (a === "--" || a === "-p" || a === "--parents")
-                                    continue;
+                                if (!ended) {
+                                    if (a === "--") {
+                                        ended = true;
+                                        continue;
+                                    }
+                                    if (a === "-p" || a === "--parents")
+                                        continue;
+                                }
                                 if (!backingMem.tryMkdirFastSync(pathOf(context, a), recursive, effectiveMode)) {
                                     allCreated = false;
                                     break;

package/dist/safe-bash/commands/grep-aliases/index.browser.js

@@ -0,0 +1,14 @@
+import {
+  createEgrepCommand,
+  createFgrepCommand,
+  createGrepAliasCommands,
+  grepAliasCommands
+} from "../../chunks/chunk-RRR7AQ24.js";
+import "../../chunks/chunk-E7OYNDGL.js";
+import "../../chunks/chunk-B7TAL7S5.js";
+export {
+  createGrepAliasCommands,
+  createEgrepCommand as egrepCommand,
+  createFgrepCommand as fgrepCommand,
+  grepAliasCommands
+};

package/dist/safe-bash/commands/html-to-markdown/index.browser.js

@@ -0,0 +1,16 @@
+import {
+  createHtmlToMarkdownCommand,
+  createHtmlToMarkdownCommands,
+  evalSyncHtmlToMarkdown,
+  evalSyncShuf,
+  htmlToMarkdownCommands
+} from "../../chunks/chunk-DQP3VHSB.js";
+import "../../chunks/chunk-IWDICZVK.js";
+import "../../chunks/chunk-B7TAL7S5.js";
+export {
+  createHtmlToMarkdownCommand,
+  createHtmlToMarkdownCommands,
+  evalSyncHtmlToMarkdown,
+  evalSyncShuf,
+  htmlToMarkdownCommands
+};

package/dist/safe-bash/commands/metadata/chmod.d.ts

@@ -1,8 +1,2 @@
-export { modeChange } from "../../../safe-bash-io-engine/commands/mode-change.js";
-import { type MetadataCommandsOptions } from "./internal.js";
-export declare function createChmodCommand(configuration?: MetadataCommandsOptions): import("../../../safe-bash-contracts/command.js").CommandDefinition;
-export declare function evalSyncChmod(opArgs: readonly string[], umask: number, chmodNodeSync?: (filePath: string, change: (stat: {
-    type: "file" | "directory" | "symlink";
-    mode: number;
-}) => number) => boolean): string | undefined;
+export * from "../../../safe-bash-command-chmod/command.js";
 //# sourceMappingURL=chmod.d.ts.map