@poe-platform/safe-bash 0.1.802 → 0.1.804

package/dist/safe-bash/shell/read-builtin.d.ts

@@ -0,0 +1,3 @@
+import type { ShellExtensionContext } from "./extensions.js";
+export declare function executeRead(nonTerminalInput: boolean, context: ShellExtensionContext): Promise<number>;
+//# sourceMappingURL=read-builtin.d.ts.map

package/dist/safe-bash/shell/read-builtin.js

@@ -0,0 +1,344 @@
+import { FsError } from "../contracts/errors.js";
+import { concatShellValues, shellValueBytes, shellValueFromBytes, shellValueText } from "../contracts/value.js";
+const usage = "read: usage: read [-Eers] [-a array] [-d delim] [-i text] [-n nchars] [-N nchars] [-p prompt] [-t timeout] [-u fd] [name ...]\n";
+function identifier(name) {
+    if (!name.length)
+        return false;
+    for (let index = 0; index < name.length; index++) {
+        const character = name[index];
+        if (character !== "_" && !(character >= "a" && character <= "z") && !(character >= "A" && character <= "Z") && !(index > 0 && character >= "0" && character <= "9"))
+            return false;
+    }
+    return true;
+}
+function decimal(value) {
+    let left = 0;
+    let right = value.length;
+    while (left < right && " \t\n\r\v\f".includes(value[left]))
+        left++;
+    while (right > left && " \t\n\r\v\f".includes(value[right - 1]))
+        right--;
+    const digits = value.slice(left, right);
+    let start = 0;
+    if (digits[0] === "+" || digits[0] === "-")
+        start++;
+    if (digits.length === start)
+        return undefined;
+    for (let index = start; index < digits.length; index++)
+        if (digits[index] < "0" || digits[index] > "9")
+            return undefined;
+    const number = Number(digits);
+    return Number.isInteger(number) && number >= 0 && number <= 2147483647 ? number : undefined;
+}
+function timeout(value) {
+    let offset = value.startsWith("+") || value.startsWith("-") ? 1 : 0;
+    let seconds = 0n;
+    while (offset < value.length && value[offset] !== ".") {
+        const character = value[offset++];
+        if (character < "0" || character > "9")
+            return undefined;
+        seconds = seconds * 10n + BigInt(character);
+        if (seconds > 9223372036854775807n)
+            return undefined;
+    }
+    if (value[offset] === ".")
+        offset++;
+    let fraction = 0;
+    let digits = 0;
+    while (offset < value.length && digits < 6) {
+        const character = value[offset++];
+        if (character < "0" || character > "9")
+            return undefined;
+        fraction = fraction * 10 + Number(character);
+        digits++;
+    }
+    fraction *= 10 ** (6 - digits);
+    if (digits === 6 && value[offset] !== undefined && value[offset] >= "5" && value[offset] <= "9")
+        fraction++;
+    if (value.startsWith("-") && (seconds > 0n || fraction > 0))
+        return undefined;
+    return Number(seconds & 4294967295n) * 1000 + fraction / 1000;
+}
+async function parse(context, validate) {
+    const options = { raw: false, exact: false, descriptor: 0, names: [] };
+    const args = context.argumentValues;
+    let offset = 0;
+    while (offset < args.length) {
+        const argument = args[offset];
+        const bytes = shellValueBytes(argument);
+        const text = shellValueText(argument);
+        if (text === "--") {
+            offset++;
+            break;
+        }
+        if (bytes[0] !== 45 || bytes.length === 1)
+            break;
+        offset++;
+        for (let index = 1; index < bytes.length; index++) {
+            const flag = String.fromCharCode(bytes[index]);
+            if (flag === "r") {
+                options.raw = true;
+                continue;
+            }
+            if (flag === "e" || flag === "E" || flag === "s") {
+                options.terminal = flag;
+                continue;
+            }
+            if (!"adnNptui".includes(flag)) {
+                await context.diagnostic(concatShellValues(["read: -", bytes[index] < 128 ? flag : shellValueFromBytes(bytes.subarray(index, index + 1)), ": invalid option"]));
+                await context.stderr.write(new TextEncoder().encode(usage));
+                return 2;
+            }
+            let value;
+            if (index + 1 < bytes.length)
+                value = typeof argument === "string" ? argument.slice(index + 1) : shellValueFromBytes(bytes.subarray(index + 1));
+            else if (offset < args.length)
+                value = args[offset++];
+            else {
+                await context.diagnostic(`read: -${flag}: option requires an argument`);
+                await context.stderr.write(new TextEncoder().encode(usage));
+                return 2;
+            }
+            const valueText = shellValueText(value);
+            if (flag === "a")
+                options.array = value;
+            else if (flag === "d")
+                options.delimiter = (index + 1 < bytes.length ? bytes[index + 1] : shellValueBytes(value)[0]) ?? 0;
+            else if (flag === "p" || flag === "i")
+                options.terminal = flag;
+            else if (flag === "t") {
+                const milliseconds = timeout(valueText);
+                if (milliseconds === undefined) {
+                    await context.diagnostic(concatShellValues(["read: ", value, ": invalid timeout specification"]));
+                    return 1;
+                }
+                options.timeout = milliseconds;
+            }
+            else {
+                const number = decimal(valueText);
+                if (number === undefined) {
+                    const detail = flag === "u" ? "file descriptor specification" : `${valueText.startsWith("0x") || valueText.startsWith("0X") ? "hex " : ""}number`;
+                    await context.diagnostic(concatShellValues(["read: ", value, `: invalid ${detail}`]));
+                    return 1;
+                }
+                if (flag === "u") {
+                    options.descriptor = number;
+                    await validate(number);
+                }
+                else {
+                    options.count = number;
+                    options.exact ||= flag === "N";
+                }
+            }
+            break;
+        }
+    }
+    options.names = args.slice(offset);
+    return options;
+}
+export async function executeRead(nonTerminalInput, context) {
+    const diagnosedDescriptorFailure = Symbol("diagnosed read descriptor failure");
+    const inputs = [];
+    let input;
+    let observer;
+    let record;
+    let writer;
+    const operation = {};
+    let completion;
+    let closed = false;
+    const check = () => { context.signal.throwIfAborted(); if (closed)
+        throw new Error("Read invocation is closed"); };
+    const close = () => {
+        closed = true;
+        return completion ??= (async () => {
+            await Promise.allSettled([operation.work]);
+            let failure;
+            for (const release of [() => writer?.close(), () => record?.release(), ...inputs.map(lease => () => lease.release()), () => observer?.release()]) {
+                try {
+                    await release();
+                }
+                catch (reason) {
+                    failure ??= { reason };
+                }
+            }
+            if (failure)
+                throw failure.reason;
+        })();
+    };
+    context.registerCleanup(close);
+    const validate = async (descriptor) => {
+        check();
+        try {
+            context.input.validateOpen(descriptor);
+        }
+        catch (error) {
+            context.signal.throwIfAborted();
+            if (error instanceof FsError && error.code === "EBADF") {
+                await context.diagnostic(`read: ${descriptor}: invalid file descriptor: Bad file descriptor`);
+                throw diagnosedDescriptorFailure;
+            }
+            throw error;
+        }
+    };
+    const select = (descriptor) => {
+        check();
+        try {
+            input = context.input.borrow(descriptor);
+            inputs.push(input);
+        }
+        catch (error) {
+            context.signal.throwIfAborted();
+            if (!(error instanceof FsError && error.code === "EBADF"))
+                throw error;
+        }
+    };
+    const observe = (descriptor) => {
+        check();
+        try {
+            observer = context.input.observe(descriptor);
+        }
+        catch (error) {
+            context.signal.throwIfAborted();
+            if (!(error instanceof FsError && error.code === "EBADF"))
+                throw error;
+        }
+    };
+    const work = Promise.resolve().then(async () => {
+        check();
+        const options = await parse(context, validate);
+        check();
+        if (typeof options === "number")
+            return options;
+        if (options.timeout === 0) {
+            observe(options.descriptor);
+            check();
+            if (!observer)
+                return 1;
+            const { readiness } = await observer.probeRead();
+            check();
+            if (readiness === "ready")
+                return 0;
+            if (readiness === "blocked")
+                return 1;
+            if (readiness !== "unknown")
+                throw new TypeError("Invalid input readiness");
+            await context.diagnostic(observer.readable ? "read: input readiness is unknown for this cursor" : "read: descriptor readiness unavailable through this extension API");
+            return 1;
+        }
+        if (options.terminal !== undefined && !nonTerminalInput) {
+            await context.diagnostic(`read: -${options.terminal}: terminal input capabilities unavailable through this extension API`);
+            return 1;
+        }
+        const invalidName = async (name) => { await context.diagnostic(concatShellValues(["read: `", name, "': not a valid identifier"])); return 1; };
+        if (options.names[0] !== undefined && !identifier(shellValueText(options.names[0])))
+            return invalidName(options.names[0]);
+        if (options.array !== undefined && typeof context.bindings.openIndexed !== "function") {
+            await context.diagnostic("read: indexed writer unavailable through this extension API");
+            return 1;
+        }
+        const ifs = options.exact ? "" : context.bindings.get("IFS") ?? " \t\n";
+        select(options.descriptor);
+        check();
+        const inherited = options.timeout === undefined && options.count !== 0 ? context.bindings.get("TMOUT") : undefined;
+        const milliseconds = options.timeout ?? (inherited === undefined ? undefined : timeout(shellValueText(inherited)));
+        let timedOut = false;
+        if (!input && options.count !== 0) {
+            if (milliseconds !== undefined && milliseconds > 0) {
+                observe(options.descriptor);
+                check();
+                if (observer) {
+                    const probe = await observer.probeRead();
+                    check();
+                    const readyUnreadable = observer.readable === false && probe.readiness === "ready";
+                    if (probe.timeout !== "ignore" && !(readyUnreadable && probe.timeout === "unknown")) {
+                        if (probe.readiness === "unknown" || probe.timeout !== "honor") {
+                            await context.diagnostic("read: descriptor timeout observation unavailable through this extension API");
+                            return 1;
+                        }
+                        if (probe.readiness === "blocked") {
+                            const outcome = await observer.waitRead({ timeoutMs: milliseconds, signal: context.signal });
+                            check();
+                            if (outcome === "unknown") {
+                                await context.diagnostic("read: descriptor timeout observation unavailable through this extension API");
+                                return 1;
+                            }
+                            if (outcome !== "ready" && outcome !== "timeout")
+                                throw new TypeError("Invalid descriptor wait result");
+                            timedOut = outcome === "timeout";
+                        }
+                        else if (probe.readiness !== "ready")
+                            throw new TypeError("Invalid descriptor readiness");
+                    }
+                }
+            }
+            if (!timedOut) {
+                await context.diagnostic(`read: ${options.descriptor}: read error: Bad file descriptor`);
+                return 1;
+            }
+        }
+        record = await input?.read(options.raw, {
+            ...(options.count === undefined ? {} : { count: options.count }),
+            ...(options.delimiter === undefined ? {} : { delimiter: options.delimiter }),
+            exact: options.exact,
+            ...(options.count !== 0 && milliseconds !== undefined && milliseconds > 0 ? { timeoutMs: milliseconds } : {}),
+        });
+        check();
+        const status = timedOut || record?.reason === "timeout" ? 142 : record?.terminated ? 0 : 1;
+        if (options.array !== undefined) {
+            const name = shellValueText(options.array);
+            if (!identifier(name))
+                return invalidName(options.array);
+            if (context.bindings.describe(name).readonly) {
+                await context.diagnostic(`${name}: readonly variable`);
+                return 1;
+            }
+            writer = await context.bindings.openIndexed(name, { clear: true });
+            check();
+            const fields = await record?.fields(ifs) ?? [];
+            for (let index = 0; index < fields.length; index++) {
+                check();
+                await writer.set(index, fields[index].value);
+            }
+        }
+        else {
+            const names = options.names.length ? options.names : ["REPLY"];
+            const fields = options.names.length ? await record?.fields(ifs, names.length) ?? [] : undefined;
+            for (let index = 0; index < names.length; index++) {
+                check();
+                const original = names[index];
+                const name = shellValueText(original);
+                if (!identifier(name))
+                    return invalidName(original);
+                if (context.bindings.describe(name).readonly) {
+                    await context.diagnostic(`${name}: readonly variable`);
+                    return options.names.length === 0 || index < names.length - 1 ? 2 : 1;
+                }
+                await context.bindings.assign(name, fields ? fields[index]?.value ?? "" : record?.shellValue ?? "");
+            }
+        }
+        return status;
+    });
+    operation.work = work;
+    let result = 1;
+    let failure;
+    try {
+        result = await work;
+    }
+    catch (reason) {
+        if (reason === diagnosedDescriptorFailure)
+            result = 1;
+        else
+            failure = { reason };
+    }
+    try {
+        await close();
+    }
+    catch (reason) {
+        failure ??= { reason };
+    }
+    context.signal.throwIfAborted();
+    if (failure)
+        throw failure.reason;
+    return result;
+}
+//# sourceMappingURL=read-builtin.js.map

