@poe-platform/safe-bash 0.1.41 → 0.1.42

package/dist/safe-bash/shell/runtime.js

@@ -1,3 +1,4 @@
+import { cancelTurn, monotonicNow, registerYieldCheckpoint, scheduleTurn, yieldTurn } from "../contracts/yield.js";
 import { ACCESS_MODES, FsError, composeMiddleware, createBytePipe, pipeBytes, resolvePath, toByteSource, validateExitCode, writeText, } from "../contracts/index.js";
 import { concatShellValues, shellValueByteLength, shellValueBytes, shellValueFromBytes, shellValueText } from "../contracts/value.js";
 import { createCommandArguments, getCommandArguments } from "../contracts/command.js";
@@ -20,9 +21,10 @@ import { ArrayFailure, ArrayOwner, exactSum } from "./arrays/ledger.js";
 import { controlNames, IndexedBinding, textToken } from "./arrays/bindings.js";
 import { arrayStore, guestArrays, requireArrays, snapshotState, stateMonitor, trackState } from "./arrays/state.js";
 import { publishPipelineStatus } from "./pipestatus.js";
-import { EreTransportRoot } from "../commands/regex-execution/ere/transport/root.js";
-import { EreTransportProfileLimitError, EreTransportSemanticError } from "../commands/regex-execution/ere/transport/protocol.js";
-import { EreProfileLimitError, EreUnsupportedError } from "../commands/regex-execution/ere/errors.js";
+import { EreProfileLimitError, EreSyntaxError, EreUnsupportedError } from "../commands/regex-execution/ere/errors.js";
+import { EreLedger } from "../commands/regex-execution/ere/limits.js";
+import { compileEre } from "../commands/regex-execution/ere/syntax.js";
+import { matchEre } from "../commands/regex-execution/ere/matcher.js";
 export const defaultLimits = {
     maxInputBytes: 32 * 1024 * 1024,
     maxOutputBytes: 16 * 1024 * 1024,
@@ -32,6 +34,8 @@ export const defaultLimits = {
     maxSourceBytes: 1024 * 1024,
     maxExpansionFields: 10_000,
     maxExpansionBytes: 16 * 1024 * 1024,
+    maxWallClockMs: 30_000,
+    maxCpuMs: 30_000,
     pipeHighWaterMark: 64 * 1024,
 };
 const shellBuiltinNames = new Set([
@@ -64,17 +68,43 @@ export class Budget {
     sourceBytes = 0;
     controller = new AbortController();
     signal;
+    #wallClockTimer;
+    #wallClockDeadline = 0;
+    #cpuStarted = monotonicNow();
     constructor(limits, signal) {
         this.limits = limits;
         this.signal = signal ? AbortSignal.any([signal, this.controller.signal]) : this.controller.signal;
         this.values = new ValueArena(limits.maxExpansionBytes, limits.maxExpansionFields, () => this.signal.throwIfAborted(), limit => this.fail(limit));
+        this.#wallClockDeadline = Date.now() + limits.maxWallClockMs;
+        this.#armWallClock();
+    }
+    #armWallClock() {
+        const remaining = this.#wallClockDeadline - Date.now();
+        if (remaining <= 0) {
+            this.controller.abort(new ShellLimitError("maxWallClockMs"));
+            return;
+        }
+        this.#wallClockTimer = setTimeout(() => this.#armWallClock(), Math.min(remaining, 2_147_483_647));
+        const timer = this.#wallClockTimer;
+        timer.unref?.();
+    }
+    close() {
+        if (this.#wallClockTimer !== undefined)
+            clearTimeout(this.#wallClockTimer);
+        this.#wallClockTimer = undefined;
     }
     fail(limit) {
         const error = new ShellLimitError(limit);
         this.controller.abort(error);
         throw error;
     }
+    cpuCheckpoint() {
+        this.signal.throwIfAborted();
+        if (monotonicNow() - this.#cpuStarted > this.limits.maxCpuMs)
+            this.fail("maxCpuMs");
+    }
     tick() {
+        this.cpuCheckpoint();
         this.signal.throwIfAborted();
         if (++this.commands > this.limits.maxCommands)
             this.fail("maxCommands");
@@ -493,7 +523,7 @@ class CdLookup {
             amount -= step;
             if (this.spent % 128 === 0) {
                 this.signal.throwIfAborted();
-                await interruptible(new Promise(resolve => setImmediate(resolve)), this.signal);
+                await yieldTurn(this.signal);
                 this.signal.throwIfAborted();
             }
         }
@@ -602,7 +632,7 @@ class DirectoryStackWork {
         this.signal.throwIfAborted();
         if (this.flushed === this.spent)
             return;
-        await interruptible(new Promise(resolve => setImmediate(resolve)), this.signal);
+        await yieldTurn(this.signal);
         this.signal.throwIfAborted();
         this.flushed = this.spent;
     }
@@ -939,20 +969,6 @@ export class Runtime {
     cancellationDepth;
     cancellationMaxDepth;
     outcomeFrame;
-    static #ereRoots = new WeakMap();
-    static registerEreRoot(budget, scope) {
-        const entry = { closed: false };
-        scope.register(async () => {
-            entry.closed = true;
-            try {
-                await entry.cleanup?.();
-            }
-            finally {
-                Runtime.#ereRoots.delete(budget);
-            }
-        });
-        Runtime.#ereRoots.set(budget, entry);
-    }
     constructor(fs, commands, middleware, budget, signal = budget.signal, fileWrites = new Map(), outputFiles = new Map(), commandSignal = signal, cancellation, cancellationState, cancellationOwner, cancellationDepth, cancellationMaxDepth, outcomeFrame = undefined) {
         this.fs = fs;
         this.commands = commands;
@@ -968,6 +984,7 @@ export class Runtime {
         this.cancellationDepth = cancellationDepth;
         this.cancellationMaxDepth = cancellationMaxDepth;
         this.outcomeFrame = outcomeFrame;
+        registerYieldCheckpoint(this.signal, () => this.budget.cpuCheckpoint());
     }
     async ereDiagnostic(io, detail) {
         try {
@@ -1021,40 +1038,23 @@ export class Runtime {
             await textToken(operation, subject, this.signal);
             const name = "BASH_REMATCH";
             const watch = await store.watch(name, operation, this.signal);
-            const entry = Runtime.#ereRoots.get(this.budget);
-            if (!entry || entry.closed)
-                throw new Error("ERE invocation owner is closed");
-            if (!entry.root)
-                entry.root = new EreTransportRoot({ maxExpansionBytes: this.budget.limits.maxExpansionBytes, maxExpansionFields: this.budget.limits.maxExpansionFields }, cleanup => {
-                    scope.assertOpen();
-                    if (entry.closed)
-                        throw new Error("ERE invocation owner is closed");
-                    entry.cleanup = cleanup;
-                });
-            const session = entry.root.openSession(cleanup => scope.register(cleanup));
+            const ledger = new EreLedger({
+                maxExpansionBytes: this.budget.limits.maxExpansionBytes,
+                maxExpansionFields: this.budget.limits.maxExpansionFields,
+            });
             let result;
-            let sessionEscaping = false;
             try {
-                result = await session.execute({ pattern: fragments, subject }, this.signal);
+                const program = await compileEre(fragments, ledger, this.signal);
+                result = await matchEre(program, subject, ledger, this.signal);
             }
             catch (error) {
-                sessionEscaping = true;
                 this.signal.throwIfAborted();
-                if (error instanceof EreTransportSemanticError || error instanceof EreUnsupportedError) {
+                if (error instanceof EreSyntaxError || error instanceof EreUnsupportedError) {
                     await this.ereDiagnostic(io, `[[ ${error.message}`);
-                    sessionEscaping = false;
                     return 2;
                 }
                 throw error;
             }
-            finally {
-                await session.close().catch(error => {
-                    if (sessionEscaping)
-                        scope.failures.push(error);
-                    else
-                        throw new NounsetDiagnosticFailure(error);
-                });
-            }
             const status = result.matched ? 0 : 1;
             this.signal.throwIfAborted();
             scope.assertOpen();
@@ -1071,8 +1071,8 @@ export class Runtime {
             const prepared = await store.prepareName(name, operation, this.signal);
             staged = IndexedBinding.create(store.owner);
             if (result.matched)
-                for (let index = 0; index < result.spans.length; index++) {
-                    const span = result.spans[index];
+                for (let index = 0; index < result.captures.length; index++) {
+                    const span = result.captures[index];
                     const size = span === null ? 0 : span.end - span.start;
                     operation.reserve({ payload: size, metadata: 32, work: size + 2 });
                     const value = span === null ? "" : subject.slice(span.start, span.end);
@@ -1235,6 +1235,8 @@ export class Runtime {
             throw new ArrayFailure(origin === "arithmetic" ? "indexed arithmetic is unsupported" : "indexed write requires prepared publication");
         if (state.readonlyVariables?.has(name))
             throw new Error(`${name}: readonly variable`);
+        if (shellValueByteLength(value) > this.budget.limits.maxExpansionBytes)
+            this.budget.fail("maxExpansionBytes");
         if (name === "OPTIND" && state.getopts?.integer && origin !== "arithmetic") {
             try {
                 value = String(evaluateArithmetic(prepareArithmetic(shellValueText(value) || "0"), this.arithmeticVariables(state)));
@@ -1801,7 +1803,7 @@ export class Runtime {
                         completed.add(index);
                         if (incoming) {
                             const upstream = index - 1;
-                            const close = setImmediate(() => {
+                            const close = scheduleTurn(() => {
                                 closing.delete(close);
                                 if (written.has(upstream) && !completed.has(upstream))
                                     controllers[upstream].abort(new PipelineClosed());
@@ -1835,7 +1837,7 @@ export class Runtime {
             }
             finally {
                 for (const close of closing)
-                    clearImmediate(close);
+                    cancelTurn(close);
                 for (const [index, controller] of controllers.entries())
                     if (!completed.has(index) || written.has(index))
                         controller.abort(new PipelineClosed());
@@ -1911,7 +1913,7 @@ export class Runtime {
             originalIO = isolateIO(originalIO);
         this.budget.tick();
         if (this.budget.commands % 128 === 0)
-            await interruptible(new Promise((resolve) => setImmediate(resolve)), this.signal);
+            await yieldTurn(this.signal);
         this.signal.throwIfAborted();
         const inputs = new Set();
         const outputs = new Set();
@@ -1961,7 +1963,7 @@ export class Runtime {
                         diagnosticFailure = error;
                         throw error;
                     }
-                    if (error instanceof EreProfileLimitError || error instanceof EreTransportProfileLimitError) {
+                    if (error instanceof EreProfileLimitError) {
                         try {
                             await this.diagnostic(io, `[[ ${error.message}`);
                         }
@@ -2039,7 +2041,7 @@ export class Runtime {
                     if (!matched)
                         for (const word of clause.patterns) {
                             if (++patterns % 128 === 0)
-                                await interruptible(new Promise((resolve) => setImmediate(resolve)), this.signal);
+                                await yieldTurn(this.signal);
                             const pattern = (await this.word(word, state, io, false, true)).join("");
                             if (await matchesPattern(pattern, subject, work)) {
                                 matched = true;
@@ -2185,7 +2187,7 @@ export class Runtime {
                 for (const warning of warnings.splice(0))
                     await writeText(io.stderr, `shell: warning: ${warning}\n`);
                 if (++words % 128 === 0)
-                    await interruptible(new Promise((resolve) => setImmediate(resolve)), this.signal);
+                    await yieldTurn(this.signal);
                 const part = (await this.word(word, state, io, false)).join("");
                 size += Buffer.byteLength(part);
                 if (size > this.budget.limits.maxExpansionBytes)
@@ -3168,7 +3170,7 @@ export class Runtime {
         let lines = 0;
         while (true) {
             if (++lines % 32 === 0)
-                await interruptible(new Promise(resolve => setImmediate(resolve)), this.signal);
+                await yieldTurn(this.signal);
             this.signal.throwIfAborted();
             const bytes = await input.sourceLine();
             const eof = bytes === undefined;
@@ -3807,7 +3809,7 @@ export class Runtime {
         };
         const checkpoint = async () => {
             this.signal.throwIfAborted();
-            await interruptible(new Promise(resolve => setImmediate(resolve)), this.signal);
+            await yieldTurn(this.signal);
             this.signal.throwIfAborted();
         };
         const { args } = context;
@@ -3863,7 +3865,7 @@ export class Runtime {
         };
         const checkpoint = async () => {
             this.signal.throwIfAborted();
-            await interruptible(new Promise(resolve => setImmediate(resolve)), this.signal);
+            await yieldTurn(this.signal);
             this.signal.throwIfAborted();
         };
         if (!Array.isArray(context.args))
@@ -5008,7 +5010,7 @@ export class Runtime {
             if (work.remaining < 0)
                 work.exhausted();
             if (++attempts % 256 === 0)
-                await new Promise(resolve => setImmediate(resolve));
+                await yieldTurn(this.signal);
             this.signal.throwIfAborted();
             if (owner)
                 await owner.ledger.checkpoint(this.signal, end - start + 1);