@poe-platform/safe-bash 0.1.630 → 0.1.631

package/dist/safe-bash/opt-in/commands/shuf/shuf.js

@@ -0,0 +1,230 @@
+import { commandRuntimeIdentity, getCommandArguments, isFsError, toByteSource, writeBytes, } from "@poe-platform/safe-bash/contracts/index";
+import { openFileOutput } from "@poe-platform/safe-bash/contracts/filesystem-output";
+import { yieldTurn } from "@poe-platform/safe-bash/contracts/yield";
+import { countMax, Diagnostic, fileQuote, parse, quote } from "./args.js";
+import { ownedBytes, records, virtualPath } from "./input.js";
+import { settings } from "./options.js";
+import { RandomIntegers } from "./random.js";
+import { shellValueByteLength } from "@poe-platform/safe-bash/contracts/value";
+const encoder = new TextEncoder();
+const errors = {
+    ENOENT: "No such file or directory", EACCES: "Permission denied", EPERM: "Operation not permitted",
+    EISDIR: "Is a directory", ENOTDIR: "Not a directory", EROFS: "Read-only file system",
+    EIO: "Input/output error", ENOSPC: "No space left on device", EPIPE: "Broken pipe",
+    ELOOP: "Too many levels of symbolic links", EBADF: "Bad file descriptor", ENAMETOOLONG: "File name too long",
+    EINVAL: "Invalid argument", EFBIG: "File too large", ENOTSUP: "Operation not supported",
+};
+export function createShufCommand(options = {}) {
+    const limits = settings(options);
+    return Object.freeze({
+        name: "shuf",
+        runtimeIdentity: commandRuntimeIdentity,
+        description: "Write a random permutation of input records",
+        async execute(context) {
+            let random;
+            let output;
+            let source;
+            let inputSource;
+            let openingInput;
+            const inputController = new AbortController();
+            const inputSignal = AbortSignal.any([context.signal, inputController.signal]);
+            let diagnostic = "read error";
+            let openingRootOutput = false;
+            let cleanup;
+            let closed = false;
+            let executionFailed = false;
+            const close = () => {
+                closed = true;
+                inputController.abort(new Error("shuf input is closed"));
+                return cleanup ??= (async () => {
+                    await openingInput?.catch(() => { });
+                    const results = await Promise.allSettled([source?.return(undefined), inputSource?.return(undefined), random?.close()]);
+                    const failed = results.find(result => result.status === "rejected");
+                    if (failed?.status === "rejected")
+                        throw failed.reason;
+                })();
+            };
+            context.registerCleanup?.(close);
+            try {
+                context.signal.throwIfAborted();
+                const parsed = parse(context);
+                if (parsed.action) {
+                    const { help, version } = await import("./usage.js");
+                    await writeBytes(context.stdout, encoder.encode(parsed.action === "help" ? help : version), context.signal);
+                    return { exitCode: 0 };
+                }
+                const lines = [];
+                let totalBytes = 0;
+                let size = parsed.count === 0n ? 0n : parsed.range?.size ?? 0n;
+                let reservoir = false;
+                if (parsed.count !== 0n && parsed.echo) {
+                    const argumentsOwned = getCommandArguments(context);
+                    for (const index of parsed.operands) {
+                        if (lines.length >= limits.maxSampleSize)
+                            throw new Diagnostic("shuf: maxSampleSize limit exceeded\n");
+                        totalBytes += shellValueByteLength(argumentsOwned.values[index]) + 1;
+                        if (totalBytes > limits.maxInputBytes)
+                            throw new Diagnostic("shuf: maxInputBytes limit exceeded\n");
+                        const bytes = argumentsOwned.bytes(index);
+                        const line = new Uint8Array(bytes.length + 1);
+                        line.set(bytes);
+                        line[bytes.length] = parsed.delimiter;
+                        lines.push(line);
+                    }
+                    size = BigInt(lines.length);
+                }
+                else if (parsed.count !== 0n && !parsed.range) {
+                    const name = parsed.operands.length ? context.args[parsed.operands[0]] : "-";
+                    let inputSize = Infinity;
+                    openingInput = Promise.resolve().then(async () => {
+                        inputSignal.throwIfAborted();
+                        let input;
+                        if (name === "-")
+                            input = context.stdin;
+                        else {
+                            diagnostic = fileQuote(name);
+                            const path = virtualPath(context.cwd, name);
+                            const stat = await context.fs.stat(path, { signal: inputSignal });
+                            if (stat.type === "file" && Number.isSafeInteger(stat.size) && stat.size >= 0)
+                                inputSize = stat.size;
+                            inputSignal.throwIfAborted();
+                            await context.fs.access(path, 4, { signal: inputSignal });
+                            inputSignal.throwIfAborted();
+                            if (context.fs.readStream)
+                                input = context.fs.readStream(path, { signal: inputSignal });
+                            else {
+                                const bytes = await context.fs.readFile(path, { signal: inputSignal, maxBytes: limits.maxInputBytes });
+                                if (bytes.byteLength > limits.maxInputBytes)
+                                    throw new Diagnostic("shuf: maxInputBytes limit exceeded\n");
+                                input = toByteSource(bytes);
+                            }
+                        }
+                        inputSource = ownedBytes(input, inputSignal);
+                        inputSignal.throwIfAborted();
+                        if (closed)
+                            throw new Error("shuf input is closed");
+                        source = records(inputSource, parsed.delimiter, limits.maxInputBytes, context.signal);
+                    });
+                    await openingInput;
+                    diagnostic = "read error";
+                    reservoir = !parsed.repeat && parsed.count < countMax && inputSize > 8 * 1024 * 1024;
+                    if (!reservoir) {
+                        for await (const line of source) {
+                            totalBytes += line.length;
+                            if (totalBytes > limits.maxInputBytes)
+                                throw new Diagnostic("shuf: maxInputBytes limit exceeded\n");
+                            if (lines.length >= limits.maxSampleSize)
+                                throw new Diagnostic("shuf: maxSampleSize limit exceeded\n");
+                            lines.push(line);
+                        }
+                        size = BigInt(lines.length);
+                    }
+                }
+                random = new RandomIntegers(context, parsed.random, limits.maxInputBytes);
+                const count = parsed.repeat || parsed.count < size ? parsed.count : size;
+                diagnostic = fileQuote(parsed.random ?? "getrandom");
+                if (reservoir || parsed.repeat || count > 0n)
+                    await random.open();
+                diagnostic = parsed.random === undefined ? "getrandom" : `${quote(parsed.random)}: read error`;
+                if (reservoir) {
+                    let seen = 0n;
+                    while (seen < parsed.count) {
+                        diagnostic = "read error";
+                        const next = await source.next();
+                        if (next.done)
+                            break;
+                        totalBytes += next.value.length;
+                        if (totalBytes > limits.maxInputBytes)
+                            throw new Diagnostic("shuf: maxInputBytes limit exceeded\n");
+                        if (lines.length >= limits.maxSampleSize)
+                            throw new Diagnostic("shuf: maxSampleSize limit exceeded\n");
+                        lines.push(next.value);
+                        seen++;
+                    }
+                    if (seen === parsed.count) {
+                        while (true) {
+                            diagnostic = parsed.random === undefined ? "getrandom" : `${quote(parsed.random)}: read error`;
+                            const chosen = await random.choose(seen + 1n);
+                            diagnostic = "read error";
+                            const next = await source.next();
+                            if (next.done)
+                                break;
+                            if (chosen < parsed.count) {
+                                const index = Number(chosen);
+                                totalBytes += next.value.length - lines[index].length;
+                                if (totalBytes > limits.maxInputBytes)
+                                    throw new Diagnostic("shuf: maxInputBytes limit exceeded\n");
+                                lines[index] = next.value;
+                            }
+                            seen++;
+                            if (seen % 1024n === 0n)
+                                await yieldTurn(context.signal);
+                        }
+                    }
+                    size = BigInt(lines.length);
+                }
+                const ahead = parsed.repeat || parsed.count < size ? parsed.count : size;
+                const permutation = [];
+                diagnostic = parsed.random === undefined ? "getrandom" : `${quote(parsed.random)}: read error`;
+                if (!parsed.repeat) {
+                    if (ahead > BigInt(limits.maxSampleSize))
+                        throw new Diagnostic("shuf: maxSampleSize limit exceeded\n");
+                    const swaps = new Map();
+                    for (let index = 0n; index < ahead; index++) {
+                        const chosen = index + await random.choose(size - index);
+                        permutation.push(swaps.get(chosen) ?? chosen);
+                        swaps.set(chosen, swaps.get(index) ?? index);
+                        swaps.delete(index);
+                        if (index % 1024n === 1023n)
+                            await yieldTurn(context.signal);
+                    }
+                }
+                if (parsed.output !== undefined) {
+                    diagnostic = fileQuote(parsed.output);
+                    openingRootOutput = parsed.output.length > 0 && Array.from(parsed.output).every(character => character === "/");
+                    output = await openFileOutput(context, virtualPath(context.cwd, parsed.output), "w");
+                    openingRootOutput = false;
+                }
+                if (parsed.repeat && parsed.count > 0n && size === 0n)
+                    throw new Diagnostic("shuf: no lines to repeat\n");
+                const sink = output?.sink ?? context.stdout;
+                for (let index = 0n; index < ahead; index++) {
+                    context.signal.throwIfAborted();
+                    diagnostic = parsed.random === undefined ? "getrandom" : `${quote(parsed.random)}: read error`;
+                    const chosen = parsed.repeat ? await random.choose(size) : permutation[Number(index)];
+                    const line = parsed.range ? encoder.encode(`${parsed.range.low + chosen}${parsed.delimiter === 0 ? "\0" : "\n"}`) : lines[Number(chosen)];
+                    diagnostic = "write error";
+                    await writeBytes(sink, line, context.signal);
+                    if (index % 256n === 255n)
+                        await yieldTurn(context.signal);
+                }
+                if (output)
+                    await output.finish();
+                context.signal.throwIfAborted();
+                return { exitCode: 0 };
+            }
+            catch (error) {
+                executionFailed = true;
+                if (output)
+                    await output.abort(error);
+                context.signal.throwIfAborted();
+                if (isFsError(error) && error.code === "EPIPE" && diagnostic === "write error")
+                    return { exitCode: 141 };
+                if (!(error instanceof Diagnostic) && !isFsError(error))
+                    throw error;
+                const message = error instanceof Diagnostic ? error.message : `shuf: ${diagnostic}: ${openingRootOutput && error.code === "EISDIR" ? "File exists" : errors[error.code] ?? error.code}\n`;
+                await writeBytes(context.stderr, error instanceof Diagnostic && error.bytes ? error.bytes : encoder.encode(message), context.signal);
+                return { exitCode: 1 };
+            }
+            finally {
+                try {
+                    await close().catch(error => { if (!executionFailed)
+                        throw error; });
+                }
+                finally {
+                    context.signal.throwIfAborted();
+                }
+            }
+        },
+    });
+}

