@poe-platform/safe-bash 0.1.799 → 0.1.801

package/dist/safe-bash-command-qpdf/index.js

@@ -4,6 +4,7 @@ import {
 
 // packages/safe-bash-command-qpdf/src/index.ts
 init_buffer();
+import { resolvePath } from "../safe-bash-contracts/path.js";
 import { yieldTurn } from "../safe-bash-contracts/yield.js";
 import { writeFileOutput } from "../safe-bash-contracts/filesystem-output-budget.js";
 import {
@@ -2365,7 +2366,6 @@ async function qpdf(context, options = {}) {
     const argumentBytes = argv.reduce((total, arg) => total + new TextEncoder().encode(arg).byteLength + 1, 0);
     if (argumentBytes > limits.maxArgumentBytes) throw new RangeError("Argument byte limit exceeded");
     const vfsFiles = /* @__PURE__ */ new Map();
-    const resolveVfsPath = (p) => p.startsWith("/") ? p : `${context.cwd === "/" ? "" : context.cwd}/${p}`;
     let accountedBytes = 0;
     const chargeBytes = (delta) => {
       if (delta > 0) {
@@ -2380,7 +2380,7 @@ async function qpdf(context, options = {}) {
       const path = token.slice(1);
       let bytes;
       try {
-        bytes = await context.fs.readFile(resolveVfsPath(path), { signal: invocation.signal });
+        bytes = await context.fs.readFile(resolvePath(context.cwd, path), { signal: invocation.signal });
       } catch {
         await writeBytes(context.stderr, new TextEncoder().encode(`qpdf: cannot open ${path}
 `), invocation.signal);
@@ -2391,16 +2391,21 @@ async function qpdf(context, options = {}) {
       argv.splice(i, 1, ...args);
       i += args.length - 1;
     }
-    for (const token of argv) {
+    const parsed = parseQpdfArguments(argv);
+    const inputs = parsed.options ? [
+      parsed.options.inputFile,
+      ...parsed.options.updateFromJsonFiles,
+      ...[
+        ...parsed.options.pageSpecs,
+        ...parsed.options.stampSpecs,
+        ...parsed.options.addAttachmentSpecs,
+        ...parsed.options.copyAttachmentsSpecs
+      ].map((spec) => spec.file)
+    ] : [];
+    for (const candidate of new Set(inputs)) {
       await yieldTurn(invocation.signal);
-      invocation.signal.throwIfAborted();
-      let candidate = token;
-      if (token.startsWith("--overlay=") || token.startsWith("--underlay=") || token.startsWith("--add-attachment=") || token.startsWith("--copy-attachments-from=") || token.startsWith("--update-from-json=")) {
-        candidate = token.slice(token.indexOf("=") + 1);
-      } else if (token.startsWith("-") || token === "--" || token === ".") {
-        continue;
-      }
-      const abs = resolveVfsPath(candidate);
+      if (!candidate || candidate === "-" || candidate === ".") continue;
+      const abs = resolvePath(context.cwd, candidate);
       let bytes;
       try {
         bytes = await context.fs.readFile(abs, { signal: invocation.signal });
@@ -2413,14 +2418,14 @@ async function qpdf(context, options = {}) {
     }
     if (argv.includes("--json-input") || argv.some((t) => t.startsWith("--update-from-json="))) {
       for (const fileBytes of [...vfsFiles.values()]) {
-        let parsed;
+        let parsed2;
         try {
-          parsed = JSON.parse(new TextDecoder().decode(fileBytes));
+          parsed2 = JSON.parse(new TextDecoder().decode(fileBytes));
         } catch {
           continue;
         }
-        if (!parsed || typeof parsed !== "object") continue;
-        const objs = Array.isArray(parsed.qpdf) && typeof parsed.qpdf[1] === "object" ? parsed.qpdf[1] : typeof parsed.objects === "object" && parsed.objects !== null ? parsed.objects : void 0;
+        if (!parsed2 || typeof parsed2 !== "object") continue;
+        const objs = Array.isArray(parsed2.qpdf) && typeof parsed2.qpdf[1] === "object" ? parsed2.qpdf[1] : typeof parsed2.objects === "object" && parsed2.objects !== null ? parsed2.objects : void 0;
         if (!objs) continue;
         for (const entry of Object.values(objs)) {
           if (typeof entry !== "object" || entry === null || !("stream" in entry)) continue;
@@ -2428,7 +2433,7 @@ async function qpdf(context, options = {}) {
           if (!stream || typeof stream.datafile !== "string" || vfsFiles.has(stream.datafile)) continue;
           let bytes;
           try {
-            bytes = await context.fs.readFile(resolveVfsPath(stream.datafile), { signal: invocation.signal });
+            bytes = await context.fs.readFile(resolvePath(context.cwd, stream.datafile), { signal: invocation.signal });
           } catch {
             invocation.signal.throwIfAborted();
             continue;
@@ -2472,8 +2477,16 @@ async function qpdf(context, options = {}) {
           const stdout = invocation.child(context.stdout);
           await writeBytes(stdout.output, fileBytes, invocation.signal);
         } else {
-          const abs = resolveVfsPath(fileKey);
-          await writeFileOutput(context, fileBytes, (data) => context.fs.writeFile(abs, data, { signal: invocation.signal }));
+          const abs = resolvePath(context.cwd, fileKey);
+          try {
+            await writeFileOutput(context, fileBytes, (data) => context.fs.writeFile(abs, data, { signal: invocation.signal }));
+          } catch (error) {
+            invocation.signal.throwIfAborted();
+            if (!(error instanceof Error) || !("code" in error)) throw error;
+            await writeBytes(context.stderr, new TextEncoder().encode(`qpdf: open ${fileKey}: ${error.code === "ENOENT" ? "No such file or directory" : error.code}
+`), invocation.signal);
+            return { exitCode: 2 };
+          }
         }
       }
     }

package/dist/safe-bash-command-rg/index.d.ts

@@ -13,3 +13,4 @@ export interface RgLimits {
 export declare function createRgCommands(options?: SearchOptions): readonly CommandDefinition[];
 export declare function rgCommands(options?: SearchOptions): VirtualShellPlugin;
 export { createRgCommand as rgCommand };
+export * from "./sync.js";

package/dist/safe-bash-command-rg/index.js

@@ -1,6 +1,6 @@
 import {
   createRgCommand
-} from "../safe-bash/command-chunks/chunk-CU5RLO62.js";
+} from "../safe-bash/command-chunks/chunk-GLOZX57Y.js";
 import {
   init_buffer
 } from "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
@@ -9,6 +9,226 @@ import {
 init_buffer();
 import { RegexExecutor } from "../safe-bash-regex-engine/execution/portable.js";
 import { createBoundedRegexProvider } from "../safe-bash-regex-engine/execution/bounded-provider.js";
+
+// packages/safe-bash-command-rg/src/sync.ts
+init_buffer();
+var syncRgDecoder = new TextDecoder("utf-8", { fatal: false });
+function evalSyncRg(stdinBytes, args, readFile, allowNullBytes = false) {
+  let fixed = false;
+  let ignoreCase = false;
+  let smartCase = false;
+  let invert = false;
+  let countOnly = false;
+  let onlyMatching = false;
+  let wordRegexp = false;
+  let lineRegexp = false;
+  let lineNumber;
+  let withFilename;
+  let filesWithMatches = false;
+  let filesWithoutMatch = false;
+  let quiet = false;
+  let nullTerminated = false;
+  let maxCount = Infinity;
+  const patterns = [];
+  let positionalPatternConsumed = false;
+  const paths = [];
+  let endOpts = false;
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (!endOpts && a === "--") {
+      endOpts = true;
+      continue;
+    }
+    if (!endOpts && (a === "-e" || a === "--regexp")) {
+      if (i + 1 >= args.length) return void 0;
+      patterns.push(args[++i]);
+      positionalPatternConsumed = true;
+      continue;
+    }
+    if (!endOpts && a.startsWith("--regexp=")) {
+      patterns.push(a.slice(9));
+      positionalPatternConsumed = true;
+      continue;
+    }
+    if (!endOpts && (a === "-r" || a === "--replace")) {
+      return void 0;
+    }
+    if (!endOpts && a.startsWith("--replace=")) {
+      return void 0;
+    }
+    if (!endOpts && (a === "-m" || a === "--max-count")) {
+      if (i + 1 >= args.length || !/^\d+$/u.test(args[i + 1])) return void 0;
+      maxCount = Number(args[++i]);
+      continue;
+    }
+    if (!endOpts && a.startsWith("--max-count=")) {
+      const v = a.slice(12);
+      if (!/^\d+$/u.test(v)) return void 0;
+      maxCount = Number(v);
+      continue;
+    }
+    if (!endOpts && a.startsWith("--") && a.length > 2) {
+      if (a === "--fixed-strings") fixed = true;
+      else if (a === "--ignore-case") {
+        ignoreCase = true;
+        smartCase = false;
+      } else if (a === "--case-sensitive") {
+        ignoreCase = false;
+        smartCase = false;
+      } else if (a === "--smart-case") {
+        smartCase = true;
+        ignoreCase = false;
+      } else if (a === "--invert-match") invert = true;
+      else if (a === "--count") countOnly = true;
+      else if (a === "--only-matching") onlyMatching = true;
+      else if (a === "--word-regexp") wordRegexp = true;
+      else if (a === "--line-regexp") lineRegexp = true;
+      else if (a === "--line-number") lineNumber = true;
+      else if (a === "--no-line-number") lineNumber = false;
+      else if (a === "--with-filename") withFilename = true;
+      else if (a === "--no-filename") withFilename = false;
+      else if (a === "--files-with-matches") filesWithMatches = true;
+      else if (a === "--files-without-match") filesWithoutMatch = true;
+      else if (a === "--quiet") quiet = true;
+      else if (a === "--null") nullTerminated = true;
+      else return void 0;
+      continue;
+    }
+    if (!endOpts && a.startsWith("-") && a.length > 1) {
+      for (let j = 1; j < a.length; j++) {
+        const ch = a[j];
+        if (ch === "F") fixed = true;
+        else if (ch === "i") {
+          ignoreCase = true;
+          smartCase = false;
+        } else if (ch === "s") {
+          ignoreCase = false;
+          smartCase = false;
+        } else if (ch === "S") {
+          smartCase = true;
+          ignoreCase = false;
+        } else if (ch === "v") invert = true;
+        else if (ch === "c") countOnly = true;
+        else if (ch === "o") onlyMatching = true;
+        else if (ch === "w") wordRegexp = true;
+        else if (ch === "x") lineRegexp = true;
+        else if (ch === "n") lineNumber = true;
+        else if (ch === "N") lineNumber = false;
+        else if (ch === "H") withFilename = true;
+        else if (ch === "I") withFilename = false;
+        else if (ch === "l") filesWithMatches = true;
+        else if (ch === "q") quiet = true;
+        else if (ch === "0") nullTerminated = true;
+        else if (ch === "e") {
+          const rest = a.slice(j + 1);
+          if (rest) patterns.push(rest);
+          else {
+            if (i + 1 >= args.length) return void 0;
+            patterns.push(args[++i]);
+          }
+          positionalPatternConsumed = true;
+          break;
+        } else if (ch === "m") {
+          const rest = a.slice(j + 1);
+          const v = rest || args[++i];
+          if (!v || !/^\d+$/u.test(v)) return void 0;
+          maxCount = Number(v);
+          break;
+        } else if (ch === "r") {
+          return void 0;
+        } else return void 0;
+      }
+      continue;
+    }
+    if (!positionalPatternConsumed) {
+      patterns.push(a);
+      positionalPatternConsumed = true;
+    } else {
+      paths.push(a);
+    }
+  }
+  if (patterns.length === 0) return void 0;
+  if (nullTerminated && (!allowNullBytes || !filesWithMatches && !filesWithoutMatch)) return void 0;
+  if (onlyMatching && (invert || countOnly || filesWithMatches || filesWithoutMatch)) return void 0;
+  const effectiveIgnoreCase = ignoreCase || smartCase && !patterns.some((p) => /[A-Z]/u.test(p));
+  const escapeRegex = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const rawSources = [];
+  for (const pat of patterns) {
+    if (fixed) {
+      rawSources.push(escapeRegex(pat));
+    } else {
+      if (!/^[a-zA-Z0-9_ :;,=.+*?^$\-[\]()|/{}\\]+$/u.test(pat) || /\([^)]*[+*][^)]*\)[+*?]/u.test(pat)) return void 0;
+      rawSources.push(pat);
+    }
+  }
+  const combinedSource = rawSources.length === 1 ? rawSources[0] : rawSources.map((s) => `(?:${s})`).join("|");
+  const wrappedSource = lineRegexp ? `^(?:${combinedSource})$` : wordRegexp ? `(?<![a-zA-Z0-9_])(?:${combinedSource})(?![a-zA-Z0-9_])` : combinedSource;
+  let reTest;
+  let reGlobal;
+  try {
+    reTest = new RegExp(wrappedSource, effectiveIgnoreCase ? "i" : "");
+    reGlobal = new RegExp(wrappedSource, effectiveIgnoreCase ? "gi" : "g");
+  } catch {
+    return void 0;
+  }
+  const targets = paths.length > 0 ? paths : ["-"];
+  const showFile = withFilename ?? targets.length > 1;
+  const showLine = lineNumber ?? false;
+  const outLines = [];
+  let anyMatched = false;
+  for (const t of targets) {
+    const b = t === "-" ? stdinBytes : readFile ? readFile(t) : void 0;
+    if (!b || b.byteLength > 65536 || b.includes(0)) return void 0;
+    const text = syncRgDecoder.decode(b);
+    const rawLines = text.length === 0 ? [] : text.endsWith("\n") ? text.slice(0, -1).split("\n") : text.split("\n");
+    let count = 0;
+    for (let idx = 0; idx < rawLines.length; idx++) {
+      const line = rawLines[idx];
+      const ok = reTest.test(line);
+      if (invert ? !ok : ok) {
+        count++;
+        if (filesWithoutMatch) {
+          break;
+        }
+        anyMatched = true;
+        if (filesWithMatches) {
+          outLines.push(t);
+          break;
+        }
+        if (!countOnly) {
+          let prefix = "";
+          if (showFile) prefix += `${t}:`;
+          if (showLine) prefix += `${idx + 1}:`;
+          if (onlyMatching) {
+            reGlobal.lastIndex = 0;
+            let m;
+            while ((m = reGlobal.exec(line)) !== null) {
+              outLines.push(prefix + m[0]);
+              if (m[0].length === 0) reGlobal.lastIndex++;
+            }
+          } else {
+            outLines.push(prefix + line);
+          }
+        }
+        if (count >= maxCount) break;
+      }
+    }
+    if (filesWithoutMatch) {
+      if (count === 0) {
+        anyMatched = true;
+        outLines.push(t);
+      }
+    } else if (countOnly && count > 0) {
+      outLines.push(showFile ? `${t}:${count}` : String(count));
+    }
+  }
+  if (!anyMatched) return void 0;
+  if (quiet) return "";
+  const sep = nullTerminated ? "\0" : "\n";
+  return outLines.length === 0 ? "" : `${outLines.join(sep)}${sep}`;
+}
+
+// packages/safe-bash-command-rg/src/index.ts
 function createRgCommand2(options = {}) {
   const provider = options.regexExecutor === void 0 ? createBoundedRegexProvider() : options.regexExecutor;
   return createRgCommand(new RegexExecutor(provider, options.regex), options);
@@ -28,6 +248,7 @@ function rgCommands(options = {}) {
 export {
   createRgCommand2 as createRgCommand,
   createRgCommands,
+  evalSyncRg,
   createRgCommand2 as rgCommand,
   rgCommands
 };

package/dist/safe-bash-command-rg/rg-command.js

@@ -2,7 +2,7 @@ import {
   clearRgFastRunnerPool,
   createRgCommand,
   preverifyMemoryRgTree
-} from "../safe-bash/command-chunks/chunk-CU5RLO62.js";
+} from "../safe-bash/command-chunks/chunk-GLOZX57Y.js";
 import "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
 export {
   clearRgFastRunnerPool,

package/dist/safe-bash-command-rg/sync.d.ts

@@ -0,0 +1 @@
+export declare function evalSyncRg(stdinBytes: Uint8Array | undefined, args: readonly string[], readFile?: (path: string) => Uint8Array | undefined, allowNullBytes?: boolean): string | undefined;

package/dist/safe-bash-command-sed/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Poe Platform
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/safe-bash-command-sed/index.d.ts

@@ -0,0 +1,7 @@
+import type { CommandDefinition, VirtualShellPlugin } from "../safe-bash-contracts/index.js";
+import type { TextProgramOptions } from "../safe-bash-io-engine/commands/text-programs/shared.js";
+export type { TextProgramOptions as SedCommandsOptions, TextProgramOptions } from "../safe-bash-io-engine/commands/text-programs/shared.js";
+export { sedCommand as createSedCommand, sedCommand } from "./sed.js";
+export type SedLimits = Omit<TextProgramOptions, "replace" | "regexExecutor" | "regex">;
+export declare function createSedCommands(options?: TextProgramOptions): readonly CommandDefinition[];
+export declare function sedCommands(options?: TextProgramOptions): VirtualShellPlugin;

package/dist/safe-bash-command-sed/index.js

@@ -0,0 +1,28 @@
+import {
+  sedCommand
+} from "../safe-bash/command-chunks/chunk-7U7EXOXX.js";
+import "../safe-bash/command-chunks/chunk-CQ5YGOGB.js";
+import {
+  init_buffer
+} from "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-sed/src/index.ts
+init_buffer();
+function createSedCommands(options = {}) {
+  return [sedCommand(options)];
+}
+function sedCommands(options = {}) {
+  const commands = createSedCommands(options);
+  return { name: "sed-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 {
+  sedCommand as createSedCommand,
+  createSedCommands,
+  sedCommand,
+  sedCommands
+};

package/dist/safe-bash-command-sed/inplace.d.ts

@@ -0,0 +1,16 @@
+import { type ByteSource, type CommandContext, type FileStagingEntry, type FileStat, type FileSystem } from "../safe-bash-contracts/index.js";
+import { Budget } from "../safe-bash-io-engine/commands/text-programs/shared.js";
+interface Target {
+    readonly path: string;
+    readonly parent: FileStat;
+    readonly original: FileStat;
+    readonly backup: FileStat | null;
+    readonly backupAncestors: readonly FileStagingEntry[];
+    readonly fs: FileSystem;
+}
+export declare function prepareInPlace(context: CommandContext, files: readonly string[], suffix: string): Promise<Target[]>;
+export declare function editInPlace<Result>(context: CommandContext, target: Target, suffix: string, budget: Budget, run: (input: ByteSource) => Promise<{
+    readonly data: Uint8Array;
+    readonly result: Result;
+}>): Promise<Result>;
+export {};

package/dist/safe-bash-command-sed/inplace.js

@@ -0,0 +1,9 @@
+import {
+  editInPlace,
+  prepareInPlace
+} from "../safe-bash/command-chunks/chunk-CQ5YGOGB.js";
+import "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
+export {
+  editInPlace,
+  prepareInPlace
+};

package/dist/safe-bash-command-sed/sed.d.ts

@@ -0,0 +1,3 @@
+import { type CommandDefinition } from "../safe-bash-contracts/index.js";
+import { type TextProgramOptions } from "../safe-bash-io-engine/commands/text-programs/shared.js";
+export declare function sedCommand(options?: TextProgramOptions): CommandDefinition;

package/dist/safe-bash-command-sed/sed.js

@@ -0,0 +1,8 @@
+import {
+  sedCommand
+} from "../safe-bash/command-chunks/chunk-7U7EXOXX.js";
+import "../safe-bash/command-chunks/chunk-CQ5YGOGB.js";
+import "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
+export {
+  sedCommand
+};

package/dist/safe-bash-command-shuf/options.d.ts

@@ -1,5 +1,6 @@
 export interface ShufCommandsOptions {
     readonly replace?: boolean;
+    readonly limits?: Partial<ShufLimits>;
     readonly maxInputBytes?: number;
     readonly maxSampleSize?: number;
 }

package/dist/safe-bash-command-shuf/options.js

@@ -1,8 +1,6 @@
 export function settings(options = {}) {
-    const limits = { maxInputBytes: options.maxInputBytes ?? Infinity, maxSampleSize: options.maxSampleSize ?? Infinity };
-    for (const [name, value] of Object.entries(options)) {
-        if (name === "replace")
-            continue;
+    const limits = { maxInputBytes: options.limits?.maxInputBytes ?? options.maxInputBytes ?? Infinity, maxSampleSize: options.limits?.maxSampleSize ?? options.maxSampleSize ?? Infinity };
+    for (const [name, value] of Object.entries(limits)) {
         if (value !== Infinity && (!Number.isSafeInteger(value) || value < 1))
             throw new RangeError(`Invalid shuf ${name}`);
     }

package/dist/safe-bash-command-shuf/shuf.js

@@ -58,6 +58,7 @@ export function createShufCommand(options = {}) {
                     await writeBytes(context.stdout, encoder.encode(parsed.action === "help" ? help : version), context.signal);
                     return { exitCode: 0 };
                 }
+                await yieldTurn(context.signal);
                 const lines = [];
                 let totalBytes = 0;
                 let size = parsed.count === 0n ? 0n : parsed.range?.size ?? 0n;
@@ -249,7 +250,7 @@ export function createShufCommand(options = {}) {
             }
         },
     });
-    if (options.maxInputBytes === undefined && options.maxSampleSize === undefined)
+    if (limits.maxInputBytes === Infinity && limits.maxSampleSize === Infinity)
         builtInDirectContextExecutors.add(command.execute);
     return command;
 }