just-bash-nx 2.14.4

package/dist/commands/seq/seq.d.ts

@@ -0,0 +1,16 @@
+import type { Command } from "../../types.js";
+/**
+ * seq - print a sequence of numbers
+ *
+ * Usage:
+ *   seq LAST           - print numbers from 1 to LAST
+ *   seq FIRST LAST     - print numbers from FIRST to LAST
+ *   seq FIRST INCR LAST - print numbers from FIRST to LAST by INCR
+ *
+ * Options:
+ *   -s STRING  use STRING to separate numbers (default: newline)
+ *   -w         equalize width by padding with leading zeros
+ */
+export declare const seqCommand: Command;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/sleep/sleep.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from "../../types.js";
+export declare const sleepCommand: Command;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/sort/comparator.d.ts

@@ -0,0 +1,9 @@
+import type { SortOptions } from "./types.js";
+/**
+ * Create a comparison function for sorting
+ */
+export declare function createComparator(options: SortOptions): (a: string, b: string) => number;
+/**
+ * Filter unique lines based on key values or whole line
+ */
+export declare function filterUnique(lines: string[], options: SortOptions): string[];

package/dist/commands/sort/parser.d.ts

@@ -0,0 +1,11 @@
+import type { KeySpec } from "./types.js";
+/**
+ * Parse a key specification like:
+ * - "1" - field 1
+ * - "1,2" - fields 1 through 2
+ * - "1.3" - field 1 starting at char 3
+ * - "1.3,2.5" - field 1 char 3 through field 2 char 5
+ * - "1n" - field 1, numeric
+ * - "1,2nr" - fields 1-2, numeric and reverse
+ */
+export declare function parseKeySpec(spec: string): KeySpec | null;

package/dist/commands/sort/sort.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from "../../types.js";
+export declare const sortCommand: Command;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/sort/types.d.ts

@@ -0,0 +1,30 @@
+export interface KeySpec {
+    startField: number;
+    startChar?: number;
+    endField?: number;
+    endChar?: number;
+    numeric?: boolean;
+    reverse?: boolean;
+    ignoreCase?: boolean;
+    ignoreLeading?: boolean;
+    humanNumeric?: boolean;
+    versionSort?: boolean;
+    dictionaryOrder?: boolean;
+    monthSort?: boolean;
+}
+export interface SortOptions {
+    reverse: boolean;
+    numeric: boolean;
+    unique: boolean;
+    ignoreCase: boolean;
+    humanNumeric: boolean;
+    versionSort: boolean;
+    dictionaryOrder: boolean;
+    monthSort: boolean;
+    ignoreLeadingBlanks: boolean;
+    stable: boolean;
+    checkOnly: boolean;
+    outputFile: string | null;
+    keys: KeySpec[];
+    fieldDelimiter: string | null;
+}

package/dist/commands/split/split.d.ts

@@ -0,0 +1,12 @@
+/**
+ * split - split a file into pieces
+ *
+ * Usage: split [OPTION]... [FILE [PREFIX]]
+ *
+ * Output pieces of FILE to PREFIXaa, PREFIXab, ...;
+ * default size is 1000 lines, and default PREFIX is 'x'.
+ */
+import type { Command } from "../../types.js";
+export declare const split: Command;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/sqlite3/formatters.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Output formatters for sqlite3 command
+ */
+export type OutputMode = "list" | "csv" | "json" | "line" | "column" | "table" | "markdown" | "tabs" | "box" | "quote" | "html" | "ascii";
+export interface FormatOptions {
+    mode: OutputMode;
+    header: boolean;
+    separator: string;
+    nullValue: string;
+    newline: string;
+}
+/**
+ * Format query results according to the specified options
+ */
+export declare function formatOutput(columns: string[], rows: unknown[][], options: FormatOptions): string;

package/dist/commands/sqlite3/sqlite3.d.ts

