@poe-platform/safe-bash 0.1.629 → 0.1.631

package/dist/safe-bash/opt-in/commands/dd/io.js

@@ -0,0 +1,244 @@
+import { FsError, readBytes, toByteSource } from "@poe-platform/safe-fs";
+import { writeBytes } from "@poe-platform/safe-bash/contracts/io";
+import { openFileOutput, writeFileOutputCounted } from "@poe-platform/safe-bash/contracts/filesystem-output";
+import { openCommandFile } from "@poe-platform/safe-bash/contracts/filesystem-descriptor";
+import { yieldTurn } from "@poe-platform/safe-bash/contracts/yield";
+import { DdError } from "./options.js";
+const countedHandles = new WeakSet();
+export async function writeDdOutput(context, handle, chunk, options, named) {
+    if (!handle.write)
+        throw new FsError("EBADF");
+    return named && !countedHandles.has(handle)
+        ? writeFileOutputCounted(context, chunk, () => handle.write(chunk, options)) : handle.write(chunk, options);
+}
+async function openDescriptor(context, path, request) {
+    const input = request.direction === "input";
+    const descriptor = await openCommandFile(context, path, {
+        access: input ? "read" : "write",
+        creation: input || request.creation === "never" ? "never" : request.creation === "exclusive" ? "exclusive" : "ifMissing",
+        truncate: request.truncate,
+        append: !input && request.flags.has("append"),
+        ...(request.synchronization === undefined ? {} : { synchronization: request.synchronization }),
+    });
+    try {
+        const stat = await descriptor.stat();
+        if (!Number.isSafeInteger(stat.size) || stat.size < 0)
+            throw new FsError("EIO", { path, syscall: "fstat" });
+        const positioned = input ? descriptor.capabilities.positionedRead : descriptor.capabilities.positionedWrite;
+        let position = 0;
+        let closed = false;
+        const handle = {
+            size: BigInt(stat.size), type: stat.type,
+            async getSize(options) {
+                const current = await descriptor.stat(options);
+                if (!Number.isSafeInteger(current.size) || current.size < 0)
+                    throw new FsError("EIO", { path, syscall: "fstat" });
+                return BigInt(current.size);
+            },
+            ...(descriptor.capabilities.position === true && descriptor.getPosition ? {
+                async getPosition(options) {
+                    const cursor = await descriptor.getPosition(options);
+                    if (!Number.isSafeInteger(position) || position < 0)
+                        throw new FsError("EIO", { path, syscall: "getPosition" });
+                    return BigInt(positioned ? position : cursor);
+                },
+            } : {}),
+            ...(input ? { async read(size, options) {
+                    const buffer = new Uint8Array(size);
+                    const count = await descriptor.read(buffer, positioned ? position : null, options);
+                    if (!Number.isSafeInteger(count) || count < 0 || count > size)
+                        throw new FsError("EIO", { path, syscall: "read" });
+                    position += count;
+                    return buffer.subarray(0, count);
+                } } : { async write(chunk, options) {
+                    const count = await descriptor.write(chunk, positioned ? position : null, options);
+                    position += count;
+                    return count;
+                } }),
+            ...(positioned ? { async seek(offset, options) {
+                    context.signal.throwIfAborted();
+                    options.signal?.throwIfAborted();
+                    if (closed)
+                        throw new FsError("EBADF", { path, syscall: "seek" });
+                    if (offset < 0n || offset > BigInt(Number.MAX_SAFE_INTEGER))
+                        throw new DdError(`${input ? "input" : "output"} offset limit exceeded`);
+                    position = Number(offset);
+                } } : {}),
+            ...(descriptor.capabilities.truncate ? { async truncate(length, options) {
+                    if (length < 0n || length > BigInt(Number.MAX_SAFE_INTEGER))
+                        throw new DdError("output offset limit exceeded");
+                    await descriptor.truncate(Number(length), options);
+                } } : {}),
+            ...(descriptor.capabilities.synchronization !== "none" ? { sync: descriptor.sync } : {}),
+            close() { closed = true; return descriptor.close(); },
+            acknowledgeCloseFailure: descriptor.acknowledgeCloseFailure,
+        };
+        if (!input)
+            countedHandles.add(handle);
+        return handle;
+    }
+    catch (error) {
+        try {
+            await descriptor.close();
+        }
+        catch { }
+        context.signal.throwIfAborted();
+        throw error;
+    }
+}
+export function errorMessage(error) {
+    const descriptions = {
+        ENOENT: "No such file or directory", EACCES: "Permission denied", EPERM: "Operation not permitted",
+        EEXIST: "File exists", EISDIR: "Is a directory", ENOTDIR: "Not a directory", ELOOP: "Too many levels of symbolic links",
+        EIO: "Input/output error", ENOTSUP: "Operation not supported", EROFS: "Read-only file system",
+        EFBIG: "File too large", ENOSPC: "No space left on device", EPIPE: "Broken pipe", EINVAL: "Invalid argument",
+        EAGAIN: "Resource temporarily unavailable", ESPIPE: "Illegal seek", EBADF: "Bad file descriptor",
+    };
+    if (error instanceof DdError)
+        return error.message;
+    if (typeof error === "object" && error !== null && "code" in error) {
+        const description = descriptions[String(error.code)];
+        if (description)
+            return description;
+    }
+    return error instanceof Error ? error.message : String(error);
+}
+export async function openDdFile(context, request) {
+    const signal = context.signal;
+    signal.throwIfAborted();
+    for (const flag of request.flags) {
+        if (["binary", "text", "noctty", "count_bytes", "skip_bytes", "seek_bytes", "fullblock"].includes(flag))
+            continue;
+        if (flag === "append")
+            continue;
+        if (request.path === undefined && flag === "nofollow")
+            continue;
+        throw new DdError(`${flag}: Operation not supported by the filesystem stream adapter`);
+    }
+    const path = request.path === undefined || request.path === "" ? request.path
+        : request.path.startsWith("/") ? request.path : `${context.cwd}/${request.path}`;
+    if (path !== undefined && context.fs.open) {
+        const capabilities = await context.fs.capabilitiesFor?.(path, { signal }) ?? context.fs.capabilities;
+        if (capabilities.open !== false && (request.direction !== "input" || (await context.fs.stat(path, { signal })).type !== "directory"))
+            return openDescriptor(context, path, request);
+    }
+    if (request.synchronization)
+        throw new DdError(`${request.synchronization === "all" ? "fsync" : "fdatasync"}: Operation not supported by the filesystem stream adapter`);
+    if (request.direction === "output" && request.flags.has("append") && request.truncate)
+        throw new DdError("append with truncation: Operation not supported by the filesystem stream adapter");
+    if (request.direction === "input") {
+        const stat = path === undefined ? undefined : await context.fs.stat(path, { signal });
+        if (path !== undefined)
+            await context.fs.access(path, 4, { signal });
+        let position = 0n;
+        let iterator;
+        let pending = new Uint8Array();
+        let consumed = 0;
+        let pulls = 0;
+        let closed = false;
+        const capabilities = path === undefined ? undefined : await context.fs.capabilitiesFor?.(path, { signal }) ?? context.fs.capabilities;
+        const streaming = path !== undefined && context.fs.readStream && capabilities?.streamingRead !== false;
+        const source = () => {
+            if (path === undefined)
+                return context.stdin;
+            if (stat?.type === "directory")
+                return { async *[Symbol.asyncIterator]() { yield* []; throw new FsError("EISDIR", { path }); } };
+            if (streaming)
+                return context.fs.readStream(path, { signal, start: Number(position), chunkSize: request.blockSize });
+            return { async *[Symbol.asyncIterator]() {
+                    const value = await context.fs.readFile(path, { signal, maxBytes: request.maxBufferBytes });
+                    yield* toByteSource(value);
+                } };
+        };
+        const closeIterator = async () => {
+            const current = iterator;
+            iterator = undefined;
+            pending = new Uint8Array();
+            consumed = 0;
+            await current?.return?.();
+        };
+        return {
+            ...(stat === undefined ? {} : { size: BigInt(stat.size), type: stat.type }),
+            async read(size) {
+                signal.throwIfAborted();
+                if (closed)
+                    throw new FsError("EBADF");
+                iterator ??= readBytes(source(), signal)[Symbol.asyncIterator]();
+                while (consumed === pending.length) {
+                    if (++pulls > request.maxReadOperations)
+                        throw new DdError("input operation limit exceeded");
+                    const result = await iterator.next();
+                    if (result.done)
+                        return new Uint8Array();
+                    if (result.value.byteLength > request.maxBufferBytes)
+                        throw new DdError("input buffer limit exceeded");
+                    pending = new Uint8Array(result.value);
+                    consumed = 0;
+                    if (pending.length === 0)
+                        await yieldTurn(signal);
+                }
+                const count = Math.min(size, pending.length - consumed);
+                const result = new Uint8Array(pending.subarray(consumed, consumed + count));
+                consumed += count;
+                position += BigInt(count);
+                return result;
+            },
+            ...(streaming && stat?.type === "file" ? { async seek(offset) {
+                    signal.throwIfAborted();
+                    if (offset < 0n || offset > BigInt(Number.MAX_SAFE_INTEGER))
+                        throw new DdError("input offset limit exceeded");
+                    await closeIterator();
+                    position = offset;
+                } } : {}),
+            async close() { closed = true; await closeIterator(); },
+        };
+    }
+    if (request.seek !== 0n || path !== undefined && (!request.truncate && !request.flags.has("append") || request.creation === "never")) {
+        throw new DdError("positioned or existing-only output: Operation not supported by the filesystem stream adapter");
+    }
+    if (path === undefined)
+        return {
+            async write(chunk) { await writeBytes(context.stdout, chunk, signal); return chunk.length; },
+            async close() { },
+        };
+    const capabilities = await context.fs.capabilitiesFor?.(path, { signal }) ?? context.fs.capabilities;
+    const flag = request.creation === "exclusive" ? request.flags.has("append") ? "ax" : "wx" : request.flags.has("append") ? "a" : "w";
+    if (!context.fs.writeStream || capabilities.streamingWrite === false)
+        throw new DdError("streaming output: Operation not supported by the filesystem");
+    if (request.creation === "exclusive" && capabilities.exclusiveCreate !== true)
+        throw new DdError("exclusive creation: Operation not supported by the filesystem");
+    if (request.flags.has("append") && capabilities.streamingAppend === false)
+        throw new DdError("streaming append: Operation not supported by the filesystem");
+    const fs = new Proxy(context.fs, { get(target, property) {
+            if (property === "writeStream")
+                return (destination, source, options) => target.writeStream(destination, source, { ...options, flag });
+            if (property === "appendFile" || property === "writeFile")
+                return () => { throw new FsError("ENOTSUP", { path }); };
+            const value = Reflect.get(target, property, target);
+            return typeof value === "function" ? value.bind(target) : value;
+        } });
+    const target = await openFileOutput({ ...context, fs }, path, request.creation === "exclusive" ? { flag: "wx" } : request.flags.has("append") ? "a" : "w");
+    let closed;
+    let failed;
+    const handle = {
+        async write(chunk) {
+            signal.throwIfAborted();
+            if (closed)
+                throw new FsError("EBADF");
+            try {
+                await target.sink.write(chunk);
+            }
+            catch (reason) {
+                failed ??= { reason };
+                throw reason;
+            }
+            return chunk.length;
+        },
+        close() {
+            closed ??= signal.aborted ? target.abort(signal.reason) : failed ? target.abort(failed.reason) : target.finish();
+            return closed;
+        },
+    };
+    countedHandles.add(handle);
+    return handle;
+}

