@poe-platform/safe-bash 0.1.710 → 0.1.712

package/dist/safe-bash-command-exiftool/arguments.js

@@ -1,128 +0,0 @@
-import { exiftoolRegistry } from "./registry.js";
-export function parseArguments(args, limits) {
-    if (args.length > 4096)
-        throw new RangeError("ExifTool argument count exceeded");
-    let extent = 0;
-    for (const arg of args) {
-        extent += arg.length * 2;
-        if (extent > limits.maxDecodedBytes)
-            throw new RangeError("ExifTool argument decoded budget exceeded");
-    }
-    const result = { files: [], tags: [], assignments: [], json: false, csv: false, quoteScalars: false, duplicates: false,
-        binary: false, missing: false, style: "short", overwrite: "backup", destination: undefined, groupFamily: undefined };
-    let literal = false;
-    let valueConvSelector = false;
-    for (let index = 0; index < args.length; index++) {
-        const arg = args[index];
-        const option = arg.toLowerCase();
-        const value = () => { if (++index >= args.length)
-            throw new Error("Missing argument for " + arg); return args[index]; };
-        if (literal || !arg.startsWith("-") || arg === "-") {
-            result.files.push(arg);
-            continue;
-        }
-        if (arg === "--") {
-            literal = true;
-            continue;
-        }
-        if (option === "-config") {
-            if (value() !== "")
-                throw new Error("User configuration modules are not supported");
-            continue;
-        }
-        if (option === "-j" || option === "-json") {
-            result.json = true;
-            continue;
-        }
-        if (option === "-csv") {
-            result.csv = true;
-            continue;
-        }
-        if (arg === "-G4") {
-            result.groupFamily = 4;
-            continue;
-        }
-        if (option === "-api") {
-            if (value().toLowerCase() !== "structformat=jsonq")
-                throw new Error("API option not yet supported");
-            result.quoteScalars = true;
-            continue;
-        }
-        if (option === "-a") {
-            result.duplicates = true;
-            continue;
-        }
-        if (option === "-b") {
-            result.binary = true;
-            continue;
-        }
-        if (option === "-f") {
-            result.missing = true;
-            continue;
-        }
-        if (arg === "-S") {
-            result.style = "compact";
-            continue;
-        }
-        if (option === "-s" || option === "-s1") {
-            result.style = "short";
-            continue;
-        }
-        if (option === "-s3") {
-            result.style = "values";
-            continue;
-        }
-        if (option === "-n")
-            continue; // admitted PNG text tags have no PrintConv
-        if (option === "-overwrite_original") {
-            result.overwrite = "replace";
-            continue;
-        }
-        if (option === "-overwrite_original_in_place") {
-            result.overwrite = "in-place";
-            continue;
-        }
-        if (option === "-o") {
-            result.destination = value();
-            continue;
-        }
-        if (["-if", "-p", "-stay_open", "-@", "-common_args"].includes(option) || option.startsWith("-execute"))
-            throw new Error("ExifTool option not yet supported (no code evaluation or ambient polling): " + arg);
-        const equals = arg.indexOf("=");
-        let name = arg.slice(1, equals < 0 ? undefined : equals);
-        const operation = name.endsWith("+") ? "add" : name.endsWith("-") ? "remove" : "set";
-        if (operation !== "set")
-            name = name.slice(0, -1);
-        if (name.endsWith("#")) {
-            if (equals < 0)
-                valueConvSelector = true;
-            name = name.slice(0, -1);
-        }
-        const known = exiftoolRegistry.tags.find(tag => tag.toLowerCase() === name.toLowerCase());
-        if (equals >= 0)
-            result.assignments.push({ name: known ?? name, operation, value: arg.slice(equals + 1) });
-        else if (known || name === "MissingTag")
-            result.tags.push(known ?? name);
-        else
-            throw new Error("ExifTool option/tag not yet supported: " + arg);
-    }
-    if (!result.files.length)
-        throw new Error("No file specified");
-    if (result.files.filter(file => file === "-").length > 1)
-        throw new Error("Repeated stdin operands are not supported");
-    if (result.files.includes("-") && result.assignments.length)
-        throw new Error("Writing stdin metadata is not yet supported");
-    if (result.files.length > 64)
-        throw new RangeError("ExifTool file count exceeded");
-    if (result.destination !== undefined && (result.files.length !== 1 || !result.assignments.length))
-        throw new Error("-o requires a single file with tag assignments in this profile");
-    if (result.json && result.binary)
-        throw new Error("JSON binary policy not yet supported");
-    if (result.csv && (result.json || result.binary || result.assignments.length))
-        throw new Error("CSV combined output/import policy not yet supported");
-    if (result.csv && valueConvSelector)
-        throw new Error("CSV ValueConv-qualified headers not yet supported");
-    if (result.groupFamily !== undefined && (!result.json || result.assignments.length))
-        throw new Error("Group-family qualification outside JSON not yet supported");
-    return result;
-}

