@poe-platform/safe-bash 0.1.745 → 0.1.747

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

@@ -2363,6 +2363,7 @@ async function executeUniqGeneral(context, preReadSource) {
     const onlyRepeated = parsed.flags.has("d");
     const onlyUnique = parsed.flags.has("u");
     const identityKey = skipFields === 0 && skipCharacters === 0 && width === Infinity && !ignoreCase;
+    const uniqDecoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
     const key = (bytes) => {
         if (identityKey)
             return bytes;
@@ -2373,8 +2374,18 @@ async function executeUniqGeneral(context, preReadSource) {
             while (offset < bytes.length && bytes[offset] !== 32 && bytes[offset] !== 9)
                 offset++;
         }
-        offset += skipCharacters;
-        const result = bytes.subarray(offset, width === Infinity ? undefined : offset + width);
+        let result;
+        try {
+            const chars = Array.from(uniqDecoder.decode(bytes.subarray(offset)));
+            result = encoder.encode((width === Infinity ? chars.slice(skipCharacters) : chars.slice(skipCharacters, skipCharacters + width)).join(""));
+        }
+        catch (error) {
+            if (!(error instanceof TypeError))
+                throw error;
+            // Invalid UTF-8 records retain byte comparisons without replacement characters.
+            offset += skipCharacters;
+            result = bytes.subarray(offset, width === Infinity ? undefined : offset + width);
+        }
         return ignoreCase ? fold(result) : result;
     };
     const records = (async function* () {

package/dist/safe-bash/commands/time-env/shared.js

@@ -8,8 +8,8 @@ export function settings(options) {
             throw new RangeError(`Invalid time-env limit: ${name}`);
     }
     const maxTimerMilliseconds = options.maxTimerMilliseconds ?? 2147483647;
-    if (!Number.isInteger(maxTimerMilliseconds) || maxTimerMilliseconds < 1 || maxTimerMilliseconds > 2147483647) {
-        throw new RangeError("maxTimerMilliseconds must be between1 and2147483647");
+    if (maxTimerMilliseconds !== Infinity && (!Number.isInteger(maxTimerMilliseconds) || maxTimerMilliseconds < 1 || maxTimerMilliseconds > 2147483647)) {
+        throw new RangeError("maxTimerMilliseconds must be between 1 and 2147483647 or Infinity");
     }
     const scheduler = options.scheduler ?? {
         now: () => performance.now(),

package/dist/safe-bash/commands/time-env/sleep.js

@@ -96,7 +96,8 @@ function delay(milliseconds, signal, configuration) {
         let handle;
         let armed = false;
         let settled = false;
-        let started;
+        let remaining = milliseconds;
+        let step = 0;
         let previous;
         const finish = (failed, reason) => {
             if (settled)
@@ -128,14 +129,15 @@ function delay(milliseconds, signal, configuration) {
                 if (!Number.isFinite(now) || Math.abs(now) > Number.MAX_SAFE_INTEGER || (previous !== undefined && now < previous)) {
                     throw new RangeError("sleep scheduler must supply finite monotonic milliseconds");
                 }
-                started ??= now;
+                if (previous !== undefined)
+                    remaining -= Math.max(step, now - previous);
                 previous = now;
-                const remaining = milliseconds - (now - started);
                 if (remaining <= 0) {
                     finish(false);
                     return;
                 }
-                const timer = scheduler.setTimeout(() => { armed = false; schedule(); }, Math.min(configuration.maxTimerMilliseconds, Math.max(1, Math.ceil(remaining))));
+                step = Math.min(2147483647, configuration.maxTimerMilliseconds, Math.max(1, Math.ceil(remaining)));
+                const timer = scheduler.setTimeout(() => { armed = false; schedule(); }, step);
                 if (settled)
                     scheduler.clearTimeout(timer);
                 else {

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

@@ -4,7 +4,14 @@ export interface TimeoutScheduler {
     setTimeout(callback: () => void, milliseconds: number): unknown;
     clearTimeout(handle: unknown): void;
 }
+export interface TimeoutLimits {
+    readonly maxArguments: number;
+    readonly maxArgumentBytes: number;
+    /** Bytes emitted by timeout itself; child output uses the child's budgets. */
+    readonly maxOutputBytes: number;
+}
 export interface TimeoutCommandOptions {
+    readonly limits?: Partial<TimeoutLimits> | undefined;
     /** Trusted host binding responsible for signalling, hard escalation and child cleanup. */
     readonly killAfterPolicy?: KillAfterPolicy | undefined;
     readonly invoke?: CommandInvoker | undefined;

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;