@poe-platform/safe-bash 0.1.802 → 0.1.804

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

@@ -0,0 +1,328 @@
+import {
+  init_buffer
+} from "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-node/src/index.ts
+init_buffer();
+import { newQuickJSAsyncWASMModule } from "quickjs-emscripten";
+import { collectBytes, resolvePath, dirname, posixPath } from "@poe-platform/safe-fs/core";
+
+// packages/safe-bash-command-node/src/runtime.ts
+init_buffer();
+var bootstrap = String.raw`
+(() => {
+const bridge = globalThis.__host;
+delete globalThis.__host;
+const call = (op, ...args) => {
+  const result = JSON.parse(bridge(op, JSON.stringify(args)));
+  if (result.error) throw Object.assign(new Error(result.error.message), {code: result.error.code});
+  return result.value;
+};
+const encoding = value => {
+  if (value !== undefined && value !== 'utf8' && value !== 'utf-8') throw new Error('Only UTF-8 encoding is supported');
+  return value;
+};
+globalThis.Buffer = class Buffer extends Uint8Array {
+  static from(value, enc) { encoding(enc); return new Buffer(typeof value === 'string' ? call('encode', value) : value); }
+  static alloc(size) { return new Buffer(size); }
+  static isBuffer(value) { return value instanceof Buffer; }
+  toString(enc = 'utf8') { encoding(enc); return call('decode', Array.from(this)); }
+};
+const fileEncoding = options => {
+  if (options !== null && typeof options === 'object') {
+    for (const key of Object.keys(options)) if (key !== 'encoding') throw new Error('Unsupported fs option: ' + key);
+    options = options.encoding;
+  }
+  return encoding(options);
+};
+const fs = {
+  readFileSync(path, enc) { enc = fileEncoding(enc); const bytes = Buffer.from(call('read', path)); return enc ? bytes.toString(enc) : bytes; },
+  writeFileSync(path, data, enc) { fileEncoding(enc); call('write', path, Array.from(Buffer.from(data))); },
+  existsSync(path) { try { call('stat', path); return true; } catch (e) { if (e.code === 'ENOENT' || e.code === 'ENOTDIR') return false; throw e; } },
+  statSync(path) { const stat = call('stat', path); return {...stat, isFile: () => stat.type === 'file', isDirectory: () => stat.type === 'directory', isSymbolicLink: () => stat.type === 'symlink'}; },
+  mkdirSync(path, options = {}) { call('mkdir', path, options.recursive === true); },
+};
+const childResult = (command, args, options = {}) => {
+  for (const key of Object.keys(options)) if (key !== 'encoding') throw new Error('Unsupported child_process option: ' + key);
+  encoding(options.encoding);
+  const result = call('exec', command, args);
+  const stdout = Buffer.from(result.bytes);
+  if (result.status !== 0) throw Object.assign(new Error('Command failed: ' + command), {status: result.status, stdout});
+  return options.encoding ? stdout.toString(options.encoding) : stdout;
+};
+const child = {
+  execSync(command, options) { return childResult('sh', ['-c', command], options); },
+  execFileSync(command, args = [], options) { return childResult(command, args, options); },
+};
+function __setup(config) {
+  globalThis.process = {argv: config.argv, env: config.env, cwd: () => config.cwd, exitCode: 0,
+    stdout: {write: value => {call('output', String(value), false); return true;}},
+    stderr: {write: value => {call('output', String(value), true); return true;}},
+  };
+  globalThis.console = {
+    log: (...values) => call('output', values.map(String).join(' ') + '\n', false),
+    error: (...values) => call('output', values.map(String).join(' ') + '\n', true),
+  };
+  const path = {sep:'/', delimiter:':',
+    resolve: (...parts) => parts.reduce((base, part) => call('resolve', base, part), config.cwd),
+    dirname: value => call('dirname', value),
+    join: (...parts) => call('path', 'join', ...parts),
+    basename: value => call('path', 'basename', value),
+    extname: value => call('path', 'extname', value),
+  };
+  path.posix = path;
+  const cache = new Map();
+  const load = base => name => {
+    if (typeof name !== 'string') throw new TypeError('Module name must be a string');
+    const builtin = name.startsWith('node:') ? name.slice(5) : name;
+    if (builtin === 'fs') return fs;
+    if (builtin === 'child_process') return child;
+    if (builtin === 'path') return path;
+    if (!(name.startsWith('./') || name.startsWith('../') || name.startsWith('/'))) throw new Error('Unsupported module: ' + name);
+    const filename = call('resolve', base, name);
+    if (cache.has(filename)) return cache.get(filename).exports;
+    const source = call('source', filename);
+    const module = {exports:{}};
+    cache.set(filename, module);
+    try {
+      if (filename.endsWith('.json')) module.exports = JSON.parse(source);
+      else new Function('exports', 'require', 'module', '__filename', '__dirname', source)(module.exports, load(path.dirname(filename)), module, filename, path.dirname(filename));
+      return module.exports;
+    } catch (e) { cache.delete(filename); throw e; }
+  };
+  globalThis.__filename = config.filename;
+  globalThis.__dirname = config.filename.startsWith('/') ? path.dirname(config.filename) : config.cwd;
+  globalThis.require = load(__dirname);
+  globalThis.module = {exports:{}};
+  globalThis.exports = module.exports;
+}
+return __setup;
+})()
+`;
+
+// packages/safe-bash-command-node/src/index.ts
+var defaults = { memoryBytes: 32 * 1024 * 1024, sourceBytes: 1024 * 1024, outputBytes: 1024 * 1024, fileBytes: 4 * 1024 * 1024, operations: 1e3, timeoutMs: 5e3 };
+var encoder = new TextEncoder();
+var decoder = new TextDecoder();
+function createNodeCommand(options = {}) {
+  const limits = { ...defaults, ...options.limits };
+  for (const [key, value] of Object.entries(limits)) {
+    if (!Object.hasOwn(defaults, key) || !Number.isSafeInteger(value) || value <= 0) throw new TypeError(`Invalid node limit: ${key}`);
+  }
+  return { name: "node", description: "Execute JavaScript in QuickJS with safe-fs and safe-bash", async execute(context) {
+    const controller = new AbortController();
+    const signal = AbortSignal.any([context.signal, controller.signal]);
+    const timeout = setTimeout(() => controller.abort(new Error("Node execution deadline exceeded")), limits.timeoutMs);
+    const deadline = Date.now() + limits.timeoutMs;
+    let closeRequested = false;
+    let completed;
+    const completion = new Promise((resolve) => {
+      completed = resolve;
+    });
+    context.registerCleanup?.(async () => {
+      closeRequested = true;
+      controller.abort();
+      await completion;
+    });
+    let vm;
+    let outputBytes = 0;
+    let sourceBytes = 0;
+    let operations = 0;
+    let limitFailure;
+    const check = () => {
+      signal.throwIfAborted();
+      if (closeRequested || Date.now() > deadline) throw new Error("Node execution deadline exceeded");
+      if (limitFailure) throw limitFailure;
+    };
+    const bound = (size, max, name) => {
+      if (size > max) {
+        limitFailure = new Error(`Node ${name} limit exceeded`);
+        throw limitFailure;
+      }
+    };
+    const path = (value) => {
+      if (typeof value !== "string" || value.includes("\0")) throw new TypeError("Expected a virtual path");
+      return resolvePath(context.cwd, value);
+    };
+    const fs = context.fs;
+    const read = async (name, source = false) => {
+      check();
+      const bytes = await fs.readFile(path(name), { signal, maxBytes: source ? limits.sourceBytes - sourceBytes : limits.fileBytes });
+      bound(bytes.length, source ? limits.sourceBytes - sourceBytes : limits.fileBytes, source ? "source" : "file");
+      if (source) sourceBytes += bytes.length;
+      return bytes;
+    };
+    const emit = async (value, stderr) => {
+      const bytes = typeof value === "string" ? encoder.encode(value) : value;
+      outputBytes += bytes.length;
+      bound(outputBytes, limits.outputBytes, "output");
+      await (stderr ? context.stderr : context.stdout).write(bytes);
+      check();
+    };
+    try {
+      const args = [...context.args];
+      let source;
+      let filename = "[stdin]";
+      let print = false;
+      const flag = args[0];
+      if (flag === "-e" || flag === "--eval" || flag === "-p" || flag === "--print") {
+        args.shift();
+        if (args.length === 0) throw new Error(`${flag} requires source`);
+        source = args.shift();
+        print = flag === "-p" || flag === "--print";
+        filename = "[eval]";
+      } else {
+        if (flag === "--") args.shift();
+        if (args[0]?.startsWith("-") && args[0] !== "-") throw new Error(`Unsupported node option: ${args[0]}`);
+        const file = args.shift();
+        if (file && file !== "-") {
+          filename = path(file);
+          source = decoder.decode(await read(filename, true));
+        } else source = decoder.decode(await collectBytes(context.stdin, { signal, maxBytes: limits.sourceBytes }));
+      }
+      if (filename[0] === "[") sourceBytes = encoder.encode(source).length;
+      bound(sourceBytes, limits.sourceBytes, "source");
+      if (source.startsWith("#!")) {
+        const end = source.indexOf("\n");
+        source = end < 0 ? "" : source.slice(end);
+      }
+      check();
+      const engine = await newQuickJSAsyncWASMModule();
+      const contextVm = engine.newContext();
+      vm = contextVm;
+      vm.runtime.setMemoryLimit(limits.memoryBytes);
+      vm.runtime.setMaxStackSize(512 * 1024);
+      vm.runtime.setInterruptHandler(() => signal.aborted || closeRequested || Date.now() > deadline || !!limitFailure);
+      const host = contextVm.newAsyncifiedFunction("__host", async (operation, payload) => {
+        try {
+          check();
+          bound(++operations, limits.operations, "operations");
+          const op = contextVm.getString(operation);
+          const values = JSON.parse(contextVm.getString(payload));
+          let value = null;
+          switch (op) {
+            case "read":
+              value = Array.from(await read(values[0]));
+              break;
+            case "source":
+              value = decoder.decode(await read(values[0], true));
+              break;
+            case "write": {
+              if (!Array.isArray(values[1]) || !values[1].every((n) => Number.isInteger(n) && n >= 0 && n <= 255)) throw new TypeError("Expected bytes");
+              bound(values[1].length, limits.fileBytes, "file");
+              await fs.writeFile(path(values[0]), new Uint8Array(values[1]), { signal });
+              break;
+            }
+            case "stat": {
+              const stat = await fs.stat(path(values[0]), { signal });
+              value = { type: stat.type, size: stat.size };
+              break;
+            }
+            case "mkdir":
+              await fs.mkdir(path(values[0]), { signal, recursive: values[1] === true });
+              break;
+            case "output":
+              await emit(String(values[0]), values[1] === true);
+              break;
+            case "encode":
+              value = Array.from(encoder.encode(String(values[0])));
+              break;
+            case "decode":
+              value = decoder.decode(new Uint8Array(values[0]));
+              break;
+            case "resolve":
+              value = resolvePath(String(values[0]), String(values[1]));
+              break;
+            case "dirname":
+              value = dirname(String(values[0]));
+              break;
+            case "path": {
+              const method = values[0];
+              if (method === "join") value = posixPath.join(...values.slice(1));
+              else if (method === "basename") value = posixPath.basename(String(values[1]));
+              else if (method === "extname") value = posixPath.extname(String(values[1]));
+              else throw new Error("Unsupported path operation");
+              break;
+            }
+            case "exec": {
+              if (!context.invoke) throw new Error("safe-bash command dispatch unavailable");
+              if (typeof values[0] !== "string" || !Array.isArray(values[1]) || !values[1].every((v) => typeof v === "string")) throw new TypeError("Expected command and string argv");
+              const chunks = [];
+              let total = 0;
+              const result2 = await context.invoke(values[0], values[1], {
+                signal,
+                stdin: { async *[Symbol.asyncIterator]() {
+                } },
+                stdout: { async write(bytes2) {
+                  total += bytes2.length;
+                  bound(total, limits.outputBytes, "child output");
+                  chunks.push(new Uint8Array(bytes2));
+                } },
+                stderr: { async write(bytes2) {
+                  await emit(bytes2, true);
+                } }
+              });
+              const bytes = new Uint8Array(total);
+              let offset = 0;
+              for (const chunk of chunks) {
+                bytes.set(chunk, offset);
+                offset += chunk.length;
+              }
+              value = { status: result2.exitCode, bytes: Array.from(bytes) };
+              break;
+            }
+            default:
+              throw new Error("Unsupported host operation");
+          }
+          check();
+          return contextVm.newString(JSON.stringify({ value }));
+        } catch (error) {
+          const failure = error;
+          return contextVm.newString(JSON.stringify({ error: { message: failure?.message ?? String(error), code: failure?.code } }));
+        }
+      });
+      vm.setProp(vm.global, "__host", host);
+      host.dispose();
+      const configuration = JSON.stringify({ cwd: context.cwd, env: context.env, argv: ["/virtual/bin/node", ...filename === "[eval]" ? [] : [filename], ...args], filename });
+      const setup = await vm.evalCodeAsync(`${bootstrap}(${configuration});`, "safe-bash-node");
+      vm.unwrapResult(setup).dispose();
+      const result = await vm.evalCodeAsync(print ? `console.log((${source}
+))` : source, filename);
+      vm.unwrapResult(result).dispose();
+      check();
+      if (vm.runtime.hasPendingJob()) throw new Error("Asynchronous jobs are unsupported by this Node profile");
+      const exit = vm.unwrapResult(await vm.evalCodeAsync("process.exitCode", "exitCode"));
+      const exitCode = vm.getNumber(exit);
+      exit.dispose();
+      if (!Number.isInteger(exitCode) || exitCode < 0 || exitCode > 255) throw new Error("Invalid process.exitCode");
+      return { exitCode };
+    } catch (error) {
+      context.signal.throwIfAborted();
+      const message = error instanceof Error ? error.message : JSON.stringify(error);
+      await context.stderr.write(encoder.encode(`node: ${message}
+`).slice(0, limits.outputBytes));
+      return { exitCode: 1 };
+    } finally {
+      clearTimeout(timeout);
+      try {
+        if (vm?.alive) vm.dispose();
+      } finally {
+        completed();
+      }
+    }
+  } };
+}
+function createNodeCommands(options = {}) {
+  return [createNodeCommand(options)];
+}
+function nodeCommands(options = {}) {
+  const command = createNodeCommand(options);
+  return { name: "quickjs-node", setup(host) {
+    host.commands.register(command, { replace: options.replace ?? false });
+  } };
+}
+export {
+  createNodeCommand,
+  createNodeCommands,
+  nodeCommands
+};

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

