@poe-platform/safe-bash 0.1.799 → 0.1.801

package/dist/safe-bash/commands/network/body.js

@@ -1,394 +1,2 @@
-import { decodeBytes, encodeBytes } from "../../byte-encoding.js";
-import { collectNetworkBytes as collectBytes } from "./shared.js";
-import { randomBytes } from "#safe-bash-network-platform";
-import { posixPath as posix } from "../../contracts/path.js";
-import { yieldTurn } from "../../contracts/yield.js";
-import { readBytes } from "../../contracts/index.js";
-import { pathOf } from "../internal.js";
-import { encode } from "./shared.js";
-import { CurlError } from "./types.js";
-import { filePartHeaders, validatePartHeader } from "./form-headers.js";
-import { formContentType } from "./form-content-type.js";
-function multipartBoundary() {
-    let boundary = "virtual-bash-";
-    for (const byte of randomBytes(18))
-        boundary += byte.toString(16).padStart(2, "0");
-    return boundary;
-}
-function percent(bytes) {
-    let output = "";
-    for (const byte of bytes)
-        output += (byte >= 65 && byte <= 90) || (byte >= 97 && byte <= 122) ||
-            (byte >= 48 && byte <= 57) || [45, 46, 95, 126].includes(byte)
-            ? String.fromCharCode(byte) : byte === 32 ? "+" : `%${byte.toString(16).toUpperCase().padStart(2, "0")}`;
-    return encode(output);
-}
-function dataPart(argument) {
-    const value = argument.value;
-    if (argument.kind === "urlencode") {
-        const equals = value.indexOf("=");
-        if (equals >= 0)
-            return [{ bytes: encode(equals ? `${value.slice(0, equals)}=` : "") }, { bytes: encode(value.slice(equals + 1)), urlencode: true }];
-        const at = value.indexOf("@");
-        // curl 8.5/8.10 omit the name as well as the value for empty file data.
-        if (at >= 0)
-            return [{ prefix: encode(at ? `${value.slice(0, at)}=` : ""), file: value.slice(at + 1), urlencode: true }];
-        return [{ bytes: encode(value), urlencode: true }];
-    }
-    if (argument.kind !== "raw" && value.startsWith("@"))
-        return [{ file: value.slice(1), strip: argument.kind === "data" }];
-    return [{ bytes: encode(value) }];
-}
-function quoted(value) {
-    if (/[\r\n\0]/.test(value))
-        throw new CurlError(2, "Invalid multipart field metadata");
-    return value.replace(/["\\]/g, "\\$&");
-}
-// curl only unescapes quotes and backslashes inside a double-quoted operand.
-function formWord(input, start, file) {
-    const delimiter = (character) => character === ";" || (file && character === ",");
-    if (input[start] === '"') {
-        let value = "";
-        for (let index = start + 1; index < input.length; index++) {
-            const character = input[index];
-            if (character === '"') {
-                let end = index + 1;
-                while (end < input.length && !delimiter(input[end]))
-                    end++;
-                return { value, end };
-            }
-            if (character === "\\" && (input[index + 1] === "\\" || input[index + 1] === '"')) {
-                value += input[++index];
-            }
-            else
-                value += character;
-        }
-        // An unmatched opening quote is literal in curl's form grammar.
-    }
-    let end = start;
-    while (end < input.length && !delimiter(input[end]))
-        end++;
-    return { value: input.slice(start, end), end };
-}
-// curl's deliberately small extension table, rather than a general MIME database.
-const multipartContentTypes = new Map([
-    ["gif", "image/gif"], ["jpg", "image/jpeg"], ["jpeg", "image/jpeg"],
-    ["png", "image/png"], ["svg", "image/svg+xml"], ["txt", "text/plain"],
-    ["html", "text/html"], ["htm", "text/html"], ["pdf", "application/pdf"],
-    ["xml", "application/xml"],
-]);
-function filenameContentType(filename) {
-    const basename = posix.basename(filename);
-    const dot = basename.lastIndexOf(".");
-    return dot < 0 ? undefined : multipartContentTypes.get(basename.slice(dot + 1).toLowerCase());
-}
-function multipart(argument, boundary) {
-    const equals = argument.value.indexOf("=");
-    if (equals < 0)
-        throw new CurlError(2, "Multipart form requires name=value");
-    const name = quoted(argument.value.slice(0, equals));
-    const input = argument.value.slice(equals + 1);
-    const upload = argument.kind === "form" && input.startsWith("@");
-    const isFile = argument.kind === "form" && (upload || input.startsWith("<"));
-    const entries = [];
-    let start = isFile ? 1 : 0;
-    do {
-        const word = argument.kind === "form" ? formWord(input, start, isFile) : { value: input, end: input.length };
-        const entry = { value: word.value };
-        if (isFile) {
-            if (!word.value)
-                throw new CurlError(2, "Empty multipart file operand");
-            entry.file = word.value;
-            if (upload)
-                entry.filename = posix.basename(word.value);
-        }
-        let end = word.end;
-        while (end < input.length && input[end] !== ",") {
-            const attributeStart = end + 1;
-            if (input.startsWith("type=", attributeStart)) {
-                const attribute = formContentType(input, attributeStart + 5, upload);
-                entry.type = attribute.value;
-                end = attribute.end;
-            }
-            else if (input.startsWith("filename=", attributeStart)) {
-                const attribute = formWord(input, attributeStart + 9, upload);
-                entry.filename = attribute.value;
-                end = attribute.end;
-            }
-            else if (input.startsWith("headers=", attributeStart)) {
-                const file = input[attributeStart + 8] === "@";
-                const attribute = formWord(input, attributeStart + 8 + (file ? 1 : 0), upload);
-                if (!attribute.value)
-                    throw new CurlError(2, "Empty multipart header operand");
-                (entry.headers ??= []).push({ value: file ? attribute.value : validatePartHeader(attribute.value), file });
-                end = attribute.end;
-            }
-            else if (input.startsWith("encoder=", attributeStart)) {
-                const attribute = formWord(input, attributeStart + 8, upload);
-                entry.encoder = attribute.value.toLowerCase();
-                end = attribute.end;
-                if (!["binary", "8bit", "7bit", "base64", "quoted-printable"].includes(entry.encoder))
-                    throw new CurlError(2, "Unsupported multipart transfer encoder");
-            }
-            else
-                throw new CurlError(2, "Unsupported multipart form attribute");
-        }
-        entries.push(entry);
-        if (end === input.length)
-            break;
-        if (!upload)
-            throw new CurlError(2, "Unsupported multipart file list");
-        start = end + 1;
-    } while (start <= input.length);
-    const mixed = entries.length > 1;
-    const childBoundary = mixed ? multipartBoundary() : boundary;
-    const disposition = `form-data${name ? `; name="${name}"` : ""}`;
-    const parts = [];
-    if (mixed)
-        parts.push({ bytes: encode(`--${boundary}\r\nContent-Disposition: ${disposition}\r\nContent-Type: multipart/mixed; boundary=${childBoundary}\r\n\r\n`) });
-    for (const entry of entries) {
-        let preamble = `--${childBoundary}\r\nContent-Disposition: ${mixed ? "attachment" : disposition}`;
-        if (entry.filename !== undefined)
-            preamble += `; filename="${quoted(entry.filename)}"`;
-        preamble += "\r\n";
-        if (entry.type || entry.filename !== undefined) {
-            const inferred = entry.filename === undefined ? undefined : filenameContentType(entry.filename) ??
-                (entry.file === undefined ? undefined : filenameContentType(entry.file));
-            preamble += `Content-Type: ${entry.type ?? inferred ?? "application/octet-stream"}\r\n`;
-        }
-        if (entry.encoder)
-            preamble += `Content-Transfer-Encoding: ${entry.encoder}\r\n`;
-        const encoding = entry.encoder === undefined ? {} : { encoder: entry.encoder };
-        parts.push({ bytes: encode(preamble), headers: entry.headers ?? [] }, entry.file !== undefined ? { file: entry.file, ...encoding } : { bytes: encode(entry.value), ...encoding }, { bytes: encode("\r\n") });
-    }
-    if (mixed)
-        parts.push({ bytes: encode(`--${childBoundary}--\r\n\r\n`) });
-    return parts;
-}
-async function* transfer(source, encoder, signal) {
-    if (!encoder || encoder === "binary" || encoder === "8bit") {
-        yield* source;
-        return;
-    }
-    let pending = [];
-    let column = 0;
-    let output = "";
-    const quotedByte = (byte, next, after) => {
-        if (byte === 13 && next === 10) {
-            output += "\r\n";
-            column = 0;
-            return 2;
-        }
-        const trailing = next === undefined || (next === 13 && after === 10);
-        const literal = (byte >= 33 && byte <= 126 && byte !== 61) || ((byte === 32 || byte === 9) && !trailing);
-        const token = literal ? String.fromCharCode(byte) : `=${byte.toString(16).toUpperCase().padStart(2, "0")}`;
-        if (column + token.length > 75) {
-            output += "=\r\n";
-            column = 0;
-        }
-        output += token;
-        column += token.length;
-        return 1;
-    };
-    for await (const raw of source) {
-        for (let offset = 0; offset < raw.length; offset += 16 * 1024) {
-            signal.throwIfAborted();
-            const chunk = raw.subarray(offset, offset + 16 * 1024);
-            if (encoder === "7bit") {
-                if (chunk.some(byte => byte > 127))
-                    throw new CurlError(26, "Non-ASCII byte in 7bit multipart data");
-                yield chunk;
-                continue;
-            }
-            pending.push(...chunk);
-            let consumed = 0;
-            if (encoder === "base64") {
-                while (pending.length - consumed >= 57) {
-                    if (column)
-                        output += "\r\n";
-                    output += decodeBytes(encodeBytes(pending.slice(consumed, consumed + 57)), "base64");
-                    consumed += 57;
-                    column = 76;
-                }
-            }
-            else {
-                while (pending.length - consumed >= 3)
-                    consumed += quotedByte(pending[consumed], pending[consumed + 1], pending[consumed + 2]);
-            }
-            pending = pending.slice(consumed);
-            if (output) {
-                yield encode(output);
-                output = "";
-            }
-            await yieldTurn(signal);
-        }
-    }
-    signal.throwIfAborted();
-    if (encoder === "base64" && pending.length) {
-        if (column)
-            output += "\r\n";
-        output += decodeBytes(encodeBytes(pending), "base64");
-    }
-    else if (encoder === "quoted-printable") {
-        for (let i = 0; i < pending.length;)
-            i += quotedByte(pending[i], pending[i + 1], pending[i + 2]);
-    }
-    if (output)
-        yield encode(output);
-}
-export function createBody(context, args, limits) {
-    if (!args.data.length && args.upload === undefined)
-        return undefined;
-    const parts = [];
-    let contentType;
-    const form = args.data.some(part => part.kind.startsWith("form"));
-    if (form) {
-        const boundary = multipartBoundary();
-        contentType = `multipart/form-data; boundary=${boundary}`;
-        for (const argument of args.data)
-            parts.push(...multipart(argument, boundary));
-        parts.push({ bytes: encode(`--${boundary}--\r\n`) });
-    }
-    else if (args.upload !== undefined)
-        parts.push({ file: args.upload });
-    else {
-        const json = args.data[0]?.kind === "json";
-        contentType = json ? "application/json" : "application/x-www-form-urlencoded";
-        args.data.forEach((argument, index) => {
-            if (index && !json)
-                parts.push({ bytes: encode("&"), separator: true });
-            parts.push(...dataPart(argument));
-        });
-    }
-    const hasStdin = parts.some(part => part.file === "-");
-    let opened = false;
-    let replayComplete = false;
-    let replayable = true;
-    let cachedBytes = 0;
-    let cache = [];
-    let stdinUsed = false;
-    const source = async function* (part, signal) {
-        if (part.bytes !== undefined) {
-            if (!part.headers) {
-                yield part.bytes;
-                return;
-            }
-            const headers = [];
-            let headerBytes = 0;
-            for (const header of part.headers) {
-                signal.throwIfAborted();
-                if (header.file) {
-                    const bytes = await collectBytes(source({ file: header.value }, signal), {
-                        signal, maxBytes: Math.min(limits.maxBufferBytes, limits.maxUploadBytes) - headerBytes,
-                    });
-                    headerBytes += bytes.length;
-                    headers.push(...filePartHeaders(bytes));
-                }
-                else {
-                    headerBytes += encode(header.value).length;
-                    if (headerBytes > Math.min(limits.maxBufferBytes, limits.maxUploadBytes))
-                        throw new CurlError(63, "Multipart headers exceed host byte limit");
-                    headers.push(header.value);
-                }
-            }
-            const overridden = new Set(headers.map(header => header.slice(0, header.indexOf(":")).toLowerCase()));
-            const defaults = decodeBytes(encodeBytes(part.bytes), "utf8").split("\r\n");
-            const preamble = defaults.filter((line, index) => index === 0 ||
-                (line && !overridden.has(line.slice(0, line.indexOf(":")).toLowerCase())));
-            yield encode([...preamble, ...headers, "", ""].join("\r\n"));
-            return;
-        }
-        if (part.file === "-") {
-            if (!stdinUsed) {
-                stdinUsed = true;
-                yield* readBytes(context.stdin, signal);
-            }
-            return;
-        }
-        try {
-            const path = pathOf(context, part.file);
-            const capabilities = await context.fs.capabilitiesFor?.(path, { signal }) ?? context.fs.capabilities;
-            signal.throwIfAborted();
-            if (context.fs.readStream && capabilities.streamingRead !== false)
-                yield* readBytes(context.fs.readStream(path, { signal }), signal);
-            else
-                yield await context.fs.readFile(path, { signal, ...(Number.isFinite(Math.min(limits.maxBufferBytes, limits.maxUploadBytes)) ? { maxBytes: Math.min(limits.maxBufferBytes, limits.maxUploadBytes) } : {}) });
-        }
-        catch (error) {
-            signal.throwIfAborted();
-            if (error instanceof CurlError)
-                throw error;
-            throw new CurlError(26, "Failed to read virtual upload file");
-        }
-    };
-    return {
-        ...(contentType === undefined ? {} : { contentType }),
-        open(signal) {
-            return (async function* () {
-                if (hasStdin && opened) {
-                    if (!replayComplete || !replayable)
-                        throw new CurlError(65, "Cannot replay stdin upload within the host buffer limit");
-                    for (const chunk of cache) {
-                        signal.throwIfAborted();
-                        yield chunk.slice();
-                    }
-                    return;
-                }
-                opened = true;
-                let count = 0;
-                let chunks = 0;
-                for (const part of parts) {
-                    if (part.separator && count === 0)
-                        continue;
-                    let prefix = part.prefix;
-                    for await (const raw of transfer(source(part, signal), part.encoder, signal)) {
-                        if (++chunks % 256 === 0)
-                            await yieldTurn(signal);
-                        for (let offset = 0; offset < raw.length; offset += 16 * 1024) {
-                            signal.throwIfAborted();
-                            let chunk = raw.subarray(offset, offset + 16 * 1024);
-                            if (part.strip)
-                                chunk = chunk.filter(byte => byte !== 0 && byte !== 10 && byte !== 13);
-                            if (part.urlencode)
-                                chunk = percent(chunk);
-                            count += chunk.length + (prefix?.length ?? 0);
-                            if (count > limits.maxUploadBytes)
-                                throw new CurlError(63, "Upload exceeds host byte limit");
-                            if (prefix?.length) {
-                                const prefixed = new Uint8Array(prefix.length + chunk.length);
-                                prefixed.set(prefix);
-                                prefixed.set(chunk, prefix.length);
-                                chunk = prefixed;
-                                prefix = undefined;
-                            }
-                            if (hasStdin && replayable) {
-                                cachedBytes += chunk.length;
-                                if (cachedBytes > limits.maxBufferBytes) {
-                                    replayable = false;
-                                    cache = [];
-                                }
-                                else
-                                    cache.push(new Uint8Array(chunk));
-                            }
-                            if (chunk.length)
-                                yield chunk;
-                        }
-                    }
-                }
-                replayComplete = true;
-            })();
-        },
-    };
-}
-export async function queryData(body, signal, limits) {
-    try {
-        return decodeBytes(encodeBytes(await collectBytes(body.open(signal), { signal, maxBytes: limits.maxBufferBytes })), "utf8");
-    }
-    catch (error) {
-        signal.throwIfAborted();
-        if (error instanceof CurlError)
-            throw error;
-        throw new CurlError(63, "Query data exceeds host buffer limit");
-    }
-}
+export * from "../../../safe-bash-network-engine/body.js";
 //# sourceMappingURL=body.js.map

package/dist/safe-bash/commands/network/curl.d.ts

@@ -1,14 +1,4 @@
-import { type CommandContext, type CommandDefinition } from "../../contracts/index.js";
-import { type CurlArguments } from "./args.js";
-import { type NetworkCommandsOptions, type NetworkLimits } from "./types.js";
-interface TransferProfile {
-    readonly name: string;
-    readonly help: string;
-    readonly version: string;
-    parse(context: CommandContext, limits: NetworkLimits): CurlArguments | Promise<CurlArguments>;
-    status(code: number): number;
-}
-export declare function createCurlCommand(options: NetworkCommandsOptions): CommandDefinition;
-export declare function createTransferCommand(options: NetworkCommandsOptions, profile: TransferProfile): CommandDefinition;
-export {};
+import type { NetworkCommandsOptions } from "./types.js";
+export * from "../../../safe-bash-command-curl/curl.js";
+export declare function createCurlCommand(options?: NetworkCommandsOptions): import("../../../safe-bash-contracts/index.js").CommandDefinition;
 //# sourceMappingURL=curl.d.ts.map