@poe-platform/safe-bash 0.1.788 → 0.1.790

package/dist/safe-bash-command-pptx/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-pptx/index.d.ts

@@ -0,0 +1,33 @@
+import { type CommandDefinition, type VirtualShellPlugin } from "../safe-bash-contracts/index.js";
+export interface PptxCommandEngine {
+    execute(request: {
+        readonly args: readonly Uint8Array[];
+        readonly signal: AbortSignal;
+        readonly readInput: (path: string, maxBytes: number) => Promise<Uint8Array>;
+        readonly publishOutput?: (publication: {
+            readonly inputPath?: string;
+            readonly protectedInputPaths?: readonly string[];
+            readonly outputPath: string;
+            readonly bytes: Uint8Array;
+            readonly originalBytes: Uint8Array;
+            readonly inPlace: boolean;
+            readonly force: boolean;
+            readonly dryRun: boolean;
+        }) => Promise<void>;
+    }): Promise<{
+        readonly exitCode: number;
+        readonly stdout: Uint8Array;
+        readonly stderr: Uint8Array;
+    }>;
+}
+export interface PptxLimits {
+    readonly maxArgumentBytes: number;
+}
+export interface PptxCommandsOptions {
+    readonly engine: PptxCommandEngine;
+    readonly replace?: boolean;
+    readonly limits?: Partial<PptxLimits>;
+}
+export declare function createPptxCommand(options: PptxCommandsOptions): CommandDefinition;
+export declare function createPptxCommands(options: PptxCommandsOptions): readonly CommandDefinition[];
+export declare function pptxCommands(options: PptxCommandsOptions): VirtualShellPlugin;

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

