@poe-platform/safe-bash 0.1.630 → 0.1.632

package/dist/safe-bash/core.d.ts

@@ -17,6 +17,7 @@ export { portableSearchCommands, type PortableSearchOptions } from "./commands/s
 export * from "./commands/bytes/index.js";
 export * from "./commands/diff-patch/index.js";
 export * from "./commands/safejs/index.js";
+export * from "./commands/python/index.js";
 export * from "./commands/node/browser.js";
 export * from "./commands/network/public.js";
 export * from "./commands/llm/index.js";

package/dist/safe-bash/core.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../src/core.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,qCAAqC,CAAC;AACpD,cAAc,uBAAuB,CAAC;AACtC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,aAAa,EAAE,YAAY,EAAE,YAAY,EAAE,gBAAgB,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAChM,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,qBAAqB,CAAC;AACpC,cAAc,sCAAsC,CAAC;AACrD,cAAc,mCAAmC,CAAC;AAClD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,4BAA4B,CAAC;AAC3C,OAAO,EAAE,sBAAsB,EAAE,KAAK,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AACnG,cAAc,2BAA2B,CAAC;AAC1C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,yBAAyB,CAAC;AACxC,cAAc,mCAAmC,CAAC;AAClD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,uCAAuC,CAAC;AACtD,cAAc,mCAAmC,CAAC;AAClD,cAAc,2BAA2B,CAAC;AAC1C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC;AACzC,cAAc,kCAAkC,CAAC;AACjD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,sCAAsC,CAAC;AACrD,cAAc,wBAAwB,CAAC;AACvC,cAAc,0BAA0B,CAAC;AACzC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,iCAAiC,CAAC;AAChD,cAAc,yBAAyB,CAAC;AACxC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,wBAAwB,CAAC;AACvC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,kCAAkC,CAAC;AACjD,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,wBAAwB,CAAC;AACvC,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,gCAAgC,CAAC"}
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../src/core.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,qCAAqC,CAAC;AACpD,cAAc,uBAAuB,CAAC;AACtC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,aAAa,EAAE,YAAY,EAAE,YAAY,EAAE,gBAAgB,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAChM,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,qBAAqB,CAAC;AACpC,cAAc,sCAAsC,CAAC;AACrD,cAAc,mCAAmC,CAAC;AAClD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,4BAA4B,CAAC;AAC3C,OAAO,EAAE,sBAAsB,EAAE,KAAK,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AACnG,cAAc,2BAA2B,CAAC;AAC1C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,yBAAyB,CAAC;AACxC,cAAc,mCAAmC,CAAC;AAClD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,uCAAuC,CAAC;AACtD,cAAc,mCAAmC,CAAC;AAClD,cAAc,2BAA2B,CAAC;AAC1C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC;AACzC,cAAc,kCAAkC,CAAC;AACjD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,sCAAsC,CAAC;AACrD,cAAc,wBAAwB,CAAC;AACvC,cAAc,0BAA0B,CAAC;AACzC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,iCAAiC,CAAC;AAChD,cAAc,yBAAyB,CAAC;AACxC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,wBAAwB,CAAC;AACvC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,kCAAkC,CAAC;AACjD,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,wBAAwB,CAAC;AACvC,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,gCAAgC,CAAC"}

package/dist/safe-bash/core.js

@@ -17,6 +17,7 @@ export { portableSearchCommands } from "./commands/search/portable.js";
 export * from "./commands/bytes/index.js";
 export * from "./commands/diff-patch/index.js";
 export * from "./commands/safejs/index.js";
+export * from "./commands/python/index.js";
 export * from "./commands/node/browser.js";
 export * from "./commands/network/public.js";
 export * from "./commands/llm/index.js";

package/dist/safe-bash/core.js.map

