@jerryan/just-bash 3.5.0

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

@@ -0,0 +1,216 @@
+import type { FeatureCoverageWriter } from "../../types.js";
+export interface StepAddress {
+    first: number;
+    step: number;
+}
+export interface RelativeOffset {
+    offset: number;
+}
+export type SedAddress = number | "$" | {
+    pattern: string;
+} | StepAddress | RelativeOffset;
+export interface AddressRange {
+    start?: SedAddress;
+    end?: SedAddress;
+    negated?: boolean;
+}
+export type SedCommandType = "substitute" | "print" | "printFirstLine" | "delete" | "deleteFirstLine" | "append" | "insert" | "change" | "hold" | "holdAppend" | "get" | "getAppend" | "exchange" | "next" | "nextAppend" | "quit" | "quitSilent" | "transliterate" | "lineNumber" | "branch" | "branchOnSubst" | "branchOnNoSubst" | "label" | "zap" | "group" | "list" | "printFilename" | "version" | "readFile" | "readFileLine" | "writeFile" | "writeFirstLine" | "execute";
+export interface SubstituteCommand {
+    type: "substitute";
+    address?: AddressRange;
+    pattern: string;
+    replacement: string;
+    global: boolean;
+    ignoreCase: boolean;
+    printOnMatch: boolean;
+    nthOccurrence?: number;
+    extendedRegex?: boolean;
+}
+export interface PrintCommand {
+    type: "print";
+    address?: AddressRange;
+}
+export interface DeleteCommand {
+    type: "delete";
+    address?: AddressRange;
+}
+export interface AppendCommand {
+    type: "append";
+    address?: AddressRange;
+    text: string;
+}
+export interface InsertCommand {
+    type: "insert";
+    address?: AddressRange;
+    text: string;
+}
+export interface ChangeCommand {
+    type: "change";
+    address?: AddressRange;
+    text: string;
+}
+export interface HoldCommand {
+    type: "hold";
+    address?: AddressRange;
+}
+export interface HoldAppendCommand {
+    type: "holdAppend";
+    address?: AddressRange;
+}
+export interface GetCommand {
+    type: "get";
+    address?: AddressRange;
+}
+export interface GetAppendCommand {
+    type: "getAppend";
+    address?: AddressRange;
+}
+export interface ExchangeCommand {
+    type: "exchange";
+    address?: AddressRange;
+}
+export interface NextCommand {
+    type: "next";
+    address?: AddressRange;
+}
+export interface QuitCommand {
+    type: "quit";
+    address?: AddressRange;
+    exitCode?: number;
+}
+export interface QuitSilentCommand {
+    type: "quitSilent";
+    address?: AddressRange;
+    exitCode?: number;
+}
+export interface NextAppendCommand {
+    type: "nextAppend";
+    address?: AddressRange;
+}
+export interface TransliterateCommand {
+    type: "transliterate";
+    address?: AddressRange;
+    source: string;
+    dest: string;
+}
+export interface LineNumberCommand {
+    type: "lineNumber";
+    address?: AddressRange;
+}
+export interface BranchCommand {
+    type: "branch";
+    address?: AddressRange;
+    label?: string;
+}
+export interface BranchOnSubstCommand {
+    type: "branchOnSubst";
+    address?: AddressRange;
+    label?: string;
+}
+export interface LabelCommand {
+    type: "label";
+    name: string;
+}
+export interface BranchOnNoSubstCommand {
+    type: "branchOnNoSubst";
+    address?: AddressRange;
+    label?: string;
+}
+export interface PrintFirstLineCommand {
+    type: "printFirstLine";
+    address?: AddressRange;
+}
+export interface DeleteFirstLineCommand {
+    type: "deleteFirstLine";
+    address?: AddressRange;
+}
+export interface ZapCommand {
+    type: "zap";
+    address?: AddressRange;
+}
+export interface GroupCommand {
+    type: "group";
+    address?: AddressRange;
+    commands: SedCommand[];
+}
+export interface ListCommand {
+    type: "list";
+    address?: AddressRange;
+}
+export interface PrintFilenameCommand {
+    type: "printFilename";
+    address?: AddressRange;
+}
+export interface VersionCommand {
+    type: "version";
+    address?: AddressRange;
+    minVersion?: string;
+}
+export interface ReadFileCommand {
+    type: "readFile";
+    address?: AddressRange;
+    filename: string;
+}
+export interface ReadFileLineCommand {
+    type: "readFileLine";
+    address?: AddressRange;
+    filename: string;
+}
+export interface WriteFileCommand {
+    type: "writeFile";
+    address?: AddressRange;
+    filename: string;
+}
+export interface WriteFirstLineCommand {
+    type: "writeFirstLine";
+    address?: AddressRange;
+    filename: string;
+}
+export interface ExecuteCommand {
+    type: "execute";
+    address?: AddressRange;
+    command?: string;
+}
+export type SedCommand = SubstituteCommand | PrintCommand | PrintFirstLineCommand | DeleteCommand | DeleteFirstLineCommand | AppendCommand | InsertCommand | ChangeCommand | HoldCommand | HoldAppendCommand | GetCommand | GetAppendCommand | ExchangeCommand | NextCommand | QuitCommand | QuitSilentCommand | NextAppendCommand | TransliterateCommand | LineNumberCommand | BranchCommand | BranchOnSubstCommand | BranchOnNoSubstCommand | LabelCommand | ZapCommand | GroupCommand | ListCommand | PrintFilenameCommand | VersionCommand | ReadFileCommand | ReadFileLineCommand | WriteFileCommand | WriteFirstLineCommand | ExecuteCommand;
+export interface SedState {
+    patternSpace: string;
+    holdSpace: string;
+    lineNumber: number;
+    totalLines: number;
+    deleted: boolean;
+    printed: boolean;
+    quit: boolean;
+    quitSilent: boolean;
+    exitCode?: number;
+    errorMessage?: string;
+    appendBuffer: string[];
+    changedText?: string;
+    substitutionMade: boolean;
+    lineNumberOutput: string[];
+    nCommandOutput: string[];
+    restartCycle: boolean;
+    inDRestartedCycle: boolean;
+    currentFilename?: string;
+    pendingFileReads: Array<{
+        filename: string;
+        wholeFile: boolean;
+    }>;
+    pendingFileWrites: Array<{
+        filename: string;
+        content: string;
+    }>;
+    rangeStates: Map<string, RangeState>;
+    lastPattern?: string;
+    branchRequest?: string;
+    linesConsumedInCycle: number;
+    coverage?: FeatureCoverageWriter;
+}
+export interface RangeState {
+    active: boolean;
+    startLine?: number;
+    completed?: boolean;
+}
+export interface SedExecutionLimits {
+    maxIterations: number;
+    maxStringLength: number;
+}

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

