@poe-platform/safe-bash 0.1.788 → 0.1.790

package/dist/safe-bash/commands/basic.js

@@ -1,6 +1,6 @@
 import { writeDiagnostic } from "../escaping.js";
-import { basename, dirname, getCommandArguments } from "../contracts/index.js";
-import { define, escapeBytes, options, output, requireOperands, UsageError, value } from "./internal.js";
+import { FsError, getCommandArguments } from "../contracts/index.js";
+import { define, escapeBytes, options, output, requireOperands, UsageError } from "./internal.js";
 import { assertCommandRequirements } from "../contracts/command-requirements.js";
 import { pwdRequirements } from "./portable-requirements.js";
 import { printfInteger } from "./printf-integer.js";
@@ -8,6 +8,8 @@ import { printfHex } from "./printf-hex.js";
 import { parsePrintfFloat } from "./printf-float.js";
 import { printfDecimal } from "./printf-decimal.js";
 import { parsePrintfDirective } from "./printf-format.js";
+import { quotePrintf } from "./printf-quote.js";
+import { widePrintf } from "./printf-wide.js";
 const utf8Encoder = new TextEncoder();
 export const defaultEchoExecutors = new WeakSet();
 export function basicCommands() {
@@ -16,10 +18,12 @@ export function basicCommands() {
         define("false", () => ({ exitCode: 1 })),
         define("echo", async (context) => {
             const arguments_ = getCommandArguments(context);
+            const external = context.externalInvocation === true;
+            const posix = external && context.env.POSIXLY_CORRECT !== undefined;
             let newline = true;
             let escapes = false;
             let offset = 0;
-            while (/^-[neE]+$/u.test(arguments_.args[offset] ?? "")) {
+            while ((!posix || arguments_.args[0] === "-n") && /^-[neE]+$/u.test(arguments_.args[offset] ?? "")) {
                 for (const flag of arguments_.args[offset].slice(1)) {
                     if (flag === "n")
                         newline = false;
@@ -28,10 +32,16 @@ export function basicCommands() {
                 }
                 offset++;
             }
+            if (posix)
+                escapes = true;
             const joined = arguments_.slice(offset).join(" ");
             const text = typeof joined === "string" ? joined : arguments_.withValues([joined]).bytes(0);
             if (escapes) {
-                const escaped = escapeBytes(text, true);
+                const locale = context.env.LC_ALL || context.env.LC_CTYPE || context.env.LANG || "C.UTF-8";
+                const escaped = escapeBytes(text, true, external, external ? undefined : {
+                    utf8: locale !== "C" && locale !== "POSIX",
+                    missingDigit() { },
+                });
                 if (escaped.stop)
                     newline = false;
                 if (newline) {
@@ -59,10 +69,21 @@ export function basicCommands() {
             return { exitCode: 0 };
         }),
         define("pwd", async (context) => {
-            let mode = context.externalInvocation && context.env.POSIXLY_CORRECT === undefined ? "physical" : "logical";
-            for (const arg of context.args) {
-                if (arg === "--" || !arg.startsWith("-") || arg === "-")
+            const external = context.externalInvocation === true;
+            let mode = external && context.env.POSIXLY_CORRECT === undefined ? "physical" : "logical";
+            let ignored = false;
+            for (let index = 0; index < context.args.length; index++) {
+                const arg = context.args[index];
+                if (arg === "--") {
+                    ignored ||= index + 1 < context.args.length;
                     break;
+                }
+                if (!arg.startsWith("-") || arg === "-") {
+                    ignored = true;
+                    if (!external || context.env.POSIXLY_CORRECT !== undefined)
+                        break;
+                    continue;
+                }
                 if (arg === "--logical") {
                     mode = "logical";
                     continue;
@@ -72,39 +93,102 @@ export function basicCommands() {
                     continue;
                 }
                 for (const flag of arg.slice(1)) {
-                    if (flag !== "L" && flag !== "P")
-                        throw new UsageError(`invalid option '${flag}'`);
+                    if (flag !== "L" && flag !== "P") {
+                        if (!external)
+                            throw new UsageError(`invalid option '${flag}'`);
+                        await writeDiagnostic(context.stderr, `pwd: invalid option '${flag}'\n`, context.signal);
+                        return { exitCode: 1 };
+                    }
                     mode = flag === "P" ? "physical" : "logical";
                 }
             }
-            assertCommandRequirements(context, pwdRequirements, [mode]);
-            if (mode === "physical" && context.fs.capabilitiesFor)
-                assertCommandRequirements(context, pwdRequirements, [mode], await context.fs.capabilitiesFor(context.cwd, { signal: context.signal }));
-            await output(context, `${mode === "physical" ? await context.fs.realpath(context.cwd, { signal: context.signal }) : context.cwd}\n`);
+            if (external && ignored)
+                await writeDiagnostic(context.stderr, "pwd: ignoring non-option arguments\n", context.signal);
+            const requiredMode = external ? "physical" : mode;
+            assertCommandRequirements(context, pwdRequirements, [requiredMode]);
+            if (requiredMode === "physical" && context.fs.capabilitiesFor)
+                assertCommandRequirements(context, pwdRequirements, [requiredMode], await context.fs.capabilitiesFor(context.cwd, { signal: context.signal }));
+            let directory = requiredMode === "physical" ? await context.fs.realpath(context.cwd, { signal: context.signal }) : context.cwd;
+            context.signal.throwIfAborted();
+            if (external && mode === "logical") {
+                const logical = context.env.PWD;
+                if (logical?.startsWith("/") && !logical.split("/").some(component => component === "." || component === "..")) {
+                    try {
+                        if (await context.fs.realpath(logical, { signal: context.signal }) === directory)
+                            directory = logical;
+                    }
+                    catch (error) {
+                        context.signal.throwIfAborted();
+                        if (!(error instanceof FsError) || !["ENOENT", "ENOTDIR", "EACCES", "ELOOP"].includes(error.code))
+                            throw error;
+                    }
+                }
+            }
+            await output(context, `${directory}\n`);
             return { exitCode: 0 };
         }),
         define("basename", async (context) => {
-            const parsed = options(context.args, "as:z", { multiple: "a", suffix: "s", zero: "z" }, true);
+            const arguments_ = getCommandArguments(context);
+            const operands = [];
+            let suffix;
+            const parsed = options(arguments_.args, "as:z", { multiple: "a", suffix: "s", zero: "z" }, true, index => { operands.push(index); }, (_key, index, offset) => { suffix = arguments_.bytes(index).subarray(offset); });
             const multiple = parsed.flags.has("a") || parsed.flags.has("s");
             requireOperands(parsed.operands, 1, multiple ? Infinity : 2);
-            const suffix = value(parsed, "s") ?? (multiple ? undefined : parsed.operands[1]);
-            for (const operand of multiple ? parsed.operands : parsed.operands.slice(0, 1)) {
-                let result = /^\/+$/u.test(operand) ? "/" : basename(operand);
-                if (suffix && result !== suffix && result.endsWith(suffix))
-                    result = result.slice(0, -suffix.length);
-                await output(context, result + (parsed.flags.has("z") ? "\0" : "\n"));
+            if (!multiple && operands.length === 2)
+                suffix = arguments_.bytes(operands[1]);
+            for (const index of multiple ? operands : operands.slice(0, 1)) {
+                const operand = arguments_.bytes(index);
+                let end = operand.length;
+                while (end > 0 && operand[end - 1] === 47)
+                    end--;
+                let start = end;
+                while (start > 0 && operand[start - 1] !== 47)
+                    start--;
+                if (end === 0 && operand.length > 0)
+                    end = 1;
+                if (suffix?.length && suffix.length < end - start) {
+                    let matches = true;
+                    for (let offset = 0; offset < suffix.length; offset++) {
+                        if (operand[end - suffix.length + offset] !== suffix[offset]) {
+                            matches = false;
+                            break;
+                        }
+                    }
+                    if (matches)
+                        end -= suffix.length;
+                }
+                const result = new Uint8Array(end - start + 1);
+                result.set(operand.subarray(start, end));
+                result[result.length - 1] = parsed.flags.has("z") ? 0 : 10;
+                await output(context, result);
             }
             return { exitCode: 0 };
         }, 1, 1),
         define("dirname", async (context) => {
-            const parsed = options(context.args, "z", { zero: "z" }, true);
+            const arguments_ = getCommandArguments(context);
+            const operands = [];
+            const parsed = options(arguments_.args, "z", { zero: "z" }, context.env.POSIXLY_CORRECT !== undefined, index => { operands.push(index); });
             requireOperands(parsed.operands);
-            for (const operand of parsed.operands) {
-                const parent = dirname(operand);
-                let end = parent.length;
-                while (end > 1 && parent[end - 1] === "/")
+            for (const index of operands) {
+                const operand = arguments_.bytes(index);
+                let end = operand.length;
+                while (end > 0 && operand[end - 1] === 47)
                     end--;
-                await output(context, parent.slice(0, end) + (parsed.flags.has("z") ? "\0" : "\n"));
+                if (end === 0 && operand.length > 0)
+                    end = 1;
+                else {
+                    while (end > 0 && operand[end - 1] !== 47)
+                        end--;
+                    while (end > 1 && operand[end - 1] === 47)
+                        end--;
+                }
+                const result = new Uint8Array((end || 1) + 1);
+                if (end)
+                    result.set(operand.subarray(0, end));
+                else
+                    result[0] = 46;
+                result[result.length - 1] = parsed.flags.has("z") ? 0 : 10;
+                await output(context, result);
             }
             return { exitCode: 0 };
         }, 1, 1),
@@ -155,7 +239,7 @@ export async function formatPrintf(context) {
                 const end = rawFormat ? rawFormat.indexOf(37, offset) : format.indexOf("%", offset);
                 const limit = end < 0 ? formatLength : end;
                 const literal = rawFormat ? rawFormat.subarray(offset, limit) : format.slice(offset, limit);
-                const escaped = escapeBytes(literal, false, false, unicode);
+                const escaped = escapeBytes(literal, false, false, unicode, true);
                 for (const escape of escapeErrors.splice(0))
                     await writeDiagnostic(context.stderr, `printf: missing ${escape === "x" ? "hex" : "unicode"} digit for \\${escape}\n`, context.signal);
                 await output(context, escaped.bytes);
@@ -200,6 +284,19 @@ export async function formatPrintf(context) {
             const supplied = args[suppliedIndex] ?? "";
             let text;
             let specialFloat;
+            if (specifier === "S" || specifier === "C") {
+                const suppliedBytes = arguments_.bytes(suppliedIndex) ?? new Uint8Array();
+                const wide = unicode.utf8 ? await widePrintf(suppliedBytes, specifier === "C", precision, context.signal)
+                    : specifier === "C" ? { bytes: suppliedBytes.length ? suppliedBytes.subarray(0, 1) : Uint8Array.of(0), characters: 1 }
+                        : { bytes: suppliedBytes.subarray(0, precision), characters: Math.min(suppliedBytes.length, precision ?? suppliedBytes.length) };
+                const padding = " ".repeat(Math.max(0, width - wide.characters));
+                if (!flags.includes("-"))
+                    await output(context, padding);
+                await output(context, wide.bytes);
+                if (flags.includes("-"))
+                    await output(context, padding);
+                continue;
+            }
             if (specifier === "b" || specifier === "s") {
                 const suppliedValue = arguments_.values[suppliedIndex] ?? "";
                 const raw = specifier === "b" && typeof suppliedValue === "string" ? suppliedValue : arguments_.bytes(suppliedIndex) ?? new Uint8Array();
@@ -226,25 +323,17 @@ export async function formatPrintf(context) {
                     await output(context, padding);
                 continue;
             }
-            if (specifier === "q") {
-                const bytes = arguments_.bytes(suppliedIndex) ?? new Uint8Array();
-                if (bytes.some(byte => byte < 32 || byte === 127 || byte >= 128)) {
-                    const controls = { 7: "\\a", 8: "\\b", 9: "\\t", 10: "\\n", 11: "\\v", 12: "\\f", 13: "\\r", 27: "\\E" };
-                    text = "$'";
-                    for (const byte of bytes) {
-                        if (controls[byte])
-                            text += controls[byte];
-                        else if (byte < 32 || byte === 127 || byte >= 128)
-                            text += `\\${byte.toString(8).padStart(3, "0")}`;
-                        else if (byte === 39 || byte === 92)
-                            text += `\\${String.fromCharCode(byte)}`;
-                        else
-                            text += String.fromCharCode(byte);
-                    }
-                    text += "'";
-                }
-                else
-                    text = supplied === "" ? "''" : supplied.replace(/[^a-zA-Z0-9_./-]/gu, character => `\\${character}`);
+            if (specifier === "q" || specifier === "Q") {
+                const suppliedBytes = arguments_.bytes(suppliedIndex) ?? new Uint8Array();
+                const quoted = await quotePrintf(specifier === "Q" ? suppliedBytes.subarray(0, precision) : suppliedBytes, unicode.utf8, context.signal, flags.includes("#"));
+                const bytes = specifier === "Q" ? quoted : quoted.subarray(0, precision);
+                const padding = " ".repeat(Math.max(0, width - bytes.length));
+                if (!flags.includes("-"))
+                    await output(context, padding);
+                await output(context, bytes);
+                if (flags.includes("-"))
+                    await output(context, padding);
+                continue;
             }
             else {
                 let number = supplied === "" ? 0 : /^["']/u.test(supplied) ? quotedNumber(suppliedIndex) : Number(supplied);
@@ -261,6 +350,10 @@ export async function formatPrintf(context) {
                     const parsed = parsePrintfFloat(supplied);
                     number = parsed?.value ?? NaN;
                     specialFloat = parsed?.special;
+                    if (parsed?.error) {
+                        await writeDiagnostic(context.stderr, `printf: '${supplied}': ${parsed.error}\n`, context.signal);
+                        exitCode = 1;
+                    }
                 }
                 if ("fFeEgGaA".includes(specifier) && (!Number.isFinite(number) && specialFloat === undefined || supplied === "" && suppliedIndex < args.length)) {
                     await writeDiagnostic(context.stderr, `printf: '${supplied}': invalid number\n`, context.signal);
@@ -342,6 +435,9 @@ export function tryFastEcho(args) {
     if (!escapes) {
         return newline ? `${text}\n` : text;
     }
+    // Unicode escapes depend on the command environment, which this path lacks.
+    if (text.includes("\\u") || text.includes("\\U"))
+        return undefined;
     const escaped = escapeBytes(text, true);
     for (let i = 0; i < escaped.bytes.byteLength; i++) {
         const b = escaped.bytes[i];
@@ -576,7 +672,9 @@ export function tryFastPrintf(args, allowNull = false) {
             }
             if (conv === 100 || conv === 105) {
                 const rawVal = args[argument++] ?? "0";
-                const val = rawVal.length === 0 ? "0" : rawVal;
+                if (rawVal.length === 0)
+                    return undefined;
+                const val = rawVal;
                 if (val.length > 15)
                     return undefined;
                 const first = val.charCodeAt(0);
@@ -628,7 +726,9 @@ export function tryFastPrintf(args, allowNull = false) {
             }
             if (conv === 120 || conv === 88 || conv === 111 || conv === 117) {
                 const rawVal = args[argument++] ?? "0";
-                const val = rawVal.length === 0 ? "0" : rawVal;
+                if (rawVal.length === 0)
+                    return undefined;
+                const val = rawVal;
                 if (val.length > 15)
                     return undefined;
                 if (val.length > 1 && val.charCodeAt(0) === 48)

package/dist/safe-bash/commands/bytes/compression/index.js

@@ -12,16 +12,16 @@ const parseSyncCompressionOptions = createOptionsParser([
     { ...formats.xz, format: "xz", names: ["xz", "unxz", "xzcat"] },
     { ...formats.xz, suffix: ".lzma", format: "xz", names: ["lzma", "unlzma", "lzcat"] },
 ]);
+import { createBzip2Commands } from "../../../../safe-bash-command-bzip2/index.js";
 import { createXzCommands } from "../../../../safe-bash-command-xz/index.js";
 import { runOperand } from "../../../../safe-bash-compression-engine/operand.js";
 import { DecodedBudget } from "./stream.js";
-import { CompressedDataError } from "./errors.js";
 export function createCompressionCommands(config = {}) {
     const maxDecodedBytes = config.maxDecodedBytes;
     if (maxDecodedBytes !== undefined && maxDecodedBytes !== Infinity && (!Number.isSafeInteger(maxDecodedBytes) || maxDecodedBytes < 0)) {
         throw new RangeError("maxDecodedBytes must be a nonnegative safe integer or Infinity");
     }
-    const commands = profiles.flatMap(profile => profile.names).map((name) => define(name, async (context) => {
+    const commands = profiles.flatMap(profile => profile.format === "bzip2" ? createBzip2Commands(config) : profile.names.map((name) => define(name, async (context) => {
         const options = parseOptions(name, context.args);
         if (options.help) {
             await output(context, `Usage: ${name} [OPTION]... [FILE]...\n-c, --stdout, --to-stdout\n-d, --decompress, --uncompress\n-k, --keep\n-f, --force\n-t, --test\n${options.format === "zstd" ? "-1..-9, --best\nHigher levels and --fast[=NUM] are unsupported by the bounded codec.\n" : "-1..-9, --fast, --best\n"}${options.format === "zstd" ? "-q, --quiet (repeat to suppress errors)\n" : ""}${options.format === "gzip" ? "-q, --quiet (suppress warnings)\n-r, --recursive (traverse directories without following symlinks)\n-n, --no-name (always enabled)\n" : `Default compression level: ${options.level}.\n`}-h, --help\nNo FILE or FILE '-' uses stdin; file output uses private VFS staging.\n`);
@@ -73,17 +73,16 @@ export function createCompressionCommands(config = {}) {
                 context.signal.throwIfAborted();
                 if (options.quiet < 2)
                     await diagnostic(context, error);
-                const failureCode = options.format === "bzip2" && error instanceof CompressedDataError ? 2 : 1;
-                exitCode = options.format === "bzip2" ? Math.max(exitCode, failureCode) : failureCode;
+                exitCode = 1;
                 if (decodedBudget.exceeded)
                     break;
             }
         }
         return { exitCode };
-    }));
+    })));
     const xzCmds = createXzCommands(config);
     if (maxDecodedBytes === undefined || maxDecodedBytes === Infinity) {
-        for (const c of xzCmds)
+        for (const c of [...commands, ...xzCmds])
             builtInDirectContextExecutors.add(c.execute);
     }
     return [...commands.slice(0, 6), ...xzCmds, ...commands.slice(6)];

package/dist/safe-bash/commands/cmp.d.ts

@@ -1,4 +1,3 @@
-import { type CommandDefinition } from "../contracts/index.js";
-export declare function cmpCommand(): CommandDefinition;
-export declare function evalSyncCmp(inBytes: Uint8Array | undefined, opArgs: readonly string[], readFileSync?: (path: string) => Uint8Array | undefined): string | undefined;
+export * from "../../safe-bash-command-cmp/index.js";
+export { createCmpCommand, createCmpCommands, cmpCommands, cmpCommand, evalSyncCmp } from "../../safe-bash-command-cmp/index.js";
 //# sourceMappingURL=cmp.d.ts.map