package/dist/safe-bash/opt-in/commands/dd/options.js

@@ -0,0 +1,184 @@
+export const conversions = new Set(["ascii", "ebcdic", "ibm", "block", "unblock", "lcase", "ucase", "sparse", "swab", "sync", "noerror", "notrunc", "excl", "nocreat", "fdatasync", "fsync"]);
+export const flags = new Set(["append", "binary", "text", "cio", "direct", "directory", "dsync", "noatime", "nocache", "noctty", "nofollow", "nolinks", "nonblock", "sync", "fullblock", "count_bytes", "skip_bytes", "seek_bytes"]);
+const maxInteger = (1n << 63n) - 1n;
+export class DdError extends Error {
+    usage;
+    warnings;
+    constructor(message, usage = false, warnings = []) {
+        super(message);
+        this.usage = usage;
+        this.warnings = warnings;
+    }
+}
+export function quote(text, style = "shell") {
+    if (style === "shell" && text.includes("'") && !["$", "`", "\\", '"'].some(character => text.includes(character))
+        && [...text].every(character => character >= " " && character <= "~"))
+        return `"${text}"`;
+    let result = "'";
+    let escaped = false;
+    const escapes = new Map([[7, "a"], [8, "b"], [9, "t"], [10, "n"], [11, "v"], [12, "f"], [13, "r"]]);
+    for (const byte of new TextEncoder().encode(text)) {
+        const special = byte < 32 || byte >= 127;
+        if (style === "locale") {
+            result += special ? `\\${escapes.get(byte) ?? byte.toString(8).padStart(3, "0")}`
+                : byte === 39 || byte === 92 ? `\\${String.fromCharCode(byte)}` : String.fromCharCode(byte);
+            continue;
+        }
+        if (special !== escaped) {
+            result += special ? "'$'" : "''";
+            escaped = special;
+        }
+        result += special ? `\\${escapes.get(byte) ?? byte.toString(8).padStart(3, "0")}`
+            : byte === 39 ? "'\\''" : String.fromCharCode(byte);
+    }
+    return `${result}'`;
+}
+function numberValue(text, warnings) {
+    let product = 1n;
+    let overflow = false;
+    const invalid = () => { throw new DdError(`invalid number: ${quote(text)}`, false, warnings); };
+    for (const factor of text.split("x")) {
+        let offset = 0;
+        while (offset < factor.length && " \t\r\n\v\f".includes(factor[offset]))
+            offset++;
+        if (factor[offset] === "+")
+            offset++;
+        const start = offset;
+        let value = 0n;
+        while (offset < factor.length && factor[offset] >= "0" && factor[offset] <= "9") {
+            if (value <= maxInteger)
+                value = value * 10n + BigInt(factor[offset]);
+            offset++;
+        }
+        const suffix = factor.slice(offset);
+        if (offset === start) {
+            if (!suffix || !"bcEGkKMPQRTwYZ".includes(suffix[0]))
+                invalid();
+            value = 1n;
+        }
+        let multiplier = 1n;
+        if (suffix === "b" || suffix === "bB")
+            multiplier = 512n;
+        else if (suffix === "w" || suffix === "wB")
+            multiplier = 2n;
+        else if (suffix !== "" && suffix !== "B" && suffix !== "c" && suffix !== "cB") {
+            const power = "KMGTPEZYRQ".indexOf(suffix[0].toUpperCase()) + 1;
+            const tail = suffix.slice(1);
+            if (!power || !["", "B", "iB", "D"].includes(tail) || !"kKMGTPEZYRQ".includes(suffix[0]))
+                invalid();
+            multiplier = (tail === "B" || tail === "D" ? 1000n : 1024n) ** BigInt(power);
+        }
+        value *= multiplier;
+        if (value > maxInteger)
+            overflow = true;
+        product *= value > maxInteger ? maxInteger + 1n : value;
+        if (product > maxInteger) {
+            overflow = true;
+            product = maxInteger + 1n;
+        }
+    }
+    for (const factor of text.split("x").slice(0, -1)) {
+        if (factor === "0" && product === 0n)
+            warnings.push("warning: '0x' is a zero multiplier; use '00x' if that is intended");
+    }
+    if (product !== 0n && overflow)
+        throw new DdError(`invalid number: ${quote(text)}: Value too large to be stored in data type`, false, warnings);
+    return product;
+}
+export function parseDd(args) {
+    for (const argument of args) {
+        if (argument === "--")
+            break;
+        if (argument.startsWith("--") && argument.length > 2) {
+            const option = argument.split("=")[0];
+            for (const name of ["help", "version"]) {
+                if (`--${name}`.startsWith(option)) {
+                    if (argument.includes("="))
+                        throw new DdError(`option '--${name}' doesn't allow an argument`, true);
+                    return name;
+                }
+            }
+            throw new DdError(`unrecognized option \`${argument}'`, true);
+        }
+        if (argument.startsWith("-") && argument !== "-")
+            throw new DdError(`invalid option -- ${quote(argument[1], "locale")}`, true);
+    }
+    const plan = { ibs: 512n, obs: 512n, cbs: 0n, countBytes: false, skip: 0n, seek: 0n,
+        skipBytes: false, seekBytes: false, convert: new Set(), inputFlags: new Set(), outputFlags: new Set(),
+        status: "default", twoBuffers: true, warnings: [] };
+    let blockSize;
+    let delimiter = false;
+    for (const argument of args) {
+        if (argument === "--" && !delimiter) {
+            delimiter = true;
+            continue;
+        }
+        const boundary = argument.indexOf("=");
+        const name = argument.slice(0, boundary), value = argument.slice(boundary + 1);
+        if (boundary < 0)
+            throw new DdError(`unrecognized operand ${quote(argument)}`, true, plan.warnings);
+        if (name === "if")
+            plan.input = value;
+        else if (name === "of")
+            plan.output = value;
+        else if (["conv", "iflag", "oflag", "status"].includes(name)) {
+            const allowed = name === "conv" ? conversions : name === "status" ? new Set(["none", "noxfer", "progress"]) : flags;
+            const category = name === "conv" ? "conversion" : name === "status" ? "status level" : name === "iflag" ? "input flag" : "output flag";
+            for (const symbol of value.split(",")) {
+                if (!allowed.has(symbol) || name === "oflag" && symbol === "fullblock")
+                    throw new DdError(`invalid ${category}: ${quote(symbol, "locale")}`, true, plan.warnings);
+                if (name === "status")
+                    plan.status = symbol;
+                else
+                    (name === "conv" ? plan.convert : name === "iflag" ? plan.inputFlags : plan.outputFlags).add(symbol);
+            }
+        }
+        else {
+            if (!["bs", "ibs", "obs", "cbs", "count", "skip", "iseek", "seek", "oseek"].includes(name)) {
+                throw new DdError(`unrecognized operand ${quote(argument)}`, true, plan.warnings);
+            }
+            const number = numberValue(value, plan.warnings);
+            if (["bs", "ibs", "obs", "cbs"].includes(name) && number === 0n)
+                throw new DdError(`invalid number: ${quote(value)}`, false, plan.warnings);
+            if (["bs", "ibs", "obs"].includes(name) && number === maxInteger)
+                throw new DdError(`invalid number: ${quote(value)}: Value too large to be stored in data type`, false, plan.warnings);
+            if (name === "bs")
+                blockSize = number;
+            else if (name === "ibs" || name === "obs" || name === "cbs")
+                plan[name] = number;
+            else if (name === "count") {
+                plan.count = number;
+                plan.countBytes = value.includes("B");
+            }
+            else if (name === "skip" || name === "iseek") {
+                plan.skip = number;
+                plan.skipBytes = value.includes("B");
+            }
+            else {
+                plan.seek = number;
+                plan.seekBytes = value.includes("B");
+            }
+        }
+    }
+    if (blockSize !== undefined)
+        plan.ibs = plan.obs = blockSize;
+    plan.twoBuffers = blockSize === undefined || [...plan.convert].some(value => ["ascii", "ebcdic", "ibm", "block", "unblock", "lcase", "ucase", "swab"].includes(value));
+    if (plan.convert.has("ascii"))
+        plan.convert.add("unblock");
+    if (plan.convert.has("ebcdic") || plan.convert.has("ibm"))
+        plan.convert.add("block");
+    if (plan.cbs === 0n) {
+        plan.convert.delete("block");
+        plan.convert.delete("unblock");
+    }
+    for (const group of [["ascii", "ebcdic", "ibm"], ["block", "unblock"], ["lcase", "ucase"], ["excl", "nocreat"]]) {
+        if (group.filter(value => plan.convert.has(value)).length > 1)
+            throw new DdError(`cannot combine ${group.length === 3 ? "any two of {ascii,ebcdic,ibm}" : group.join(" and ")}`, false, plan.warnings);
+    }
+    if ([plan.inputFlags, plan.outputFlags].some(values => values.has("direct") && values.has("nocache")))
+        throw new DdError("cannot combine direct and nocache", false, plan.warnings);
+    plan.countBytes ||= plan.inputFlags.has("count_bytes");
+    plan.skipBytes ||= plan.inputFlags.has("skip_bytes");
+    plan.seekBytes ||= plan.outputFlags.has("seek_bytes");
+    return plan;
+}