@@ -0,0 +1,22 @@
+/**
+ * sqlite3 - SQLite database CLI
+ *
+ * Wraps sql.js (WASM) to provide SQLite database access through the virtual filesystem.
+ * Databases are loaded from buffers and written back after modifications.
+ *
+ * Queries run in a worker thread with a timeout to prevent runaway queries
+ * (e.g., infinite recursive CTEs) from blocking execution.
+ *
+ * Security: sql.js is fully sandboxed - it cannot access the real filesystem,
+ * making ATTACH DATABASE and VACUUM INTO safe (they only operate on virtual buffers).
+ */
+import { Worker } from "node:worker_threads";
+import type { Command } from "../../types.js";
+import type { WorkerInput } from "./worker.js";
+/** @internal Exposed for testing only */
+export declare const _internals: {
+    createWorker(workerPath: string, input: WorkerInput): Worker;
+};
+export declare const sqlite3Command: Command;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/sqlite3/worker.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Worker thread for sqlite3 query execution.
+ *
+ * This isolates potentially long-running queries so they can be
+ * terminated if they exceed the timeout.
+ *
+ * Uses sql.js (WASM-based SQLite) which is fully sandboxed and cannot
+ * access the real filesystem.
+ *
+ * Security: Uses phased defense-in-depth:
+ * 1. Init phase: sql.js WASM loads without restrictions
+ * 2. Defense phase: Activate full blocking after sql.js init
+ * 3. Execute phase: User SQL runs with all dangerous globals blocked
+ */
+import { type WorkerDefenseStats } from "../../security/index.js";
+export interface WorkerInput {
+    protocolToken: string;
+    dbBuffer: Uint8Array | null;
+    sql: string;
+    options: {
+        bail: boolean;
+        echo: boolean;
+    };
+}
+export interface WorkerSuccess {
+    success: true;
+    results: StatementResult[];
+    hasModifications: boolean;
+    dbBuffer: Uint8Array | null;
+    /** Defense-in-depth stats if enabled */
+    defenseStats?: WorkerDefenseStats;
+}
+export interface StatementResult {
+    type: "data" | "error";
+    columns?: string[];
+    rows?: unknown[][];
+    error?: string;
+}
+export interface WorkerError {
+    success: false;
+    error: string;
+    /** Defense-in-depth stats if enabled */
+    defenseStats?: WorkerDefenseStats;
+}
+export type WorkerOutput = WorkerSuccess | WorkerError;

package/dist/commands/stat/stat.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from "../../types.js";
+export declare const statCommand: Command;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/strings/strings.d.ts

@@ -0,0 +1,12 @@
+/**
+ * strings - print the sequences of printable characters in files
+ *
+ * Usage: strings [OPTION]... [FILE]...
+ *
+ * For each FILE, print the printable character sequences that are at least
+ * MIN characters long. If no FILE is specified, standard input is read.
+ */
+import type { Command } from "../../types.js";
+export declare const strings: Command;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/tac/tac.d.ts

@@ -0,0 +1,11 @@
+/**
+ * tac - concatenate and print files in reverse
+ *
+ * Usage: tac [OPTION]... [FILE]...
+ *
+ * Writes each FILE to standard output, last line first.
+ */
+import type { Command } from "../../types.js";
+export declare const tac: Command;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/tail/tail.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from "../../types.js";
+export declare const tailCommand: Command;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/tar/archive.d.ts

