@poe-platform/safe-bash 0.1.744 → 0.1.746

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

@@ -1,4 +1,5 @@
-import { getCommandArguments, writeBytes } from "../../contracts/index.js";
+import { FsError, getCommandArguments, writeBytes } from "../../contracts/index.js";
+import { shellValueByteLength } from "../../contracts/value.js";
 import { parseDuration } from "./duration.js";
 import { parseSignal } from "./signal.js";
 import { createDeadline, defaultSchedulerBinding } from "./scheduler.js";
@@ -25,6 +26,14 @@ function optionsObject(value) {
 }
 function settings(value, includeReplace) {
     const options = optionsObject(value);
+    const configuredLimits = optionsObject(options?.limits);
+    const limits = {
+        maxArguments: Infinity, maxArgumentBytes: Infinity, maxOutputBytes: Infinity, ...configuredLimits,
+    };
+    for (const [name, limit] of Object.entries(limits)) {
+        if (limit !== Infinity && (!Number.isSafeInteger(limit) || limit < 1))
+            throw new RangeError(`Invalid timeout limit: ${name}`);
+    }
     const killAfterPolicy = options?.killAfterPolicy;
     if (killAfterPolicy !== undefined && typeof killAfterPolicy !== "function")
         throw new TypeError("Timeout killAfterPolicy must be a function");
@@ -54,8 +63,8 @@ function settings(value, includeReplace) {
     const maximum = options?.maxTimerMilliseconds;
     if (maximum !== undefined && typeof maximum !== "number")
         throw new TypeError("Timeout maxTimerMilliseconds must be a number");
-    if (maximum !== undefined && (!Number.isInteger(maximum) || maximum < 1 || maximum > 2147483647)) {
-        throw new RangeError("Timeout maxTimerMilliseconds must be an integer from 1 through 2147483647");
+    if (maximum !== undefined && maximum !== Infinity && (!Number.isInteger(maximum) || maximum < 1 || maximum > 2147483647)) {
+        throw new RangeError("Timeout maxTimerMilliseconds must be an integer from 1 through 2147483647 or Infinity");
     }
     let replace = false;
     if (includeReplace) {
@@ -64,9 +73,11 @@ function settings(value, includeReplace) {
             throw new TypeError("Timeout replace must be a boolean");
         replace = configured ?? false;
     }
-    return { invoke, killAfterPolicy: killAfterPolicy, scheduler: binding, maxTimerMilliseconds: maximum ?? 2147483647, replace };
+    return { limits, invoke, killAfterPolicy: killAfterPolicy, scheduler: binding, maxTimerMilliseconds: maximum ?? 2147483647, replace };
 }
-async function status(context, bytes, exitCode, stdout = false) {
+async function status(configuration, context, bytes, exitCode, stdout = false) {
+    if (bytes.length > configuration.limits.maxOutputBytes)
+        throw new FsError("EFBIG", { message: "timeout output limit exceeded" });
     await writeBytes(stdout ? context.stdout : context.stderr, bytes, context.signal);
     return { exitCode };
 }
@@ -82,7 +93,18 @@ function definition(configuration) {
         name: "timeout",
         description: "Run a virtual command with a cooperative time limit",
         async execute(context) {
+            context.signal.throwIfAborted();
             const originalArgs = context.args;
+            if (originalArgs.length > configuration.limits.maxArguments)
+                throw new FsError("EFBIG", { message: "timeout argument count limit exceeded" });
+            const suppliedValues = "argumentValues" in context ? context.argumentValues : undefined;
+            const ownedArguments = suppliedValues === undefined ? undefined : getCommandArguments(context);
+            let argumentBytes = 0;
+            for (const argument of ownedArguments?.values ?? originalArgs) {
+                argumentBytes += shellValueByteLength(argument);
+                if (argumentBytes > configuration.limits.maxArgumentBytes)
+                    throw new FsError("EFBIG", { message: "timeout argument limit exceeded" });
+            }
             let offset = 0;
             let preserveStatus = false;
             let verbose = false;
@@ -96,9 +118,9 @@ function definition(configuration) {
                     break;
                 }
                 if (token === "--help")
-                    return status(context, records.help, 0, true);
+                    return status(configuration, context, records.help, 0, true);
                 if (token === "--version")
-                    return status(context, records.version, 0, true);
+                    return status(configuration, context, records.version, 0, true);
                 if (token === "-" || !token.startsWith("-"))
                     break;
                 if (token === "--verbose") {
@@ -119,12 +141,12 @@ function definition(configuration) {
                 if (token === "--kill-after" || token.startsWith("--kill-after=")) {
                     const duration = token === "--kill-after" ? originalArgs[++offset] : token.slice(13);
                     if (duration === undefined)
-                        return status(context, records.missingDuration, 125);
+                        return status(configuration, context, records.missingDuration, 125);
                     const killAfter = parseDuration(duration);
                     if (killAfter.kind === "invalid")
-                        return status(context, records.invalidDuration, 125);
+                        return status(configuration, context, records.invalidDuration, 125);
                     if (killAfter.kind === "overflow")
-                        return status(context, records.durationOverflow, 125);
+                        return status(configuration, context, records.durationOverflow, 125);
                     killAfterMilliseconds = killAfter.milliseconds;
                     offset++;
                     continue;
@@ -132,10 +154,10 @@ function definition(configuration) {
                 if (token === "--signal" || token.startsWith("--signal=")) {
                     const signalToken = token === "--signal" ? originalArgs[++offset] : token.slice(9);
                     if (signalToken === undefined)
-                        return status(context, records.invalidSignal, 125);
+                        return status(configuration, context, records.invalidSignal, 125);
                     const parsedSignal = parseSignal(signalToken);
                     if (parsedSignal === undefined)
-                        return status(context, records.invalidSignal, 125);
+                        return status(configuration, context, records.invalidSignal, 125);
                     signalNumber = parsedSignal;
                     offset++;
                     continue;
@@ -162,46 +184,44 @@ function definition(configuration) {
                         if (flag === "k") {
                             const duration = token.slice(position + 1) || originalArgs[++offset];
                             if (duration === undefined)
-                                return status(context, records.missingDuration, 125);
+                                return status(configuration, context, records.missingDuration, 125);
                             const killAfter = parseDuration(duration);
                             if (killAfter.kind === "invalid")
-                                return status(context, records.invalidDuration, 125);
+                                return status(configuration, context, records.invalidDuration, 125);
                             if (killAfter.kind === "overflow")
-                                return status(context, records.durationOverflow, 125);
+                                return status(configuration, context, records.durationOverflow, 125);
                             killAfterMilliseconds = killAfter.milliseconds;
                             break;
                         }
                         if (flag === "s") {
                             const signalToken = token.slice(position + 1) || originalArgs[++offset];
                             if (signalToken === undefined)
-                                return status(context, records.invalidSignal, 125);
+                                return status(configuration, context, records.invalidSignal, 125);
                             const parsedSignal = parseSignal(signalToken);
                             if (parsedSignal === undefined)
-                                return status(context, records.invalidSignal, 125);
+                                return status(configuration, context, records.invalidSignal, 125);
                             signalNumber = parsedSignal;
                             break;
                         }
-                        return status(context, records.invalidOption, 125);
+                        return status(configuration, context, records.invalidOption, 125);
                     }
                     offset++;
                     continue;
                 }
-                return status(context, records.invalidOption, 125);
+                return status(configuration, context, records.invalidOption, 125);
             }
             const durationToken = originalArgs[offset];
             if (durationToken === undefined)
-                return status(context, records.missingDuration, 125);
+                return status(configuration, context, records.missingDuration, 125);
             const parsed = parseDuration(durationToken);
             if (parsed.kind === "invalid")
-                return status(context, records.invalidDuration, 125);
+                return status(configuration, context, records.invalidDuration, 125);
             if (parsed.kind === "overflow")
-                return status(context, records.durationOverflow, 125);
+                return status(configuration, context, records.durationOverflow, 125);
             const command = originalArgs[offset + 1];
             if (command === undefined)
-                return status(context, records.missingCommand, 125);
-            const suppliedValues = "argumentValues" in context ? context.argumentValues : undefined;
-            const argumentValues = suppliedValues === undefined ? undefined
-                : getCommandArguments({ args: originalArgs, argumentValues: suppliedValues }).slice(offset + 2);
+                return status(configuration, context, records.missingCommand, 125);
+            const argumentValues = ownedArguments?.slice(offset + 2);
             const args = argumentValues?.args ?? Object.freeze(originalArgs.slice(offset + 2));
             const streams = {
                 ...(argumentValues === undefined ? {} : { argumentValues }),
@@ -214,7 +234,7 @@ function definition(configuration) {
             if (killAfterMilliseconds !== undefined && killAfterMilliseconds !== 0 && parsed.milliseconds !== 0 && parsed.milliseconds !== Infinity) {
                 context.signal.throwIfAborted();
                 if (typeof killAfterPolicy !== "function")
-                    return status(context, records.escalationUnavailable, 125);
+                    return status(configuration, context, records.escalationUnavailable, 125);
                 let result;
                 try {
                     result = await killAfterPolicy(context, command, args, { signal: context.signal, ...streams }, Object.freeze({
@@ -233,7 +253,7 @@ function definition(configuration) {
             const selected = childInvoker(context, configuration.invoke);
             if (parsed.milliseconds === 0 || parsed.milliseconds === Infinity) {
                 if (selected === undefined)
-                    return status(context, records.invokeUnavailable, 125);
+                    return status(configuration, context, records.invokeUnavailable, 125);
                 context.signal.throwIfAborted();
                 let result;
                 try {
@@ -247,7 +267,7 @@ function definition(configuration) {
                 return result;
             }
             if (selected === undefined)
-                return status(context, records.invokeUnavailable, 125);
+                return status(configuration, context, records.invokeUnavailable, 125);
             context.signal.throwIfAborted();
             const deadline = createDeadline(configuration.scheduler, parsed.milliseconds, configuration.maxTimerMilliseconds, signalNumber !== 0);
             context.registerCleanup?.(deadline.retire);
@@ -267,7 +287,7 @@ function definition(configuration) {
                 context.signal.throwIfAborted();
                 if (retirementFailed)
                     throw retirementFailure;
-                return status(context, records.timerSetupFailed, 125);
+                return status(configuration, context, records.timerSetupFailed, 125);
             }
             let returned = false;
             let result;
@@ -294,12 +314,12 @@ function definition(configuration) {
             if (retirementFailed)
                 throw retirementFailure;
             if (verbose && deadline.expired) {
-                await writeBytes(context.stderr, encoder.encode(`timeout: cooperative deadline expired for command ‘${command}’\n`), context.signal);
+                await status(configuration, context, encoder.encode(`timeout: cooperative deadline expired for command ‘${command}’\n`), 0);
             }
             if (!returned && invocationFailure === deadline.deadlineReason)
                 return { exitCode: signalNumber === 9 || preserveStatus ? 128 + signalNumber : 124 };
             if (deadline.signal.aborted && deadline.signal.reason === deadline.timerFailureReason)
-                return status(context, records.timerSetupFailed, 125);
+                return status(configuration, context, records.timerSetupFailed, 125);
             if (deadline.expired && (!preserveStatus || signalNumber === 9))
                 return { exitCode: signalNumber === 9 ? 137 : 124 };
             return result;

package/dist/safe-bash/commands/timeout/scheduler.js

@@ -1,8 +1,8 @@
 export const defaultSchedulerBinding = Object.freeze({
     receiver: globalThis,
-    now: globalThis.performance.now.bind(globalThis.performance),
-    setTimeout: globalThis.setTimeout.bind(globalThis),
-    clearTimeout: globalThis.clearTimeout.bind(globalThis),
+    now: () => globalThis.performance.now(),
+    setTimeout: (callback, milliseconds) => globalThis.setTimeout(callback, milliseconds),
+    clearTimeout: (handle) => globalThis.clearTimeout(handle),
 });
 function clock(binding, previous) {
     const sample = Reflect.apply(binding.now, binding.receiver, []);
@@ -20,6 +20,7 @@ export function createDeadline(binding, duration, maximumChunk, cancel = true) {
     let expired = false;
     let remaining = duration;
     let previous = 0;
+    let step = 0;
     let handle;
     let handleLive = false;
     let cleanupFailed = false;
@@ -50,8 +51,8 @@ export function createDeadline(binding, duration, maximumChunk, cancel = true) {
         controller.abort(timerFailureReason);
     };
     const arm = () => {
-        const milliseconds = Math.min(maximumChunk, Math.max(1, Math.ceil(remaining)));
-        handle = Reflect.apply(binding.setTimeout, binding.receiver, [wake, milliseconds]);
+        step = Math.min(2147483647, maximumChunk, Math.max(1, Math.ceil(remaining)));
+        handle = Reflect.apply(binding.setTimeout, binding.receiver, [wake, step]);
         handleLive = true;
     };
     const wake = () => {
@@ -65,7 +66,7 @@ export function createDeadline(binding, duration, maximumChunk, cancel = true) {
             failTimer();
             return;
         }
-        remaining -= sample - previous;
+        remaining -= Math.max(step, sample - previous);
         previous = sample;
         if (remaining <= 0) {
             admissionOpen = false;