package/dist/safe-bash/shell/runtime.d.ts

@@ -66,6 +66,7 @@ export declare class Budget {
     private _wallClockTimer;
     private _wallClockDeadline;
     private _pipelineStages;
+    private pipelineBytes;
     private _fileSystemOperations;
     get fileSystemOperations(): number;
     private readonly _cpuStarted;
@@ -108,6 +109,8 @@ export declare class Budget {
     canFileSystemOperation(): boolean;
     get fsOperations(): number;
     set fsOperations(value: number);
+    readonly pipelineInput: (bytes: number) => void;
+    assertPipelineInput(bytes: number): void;
     reservePipelineStages(count: number): () => void;
     enterPipelineStages(count: number): void;
     leavePipelineStages(count: number): void;
@@ -190,6 +193,14 @@ export interface State extends DynamicVariableState {
     extglob?: boolean;
     globstar?: boolean;
     nullglob?: boolean;
+    failglob?: boolean;
+    lastpipe?: boolean;
+    inherit_errexit?: boolean;
+    expand_aliases?: boolean;
+    aliases?: Map<string, string>;
+    processSubstitutionIds?: {
+        next: number;
+    };
     nocaseglob?: boolean;
     nocasematch?: boolean;
     braceexpand?: boolean;
@@ -208,7 +219,15 @@ export interface State extends DynamicVariableState {
     hashedCommands?: Map<string, string>;
 }
 declare const declarationArrays: unique symbol;
+interface ExecDescriptorFrame {
+    version: number;
+    descriptors: Map<number, Descriptor>;
+    revisions: Map<number, number>;
+    releases: Map<number, () => Promise<void>>;
+}
 interface IO {
+    readonly execVersion?: number;
+    readonly execFrame?: ExecDescriptorFrame;
     /** Zeroth argument identity; command remains the name used for lookup. */
     readonly argv0?: string | undefined;
     readonly [declarationArrays]?: ReadonlyMap<number, ArrayAssignment> | undefined;
@@ -344,6 +363,7 @@ export { getRuntimeBackingFileSystem, interruptible, registerRuntimeBackingFileS
 export declare function clearRuntimePools(): void;
 export declare class Runtime {
     private readonly reuseDefaultContextFs;
+    private persistentIO;
     static clearStaticPools(): void;
     readonly commands: CommandRegistry;
     readonly middleware: readonly Middleware[];
@@ -484,11 +504,7 @@ export declare class Runtime {
     private tryFastSinglePipelineUnit;
     private finishFastSingleExternalUnit;
     private finishFastSingleExternalUnitAsync;
-    private executeFastPurePipelineUnit;
     private tryExecuteSyncPurePipelineUnit;
-    private executeFastPurePipelineUnitSlow;
-    private finishFastPurePipelineStageAsync;
-    private finishFastPurePipelineUnitAsync;
     private inputUnit;
     private trySyncPipeline;
     private canSyncCommandCompound;
@@ -597,6 +613,7 @@ export declare class Runtime {
     }>, outputs: Set<OutputFinalizer>, snapshotHolder: {
         scope?: InvocationScope;
         finish?: () => void;
+        persistentRedirects?: boolean;
     }, fileShortcut?: boolean, terminal?: IO["terminal"]): Promise<number>;
     private simpleWithSetup;
     getContextFsForFast(umask: number, signal: AbortSignal): FileSystem;
@@ -763,6 +780,9 @@ export declare class RootShellState implements State {
     } | undefined;
     dotglob: boolean;
     globstar: boolean;
+    processSubstitutionIds: {
+        next: number;
+    };
     status: number;
     substitutionStatus: number;
     lastArgument: string;