package/dist/safe-bash/opt-in/commands/dd/report.js

@@ -0,0 +1,69 @@
+import { writeBytes } from "@poe-platform/safe-bash/contracts/io";
+function human(value, base) {
+    let exponent = 0;
+    while (value >= base && exponent < 10) {
+        value /= base;
+        exponent++;
+    }
+    if (Math.round(value) >= base && exponent < 10) {
+        value /= base;
+        exponent++;
+    }
+    const tenths = Math.round(value * 10);
+    const number = exponent > 0 && tenths < 100 ? (tenths / 10).toFixed(1) : Math.round(value).toString();
+    const unit = exponent === 0 ? "B" : `${(base === 1000 ? "kMGTPEZYRQ" : "KMGTPEZYRQ")[exponent - 1]}${base === 1024 ? "i" : ""}B`;
+    return `${number} ${unit}`;
+}
+export function transferReport(bytes, elapsedMs, progress = false) {
+    const seconds = Math.max(0, elapsedMs) / 1000;
+    const size = Number(bytes);
+    const decimal = human(size, 1000), binary = human(size, 1024);
+    const suffix = size < 1000 ? "" : size < 1024 ? ` (${decimal})` : ` (${decimal}, ${binary})`;
+    const rounded = Number(seconds.toPrecision(6));
+    let elapsed = progress ? Math.round(seconds).toString() : rounded.toString();
+    if (!progress && rounded && (rounded < 0.0001 || rounded >= 1000000)) {
+        const [significand, exponent] = rounded.toExponential().split("e");
+        const power = Number(exponent);
+        elapsed = `${significand}e${power < 0 ? "-" : "+"}${Math.abs(power).toString().padStart(2, "0")}`;
+    }
+    const rate = seconds > 0 ? `${human(size / seconds, 1000)}/s` : "Infinity B/s";
+    return `${bytes} ${bytes === 1n ? "byte" : "bytes"}${suffix} copied, ${elapsed} s, ${rate}`;
+}
+export class DdReporter {
+    context;
+    status;
+    now;
+    stats = { inputFull: 0n, inputPartial: 0n, outputFull: 0n, outputPartial: 0n, truncated: 0n, bytes: 0n };
+    start;
+    next = 1000;
+    progressLength = 0;
+    constructor(context, status, now) {
+        this.context = context;
+        this.status = status;
+        this.now = now;
+        this.start = now();
+    }
+    async progress() {
+        if (this.status !== "progress")
+            return;
+        const elapsed = this.now() - this.start;
+        if (elapsed < this.next)
+            return;
+        this.next += 1000;
+        const line = transferReport(this.stats.bytes, elapsed, true);
+        await writeBytes(this.context.stderr, new TextEncoder().encode(`\r${line}${" ".repeat(Math.max(0, this.progressLength - line.length))}`), this.context.signal);
+        this.progressLength = line.length;
+    }
+    async report() {
+        if (this.status === "none")
+            return;
+        let text = this.progressLength ? "\n" : "";
+        this.progressLength = 0;
+        text += `${this.stats.inputFull}+${this.stats.inputPartial} records in\n${this.stats.outputFull}+${this.stats.outputPartial} records out\n`;
+        if (this.stats.truncated)
+            text += `${this.stats.truncated} truncated record${this.stats.truncated === 1n ? "" : "s"}\n`;
+        if (this.status !== "noxfer")
+            text += `${transferReport(this.stats.bytes, this.now() - this.start)}\n`;
+        await writeBytes(this.context.stderr, new TextEncoder().encode(text), this.context.signal);
+    }
+}