package/dist/safe-bash-command-exiftool/command.js

@@ -1,324 +0,0 @@
-import { commandRuntimeIdentity, getCommandArguments } from "../safe-bash-contracts/command.js";
-import { FsError } from "../safe-bash-contracts/errors.js";
-import { readBytes, writeBytes } from "../safe-bash-contracts/io.js";
-import { createOutputOperation } from "../safe-bash-contracts/output.js";
-import { shellValueByteLength } from "../safe-bash-contracts/value.js";
-import { parseArguments } from "./arguments.js";
-import { inspectPng, editPng } from "./png.js";
-import { Publication } from "./publication.js";
-import { Resources, ResourceLimitError } from "./resources.js";
-import { encodeJsonScalar, printable } from "./scalar.js";
-import { exiftoolRegistry } from "./registry.js";
-import { isNumericShift } from "./shifts.js";
-import { CsvTable } from "./csv.js";
-import { expandArgfiles } from "./argfiles.js";
-import { virtualPath } from "./paths.js";
-function selected(tags, names, duplicates, resources) {
-    resources.admit("work", tags.length + names.length);
-    resources.admit("retained", tags.length * 32);
-    const requested = names.length ? names : [...new Set(tags.map(tag => tag.name))];
-    const requestedExtent = requested.reduce((sum, name) => sum + name.length + 1, 0);
-    const tagExtent = tags.reduce((sum, tag) => sum + tag.name.length + 1, 0);
-    // Includes per-predicate lowercasing/comparison and every transient matching
-    // array, plus selected output references. Admit before the multiplicative loop.
-    resources.admit("work", tags.length * requestedExtent + tagExtent * requested.length * 2);
-    resources.admit("retained", requested.length * (128 + tags.length * 16));
-    const values = [];
-    for (const name of requested) {
-        const matching = tags.filter(tag => tag.name.toLowerCase() === name.toLowerCase());
-        if (duplicates)
-            values.push(...matching);
-        else if (matching.length)
-            values.push(matching[matching.length - 1]);
-    }
-    return values;
-}
-export function createExiftoolCommand(options = {}) {
-    const limits = Object.freeze({ ...options.limits });
-    return Object.freeze({
-        name: "exiftool", runtimeIdentity: commandRuntimeIdentity,
-        description: "Inspect and edit admitted PNG metadata through virtual files",
-        async execute(context) {
-            const publication = new Publication(context);
-            let stdout, stderr;
-            let failed = false, failure;
-            let closing;
-            const cleanup = () => {
-                closing ??= (async () => {
-                    const results = await Promise.allSettled([publication.close(), stdout?.close(), stderr?.close()]);
-                    const failures = results.filter(result => result.status === "rejected").map(result => result.reason);
-                    if (failures.length) {
-                        if (failed)
-                            failures.unshift(failure);
-                        throw new AggregateError(failures, "ExifTool invocation and cleanup failed");
-                    }
-                })();
-                return closing;
-            };
-            context.registerCleanup?.(cleanup);
-            try {
-                stdout = createOutputOperation(context, context.stdout);
-                stderr = createOutputOperation(context, context.stderr);
-                const resources = new Resources({ ...limits, signal: context.signal });
-                const output = async (text, error = false) => {
-                    resources.admit("work", text.length * 2);
-                    resources.admit("output", text.length * 3);
-                    resources.admit("retained", text.length * 5);
-                    await writeBytes(error ? stderr.output : stdout.output, new TextEncoder().encode(text), context.signal);
-                };
-                let invocation;
-                try {
-                    const carrier = getCommandArguments(context);
-                    for (let index = 0; index < carrier.values.length; index++) {
-                        const extent = shellValueByteLength(carrier.values[index]);
-                        resources.admit("decoded", context.args[index].length * 2);
-                        resources.admit("retained", extent + 128);
-                        resources.admit("work", extent * 4);
-                        const bytes = carrier.bytes(index);
-                        try {
-                            if (new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes) !== context.args[index])
-                                throw new Error("Argv Unicode mismatch");
-                        }
-                        catch {
-                            throw new Error("Only qualified UTF-8 argv is currently supported");
-                        }
-                    }
-                    invocation = parseArguments(await expandArgfiles(context.args, context, publication, resources), resources.limits);
-                }
-                catch (error) {
-                    context.signal.throwIfAborted();
-                    if (error instanceof ResourceLimitError)
-                        throw error;
-                    await output("Error: " + (error instanceof Error ? error.message : String(error)) + "\n", true);
-                    return { exitCode: 1 };
-                }
-                const json = [];
-                const csv = invocation.csv ? new CsvTable(resources, invocation.missing, invocation.tags) : undefined;
-                const assignment = invocation.assignments.length === 1 ? invocation.assignments[0] : undefined;
-                if (assignment?.operation === "add" && Object.hasOwn(exiftoolRegistry.scalarShiftErrorGroups, assignment.name) && !isNumericShift(assignment.value)) {
-                    await output("Warning: Shift value for " + exiftoolRegistry.scalarShiftErrorGroups[assignment.name] + ":" + assignment.name + " is not a number\nNothing to do.\n", true);
-                    return { exitCode: 1 };
-                }
-                let errors = 0, updated = 0, created = 0, unchanged = 0, read = 0;
-                for (const file of invocation.files) {
-                    let tags = [];
-                    try {
-                        const path = file === "-" ? "-" : virtualPath(context.cwd, file, resources);
-                        const original = file === "-" ? undefined : await publication.track(() => context.fs.lstat(path, { signal: context.signal }));
-                        if (original && original.type !== "file")
-                            throw new Error("Only regular VFS files are admitted");
-                        if (original) {
-                            resources.admit("input", original.size);
-                            resources.admit("retained", original.size * 32 + 256);
-                            resources.admit("decoded", original.size * 2);
-                            resources.admit("work", original.size * 20);
-                        }
-                        const bytes = await publication.track(async () => {
-                            if (original && !context.fs.readStream) {
-                                const result = await context.fs.readFile(path, { signal: context.signal, maxBytes: original.size });
-                                context.signal.throwIfAborted();
-                                if (result.length > original.size)
-                                    throw new RangeError("ExifTool input grew beyond admitted size");
-                                return result;
-                            }
-                            const chunks = [];
-                            let size = 0;
-                            const source = original ? context.fs.readStream(path, { signal: context.signal }) : context.stdin;
-                            for await (const chunk of readBytes(source, context.signal)) {
-                                resources.admit("work", chunk.length + 64);
-                                if (original && chunk.length > original.size - size)
-                                    throw new RangeError("ExifTool input grew beyond admitted size");
-                                if (!original) {
-                                    resources.admit("input", chunk.length);
-                                    resources.admit("retained", chunk.length * 32 + 256);
-                                    resources.admit("decoded", chunk.length * 2);
-                                    resources.admit("work", chunk.length * 20);
-                                }
-                                resources.admit("retained", chunk.length + 128);
-                                if (chunk.length)
-                                    chunks.push(new Uint8Array(chunk));
-                                size += chunk.length;
-                            }
-                            resources.admit("retained", size);
-                            const result = new Uint8Array(size);
-                            let position = 0;
-                            for (const chunk of chunks) {
-                                result.set(chunk, position);
-                                position += chunk.length;
-                            }
-                            return result;
-                        });
-                        if (!bytes.length)
-                            throw new Error("File is empty");
-                        const extension = file.slice(file.lastIndexOf(".") + 1).toUpperCase();
-                        if (invocation.assignments.length && ["DOCX", "PPTX", "XLSX"].includes(extension))
-                            throw new Error("Writing of " + extension + " files is not yet supported");
-                        if (extension === "PDF")
-                            throw new Error("PDF parser/writer not yet supported; metadata deletion retains historical revisions and never guarantees redaction");
-                        const png = bytes.length >= 8 && bytes[0] === 137 && bytes[1] === 80 && bytes[2] === 78 && bytes[3] === 71;
-                        if (invocation.assignments.length) {
-                            if (!original)
-                                throw new Error("Writing stdin metadata is not yet supported");
-                            if (!png)
-                                throw new Error("Format writer not yet supported");
-                            const edited = editPng(bytes, invocation.assignments, resources);
-                            resources.admit("retained", edited.length * 3);
-                            resources.admit("work", bytes.length);
-                            if (invocation.destination === undefined && !invocation.assignments.some(op => op.operation === "set" && op.value !== "") && edited.length === bytes.length && edited.every((byte, index) => byte === bytes[index])) {
-                                unchanged++;
-                                continue;
-                            }
-                            resources.admit("output", edited.length);
-                            const inPlace = invocation.overwrite === "in-place";
-                            const destination = invocation.destination === undefined ? path : virtualPath(context.cwd, invocation.destination, resources);
-                            if (invocation.destination === undefined) {
-                                await publication.track(() => context.fs.access(path, 2, { signal: context.signal }));
-                                if (!inPlace && original.nlink !== 1)
-                                    throw new Error("VFS hardlink replacement is not yet supported");
-                                if (invocation.overwrite === "backup") {
-                                    const backup = path + "_original";
-                                    let existing = false;
-                                    try {
-                                        await publication.track(() => context.fs.lstat(backup, { signal: context.signal }));
-                                        existing = true;
-                                    }
-                                    catch (error) {
-                                        if (!(error instanceof FsError) || error.code !== "ENOENT")
-                                            throw error;
-                                    }
-                                    if (!existing) {
-                                        resources.admit("output", bytes.length);
-                                        await publication.publish(backup, bytes, null, false);
-                                    }
-                                }
-                            }
-                            await publication.publish(destination, edited, invocation.destination === undefined ? original : null, invocation.destination === undefined && inPlace);
-                            if (invocation.destination === undefined)
-                                updated++;
-                            else
-                                created++;
-                            continue;
-                        }
-                        // Unrecognized nonempty formats match the validated no-selected-tag control.
-                        if (!png && ["XMP", "DOCX", "PPTX", "XLSX", "JPG", "JPEG", "TIF", "TIFF"].includes(extension))
-                            throw new Error(extension + " reader not yet supported");
-                        tags = png ? inspectPng(bytes, resources).tags : [];
-                    }
-                    catch (error) {
-                        context.signal.throwIfAborted();
-                        if (error instanceof ResourceLimitError)
-                            throw error;
-                        errors++;
-                        const message = error instanceof FsError && error.code === "ENOENT" ? "File not found" : error instanceof Error ? error.message : String(error);
-                        await output("Error: " + message + " - " + file + "\n", true);
-                        continue;
-                    }
-                    read++;
-                    const chosen = selected(tags, invocation.tags, invocation.json ? invocation.groupFamily === 4 : invocation.duplicates && !invocation.csv, resources);
-                    if (csv) {
-                        csv.add(file, chosen);
-                        continue;
-                    }
-                    const present = new Set();
-                    if (invocation.missing) {
-                        resources.admit("retained", chosen.length * 64);
-                        for (const tag of chosen) {
-                            resources.admit("work", tag.name.length + 1);
-                            present.add(tag.name);
-                        }
-                        resources.admit("work", invocation.tags.reduce((sum, name) => sum + name.length + 1, 0));
-                    }
-                    const scalarOptions = { quoteScalars: invocation.quoteScalars, signal: context.signal,
-                        maxDecodedBytes: resources.limits.maxDecodedBytes, maxOutputBytes: resources.limits.maxOutputBytes, maxWork: resources.limits.maxWork, maxRetainedBytes: resources.limits.maxRetainedBytes };
-                    if (invocation.json) {
-                        const entries = ['  "SourceFile": ' + encodeJsonScalar(file, { ...scalarOptions, quoteScalars: true })];
-                        const tokens = new Set(['"SourceFile"']);
-                        const primaryInstances = new Map();
-                        if (invocation.groupFamily === 4)
-                            for (const tag of tags) {
-                                resources.admit("work", tag.name.length + 1);
-                                resources.admit("retained", tag.name.length * 2 + 64);
-                                primaryInstances.set(tag.name, Math.max(primaryInstances.get(tag.name) ?? 0, tag.instance));
-                            }
-                        for (const tag of chosen) {
-                            resources.admit("work", tag.name.length * 4);
-                            const name = invocation.groupFamily === 4 ? (tag.instance === primaryInstances.get(tag.name) ? "" : "Copy" + (tag.instance + 1)) + ":" + tag.name : tag.name;
-                            const token = encodeJsonScalar(name, { ...scalarOptions, quoteScalars: true });
-                            if (tokens.has(token))
-                                continue;
-                            tokens.add(token);
-                            resources.admit("work", tag.value.length * 4);
-                            entries.push("  " + token + ": " + encodeJsonScalar(tag.value, scalarOptions));
-                        }
-                        if (invocation.missing)
-                            for (const name of invocation.tags) {
-                                if (present.has(name))
-                                    continue;
-                                resources.admit("work", name.length * 4 + 1);
-                                const token = encodeJsonScalar((invocation.groupFamily === 4 ? ":" : "") + name, { ...scalarOptions, quoteScalars: true });
-                                if (tokens.has(token))
-                                    continue;
-                                tokens.add(token);
-                                entries.push("  " + token + ': "-"');
-                            }
-                        const record = "{\n" + entries.join(",\n") + "\n}";
-                        resources.admit("retained", record.length * 2);
-                        json.push(record);
-                    }
-                    else {
-                        for (const tag of chosen) {
-                            if (invocation.binary) {
-                                // -b suppresses PrintConv, not ValueConv. tEXt's stored Latin-1
-                                // and tIME's packed fields therefore differ from output bytes.
-                                const converted = tag.chunkType !== "iTXt";
-                                const extent = converted ? tag.value.length * 3 : tag.raw.length;
-                                resources.admit("work", extent);
-                                resources.admit("output", extent);
-                                if (converted)
-                                    resources.admit("retained", extent);
-                                await writeBytes(stdout.output, converted ? new TextEncoder().encode(tag.value) : tag.raw, context.signal);
-                            }
-                            else {
-                                resources.admit("work", (tag.name.length + tag.value.length) * 4);
-                                const value = printable(tag.value, scalarOptions);
-                                await output(invocation.style === "values" ? value + "\n" : (invocation.style === "compact" ? tag.name + ": " : tag.name.padEnd(32) + ": ") + value + "\n");
-                            }
-                        }
-                        if (invocation.missing && !invocation.binary)
-                            for (const name of invocation.tags) {
-                                if (!present.has(name))
-                                    await output(invocation.style === "values" ? "-\n" : (invocation.style === "compact" ? name + ": " : name.padEnd(32) + ": ") + "-\n");
-                            }
-                    }
-                }
-                if (invocation.json && !invocation.assignments.length)
-                    await output("[" + json.join(",\n") + "]\n");
-                if (csv) {
-                    await output(csv.render());
-                    if (invocation.files.length > 1)
-                        await output(String(read).padStart(5) + " image files read\n", true);
-                }
-                if (updated || unchanged)
-                    await output(String(updated).padStart(5) + " image files updated\n");
-                if (created)
-                    await output(String(created).padStart(5) + " image files created\n");
-                if (unchanged)
-                    await output(String(unchanged).padStart(5) + " image files unchanged\n");
-                return { exitCode: errors ? 1 : 0 };
-            }
-            catch (error) {
-                failed = true;
-                failure = error;
-                throw error;
-            }
-            finally {
-                await cleanup();
-            }
-        },
-    });
-}
-export const exiftoolCommand = createExiftoolCommand();
-export function exiftoolCommands(options = {}) {
-    const command = createExiftoolCommand(options);
-    return { name: "exiftool", setup(host) { host.commands.register(command); } };
-}