@@ -0,0 +1,16 @@
+import type { RuntimeCommand } 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: RuntimeCommand;
+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 { RuntimeCommand } from "../../types.js";
+export declare const sleepCommand: RuntimeCommand;
+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 { RuntimeCommand } from "../../types.js";
+export declare const sortCommand: RuntimeCommand;
+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 { RuntimeCommand } from "../../types.js";
+export declare const split: RuntimeCommand;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

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

@@ -0,0 +1,17 @@
+/**
+ * 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;
+    /** Maximum encoded output bytes produced by this formatting call. */
+    maxOutputSize?: number;
+}
+/**
+ * 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,24 @@
+/**
+ * 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 { RuntimeCommand } from "../../types.js";
+import type { WorkerInput } from "./worker.js";
+/** @internal Exposed for testing only */
+export declare const _internals: {
+    createWorker(workerPath: string, input: WorkerInput): Worker;
+    findWorkerPath(currentDir?: string): string;
+    acquireDatabaseLock(fsIdentity: object, path: string, signal?: AbortSignal): Promise<() => void>;
+};
+export declare const sqlite3Command: RuntimeCommand;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

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

@@ -0,0 +1,50 @@
+/**
+ * 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;
+    };
+    limits: {
+        maxResultRows: number;
+        maxResultBytes: number;
+        maxDatabaseBytes: number;
+    };
+}
+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;