package/dist/safe-bash/opt-in/commands/shuf/usage.js

@@ -0,0 +1,24 @@
+export const help = `Usage: shuf [OPTION]... [FILE]
+  or:  shuf -e [OPTION]... [ARG]...
+  or:  shuf -i LO-HI [OPTION]...
+Write a random permutation of the input lines to standard output.
+
+With no FILE, or when FILE is -, read standard input.
+
+Mandatory arguments to long options are mandatory for short options too.
+  -e, --echo                treat each ARG as an input line
+  -i, --input-range=LO-HI   treat each number LO through HI as an input line
+  -n, --head-count=COUNT    output at most COUNT lines
+  -o, --output=FILE         write result to FILE instead of standard output
+      --random-source=FILE  get random bytes from FILE
+  -r, --repeat              output lines can be repeated
+  -z, --zero-terminated     line delimiter is NUL, not newline
+      --help        display this help and exit
+      --version     output version information and exit
+
+GNU coreutils online help: <https://www.gnu.org/software/coreutils/>
+Report any translation bugs to <https://translationproject.org/team/>
+Full documentation <https://www.gnu.org/software/coreutils/shuf>
+or available locally via: info '(coreutils) shuf invocation'
+`;
+export const version = "shuf (virtual-bash, GNU coreutils 9.7 profile)\n";