@@ -0,0 +1,168 @@
+import {
+  init_buffer
+} from "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-pptx/dist/index.js
+init_buffer();
+import { shellValueByteLength } from "../safe-bash-contracts/value.js";
+import { collectBytes, FsError, getCommandArguments, writeBytes } from "../safe-bash-contracts/index.js";
+import { writeFileOutput } from "../safe-bash-contracts/filesystem-output.js";
+import { compareObservedEntries } from "../safe-bash-contracts/filesystem-identity.js";
+import { pathOf } from "../safe-bash-io-engine/internal.js";
+import { inputRequirements } from "../safe-bash-io-engine/portable-requirements.js";
+function createPptxCommand(options) {
+  if (!options?.engine || typeof options.engine.execute !== "function")
+    throw new TypeError("An explicit pptx command engine is required.");
+  if (options.replace !== void 0 && typeof options.replace !== "boolean")
+    throw new TypeError("pptx replace must be boolean");
+  const maxArgumentBytes = options.limits?.maxArgumentBytes ?? Infinity;
+  if (maxArgumentBytes !== Infinity && (!Number.isSafeInteger(maxArgumentBytes) || maxArgumentBytes < 0)) {
+    throw new RangeError("maxArgumentBytes must be a nonnegative safe integer or Infinity");
+  }
+  const engine = options.engine;
+  return { name: "pptx", filesystemRequirements: inputRequirements, async execute(context) {
+    const arguments_ = getCommandArguments(context);
+    let argumentBytes = 0;
+    for (let index = 0; index < arguments_.args.length; index++) {
+      const bytes = shellValueByteLength(arguments_.values[index]);
+      if (bytes > maxArgumentBytes - argumentBytes)
+        throw new FsError("EFBIG", { message: "document argument limit exceeded" });
+      argumentBytes += bytes;
+    }
+    const snapshots = /* @__PURE__ */ new Map();
+    const result = await engine.execute({
+      args: arguments_.args.map((_, index) => arguments_.bytes(index)),
+      signal: context.signal,
+      async readInput(path, maxBytes) {
+        try {
+          context.signal.throwIfAborted();
+          if (path === "-")
+            return await collectBytes(context.stdin, { maxBytes, signal: context.signal });
+          const resolved = pathOf(context, path);
+          if (!snapshots.has(resolved)) {
+            try {
+              snapshots.set(resolved, await context.fs.lstat(resolved, { signal: context.signal }));
+            } catch {
+              context.signal.throwIfAborted();
+            }
+          }
+          const capabilities = await context.fs.capabilitiesFor?.(resolved, { signal: context.signal }) ?? context.fs.capabilities;
+          context.signal.throwIfAborted();
+          if (context.fs.readStream && capabilities.streamingRead !== false) {
+            let emitted = false;
+            try {
+              const stream = context.fs.readStream(resolved, { signal: context.signal });
+              return await collectBytes((async function* () {
+                for await (const chunk of stream) {
+                  if (chunk.byteLength)
+                    emitted = true;
+                  yield chunk;
+                }
+              })(), { maxBytes, signal: context.signal });
+            } catch (error) {
+              context.signal.throwIfAborted();
+              if (emitted || !(error instanceof FsError) || error.code !== "ENOTSUP")
+                throw error;
+            }
+          }
+          if (capabilities.read === false)
+            throw new FsError("ENOTSUP");
+          const bytes = await context.fs.readFile(resolved, { maxBytes, signal: context.signal });
+          context.signal.throwIfAborted();
+          if (bytes.byteLength > maxBytes)
+            throw new FsError("EFBIG");
+          return bytes;
+        } catch (error) {
+          context.signal.throwIfAborted();
+          throw Object.assign(new Error("Input could not be read."), { code: error instanceof FsError && error.code === "EFBIG" ? "resource-limit" : "io-failure" });
+        }
+      },
+      async publishOutput(publication) {
+        try {
+          const { fs, signal } = context;
+          signal.throwIfAborted();
+          const input = publication.inputPath === void 0 || publication.inputPath === "-" ? void 0 : pathOf(context, publication.inputPath);
+          const output = pathOf(context, publication.outputPath);
+          if (publication.inPlace ? !input || input !== output : input === output)
+            throw new FsError("EINVAL");
+          const capabilities = await fs.capabilitiesFor?.(output, { signal }) ?? fs.capabilities;
+          signal.throwIfAborted();
+          if (capabilities.readOnly === true || capabilities.write === false || !capabilities.atomicFileMutation || !fs.writeFileConditional)
+            throw new FsError("ENOTSUP");
+          let destination;
+          try {
+            destination = await fs.lstat(output, { signal });
+          } catch (error) {
+            signal.throwIfAborted();
+            if (!(error instanceof FsError) || error.code !== "ENOENT")
+              throw error;
+            destination = null;
+          }
+          if (destination && destination.type !== "file")
+            throw new FsError("EINVAL");
+          if (destination) {
+            const protectedInputs = new Set((publication.protectedInputPaths ?? []).filter((path) => path !== "-").map((path) => pathOf(context, path)));
+            for (const [source, observed] of snapshots) {
+              if (source === input && !protectedInputs.has(source))
+                continue;
+              const identity = observed.type === "symlink" ? await fs.stat(source, { signal }) : observed;
+              if (source === output || await compareObservedEntries(fs, source, identity, fs, output, destination, { signal }) !== "distinct")
+                throw new FsError("EINVAL");
+            }
+          }
+          if (destination && !publication.inPlace) {
+            if (!publication.force)
+              throw new FsError("EEXIST");
+            if (input && await compareObservedEntries(fs, input, await fs.stat(input, { signal }), fs, output, destination, { signal }) !== "distinct")
+              throw new FsError("EINVAL");
+          }
+          const parentPath = output.slice(0, output.lastIndexOf("/")) || "/";
+          const parent = await fs.stat(parentPath, { signal });
+          if (parent.type !== "directory")
+            throw new FsError("ENOTDIR");
+          if (publication.inPlace) {
+            const original = snapshots.get(input);
+            if (!original || original.type !== "file" || !destination || original.revision === void 0 || original.revision !== destination.revision || original.size !== destination.size || original.mode !== destination.mode || original.nlink !== destination.nlink || original.mtimeMs !== destination.mtimeMs || original.ctimeMs !== destination.ctimeMs || await compareObservedEntries(fs, input, original, fs, output, destination, { signal }) !== "same")
+              throw new FsError("EAGAIN");
+            const current = await fs.readFile(input, { maxBytes: publication.originalBytes.length, signal });
+            if (current.length !== publication.originalBytes.length || current.some((byte, index) => byte !== publication.originalBytes[index]))
+              throw new FsError("EAGAIN");
+            destination = original;
+          }
+          signal.throwIfAborted();
+          if (!publication.dryRun)
+            await writeFileOutput(context, publication.bytes, async (bytes) => {
+              await fs.writeFileConditional(output, bytes, { parent, expected: destination, signal });
+            });
+        } catch (error) {
+          context.signal.throwIfAborted();
+          const code = error instanceof FsError && error.code === "EAGAIN" ? "stale-input" : error instanceof FsError && error.code === "ENOTSUP" ? "publication-unsupported" : "io-failure";
+          throw Object.assign(new Error("Output could not be published."), { code });
+        }
+      }
+    });
+    if (result.stdout.length)
+      await writeBytes(context.stdout, result.stdout, context.signal);
+    if (result.stderr.length)
+      await writeBytes(context.stderr, result.stderr, context.signal);
+    return { exitCode: result.exitCode };
+  } };
+}
+function createPptxCommands(options) {
+  return [createPptxCommand(options)];
+}
+function pptxCommands(options) {
+  const commands = createPptxCommands(options);
+  const replace = options.replace ?? false;
+  return { name: "pptx-commands", setup(host) {
+    if (!replace && host.commands.has("pptx"))
+      throw new Error("Command already registered: pptx");
+    for (const command of commands)
+      host.commands.register(command, { replace });
+  } };
+}
+export {
+  createPptxCommand,
+  createPptxCommands,
+  pptxCommands
+};

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