@@ -0,0 +1,135 @@
+/**
+ * Tar archive utilities using modern-tar
+ *
+ * Provides helpers for creating and extracting tar archives
+ * with optional gzip, bzip2, and xz compression.
+ */
+import { type ParsedTarEntryWithData, type TarEntry, type TarHeader } from "modern-tar";
+export type { TarEntry, TarHeader, ParsedTarEntryWithData };
+/**
+ * Entry for creating a tar archive
+ */
+export interface TarCreateEntry {
+    name: string;
+    content?: Uint8Array | string;
+    mode?: number;
+    mtime?: Date;
+    isDirectory?: boolean;
+    isSymlink?: boolean;
+    linkTarget?: string;
+    uid?: number;
+    gid?: number;
+}
+/**
+ * Create a tar archive from entries
+ */
+export declare function createArchive(entries: TarCreateEntry[]): Promise<Uint8Array>;
+/**
+ * Create a gzip-compressed tar archive from entries
+ */
+export declare function createCompressedArchive(entries: TarCreateEntry[]): Promise<Uint8Array>;
+/**
+ * Parsed tar entry for extraction
+ */
+export interface ParsedEntry {
+    name: string;
+    mode: number;
+    uid: number;
+    gid: number;
+    size: number;
+    mtime: Date;
+    type: "file" | "directory" | "symlink" | "hardlink" | "other";
+    linkTarget?: string;
+    content: Uint8Array;
+}
+/**
+ * Parse a tar archive and return entries
+ */
+export declare function parseArchive(data: Uint8Array): Promise<{
+    entries: ParsedEntry[];
+    error?: string;
+}>;
+/**
+ * Parse a gzip-compressed tar archive
+ */
+export declare function parseCompressedArchive(data: Uint8Array): Promise<{
+    entries: ParsedEntry[];
+    error?: string;
+}>;
+/**
+ * Check if data is gzip compressed (magic bytes 0x1f 0x8b)
+ */
+export declare function isGzipCompressed(data: Uint8Array): boolean;
+/**
+ * Check if data is bzip2 compressed (magic bytes "BZh")
+ */
+export declare function isBzip2Compressed(data: Uint8Array): boolean;
+/**
+ * Check if data is xz compressed (magic bytes 0xFD 0x37 0x7A 0x58 0x5A 0x00)
+ */
+export declare function isXzCompressed(data: Uint8Array): boolean;
+/**
+ * Create a bzip2-compressed tar archive from entries
+ */
+export declare function createBzip2CompressedArchive(entries: TarCreateEntry[]): Promise<Uint8Array>;
+/**
+ * Create an xz-compressed tar archive from entries.
+ *
+ * @param entries - Archive entries to include
+ * @param options - Options controlling compression behavior
+ * @param options.allowNativeCodecs - When false (default), rejects xz compression
+ *   to avoid passing attacker-controlled bytes to native addons (node-liblzma).
+ */
+export declare function createXzCompressedArchive(entries: TarCreateEntry[], options?: {
+    allowNativeCodecs?: boolean;
+}): Promise<Uint8Array>;
+/**
+ * Parse a bzip2-compressed tar archive
+ */
+export declare function parseBzip2CompressedArchive(data: Uint8Array): Promise<{
+    entries: ParsedEntry[];
+    error?: string;
+}>;
+/**
+ * Parse an xz-compressed tar archive.
+ *
+ * @param data - Raw archive bytes
+ * @param options - Options controlling decompression behavior
+ * @param options.allowNativeCodecs - When false (default), rejects xz decompression
+ *   to avoid passing untrusted bytes to native addons (node-liblzma).
+ */
+export declare function parseXzCompressedArchive(data: Uint8Array, options?: {
+    allowNativeCodecs?: boolean;
+}): Promise<{
+    entries: ParsedEntry[];
+    error?: string;
+}>;
+/**
+ * Check if data is zstd compressed (magic number 0x28 0xB5 0x2F 0xFD)
+ */
+export declare function isZstdCompressed(data: Uint8Array): boolean;
+/**
+ * Create a zstd-compressed tar archive from entries.
+ *
+ * @param entries - Archive entries to include
+ * @param options - Options controlling compression behavior
+ * @param options.allowNativeCodecs - When false (default), rejects zstd compression
+ *   to avoid passing attacker-controlled bytes to native addons (@mongodb-js/zstd).
+ */
+export declare function createZstdCompressedArchive(entries: TarCreateEntry[], options?: {
+    allowNativeCodecs?: boolean;
+}): Promise<Uint8Array>;
+/**
+ * Parse a zstd-compressed tar archive.
+ *
+ * @param data - Raw archive bytes
+ * @param options - Options controlling decompression behavior
+ * @param options.allowNativeCodecs - When false (default), rejects zstd decompression
+ *   to avoid passing untrusted bytes to native addons (@mongodb-js/zstd).
+ */
+export declare function parseZstdCompressedArchive(data: Uint8Array, options?: {
+    allowNativeCodecs?: boolean;
+}): Promise<{
+    entries: ParsedEntry[];
+    error?: string;
+}>;

package/dist/commands/tar/bzip2-compress.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Pure JavaScript bzip2 compressor.
+ *
+ * Implements the bzip2 compression algorithm (public domain, Julian Seward 1996).
+ * Pipeline: RLE1 → BWT → MTF → RLE2 (RUNA/RUNB) → Huffman → bitstream output.
+ *
+ * This exists because no permissively-licensed JS bzip2 compressor is available
+ * on npm. Decompression uses the MIT-licensed `seek-bzip` package instead.
+ */
+/**
+ * Compress data using bzip2 algorithm.
+ * @param data - Input data to compress
+ * @param blockSizeLevel - Block size level 1-9 (x 100KB), default 9
+ * @param maxSize - Maximum input size in bytes (default 10MB)
+ * @returns Compressed bzip2 data
+ */
+export declare function bzip2Compress(data: Uint8Array, blockSizeLevel?: number, maxSize?: number): Uint8Array;

package/dist/commands/tar/tar-options.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Option parsing for tar command
+ */
+import type { ExecResult } from "../../types.js";
+export interface TarOptions {
+    create: boolean;
+    append: boolean;
+    update: boolean;
+    extract: boolean;
+    list: boolean;
+    file: string;
+    autoCompress: boolean;
+    gzip: boolean;
+    bzip2: boolean;
+    xz: boolean;
+    zstd: boolean;
+    verbose: boolean;
+    toStdout: boolean;
+    keepOldFiles: boolean;
+    touch: boolean;
+    directory: string;
+    preserve: boolean;
+    absoluteNames: boolean;
+    strip: number;
+    exclude: string[];
+    filesFrom: string;
+    excludeFrom: string;
+    wildcards: boolean;
+}
+export declare function parseOptions(args: string[]): {
+    ok: true;
+    options: TarOptions;
+    files: string[];
+} | {
+    ok: false;
+    error: ExecResult;
+};

package/dist/commands/tar/tar.d.ts