@@ -1 +1 @@
-{"version":3,"file":"core.js","sourceRoot":"","sources":["../src/core.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,qCAAqC,CAAC;AACpD,cAAc,uBAAuB,CAAC;AACtC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,aAAa,EAAE,YAAY,EAAE,YAAY,EAAE,gBAAgB,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAChM,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,qBAAqB,CAAC;AACpC,cAAc,sCAAsC,CAAC;AACrD,cAAc,mCAAmC,CAAC;AAClD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,4BAA4B,CAAC;AAC3C,OAAO,EAAE,sBAAsB,EAA8B,MAAM,+BAA+B,CAAC;AACnG,cAAc,2BAA2B,CAAC;AAC1C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,yBAAyB,CAAC;AACxC,cAAc,mCAAmC,CAAC;AAClD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,uCAAuC,CAAC;AACtD,cAAc,mCAAmC,CAAC;AAClD,cAAc,2BAA2B,CAAC;AAC1C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC;AACzC,cAAc,kCAAkC,CAAC;AACjD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,sCAAsC,CAAC;AACrD,cAAc,wBAAwB,CAAC;AACvC,cAAc,0BAA0B,CAAC;AACzC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,iCAAiC,CAAC;AAChD,cAAc,yBAAyB,CAAC;AACxC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,wBAAwB,CAAC;AACvC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,kCAAkC,CAAC;AACjD,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,wBAAwB,CAAC;AACvC,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,gCAAgC,CAAC"}
+{"version":3,"file":"core.js","sourceRoot":"","sources":["../src/core.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,qCAAqC,CAAC;AACpD,cAAc,uBAAuB,CAAC;AACtC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,aAAa,EAAE,YAAY,EAAE,YAAY,EAAE,gBAAgB,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAChM,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,qBAAqB,CAAC;AACpC,cAAc,sCAAsC,CAAC;AACrD,cAAc,mCAAmC,CAAC;AAClD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,4BAA4B,CAAC;AAC3C,OAAO,EAAE,sBAAsB,EAA8B,MAAM,+BAA+B,CAAC;AACnG,cAAc,2BAA2B,CAAC;AAC1C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,yBAAyB,CAAC;AACxC,cAAc,mCAAmC,CAAC;AAClD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,uCAAuC,CAAC;AACtD,cAAc,mCAAmC,CAAC;AAClD,cAAc,2BAA2B,CAAC;AAC1C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC;AACzC,cAAc,kCAAkC,CAAC;AACjD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,sCAAsC,CAAC;AACrD,cAAc,wBAAwB,CAAC;AACvC,cAAc,0BAA0B,CAAC;AACzC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,iCAAiC,CAAC;AAChD,cAAc,yBAAyB,CAAC;AACxC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,wBAAwB,CAAC;AACvC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,kCAAkC,CAAC;AACjD,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,wBAAwB,CAAC;AACvC,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,gCAAgC,CAAC"}

package/dist/safe-bash/opt-in/commands/cmp/compare.js

@@ -0,0 +1,95 @@
+import { InputError, observe, Session } from "./io.js";
+import { integerMaximum, quote } from "./options.js";
+import { yieldTurn } from "@poe-platform/safe-bash/contracts/yield";
+function displayByte(byte) {
+    const high = byte >= 128;
+    const value = high ? byte - 128 : byte;
+    return `${high ? "M-" : ""}${value < 32 ? `^${String.fromCharCode(value + 64)}` : value === 127 ? "^?" : String.fromCharCode(value)}`;
+}
+function remaining(input, skip) {
+    if (input.stat?.type !== "file" || !Number.isSafeInteger(input.stat.size) || input.stat.size < 0)
+        return undefined;
+    const size = BigInt(input.stat.size);
+    return skip < size ? size - skip : 0n;
+}
+export async function compare(session, args) {
+    const left = await session.open(args.files[0]);
+    if (args.files[0] === args.files[1] && (args.files[0] === "-" || args.skips[0] === args.skips[1] && args.skips[0] <= integerMaximum))
+        return 0;
+    const right = await session.open(args.files[1]);
+    if (left.path !== undefined && right.path !== undefined && args.skips[0] === args.skips[1] && args.skips[0] <= integerMaximum
+        && session.context.fs.compareEntry && await observe(() => session.context.fs.compareEntry(left.path, session.context.fs, right.path, { signal: session.signal }), session.signal) === "same")
+        return 0;
+    const sizes = [remaining(left, args.skips[0]), remaining(right, args.skips[1])];
+    if (args.mode === "silent" && sizes[0] !== undefined && sizes[1] !== undefined && sizes[0] !== sizes[1]
+        && (sizes[0] < sizes[1] ? sizes[0] : sizes[1]) < args.count)
+        return 1;
+    const comparisonBlockBytes = session.comparisonBlockBytes ?? left.stat?.ioBlockSize ?? 65536;
+    if (!Number.isSafeInteger(comparisonBlockBytes) || comparisonBlockBytes < 1) {
+        throw new InputError(left.name, new Error("invalid preferred I/O block size"), false);
+    }
+    let maximum = args.count;
+    for (const size of sizes)
+        if (size !== undefined && size < maximum)
+            maximum = size;
+    const width = maximum.toString().length;
+    const inputs = [left, right];
+    const cursors = inputs.map((input, index) => session.cursor(input, args.skips[index]));
+    for (let index = 0; index < 2; index++) {
+        const skip = args.skips[index];
+        if (skip > integerMaximum && inputs[index].stat?.type !== "file")
+            throw new InputError(inputs[index].name, new Error("Value too large to be stored in data type"), false);
+        if (inputs[index].path === undefined || session.context.fs.readStream && (inputs[index].stat?.type !== "file" || inputs[index].stat.size < 0))
+            await cursors[index].skip(skip);
+        if (inputs[index].stat?.type === "directory")
+            await cursors[index].available();
+    }
+    let compared = 0n, line = 1n, atLineStart = true, work = 0;
+    while (true) {
+        const remaining = args.count - compared;
+        const requested = Number(remaining < BigInt(comparisonBlockBytes) ? remaining : BigInt(comparisonBlockBytes));
+        const first = await cursors[0].block(requested), second = await cursors[1].block(requested);
+        const count = Math.min(first.length, second.length);
+        let different = false, output = "";
+        for (let offset = 0; offset < count; offset++) {
+            const byteLeft = first[offset], byteRight = second[offset];
+            compared++;
+            if (byteLeft !== byteRight) {
+                different = true;
+                if (args.mode === "silent")
+                    return 1;
+                const octalLeft = byteLeft.toString(8).padStart(3, " "), octalRight = byteRight.toString(8).padStart(3, " ");
+                if (args.mode === "first") {
+                    await session.output(`${left.name} ${right.name} differ: ${args.printBytes ? "byte" : "char"} ${compared}, line ${line}${args.printBytes ? ` is ${octalLeft} ${displayByte(byteLeft)} ${octalRight} ${displayByte(byteRight)}` : ""}\n`);
+                    return 1;
+                }
+                output += `${compared.toString().padStart(width, " ")} ${octalLeft} ${args.printBytes ? `${displayByte(byteLeft).padEnd(4, " ")} ` : ""}${octalRight}${args.printBytes ? ` ${displayByte(byteRight)}` : ""}\n`;
+                if (output.length >= 16384) {
+                    await session.output(output);
+                    output = "";
+                }
+            }
+            if (byteLeft === 10)
+                line++;
+            atLineStart = byteLeft === 10;
+        }
+        if (output)
+            await session.output(output);
+        if (first.length !== second.length) {
+            if (args.mode !== "silent") {
+                const name = first.length < second.length ? left.name : right.name;
+                const extra = compared === 0n ? "which is empty" : args.mode === "all" ? `after byte ${compared}`
+                    : `after byte ${compared}, ${atLineStart ? "line" : "in line"} ${atLineStart ? line - 1n : line}`;
+                await session.output(`cmp: EOF on ${quote(name)} ${extra}\n`, true);
+            }
+            return 1;
+        }
+        if (first.length !== comparisonBlockBytes)
+            return different ? 1 : 0;
+        work += count;
+        if (work >= 65536) {
+            await yieldTurn(session.signal);
+            work = 0;
+        }
+    }
+}

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

@@ -0,0 +1,6 @@
+import { type CommandDefinition, type VirtualShellPlugin } from "@poe-platform/safe-bash/contracts/index";
+import { type CmpCommandsOptions } from "./options.js";
+export type { CmpCommandsOptions, CmpLimits } from "./options.js";
+export declare function createCmpCommand(options?: CmpCommandsOptions): CommandDefinition;
+export declare function createCmpCommands(options?: CmpCommandsOptions): readonly CommandDefinition[];
+export declare function cmpCommands(options?: CmpCommandsOptions): VirtualShellPlugin;

package/dist/safe-bash/opt-in/commands/cmp/index.js

@@ -0,0 +1,99 @@
+import { commandRuntimeIdentity } from "@poe-platform/safe-bash/contracts/index";
+import { compare } from "./compare.js";
+import { errorText, InputError, inputDiagnostic, Session } from "./io.js";
+import { limitsFor, parseArguments, UsageError } from "./options.js";
+export function createCmpCommand(options = {}) {
+    const limits = limitsFor(options);
+    const comparisonBlockBytes = options.comparisonBlockBytes;
+    if (comparisonBlockBytes !== undefined && (!Number.isSafeInteger(comparisonBlockBytes) || comparisonBlockBytes < 1)) {
+        throw new RangeError("cmp comparisonBlockBytes must be a positive safe integer");
+    }
+    return {
+        name: "cmp", runtimeIdentity: commandRuntimeIdentity, description: "Compare two inputs byte by byte",
+        async execute(context) {
+            context.signal.throwIfAborted();
+            const session = new Session(context, limits, comparisonBlockBytes);
+            let silent = false, exitCode = 0;
+            let failure;
+            try {
+                const args = parseArguments(context.args, context.env.POSIXLY_CORRECT !== undefined);
+                silent = args.mode === "silent";
+                if (args.information) {
+                    await session.output(args.information === "version" ? "cmp (virtual-bash, GNU diffutils 3.12 profile)\n"
+                        : `Usage: cmp [OPTION]... FILE1 [FILE2 [SKIP1 [SKIP2]]]
+Compare two files byte by byte.
+
+The optional SKIP1 and SKIP2 specify the number of bytes to skip
+at the beginning of each file (zero by default).
+
+Mandatory arguments to long options are mandatory for short options too.
+  -b, --print-bytes          print differing bytes
+  -i, --ignore-initial=SKIP         skip first SKIP bytes of both inputs
+  -i, --ignore-initial=SKIP1:SKIP2  skip first SKIP1 bytes of FILE1 and
+                                      first SKIP2 bytes of FILE2
+  -l, --verbose              output byte numbers and differing byte values
+  -n, --bytes=LIMIT          compare at most LIMIT bytes
+  -s, --quiet, --silent      suppress all normal output
+      --help                 display this help and exit
+  -v, --version              output version information and exit
+
+SKIP values may be followed by the following multiplicative suffixes:
+kB 1000, K 1024, MB 1,000,000, M 1,048,576,
+GB 1,000,000,000, G 1,073,741,824, and so on for T, P, E, Z, Y.
+
+If a FILE is '-' or missing, read standard input.
+Exit status is 0 if inputs are the same, 1 if different, 2 if trouble.
+
+Report bugs to: bug-diffutils@gnu.org
+GNU diffutils home page: <https://www.gnu.org/software/diffutils/>
+General help using GNU software: <https://www.gnu.org/gethelp/>
+`);
+                }
+                else
+                    exitCode = await compare(session, args);
+            }
+            catch (error) {
+                failure = { reason: error };
+            }
+            try {
+                await session.close(false);
+            }
+            catch (error) {
+                failure ??= { reason: error };
+            }
+            context.signal.throwIfAborted();
+            session.signal.throwIfAborted();
+            if (!failure)
+                return { exitCode };
+            const error = failure.reason;
+            if (error instanceof UsageError)
+                await session.output(`cmp: ${error.message}\ncmp: Try 'cmp --help' for more information.\n`, true);
+            else if (error instanceof InputError) {
+                if (!silent || !error.opening)
+                    await session.output(inputDiagnostic(error), true);
+            }
+            else
+                await session.output(`cmp: ${errorText(error)}\n`, true);
+            return { exitCode: 2 };
+        },
+    };
+}
+export function createCmpCommands(options = {}) {
+    return Object.freeze([createCmpCommand(options)]);
+}
+export function cmpCommands(options = {}) {
+    const commands = createCmpCommands(options);
+    const replace = options.replace ?? false;
+    return {
+        name: "cmp-commands",
+        setup(host) {
+            if (!replace)
+                for (const command of commands) {
+                    if (host.commands.has(command.name))
+                        throw new Error(`Command already registered: ${command.name}`);
+                }
+            for (const command of commands)
+                host.commands.register(command, { replace });
+        },
+    };
+}

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

@@ -0,0 +1,218 @@
+import { FsError, readBytes, resolvePath, writeBytes } from "@poe-platform/safe-bash/contracts/index";
+import { integerMaximum, pathQuote } from "./options.js";
+import { yieldTurn } from "@poe-platform/safe-bash/contracts/yield";
+export async function observe(operation, signal) {
+    signal.throwIfAborted();
+    return new Promise((resolve, reject) => {
+        const abort = () => { signal.removeEventListener("abort", abort); reject(signal.reason); };
+        signal.addEventListener("abort", abort, { once: true });
+        Promise.resolve().then(() => { signal.throwIfAborted(); return operation(); }).then(value => {
+            signal.removeEventListener("abort", abort);
+            resolve(value);
+        }, error => {
+            signal.removeEventListener("abort", abort);
+            reject(error);
+        });
+    });
+}
+export class InputError extends Error {
+    operand;
+    reason;
+    opening;
+    constructor(operand, reason, opening) {
+        super("cmp input failure");
+        this.operand = operand;
+        this.reason = reason;
+        this.opening = opening;
+    }
+}
+const errnoMessages = {
+    ENOENT: "No such file or directory", EACCES: "Permission denied", EPERM: "Operation not permitted",
+    EISDIR: "Is a directory", ENOTDIR: "Not a directory", EIO: "Input/output error", EBADF: "Bad file descriptor",
+    ELOOP: "Too many levels of symbolic links", ENAMETOOLONG: "File name too long", ENOSPC: "No space left on device",
+    EMFILE: "Too many open files", ENFILE: "Too many open files in system", EPIPE: "Broken pipe",
+    EOVERFLOW: "Value too large to be stored in data type", ENOTSUP: "Operation not supported", EFBIG: "File too large",
+};
+export function errorText(error) {
+    if (error instanceof FsError)
+        return errnoMessages[error.code] ?? error.message;
+    return error instanceof Error ? error.message : String(error);
+}
+export class Cursor {
+    operand;
+    signal;
+    maxChunkBytes;
+    reader;
+    chunk = new Uint8Array();
+    offset = 0;
+    done = false;
+    closed;
+    returned;
+    untilYield = 65536;
+    constructor(operand, source, signal, maxChunkBytes) {
+        this.operand = operand;
+        this.signal = signal;
+        this.maxChunkBytes = maxChunkBytes;
+        this.reader = readBytes({
+            [Symbol.asyncIterator]: () => {
+                const iterator = source[Symbol.asyncIterator]();
+                return {
+                    next: () => iterator.next(),
+                    return: () => {
+                        this.returned ??= Promise.resolve().then(() => iterator.return ? iterator.return() : { value: undefined, done: true });
+                        return this.returned;
+                    },
+                };
+            },
+        }, signal);
+    }
+    async available() {
+        try {
+            this.signal.throwIfAborted();
+            while (!this.done && this.offset === this.chunk.length) {
+                if (this.untilYield <= 0) {
+                    await yieldTurn(this.signal);
+                    this.untilYield = 65536;
+                }
+                const next = await this.reader.next();
+                this.done = Boolean(next.done);
+                if (next.done) {
+                    this.chunk = new Uint8Array();
+                    this.offset = 0;
+                    break;
+                }
+                if (next.value.byteLength > this.maxChunkBytes)
+                    throw new Error("input chunk bytes limit exceeded");
+                this.untilYield -= Math.max(64, next.value.byteLength);
+                this.chunk = new Uint8Array(next.value);
+                this.offset = 0;
+            }
+            return this.chunk.subarray(this.offset);
+        }
+        catch (error) {
+            this.signal.throwIfAborted();
+            throw new InputError(this.operand, error, false);
+        }
+    }
+    consume(count) { this.offset += count; }
+    async block(count) {
+        const bytes = new Uint8Array(count);
+        let size = 0;
+        while (size < count) {
+            const chunk = await this.available();
+            if (!chunk.length)
+                break;
+            const length = Math.min(count - size, chunk.length);
+            bytes.set(chunk.subarray(0, length), size);
+            this.consume(length);
+            size += length;
+        }
+        return bytes.subarray(0, size);
+    }
+    async skip(count) {
+        while (count > 0n) {
+            const chunk = await this.available();
+            if (!chunk.length)
+                break;
+            const amount = Number(count < BigInt(chunk.length) ? count : BigInt(chunk.length));
+            this.consume(amount);
+            count -= BigInt(amount);
+        }
+    }
+    close() {
+        this.closed ??= (async () => {
+            try {
+                await this.reader.return(undefined);
+                await this.returned;
+            }
+            catch (error) {
+                throw new InputError(this.operand, error, false);
+            }
+            finally {
+                this.chunk = new Uint8Array();
+            }
+        })();
+        return this.closed;
+    }
+}
+export class Session {
+    context;
+    limits;
+    comparisonBlockBytes;
+    controller = new AbortController();
+    signal;
+    cursors = [];
+    closed;
+    constructor(context, limits, comparisonBlockBytes) {
+        this.context = context;
+        this.limits = limits;
+        this.comparisonBlockBytes = comparisonBlockBytes;
+        this.signal = AbortSignal.any([context.signal, this.controller.signal]);
+        context.registerCleanup?.(() => this.close());
+    }
+    async open(name) {
+        this.signal.throwIfAborted();
+        if (name === "-")
+            return { name };
+        try {
+            if (!name)
+                throw new FsError("ENOENT");
+            const path = resolvePath(this.context.cwd, name);
+            const stat = await observe(() => this.context.fs.stat(path, { signal: this.signal }), this.signal);
+            this.signal.throwIfAborted();
+            await observe(() => this.context.fs.access(path, 4, { signal: this.signal }), this.signal);
+            this.signal.throwIfAborted();
+            return { name, path, stat };
+        }
+        catch (error) {
+            this.signal.throwIfAborted();
+            throw new InputError(name, error, true);
+        }
+    }
+    cursor(input, skip) {
+        this.signal.throwIfAborted();
+        const { context, signal, limits } = this;
+        const source = input.path === undefined ? context.stdin : (async function* () {
+            if (input.stat?.type === "directory")
+                throw new FsError("EISDIR");
+            if (skip > integerMaximum && input.stat?.type === "file")
+                return;
+            if (context.fs.readStream) {
+                const start = input.stat?.type === "file" && input.stat.size >= 0 ? Number(skip < BigInt(Number.MAX_SAFE_INTEGER) ? skip : BigInt(Number.MAX_SAFE_INTEGER)) : 0;
+                yield* context.fs.readStream(input.path, { signal, start, chunkSize: Math.min(65536, limits.maxChunkBytes) });
+            }
+            else {
+                if (!input.stat || !Number.isSafeInteger(input.stat.size) || input.stat.size < 0 || input.stat.size > limits.maxFallbackBytes) {
+                    throw new Error("bounded comparison requires readStream or a file within maxFallbackBytes");
+                }
+                const bytes = await observe(() => context.fs.readFile(input.path, { signal, maxBytes: limits.maxFallbackBytes }), signal);
+                if (bytes.length > limits.maxFallbackBytes)
+                    throw new Error("input fallback bytes limit exceeded");
+                for (let offset = Number(skip < BigInt(bytes.length) ? skip : BigInt(bytes.length)); offset < bytes.length; offset += limits.maxChunkBytes)
+                    yield bytes.subarray(offset, offset + limits.maxChunkBytes);
+            }
+        })();
+        const cursor = new Cursor(input.name, source, signal, limits.maxChunkBytes);
+        this.cursors.push(cursor);
+        return cursor;
+    }
+    async output(text, stderr = false) {
+        await writeBytes(stderr ? this.context.stderr : this.context.stdout, new TextEncoder().encode(text), this.signal);
+    }
+    close(cancel = true) {
+        if (!this.closed) {
+            this.closed = Promise.resolve().then(async () => {
+                const results = await Promise.allSettled(this.cursors.map(cursor => cursor.close()));
+                const failure = results.find(result => result.status === "rejected");
+                if (failure?.status === "rejected")
+                    throw failure.reason;
+            });
+            if (cancel)
+                this.controller.abort(new Error("cmp invocation closed"));
+        }
+        return this.closed;
+    }
+}
+export function inputDiagnostic(error) {
+    return `cmp: ${pathQuote(error.operand)}: ${errorText(error.reason)}\n`;
+}

package/dist/safe-bash/opt-in/commands/cmp/options.d.ts

@@ -0,0 +1,24 @@
+export interface CmpLimits {
+    readonly maxChunkBytes: number;
+    readonly maxFallbackBytes: number;
+}
+export interface CmpCommandsOptions {
+    readonly replace?: boolean;
+    readonly comparisonBlockBytes?: number;
+    readonly limits?: Partial<CmpLimits>;
+}
+export declare const integerMaximum = 9223372036854775807n;
+export interface CmpArguments {
+    readonly files: readonly [string, string];
+    readonly skips: readonly [bigint, bigint];
+    readonly count: bigint;
+    readonly mode: "first" | "all" | "silent";
+    readonly printBytes: boolean;
+    readonly information?: "help" | "version";
+}
+export declare class UsageError extends Error {
+}
+export declare function quote(value: string): string;
+export declare function pathQuote(value: string): string;
+export declare function parseArguments(args: readonly string[], posix: boolean): CmpArguments;
+export declare function limitsFor(options: CmpCommandsOptions): CmpLimits;