package/dist/safe-bash/opt-in/commands/truncate/arguments.js

@@ -0,0 +1,186 @@
+export const maximumSize = (1n << 63n) - 1n;
+export const minimumSize = -(1n << 63n);
+export class TruncateError extends Error {
+    usage;
+    raw;
+    constructor(message, usage = false, raw = false) {
+        super(message);
+        this.usage = usage;
+        this.raw = raw;
+    }
+}
+export function argumentBytes(value) {
+    return Uint8Array.from(value, character => character.charCodeAt(0));
+}
+const escapes = new Map([[7, "a"], [8, "b"], [9, "t"], [10, "n"], [11, "v"], [12, "f"], [13, "r"]]);
+export function quote(value, numeric = false) {
+    const bytes = argumentBytes(value);
+    if (!numeric && bytes.every(byte => byte >= 32 && byte < 127)) {
+        return value.includes("'") && !["\"", "$", "`", "\\"].some(character => value.includes(character))
+            ? `"${value}"` : `'${value.replaceAll("'", "'\\''")}'`;
+    }
+    let result = "'", escaped = false;
+    for (const byte of bytes) {
+        const special = byte < 32 || byte >= 127;
+        if (!numeric && special !== escaped) {
+            result += special ? "'$'" : "''";
+            escaped = special;
+        }
+        result += special ? `\\${escapes.get(byte) ?? byte.toString(8).padStart(3, "0")}`
+            : numeric && (byte === 39 || byte === 92) ? `\\${String.fromCharCode(byte)}`
+                : byte === 39 ? "'\\''" : String.fromCharCode(byte);
+    }
+    return `${result}'`;
+}
+function skipSpace(value) {
+    let offset = 0;
+    while (offset < value.length && " \t\n\r\v\f".includes(value[offset]))
+        offset++;
+    return value.slice(offset);
+}
+function parseSize(value, previousMode) {
+    let text = skipSpace(value), mode = previousMode;
+    if (text[0] === "<" || text[0] === ">" || text[0] === "/" || text[0] === "%") {
+        mode = text[0];
+        text = skipSpace(text.slice(1));
+    }
+    if (text[0] === "+" || text[0] === "-") {
+        if (mode !== "absolute")
+            throw new TruncateError("multiple relative modifiers specified", true);
+        mode = "relative";
+    }
+    const negative = text[0] === "-", signed = negative || text[0] === "+";
+    let offset = signed ? 1 : 0, amount = 0n;
+    const start = offset;
+    while (offset < text.length && text[offset] >= "0" && text[offset] <= "9") {
+        if (amount <= maximumSize + 1n)
+            amount = amount * 10n + BigInt(text.charCodeAt(offset) - 48);
+        offset++;
+    }
+    const suffix = text.slice(offset);
+    const invalid = () => new TruncateError(`Invalid number: ${quote(text, true)}`);
+    if (offset === start) {
+        if (signed || !suffix)
+            throw invalid();
+        amount = 1n;
+    }
+    if (suffix) {
+        const powers = { k: 1, K: 1, m: 2, M: 2, g: 3, G: 3, t: 4, T: 4, P: 5, E: 6, Z: 7, Y: 8, R: 9, Q: 10 };
+        const power = powers[suffix[0]], tail = suffix.slice(1);
+        if (power === undefined || (tail !== "" && tail !== "B" && tail !== "D" && tail !== "iB"))
+            throw invalid();
+        amount *= (tail === "B" || tail === "D" ? 1000n : 1024n) ** BigInt(power);
+    }
+    if (negative)
+        amount = -amount;
+    if (amount < minimumSize || amount > maximumSize)
+        throw new TruncateError(`Invalid number: ${quote(text, true)}: Value too large to be stored in data type`);
+    if ((mode === "/" || mode === "%") && amount === 0n)
+        throw new TruncateError("division by zero");
+    return { size: amount, mode };
+}
+export function parseArguments(args, posix, owned) {
+    const readArgument = (index) => {
+        const value = args[index];
+        if (value === undefined)
+            return undefined;
+        return Array.from(owned?.bytes(index) ?? new TextEncoder().encode(value), byte => String.fromCharCode(byte)).join("");
+    };
+    const files = [];
+    let noCreate = false, ioBlocks = false, ended = false;
+    let reference, size, mode = "absolute";
+    const longOptions = { "no-create": "c", "io-blocks": "o", reference: "r", size: "s", help: "help", version: "version" };
+    for (let index = 0; index < args.length; index++) {
+        const argument = readArgument(index);
+        if (ended || argument === "-" || !argument.startsWith("-")) {
+            files.push(argument);
+            if (posix)
+                ended = true;
+            continue;
+        }
+        if (argument === "--") {
+            ended = true;
+            continue;
+        }
+        const long = argument.startsWith("--");
+        const equals = argument.indexOf("=");
+        let name = argument.slice(2, equals < 0 ? undefined : equals);
+        let keys = argument.slice(1);
+        if (long) {
+            const matching = Object.keys(longOptions).filter(option => option.startsWith(name));
+            const matched = Object.hasOwn(longOptions, name) ? name : matching[0];
+            if (!matched)
+                throw new TruncateError(`unrecognized option '${argument}'`, true, true);
+            if (!Object.hasOwn(longOptions, name) && matching.length > 1)
+                throw new TruncateError(`option '${argument}' is ambiguous; possibilities: ${matching.map(option => `'--${option}'`).join(" ")}`, true, true);
+            keys = longOptions[matched];
+            name = matched;
+        }
+        if (long && (keys === "help" || keys === "version")) {
+            if (equals >= 0)
+                throw new TruncateError(`option '--${name}' doesn't allow an argument`, true);
+            return { files, noCreate, ioBlocks, mode, display: keys };
+        }
+        for (let offset = 0; offset < keys.length; offset++) {
+            const key = keys[offset];
+            if (key !== "c" && key !== "o" && key !== "r" && key !== "s")
+                throw new TruncateError(`invalid option -- '${key}'`, true, true);
+            if (key === "c" || key === "o") {
+                if (long && equals >= 0)
+                    throw new TruncateError(`option '--${name}' doesn't allow an argument`, true);
+                if (key === "c")
+                    noCreate = true;
+                else
+                    ioBlocks = true;
+                continue;
+            }
+            const value = long ? equals >= 0 ? argument.slice(equals + 1) : readArgument(++index) : keys.slice(offset + 1) || readArgument(++index);
+            if (value === undefined)
+                throw new TruncateError(long ? `option '--${name}' requires an argument` : `option requires an argument -- '${key}'`, true);
+            if (key === "r")
+                reference = value;
+            else
+                ({ size, mode } = parseSize(value, mode));
+            break;
+        }
+    }
+    if (reference === undefined && size === undefined)
+        throw new TruncateError("you must specify either '--size' or '--reference'", true);
+    if (reference !== undefined && size !== undefined && mode === "absolute")
+        throw new TruncateError("you must specify a relative '--size' with '--reference'", true);
+    if (ioBlocks && size === undefined)
+        throw new TruncateError("'--io-blocks' was specified but '--size' was not", true);
+    if (files.length === 0)
+        throw new TruncateError("missing file operand", true);
+    return { files, noCreate, ioBlocks, mode, ...(reference === undefined ? {} : { reference }), ...(size === undefined ? {} : { size }) };
+}
+export const helpText = `Usage: truncate OPTION... FILE...
+Shrink or extend the size of each FILE to the specified size
+
+A FILE argument that does not exist is created.
+
+If a FILE is larger than the specified size, the extra data is lost.
+If a FILE is shorter, it is extended and the sparse extended part (hole)
+reads as zero bytes.
+
+Mandatory arguments to long options are mandatory for short options too.
+  -c, --no-create        do not create any files
+  -o, --io-blocks        treat SIZE as number of IO blocks instead of bytes
+  -r, --reference=RFILE  base size on RFILE
+  -s, --size=SIZE        set or adjust the file size by SIZE bytes
+      --help        display this help and exit
+      --version     output version information and exit
+
+The SIZE argument is an integer and optional unit (example: 10K is 10*1024).
+Units are K,M,G,T,P,E,Z,Y,R,Q (powers of 1024) or KB,MB,... (powers of 1000).
+Binary prefixes can be used, too: KiB=K, MiB=M, and so on.
+
+SIZE may also be prefixed by one of the following modifying characters:
+'+' extend by, '-' reduce by, '<' at most, '>' at least,
+'/' round down to multiple of, '%' round up to multiple of.
+
+GNU coreutils online help: <https://www.gnu.org/software/coreutils/>
+Report any translation bugs to <https://translationproject.org/team/>
+Full documentation <https://www.gnu.org/software/coreutils/truncate>
+or available locally via: info '(coreutils) truncate invocation'
+`;

package/dist/safe-bash/opt-in/commands/truncate/index.d.ts

@@ -0,0 +1,9 @@
+import { type CommandContext, type CommandDefinition, type FileStat, type VirtualShellPlugin } from "@poe-platform/safe-bash/contracts/index";
+export interface TruncateCommandsOptions {
+    readonly replace?: boolean;
+    readonly ioBlockSize?: (path: string, stat: FileStat, context: CommandContext) => number | Promise<number>;
+    readonly seekEnd?: (path: string, stat: FileStat, context: CommandContext) => number | Promise<number>;
+}
+export declare function createTruncateCommand(options?: TruncateCommandsOptions): CommandDefinition;
+export declare function createTruncateCommands(options?: TruncateCommandsOptions): readonly CommandDefinition[];
+export declare function truncateCommands(options?: TruncateCommandsOptions): VirtualShellPlugin;