@@ -0,0 +1,10 @@
+/**
+ * tar - manipulate tape archives
+ *
+ * Supports creating, extracting, and listing tar archives
+ * with optional gzip, bzip2, and xz compression.
+ */
+import type { Command } from "../../types.js";
+export declare const tarCommand: Command;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/tee/tee.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from "../../types.js";
+export declare const teeCommand: Command;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/time/time.d.ts

@@ -0,0 +1,27 @@
+import type { Command } from "../../types.js";
+/**
+ * time - time command execution
+ *
+ * Usage: time [-f FORMAT] [-o FILE] [-a] [-v] [-p] command [arguments...]
+ *
+ * Times the execution of a command and outputs timing statistics.
+ *
+ * Options:
+ *   -f FORMAT    Use FORMAT for output (GNU time format specifiers)
+ *   -o FILE      Write timing output to FILE
+ *   -a           Append to output file (with -o)
+ *   -v           Verbose output
+ *   -p           POSIX portable output format
+ *
+ * Format specifiers:
+ *   %e    Elapsed real time in seconds
+ *   %M    Maximum resident set size (KB)
+ *   %S    System CPU time (seconds)
+ *   %U    User CPU time (seconds)
+ *
+ * Note: In this JavaScript implementation, user/system CPU time and memory
+ * metrics are not available, so %M, %S, %U output 0.
+ */
+export declare const timeCommand: Command;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/timeout/timeout.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from "../../types.js";
+export declare const timeoutCommand: Command;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/touch/touch.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from "../../types.js";
+export declare const touchCommand: Command;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/tr/tr.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from "../../types.js";
+export declare const trCommand: Command;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/tree/tree.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from "../../types.js";
+export declare const treeCommand: Command;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/true/true.d.ts

@@ -0,0 +1,6 @@
+import type { Command } from "../../types.js";
+export declare const trueCommand: Command;
+export declare const falseCommand: Command;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;
+export declare const falseFlagsForFuzzing: CommandFuzzInfo;

package/dist/commands/uniq/uniq.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from "../../types.js";
+export declare const uniqCommand: Command;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/wc/wc.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from "../../types.js";
+export declare const wcCommand: Command;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/which/which.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from "../../types.js";
+export declare const whichCommand: Command;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/whoami/whoami.d.ts

@@ -0,0 +1,11 @@
+/**
+ * whoami - print effective user name
+ *
+ * Usage: whoami
+ *
+ * In sandboxed environment, always returns "user".
+ */
+import type { Command } from "../../types.js";
+export declare const whoami: Command;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/worker-bridge/bridge-handler.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Main thread bridge handler
+ *
+ * Runs on the main thread and processes filesystem, I/O, HTTP, and exec
+ * requests from a worker thread via SharedArrayBuffer + Atomics.
+ */
+import type { IFileSystem } from "../../fs/interface.js";
+import type { SecureFetch } from "../../network/fetch.js";
+import type { CommandExecOptions, ExecResult } from "../../types.js";
+export interface BridgeOutput {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}
+/**
+ * Handles requests from a worker thread.
+ */
+export declare class BridgeHandler {
+    private fs;
+    private cwd;
+    private commandName;
+    private secureFetch;
+    private maxOutputSize;
+    private exec;
+    private protocol;
+    private running;
+    private output;
+    private outputLimitExceeded;
+    private startTime;
+    private timeoutMs;
+    constructor(sharedBuffer: SharedArrayBuffer, fs: IFileSystem, cwd: string, commandName: string, secureFetch?: SecureFetch | undefined, maxOutputSize?: number, exec?: ((command: string, options: CommandExecOptions) => Promise<ExecResult>) | undefined);
+    /**
+     * Returns remaining milliseconds before the overall execution deadline.
+     */
+    private remainingMs;
+    /**
+     * Races a promise against the remaining execution deadline.
+     * If the deadline expires first, sets `this.running = false` and rejects.
+     */
+    private raceDeadline;
+    /**
+     * Run the handler loop until EXIT operation or timeout.
+     */
+    run(timeoutMs: number): Promise<BridgeOutput>;
+    stop(): void;
+    private handleOperation;
+    private resolvePath;
+    private handleReadFile;
+    private handleWriteFile;
+    private handleStat;
+    private handleLstat;
+    private handleReaddir;
+    private handleMkdir;
+    private handleRm;
+    private handleExists;
+    private handleAppendFile;
+    private handleSymlink;
+    private handleReadlink;
+    private handleChmod;
+    private handleRealpath;
+    private handleRename;
+    private handleCopyFile;
+    private handleWriteStdout;
+    private handleWriteStderr;
+    private handleExit;
+    private tryAppendOutput;
+    private appendOutputLimitError;
+    private handleHttpRequest;
+    private handleExecCommand;
+    private setErrorFromException;
+}