@@ -1,6 +1,12 @@
 import { type CommandContext, type CommandDefinition } from "../safe-bash-contracts/command.js";
 import type { VirtualShellPlugin } from "../safe-bash-contracts/plugin.js";
+export interface QpdfLimits {
+    readonly maxInputBytes: number;
+    readonly maxOutputBytes: number;
+    readonly maxArgumentBytes: number;
+}
 export interface QpdfCommandOptions {
+    readonly limits?: Partial<QpdfLimits>;
     readonly replace?: boolean;
 }
 export interface QpdfCliResult {
@@ -9,12 +15,12 @@ export interface QpdfCliResult {
     readonly stderr: string;
 }
 export declare function parseQpdfPageRange(rangeSpec: string, totalPages: number): number[];
-export declare function runQpdfCli(argv: readonly string[], files: Map<string, Uint8Array>, readStdin?: () => Promise<void>): Promise<QpdfCliResult>;
+export declare function runQpdfCli(argv: readonly string[], files: Map<string, Uint8Array>, readStdin?: () => Promise<void>, signal?: AbortSignal): Promise<QpdfCliResult>;
 export declare function runQpdfCliSync(argv: readonly string[], files: Map<string, Uint8Array>): QpdfCliResult;
-export declare function qpdf(context: CommandContext): Promise<{
+export declare function qpdf(context: CommandContext, options?: QpdfCommandOptions): Promise<{
     exitCode: number;
 }>;
-export declare function createQpdfCommand(_options?: QpdfCommandOptions): CommandDefinition;
+export declare function createQpdfCommand(options?: QpdfCommandOptions): CommandDefinition;
 export declare const qpdfCommand: CommandDefinition;
 export declare function qpdfCommands(options?: QpdfCommandsOptions): VirtualShellPlugin;
 export type QpdfCommandsOptions = QpdfCommandOptions;