@poe-platform/safe-bash 0.1.53 → 0.1.55

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

@@ -13,6 +13,8 @@ import { byteLocale } from "./locale.js";
 import { functionDisplay } from "./display.js";
 import { ConditionalUnsupported, evaluateConditional } from "./conditional.js";
 import { invocationScope, throwCleanupFailures } from "./cleanup.js";
+import { bindFileOutputBudget, openFileOutput } from "../contracts/filesystem-output.js";
+import { outputFailure } from "../contracts/io.js";
 import { executionCommands } from "../commands/execution.js";
 import { cloneGetoptsState, createGetoptsState, GetoptsError, scanGetopts, withGetoptsIndex } from "./getopts.js";
 import { activateChildCancellation, prepareChildCancellation, selectRuntimeCancellationOutcome, subscribeCancellation, } from "./cancellation.js";
@@ -140,6 +142,7 @@ export class Budget {
         if (ownership?.budget === this && ownership.write === sink.write)
             return signalSink(sink, signal);
         const output = {
+            ...(sink[outputFailure] ? { [outputFailure]: sink[outputFailure] } : {}),
             ...(sink.ownedOutput ? { ownedOutput: {
                     consumerClosed: sink.ownedOutput.consumerClosed,
                     write: async (chunk) => {
@@ -299,6 +302,7 @@ function signalSink(sink, signal) {
     const owned = ownership?.write === sink.write ? ownership : undefined;
     const write = owned ? owned.write.bind(sink) : (chunk) => sink.write(chunk);
     const output = {
+        ...(sink[outputFailure] ? { [outputFailure]: sink[outputFailure] } : {}),
         ...(sink.ownedOutput ? { ownedOutput: {
                 consumerClosed: sink.ownedOutput.consumerClosed,
                 async write(chunk) { signal.throwIfAborted(); await interruptible(sink.ownedOutput.write(chunk), signal); },
@@ -1796,7 +1800,7 @@ export class Runtime {
                     const frame = {};
                     const runtime = new Runtime(this.fs, this.commands, this.middleware, this.budget, signal, this.fileWrites, this.outputFiles, boundary.deliverySignal, boundary, this.cancellationState, owner, childDepth, this.cancellationMaxDepth, frame);
                     const input = new ShellInput(incoming?.readable ?? io.stdin, this.budget, signal);
-                    const pipeOutput = outgoing && { ownedOutput: outgoing.writable.ownedOutput, write: async (chunk) => {
+                    const pipeOutput = outgoing && { [outputFailure]: outgoing.abort, ownedOutput: outgoing.writable.ownedOutput, write: async (chunk) => {
                             try {
                                 await outgoing.writable.write(chunk);
                                 if (chunk.byteLength)
@@ -1962,181 +1966,192 @@ export class Runtime {
         this.signal.throwIfAborted();
         const inputs = new Set();
         const outputs = new Set();
+        const finishOutputs = async (status) => {
+            const pending = [...outputs];
+            outputs.clear();
+            const settled = await Promise.allSettled(pending.map(close => close({ status })));
+            throwCleanupFailures(settled.filter(result => result.status === "rejected").map(result => result.reason));
+        };
         const allocation = this.budget.values.scope();
         originalIO = { ...originalIO, [valueScope]: allocation };
         let io = originalIO;
         let diagnosticFailure;
         try {
-            if (command.kind === "function") {
-                if (state.profile === "sh" && specialBuiltinNames.has(command.name)) {
-                    await this.diagnostic(io, `\`${command.name}': is a special builtin`);
-                    throw new Flow("exit", 2);
-                }
-                state.functions.set(command.name, { ...command.body, sourceName: io.scriptName ?? "shell" });
-                return 0;
-            }
-            if (command.kind === "simple")
-                return await this.simple(command, state, originalIO, inputs, outputs, fileShortcut);
-            io = await this.redirect(command.redirects, state, io, inputs, outputs, command.kind === "subshell", command.kind !== "subshell");
-            if (command.kind === "conditional") {
-                try {
-                    return await evaluateConditional(command.expression, {
-                        fs: this.fs, cwd: state.cwd, signal: this.signal,
-                        locale: state.variables.LC_ALL || state.variables.LC_COLLATE || state.variables.LANG || "C",
-                        work: { remaining: this.budget.limits.maxExpansionBytes, signal: this.signal, exhausted: () => this.budget.fail("maxExpansionBytes") },
-                        expand: async (word, pattern = false) => (await this.word(word, state, io, false, pattern, false, pattern)).join(""),
-                        regex: (subject, pattern) => this.ere(subject, pattern, state, io),
-                        option: name => name === "errexit" ? !!state.errexit : name === "nounset" ? !!state.nounset : name === "pipefail" ? state.pipefail : false,
-                        present: name => {
-                            const match = /^([a-zA-Z_][a-zA-Z_0-9]*)(?:\[(0|[1-9][0-9]*|[@*])\])?$/u.exec(name);
-                            if (!match)
-                                throw new ConditionalUnsupported("[[ variable selector: unsupported conditional profile");
-                            const binding = arrayStore(state)?.get(match[1]);
-                            const selector = match[2];
-                            if (selector === "@" || selector === "*")
-                                return binding ? binding.values.size > 0 : this.variable(state, match[1]) !== undefined;
-                            const index = selector === undefined ? 0 : numericIndex({ decimal: selector });
-                            if (index === undefined)
-                                throw new ConditionalUnsupported("[[ variable index: unsupported conditional profile");
-                            return binding ? binding.get(index) !== undefined : index === 0 && this.variable(state, match[1]) !== undefined;
-                        },
-                    });
+            const execute = async () => {
+                if (command.kind === "function") {
+                    if (state.profile === "sh" && specialBuiltinNames.has(command.name)) {
+                        await this.diagnostic(io, `\`${command.name}': is a special builtin`);
+                        throw new Flow("exit", 2);
+                    }
+                    state.functions.set(command.name, { ...command.body, sourceName: io.scriptName ?? "shell" });
+                    return 0;
                 }
-                catch (error) {
-                    this.signal.throwIfAborted();
-                    if (error instanceof NounsetDiagnosticFailure) {
-                        diagnosticFailure = error;
-                        throw error;
+                if (command.kind === "simple")
+                    return await this.simple(command, state, originalIO, inputs, outputs, fileShortcut);
+                io = await this.redirect(command.redirects, state, io, inputs, outputs, command.kind === "subshell", command.kind !== "subshell");
+                if (command.kind === "conditional") {
+                    try {
+                        return await evaluateConditional(command.expression, {
+                            fs: this.fs, cwd: state.cwd, signal: this.signal,
+                            locale: state.variables.LC_ALL || state.variables.LC_COLLATE || state.variables.LANG || "C",
+                            work: { remaining: this.budget.limits.maxExpansionBytes, signal: this.signal, exhausted: () => this.budget.fail("maxExpansionBytes") },
+                            expand: async (word, pattern = false) => (await this.word(word, state, io, false, pattern, false, pattern)).join(""),
+                            regex: (subject, pattern) => this.ere(subject, pattern, state, io),
+                            option: name => name === "errexit" ? !!state.errexit : name === "nounset" ? !!state.nounset : name === "pipefail" ? state.pipefail : false,
+                            present: name => {
+                                const match = /^([a-zA-Z_][a-zA-Z_0-9]*)(?:\[(0|[1-9][0-9]*|[@*])\])?$/u.exec(name);
+                                if (!match)
+                                    throw new ConditionalUnsupported("[[ variable selector: unsupported conditional profile");
+                                const binding = arrayStore(state)?.get(match[1]);
+                                const selector = match[2];
+                                if (selector === "@" || selector === "*")
+                                    return binding ? binding.values.size > 0 : this.variable(state, match[1]) !== undefined;
+                                const index = selector === undefined ? 0 : numericIndex({ decimal: selector });
+                                if (index === undefined)
+                                    throw new ConditionalUnsupported("[[ variable index: unsupported conditional profile");
+                                return binding ? binding.get(index) !== undefined : index === 0 && this.variable(state, match[1]) !== undefined;
+                            },
+                        });
                     }
-                    if (error instanceof EreProfileLimitError) {
-                        try {
-                            await this.diagnostic(io, `[[ ${error.message}`);
-                        }
-                        catch (reason) {
-                            this.signal.throwIfAborted();
-                            if (reason instanceof ShellLimitError)
-                                throw reason;
-                            diagnosticFailure = new NounsetDiagnosticFailure(reason);
-                            throw diagnosticFailure;
+                    catch (error) {
+                        this.signal.throwIfAborted();
+                        if (error instanceof NounsetDiagnosticFailure) {
+                            diagnosticFailure = error;
+                            throw error;
                         }
-                        return 3;
-                    }
-                    if (error instanceof ConditionalUnsupported) {
-                        try {
-                            await this.diagnostic(io, error.message);
+                        if (error instanceof EreProfileLimitError) {
+                            try {
+                                await this.diagnostic(io, `[[ ${error.message}`);
+                            }
+                            catch (reason) {
+                                this.signal.throwIfAborted();
+                                if (reason instanceof ShellLimitError)
+                                    throw reason;
+                                diagnosticFailure = new NounsetDiagnosticFailure(reason);
+                                throw diagnosticFailure;
+                            }
+                            return 3;
                         }
-                        catch (reason) {
-                            this.signal.throwIfAborted();
-                            if (reason instanceof ShellLimitError)
-                                throw reason;
-                            diagnosticFailure = new NounsetDiagnosticFailure(reason);
-                            throw diagnosticFailure;
+                        if (error instanceof ConditionalUnsupported) {
+                            try {
+                                await this.diagnostic(io, error.message);
+                            }
+                            catch (reason) {
+                                this.signal.throwIfAborted();
+                                if (reason instanceof ShellLimitError)
+                                    throw reason;
+                                diagnosticFailure = new NounsetDiagnosticFailure(reason);
+                                throw diagnosticFailure;
+                            }
+                            return 2;
                         }
-                        return 2;
+                        if (error instanceof ExpansionFailure || error instanceof Flow || error instanceof ShellLimitError || error instanceof ShellSyntaxError || error instanceof ArrayFailure)
+                            throw error;
+                        diagnosticFailure = new NounsetDiagnosticFailure(error);
+                        throw diagnosticFailure;
                     }
-                    if (error instanceof ExpansionFailure || error instanceof Flow || error instanceof ShellLimitError || error instanceof ShellSyntaxError || error instanceof ArrayFailure)
-                        throw error;
-                    diagnosticFailure = new NounsetDiagnosticFailure(error);
-                    throw diagnosticFailure;
-                }
-            }
-            if (command.kind === "arithmetic") {
-                try {
-                    return Number(evaluatePositionalArithmetic(command.expression, {
-                        positional: state.positional, arg0: state.arg0 ?? "virtual-bash", owner: arrayStore(state)?.owner,
-                        maximumBytes: this.budget.limits.maxExpansionBytes,
-                        checkpoint: () => this.signal.throwIfAborted(),
-                        requireParameter: (name, value) => this.requireParameter(value, name, state, io),
-                        limit: () => this.budget.fail("maxExpansionBytes"),
-                    }, (prepared) => evaluateArithmetic(prepared, this.arithmeticVariables(state, io.diagnosticLine))) === 0n);
                 }
-                catch (error) {
-                    this.rethrowArithmeticControl(error);
-                    throw new Error(`((: ${message(error)}`);
+                if (command.kind === "arithmetic") {
+                    try {
+                        return Number(evaluatePositionalArithmetic(command.expression, {
+                            positional: state.positional, arg0: state.arg0 ?? "virtual-bash", owner: arrayStore(state)?.owner,
+                            maximumBytes: this.budget.limits.maxExpansionBytes,
+                            checkpoint: () => this.signal.throwIfAborted(),
+                            requireParameter: (name, value) => this.requireParameter(value, name, state, io),
+                            limit: () => this.budget.fail("maxExpansionBytes"),
+                        }, (prepared) => evaluateArithmetic(prepared, this.arithmeticVariables(state, io.diagnosticLine))) === 0n);
+                    }
+                    catch (error) {
+                        this.rethrowArithmeticControl(error);
+                        throw new Error(`((: ${message(error)}`);
+                    }
                 }
-            }
-            if (command.kind === "subshell") {
-                const child = await cloneState(state, this.signal);
-                child.isolated = true;
-                child.loopDepth = 0;
-                try {
-                    return await this.run(command.body, child, io);
+                if (command.kind === "subshell") {
+                    const child = await cloneState(state, this.signal);
+                    child.isolated = true;
+                    child.loopDepth = 0;
+                    try {
+                        return await this.run(command.body, child, io);
+                    }
+                    finally {
+                        stateMonitor(child)?.closeValues();
+                    }
                 }
-                finally {
-                    stateMonitor(child)?.closeValues();
+                if (command.kind === "group")
+                    return await this.script(command.body, state, io);
+                if (command.kind === "if") {
+                    for (const branch of command.branches) {
+                        if (await this.script(branch.condition, state, { ...io, execution: { ignoreErrexit: true } }) === 0)
+                            return await this.script(branch.body, state, io);
+                    }
+                    return command.otherwise ? await this.script(command.otherwise, state, io) : 0;
                 }
-            }
-            if (command.kind === "group")
-                return await this.script(command.body, state, io);
-            if (command.kind === "if") {
-                for (const branch of command.branches) {
-                    if (await this.script(branch.condition, state, { ...io, execution: { ignoreErrexit: true } }) === 0)
-                        return await this.script(branch.body, state, io);
+                if (command.kind === "case") {
+                    const subject = (await this.word(command.subject, state, io, false)).join("");
+                    const work = { remaining: this.budget.limits.maxExpansionBytes, signal: this.signal, exhausted: () => this.budget.fail("maxExpansionBytes") };
+                    let status = 0;
+                    let fallthrough = false;
+                    let patterns = 0;
+                    for (const clause of command.clauses) {
+                        let matched = fallthrough;
+                        if (!matched)
+                            for (const word of clause.patterns) {
+                                if (++patterns % 128 === 0)
+                                    await yieldTurn(this.signal);
+                                const pattern = (await this.word(word, state, io, false, true)).join("");
+                                if (await matchesPattern(pattern, subject, work)) {
+                                    matched = true;
+                                    break;
+                                }
+                            }
+                        if (!matched)
+                            continue;
+                        if (clause.body.lists.length)
+                            status = await this.script(clause.body, state, io);
+                        if (clause.terminator === ";;" || clause.terminator === "esac")
+                            break;
+                        fallthrough = clause.terminator === ";&";
+                    }
+                    return status;
                 }
-                return command.otherwise ? await this.script(command.otherwise, state, io) : 0;
-            }
-            if (command.kind === "case") {
-                const subject = (await this.word(command.subject, state, io, false)).join("");
-                const work = { remaining: this.budget.limits.maxExpansionBytes, signal: this.signal, exhausted: () => this.budget.fail("maxExpansionBytes") };
                 let status = 0;
-                let fallthrough = false;
-                let patterns = 0;
-                for (const clause of command.clauses) {
-                    let matched = fallthrough;
-                    if (!matched)
-                        for (const word of clause.patterns) {
-                            if (++patterns % 128 === 0)
-                                await yieldTurn(this.signal);
-                            const pattern = (await this.word(word, state, io, false, true)).join("");
-                            if (await matchesPattern(pattern, subject, work)) {
-                                matched = true;
+                const loopRestoration = stateMonitor(state)?.restoration();
+                state.loopDepth++;
+                try {
+                    if (command.kind === "for") {
+                        const values = command.words ? await this.valueWords(command.words, state, io) : this.positionalValues(state);
+                        for (const value of values) {
+                            this.budget.loop();
+                            await this.assignVariable(state, command.name, value);
+                            const result = await this.loopBody(command.body, state, io);
+                            status = result.status;
+                            if (result.stop)
                                 break;
-                            }
                         }
-                    if (!matched)
-                        continue;
-                    if (clause.body.lists.length)
-                        status = await this.script(clause.body, state, io);
-                    if (clause.terminator === ";;" || clause.terminator === "esac")
-                        break;
-                    fallthrough = clause.terminator === ";&";
-                }
-                return status;
-            }
-            let status = 0;
-            const loopRestoration = stateMonitor(state)?.restoration();
-            state.loopDepth++;
-            try {
-                if (command.kind === "for") {
-                    const values = command.words ? await this.valueWords(command.words, state, io) : this.positionalValues(state);
-                    for (const value of values) {
-                        this.budget.loop();
-                        await this.assignVariable(state, command.name, value);
-                        const result = await this.loopBody(command.body, state, io);
-                        status = result.status;
-                        if (result.stop)
-                            break;
                     }
-                }
-                else {
-                    while (true) {
-                        this.budget.loop();
-                        const condition = await this.script(command.condition, state, { ...io, execution: { ignoreErrexit: true } });
-                        if ((condition === 0) !== (command.kind === "while"))
-                            break;
-                        const result = await this.loopBody(command.body, state, io);
-                        status = result.status;
-                        if (result.stop)
-                            break;
+                    else {
+                        while (true) {
+                            this.budget.loop();
+                            const condition = await this.script(command.condition, state, { ...io, execution: { ignoreErrexit: true } });
+                            if ((condition === 0) !== (command.kind === "while"))
+                                break;
+                            const result = await this.loopBody(command.body, state, io);
+                            status = result.status;
+                            if (result.stop)
+                                break;
+                        }
                     }
                 }
-            }
-            finally {
-                if (loopRestoration)
-                    loopRestoration.apply(() => { state.loopDepth--; });
-                else
-                    state.loopDepth--;
-            }
+                finally {
+                    if (loopRestoration)
+                        loopRestoration.apply(() => { state.loopDepth--; });
+                    else
+                        state.loopDepth--;
+                }
+                return status;
+            };
+            const status = await execute();
+            await finishOutputs(status);
             return status;
         }
         catch (caught) {
@@ -2147,6 +2162,8 @@ export class Runtime {
             if (error instanceof NounsetDiagnosticFailure)
                 diagnosticFailure = error;
             this.signal.throwIfAborted();
+            if (error instanceof Flow)
+                await finishOutputs(error.status);
             if (error instanceof Flow || error instanceof ShellLimitError || error instanceof ShellSyntaxError)
                 throw error;
             this.clearOutcomeReport();
@@ -2197,7 +2214,7 @@ export class Runtime {
         }
         finally {
             await Promise.allSettled([
-                ...[...outputs].map(async (close) => close()),
+                ...[...outputs].map(async (close) => close({ reason: new FsError("ECANCELED", { syscall: "redirect" }) })),
                 ...[...inputs].map(async (input) => input.close()),
             ]).then(results => {
                 const failures = results.filter(result => result.status === "rejected").map(result => result.reason);
@@ -2358,48 +2375,91 @@ export class Runtime {
                     }
                     else {
                         const append = redirect.operator === ">>";
+                        const capabilities = await this.fs.capabilitiesFor?.(path, options) ?? this.fs.capabilities;
+                        const random = capabilities.randomAccessWrite === true;
                         let file;
                         await this.fileOperation(path, async () => {
-                            await this.fs.writeFile(path, new Uint8Array(), { ...options, flag: append ? "a" : "w" });
                             file = this.outputFiles.get(path) ?? { data: undefined, references: 0 };
-                            if (!append)
-                                file.data = new Uint8Array();
+                            if (!random && file.references)
+                                throw new FsError("ENOTSUP", { path, message: "Conflicting sequential output descriptors" });
                             file.references++;
                             this.outputFiles.set(path, file);
                         });
                         let closed = false;
-                        outputs.add(() => {
-                            closed = true;
-                            if (--file.references === 0 && this.outputFiles.get(path) === file)
-                                this.outputFiles.delete(path);
-                        });
                         let offset = 0;
-                        const output = this.budget.sink({ write: (chunk) => {
-                                const copy = new Uint8Array(chunk);
-                                return this.fileOperation(path, async () => {
-                                    if (closed)
-                                        throw new Error("Output descriptor is closed");
-                                    const current = file.data;
-                                    if (append) {
-                                        await this.fs.appendFile(path, copy, options);
-                                        if (current) {
-                                            const bytes = new Uint8Array(current.length + copy.length);
-                                            bytes.set(current);
-                                            bytes.set(copy, current.length);
+                        const incremental = async () => {
+                            await this.fileOperation(path, async () => {
+                                if (append)
+                                    await this.fs.appendFile(path, new Uint8Array(), options);
+                                else
+                                    await this.fs.writeFile(path, new Uint8Array(), { ...options, flag: "w" });
+                                if (!append)
+                                    file.data = new Uint8Array();
+                            });
+                            return { write: (chunk) => {
+                                    const copy = new Uint8Array(chunk);
+                                    return this.fileOperation(path, async () => {
+                                        if (closed)
+                                            throw new Error("Output descriptor is closed");
+                                        const current = file.data;
+                                        if (append) {
+                                            await this.fs.appendFile(path, copy, options);
+                                            if (current) {
+                                                const bytes = new Uint8Array(current.length + copy.length);
+                                                bytes.set(current);
+                                                bytes.set(copy, current.length);
+                                                file.data = bytes;
+                                            }
+                                        }
+                                        else {
+                                            const bytes = new Uint8Array(Math.max(current?.length ?? 0, offset + copy.length));
+                                            if (current)
+                                                bytes.set(current);
+                                            bytes.set(copy, offset);
+                                            await this.fs.writeFile(path, bytes, options);
                                             file.data = bytes;
+                                            offset += copy.length;
                                         }
+                                    });
+                                } };
+                        };
+                        const release = () => {
+                            if (closed)
+                                return;
+                            closed = true;
+                            if (--file.references === 0 && this.outputFiles.get(path) === file)
+                                this.outputFiles.delete(path);
+                        };
+                        let target;
+                        try {
+                            target = await openFileOutput({ fs: this.fs, signal: this.signal, registerCleanup: cleanup => io[invocationScope].register(cleanup) }, path, append ? "a" : "w", random ? incremental : undefined);
+                        }
+                        catch (error) {
+                            release();
+                            throw error;
+                        }
+                        outputs.add(async (completion) => {
+                            try {
+                                if (this.signal.aborted)
+                                    await target.abort(this.signal.reason);
+                                else if ("reason" in completion)
+                                    await target.abort(completion.reason);
+                                else {
+                                    try {
+                                        await target.finish();
                                     }
-                                    else {
-                                        const bytes = new Uint8Array(Math.max(current?.length ?? 0, offset + copy.length));
-                                        if (current)
-                                            bytes.set(current);
-                                        bytes.set(copy, offset);
-                                        await this.fs.writeFile(path, bytes, options);
-                                        file.data = bytes;
-                                        offset += copy.length;
+                                    catch (error) {
+                                        this.signal.throwIfAborted();
+                                        if (completion.status === 0)
+                                            throw error;
                                     }
-                                });
-                            } }, this.signal);
+                                }
+                            }
+                            finally {
+                                release();
+                            }
+                        });
+                        const output = this.budget.sink(target.sink, this.signal);
                         descriptors.set(redirect.descriptor, { output });
                         if (redirect.operator === "&>") {
                             replaced.add(2);
@@ -2657,6 +2717,7 @@ export class Runtime {
                 return invocation;
             },
         };
+        bindFileOutputBudget(context, sink => this.budget.sink(sink, this.signal));
         if (argumentValues.values.every(value => typeof value === "string"))
             Reflect.deleteProperty(context, "argumentValues");
         const middleware = this.middleware.map((handler) => (context, next) => {
@@ -3301,6 +3362,7 @@ export class Runtime {
                     return invocation;
                 },
             };
+            bindFileOutputBudget(context, sink => this.budget.sink(sink, runtime.signal));
             if (argumentValues.values.every(value => typeof value === "string"))
                 Reflect.deleteProperty(context, "argumentValues");
             const child = await runtime.shebangState(context, state);