@@ -2516,6 +2516,7 @@ function numfmtCommand(options = {}) {
             if (item.done) break;
             if (item.value.length > limits.maxSingleChunkBytes || item.value.length > limits.maxInputBytes - received) throw new PublicDiagnostic("byte command input limit exceeded");
             received += item.value.length;
+            context.inputBudget?.check(received);
             if (!item.value.length && ++empty > limits.maxEmptyChunks) throw new PublicDiagnostic("empty input chunk limit exceeded");
             const chunk = new Uint8Array(item.value);
             const sepByte = settings2.separator.charCodeAt(0);

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

@@ -139,10 +139,12 @@ function output(context, text) {
   return writeBytes(context.stdout, bytes, context.signal);
 }
 var ByteInputBudget = class {
-  constructor(maxInputBytes) {
+  constructor(maxInputBytes, inputBudget) {
     this.maxInputBytes = maxInputBytes;
+    this.inputBudget = inputBudget;
   }
   maxInputBytes;
+  inputBudget;
   #bytes = 0;
   #failure;
   assertOpen(signal) {
@@ -158,13 +160,14 @@ var ByteInputBudget = class {
         throw this.#failure;
       }
       this.#bytes += chunk.byteLength;
+      this.inputBudget?.check(this.#bytes);
       yield chunk;
       this.assertOpen(signal);
     }
   }
 };
 async function* sources(context, operands, maxInputBytes, onFileError) {
-  const budget = new ByteInputBudget(maxInputBytes);
+  const budget = new ByteInputBudget(maxInputBytes, context.inputBudget);
   let usedStdin = false;
   let emptyChunks = 0;
   for (const operand of operands.length ? operands : ["-"]) {
@@ -368,7 +371,6 @@ function formats(text) {
       offset++;
     }
     result.push({ kind, size, ...printable ? { printable: true } : {} });
-    if (result.length > 16) throw new UsageError("at most 16 output types are supported");
   }
   if (!result.length) throw new UsageError("empty output type");
   return result;
@@ -510,6 +512,7 @@ function defineOdCommand(handler) {
         return await handler(context);
       } catch (error) {
         context.signal.throwIfAborted();
+        if (error instanceof Error && (error.name === "BudgetExceededError" || error.name === "AbortError")) throw error;
         await writeDiagnostic(
           context.stderr,
           `${context.command}: ${publicDiagnosticMessage(error, context.onInternalError)}
@@ -635,24 +638,28 @@ function createOdCommand(optionsOrMaxBytes) {
       "little"
     );
     const selected = (parsed.values.get("t") ?? ["o2"]).flatMap(formats);
-    const width = validatedOption(
+    const requestedWidth = validatedOption(
       parsed,
       "w",
       (text) => {
         const number = numeric(text);
-        if (number < 1 || selected.some((format) => number % format.size !== 0)) {
-          throw new UsageError("width must be positive and a multiple of each output type size");
-        }
+        if (number < 1) throw new UsageError("width must be positive");
         return number;
       },
       16
     );
+    const alignment = selected.reduce((size, format) => Math.max(size, format.size), 1);
+    const width = requestedWidth % alignment === 0 ? requestedWidth : alignment;
+    if (width !== requestedWidth) {
+      await writeDiagnostic(context.stderr, `${context.command}: warning: invalid width ${requestedWidth}; using ${width} instead
+`, context.signal);
+    }
     const skip = validatedOption(parsed, "j", (text) => numeric(text, true), 0);
     const count = validatedOption(parsed, "N", (text) => numeric(text, true), Infinity);
     if (count === 0 && skip === 0 && parsed.operands[0] && parsed.operands[0] !== "-") {
       await context.fs.stat(pathOf(context, parsed.operands[0]), { signal: context.signal });
     }
-    const charsPerByte = Math.max(...selected.map((format) => (fieldWidth(format) + 1) / format.size));
+    const charsPerByte = selected.reduce((width2, format) => Math.max(width2, (fieldWidth(format) + 1) / format.size), 0);
     const minimumStringLength = validatedOption(
       parsed,
       "S",
@@ -736,6 +743,7 @@ function createOdCommand(optionsOrMaxBytes) {
           offset = addOffset(offset, row.length);
           if (!flushedFirst && outBuf || outBuf.length >= 16384) await flushOut();
         }
+        await flushOut();
       }
     } finally {
       await flushOut();