package/dist/safe-bash-command-exiftool/csv.js

@@ -1,78 +0,0 @@
-/** Invocation-owned table. CSV values bypass Printable and retain NUL bytes. */
-export class CsvTable {
-    resources;
-    missing;
-    headers = new Map();
-    records = [];
-    sortHeaders = false;
-    constructor(resources, missing, names) {
-        this.resources = resources;
-        this.missing = missing;
-        for (const name of names) {
-            resources.admit("work", name.length * 2 + 1);
-            resources.admit("retained", name.length * 4 + 128);
-            const key = name.toLowerCase();
-            if (key !== "sourcefile" && !this.headers.has(key))
-                this.headers.set(key, { name, found: missing });
-        }
-    }
-    add(file, tags) {
-        this.resources.admit("work", file.length + tags.length);
-        this.resources.admit("retained", file.length * 2 + 256);
-        const fields = new Map();
-        for (const tag of tags) {
-            this.resources.admit("work", tag.name.length * 2 + tag.value.length + 1);
-            this.resources.admit("retained", (tag.name.length + tag.value.length) * 4 + 256);
-            const key = tag.name.toLowerCase();
-            if (key === "sourcefile")
-                continue;
-            if (!this.headers.has(key)) {
-                if (this.records.length)
-                    this.sortHeaders = true;
-                this.headers.set(key, { name: tag.name, found: true });
-            }
-            else {
-                this.headers.set(key, { name: tag.name, found: true });
-            }
-            fields.set(key, tag.value);
-        }
-        this.records.push({ file, fields });
-    }
-    render() {
-        const extent = [...this.headers.keys()].reduce((total, key) => total + key.length + 1, 0);
-        this.resources.admit("work", extent * (this.headers.size + 1) + this.records.length * (this.headers.size + 1));
-        this.resources.admit("retained", this.headers.size * 64 + this.records.length * 32);
-        const columns = [...this.headers].filter(([, header]) => header.found);
-        if (this.sortHeaders)
-            columns.sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
-        const quote = (value) => {
-            this.resources.admit("work", value.length * 4 + 1);
-            this.resources.admit("retained", value.length * 8 + 16);
-            let quoted = false;
-            let text = "";
-            for (const character of value) {
-                if (character === '"') {
-                    text += '""';
-                    quoted = true;
-                }
-                else
-                    text += character;
-                if (character === "," || character === "\n" || character === "\r")
-                    quoted = true;
-            }
-            const whitespace = (character) => " \t\n\r\f\v\u0085\u00A0\u1680\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u2028\u2029\u202F\u205F\u3000".includes(character);
-            if (value.length && (whitespace(value[0]) || whitespace(value[value.length - 1])))
-                quoted = true;
-            return quoted ? '"' + text + '"' : text;
-        };
-        const lines = [["SourceFile", ...columns.map(([, header]) => quote(header.name))].join(",")];
-        for (const record of this.records) {
-            this.resources.admit("retained", (columns.length + 1) * 16);
-            lines.push([quote(record.file), ...columns.map(([key]) => quote(record.fields.get(key) ?? (this.missing ? "-" : "")))].join(","));
-        }
-        const size = lines.reduce((total, line) => total + line.length + 1, 0);
-        this.resources.admit("work", size * 2);
-        this.resources.admit("retained", size * 4);
-        return lines.join("\n") + "\n";
-    }
-}

package/dist/safe-bash-command-exiftool/paths.js

@@ -1,18 +0,0 @@
-/** Literal VFS resolution with scratch admission before splitting components. */
-export function virtualPath(cwd, input, resources) {
-    if (input.includes("\0") || input === "-")
-        throw new Error("Invalid or unsupported ExifTool file path");
-    const extent = input.length + (input.startsWith("/") ? 0 : cwd.length + 1);
-    // Includes separator-only and dot-only inputs with short normalized results.
-    resources.admit("decoded", extent * 2);
-    resources.admit("retained", extent * 32 + 256);
-    resources.admit("work", extent * 24 + 16);
-    const parts = [];
-    for (const part of (input.startsWith("/") ? input : cwd + "/" + input).split("/")) {
-        if (part === "..")
-            parts.pop();
-        else if (part && part !== ".")
-            parts.push(part);
-    }
-    return "/" + parts.join("/");
-}