dotdo 0.0.1 → 0.0.2

package/dist/primitives/bashx/src/do/commands/system-utils.js

@@ -0,0 +1,687 @@
+/**
+ * System Utilities Commands
+ *
+ * Native implementations for system utility commands:
+ * - sleep: Delay execution for a specified duration
+ * - yes: Output a string repeatedly
+ * - seq: Generate number sequences
+ * - pwd: Print working directory
+ * - whoami: Print current username
+ * - hostname: Print system hostname
+ * - printenv: Print environment variables
+ *
+ * @module bashx/do/commands/system-utils
+ */
+// ============================================================================
+// SET OF COMMANDS
+// ============================================================================
+/**
+ * Set of system utility commands handled by this module
+ */
+export const SYSTEM_UTILS_COMMANDS = new Set([
+    'sleep',
+    'yes',
+    'seq',
+    'pwd',
+    'whoami',
+    'hostname',
+    'printenv',
+]);
+/**
+ * Check if a command is a system utility command
+ */
+export function isSystemUtilsCommand(cmd) {
+    return SYSTEM_UTILS_COMMANDS.has(cmd);
+}
+// ============================================================================
+// TIMING UTILITIES
+// ============================================================================
+/**
+ * Time unit multipliers in milliseconds
+ */
+const TIME_UNIT_MS = {
+    s: 1000,
+    m: 60 * 1000,
+    h: 60 * 60 * 1000,
+    d: 24 * 60 * 60 * 1000,
+};
+/**
+ * Parse a duration string into milliseconds
+ *
+ * @param duration - Duration string with optional unit suffix (s, m, h, d)
+ * @returns Duration in milliseconds
+ * @throws Error if duration format is invalid
+ *
+ * @example
+ * ```typescript
+ * parseDuration('5')     // 5000 (seconds)
+ * parseDuration('1.5s')  // 1500
+ * parseDuration('2m')    // 120000
+ * parseDuration('1h')    // 3600000
+ * parseDuration('1d')    // 86400000
+ * ```
+ */
+export function parseDuration(duration) {
+    // Handle 'infinity' case
+    if (duration.toLowerCase() === 'infinity') {
+        return Infinity;
+    }
+    const match = duration.match(/^(\d+(?:\.\d+)?)(s|m|h|d)?$/i);
+    if (!match) {
+        throw new Error(`Invalid duration: ${duration}`);
+    }
+    const value = parseFloat(match[1]);
+    const unit = match[2]?.toLowerCase() || 's';
+    return value * (TIME_UNIT_MS[unit] ?? 1000);
+}
+/**
+ * Create a delay promise
+ */
+function delay(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+// ============================================================================
+// SLEEP COMMAND
+// ============================================================================
+/**
+ * Execute sleep command - delay for a specified duration
+ *
+ * Supports multiple duration arguments which are summed together.
+ * Durations can have suffixes: s (seconds, default), m (minutes),
+ * h (hours), d (days).
+ *
+ * @param args - Duration arguments
+ * @param options - Sleep options
+ * @returns Promise resolving to command result
+ *
+ * @example
+ * ```typescript
+ * await executeSleep(['1'])        // Sleep 1 second
+ * await executeSleep(['0.5'])      // Sleep 500ms
+ * await executeSleep(['1m'])       // Sleep 1 minute
+ * await executeSleep(['1', '2'])   // Sleep 3 seconds total
+ * ```
+ */
+export async function executeSleep(args, options = {}) {
+    if (args.length === 0) {
+        return {
+            stdout: '',
+            stderr: 'sleep: missing operand',
+            exitCode: 1,
+        };
+    }
+    const maxDuration = options.maxDuration ?? 600000; // 10 minutes default max
+    try {
+        let totalMs = 0;
+        for (const duration of args) {
+            const ms = parseDuration(duration);
+            if (ms < 0) {
+                return {
+                    stdout: '',
+                    stderr: `sleep: invalid time interval '${duration}'`,
+                    exitCode: 1,
+                };
+            }
+            if (!isFinite(ms)) {
+                // Infinity - would sleep forever, but we'll cap it
+                return {
+                    stdout: '',
+                    stderr: 'sleep: cannot sleep indefinitely in this environment',
+                    exitCode: 1,
+                };
+            }
+            totalMs += ms;
+        }
+        // Apply safety limit
+        const actualDuration = Math.min(totalMs, maxDuration);
+        await delay(actualDuration);
+        return {
+            stdout: '',
+            stderr: '',
+            exitCode: 0,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            stdout: '',
+            stderr: `sleep: ${message}`,
+            exitCode: 1,
+        };
+    }
+}
+// ============================================================================
+// YES COMMAND
+// ============================================================================
+/**
+ * Execute yes command - output string repeatedly
+ *
+ * Outputs "y" (or the specified string) repeatedly, one per line.
+ * Limited to maxLines for safety in non-streaming environments.
+ *
+ * @param args - Optional string to repeat (default: "y")
+ * @param options - Yes options
+ * @returns Command result
+ *
+ * @example
+ * ```typescript
+ * executeYes([])           // "y\ny\ny\n..." (1000 times)
+ * executeYes(['hello'])    // "hello\nhello\nhello\n..." (1000 times)
+ * executeYes(['a', 'b'])   // "a b\na b\na b\n..." (arguments joined)
+ * ```
+ */
+export function executeYes(args, options = {}) {
+    const maxLines = options.maxLines ?? 1000;
+    const output = args.length > 0 ? args.join(' ') : 'y';
+    const lines = [];
+    for (let i = 0; i < maxLines; i++) {
+        lines.push(output);
+    }
+    return {
+        stdout: lines.join('\n') + '\n',
+        stderr: '',
+        exitCode: 0,
+    };
+}
+// ============================================================================
+// SEQ COMMAND
+// ============================================================================
+/**
+ * Execute seq command - generate number sequence
+ *
+ * Generates a sequence of numbers from first to last with given increment.
+ *
+ * @param args - Number arguments: [last], [first, last], or [first, incr, last]
+ * @param options - Seq options
+ * @returns Command result
+ *
+ * @example
+ * ```typescript
+ * executeSeq(['5'])           // "1\n2\n3\n4\n5\n"
+ * executeSeq(['2', '5'])      // "2\n3\n4\n5\n"
+ * executeSeq(['1', '2', '10']) // "1\n3\n5\n7\n9\n"
+ * executeSeq(['5', '-1', '1']) // "5\n4\n3\n2\n1\n"
+ * ```
+ */
+export function executeSeq(args, options = {}) {
+    if (args.length === 0) {
+        return {
+            stdout: '',
+            stderr: 'seq: missing operand',
+            exitCode: 1,
+        };
+    }
+    // Parse numeric arguments
+    const numArgs = [];
+    for (const arg of args) {
+        const num = parseFloat(arg);
+        if (isNaN(num)) {
+            return {
+                stdout: '',
+                stderr: `seq: invalid floating point argument: '${arg}'`,
+                exitCode: 1,
+            };
+        }
+        numArgs.push(num);
+    }
+    // Determine first, increment, last
+    let first = 1;
+    let increment = 1;
+    let last;
+    if (numArgs.length === 1) {
+        last = numArgs[0];
+    }
+    else if (numArgs.length === 2) {
+        first = numArgs[0];
+        last = numArgs[1];
+    }
+    else if (numArgs.length >= 3) {
+        first = numArgs[0];
+        increment = numArgs[1];
+        last = numArgs[2];
+    }
+    else {
+        return {
+            stdout: '',
+            stderr: 'seq: missing operand',
+            exitCode: 1,
+        };
+    }
+    // Handle impossible ranges
+    if (increment === 0) {
+        return {
+            stdout: '',
+            stderr: 'seq: invalid Zero increment value',
+            exitCode: 1,
+        };
+    }
+    // Handle backwards sequences
+    if ((increment > 0 && first > last) || (increment < 0 && first < last)) {
+        return {
+            stdout: '',
+            stderr: '',
+            exitCode: 0,
+        };
+    }
+    const results = [];
+    const separator = options.separator ?? '\n';
+    // Calculate width for equal-width option
+    const firstStr = String(first);
+    const lastStr = String(last);
+    const maxWidth = Math.max(firstStr.length, lastStr.length);
+    // Determine decimal places
+    const firstDecimals = (firstStr.split('.')[1] || '').length;
+    const incrementDecimals = (String(increment).split('.')[1] || '').length;
+    const lastDecimals = (lastStr.split('.')[1] || '').length;
+    const decimalPlaces = Math.max(firstDecimals, incrementDecimals, lastDecimals);
+    // Safety limit
+    const maxIterations = 100000;
+    let iterations = 0;
+    if (increment > 0) {
+        for (let i = first; i <= last && iterations < maxIterations; i += increment) {
+            let numStr;
+            if (options.format) {
+                // Simple format support
+                numStr = formatNumber(i, options.format);
+            }
+            else if (decimalPlaces > 0) {
+                numStr = i.toFixed(decimalPlaces);
+            }
+            else {
+                numStr = String(Math.round(i));
+            }
+            if (options.equalWidth && !options.format) {
+                numStr = numStr.padStart(maxWidth, '0');
+            }
+            results.push(numStr);
+            iterations++;
+        }
+    }
+    else {
+        for (let i = first; i >= last && iterations < maxIterations; i += increment) {
+            let numStr;
+            if (options.format) {
+                numStr = formatNumber(i, options.format);
+            }
+            else if (decimalPlaces > 0) {
+                numStr = i.toFixed(decimalPlaces);
+            }
+            else {
+                numStr = String(Math.round(i));
+            }
+            if (options.equalWidth && !options.format) {
+                numStr = numStr.padStart(maxWidth, '0');
+            }
+            results.push(numStr);
+            iterations++;
+        }
+    }
+    return {
+        stdout: results.join(separator) + (results.length > 0 ? '\n' : ''),
+        stderr: '',
+        exitCode: 0,
+    };
+}
+/**
+ * Format a number using a printf-style format string
+ */
+function formatNumber(value, format) {
+    // Support %g, %f, %e formats
+    const match = format.match(/%(\d+)?(?:\.(\d+))?([gfeE])/);
+    if (!match) {
+        return String(value);
+    }
+    const width = match[1] ? parseInt(match[1], 10) : 0;
+    const precision = match[2] ? parseInt(match[2], 10) : undefined;
+    const type = match[3];
+    let result;
+    switch (type) {
+        case 'f':
+            result = precision !== undefined ? value.toFixed(precision) : value.toFixed(6);
+            break;
+        case 'e':
+            result = precision !== undefined ? value.toExponential(precision) : value.toExponential();
+            break;
+        case 'E':
+            result = (precision !== undefined ? value.toExponential(precision) : value.toExponential()).toUpperCase();
+            break;
+        case 'g':
+        default:
+            result = precision !== undefined ? value.toPrecision(precision) : String(value);
+            break;
+    }
+    if (width > result.length) {
+        result = result.padStart(width, ' ');
+    }
+    return result;
+}
+// ============================================================================
+// PWD COMMAND
+// ============================================================================
+/**
+ * Execute pwd command - print working directory
+ *
+ * Returns the current working directory. With -L flag (default), returns
+ * the logical path (may include symlinks). With -P flag, returns the
+ * physical path (symlinks resolved).
+ *
+ * @param args - Command arguments (-L or -P)
+ * @param context - Execution context with cwd
+ * @returns Command result
+ *
+ * @example
+ * ```typescript
+ * executePwd([], { cwd: '/home/user' })
+ * // => { stdout: '/home/user\n', ... }
+ *
+ * executePwd(['-P'], { cwd: '/home/user' })
+ * // => { stdout: '/home/user\n', ... } (symlinks resolved if any)
+ * ```
+ */
+export function executePwd(args, context = {}) {
+    // Parse flags
+    let usePhysical = false;
+    for (const arg of args) {
+        if (arg === '-P') {
+            usePhysical = true;
+        }
+        else if (arg === '-L') {
+            usePhysical = false;
+        }
+        else if (arg.startsWith('-') && arg !== '-') {
+            return {
+                stdout: '',
+                stderr: `pwd: invalid option -- '${arg.slice(1)}'`,
+                exitCode: 1,
+            };
+        }
+    }
+    // Get current working directory
+    let cwd = context.cwd || '/';
+    // In Workers environment, we don't have real symlink resolution,
+    // but we support the -P flag for compatibility
+    if (usePhysical) {
+        // Normalize path by removing . and .. components
+        cwd = normalizePath(cwd);
+    }
+    return {
+        stdout: cwd + '\n',
+        stderr: '',
+        exitCode: 0,
+    };
+}
+/**
+ * Normalize a path by resolving . and .. components
+ */
+function normalizePath(path) {
+    const isAbsolute = path.startsWith('/');
+    const parts = path.split('/').filter(p => p && p !== '.');
+    const result = [];
+    for (const part of parts) {
+        if (part === '..') {
+            if (result.length > 0 && result[result.length - 1] !== '..') {
+                result.pop();
+            }
+            else if (!isAbsolute) {
+                result.push('..');
+            }
+        }
+        else {
+            result.push(part);
+        }
+    }
+    const normalized = result.join('/');
+    return isAbsolute ? '/' + normalized : normalized || '.';
+}
+// ============================================================================
+// WHOAMI COMMAND
+// ============================================================================
+/**
+ * Execute whoami command - print current username
+ *
+ * Returns the username from context or environment variables.
+ * Checks in order: context.user, env.USER, env.LOGNAME, then defaults.
+ *
+ * @param _args - Command arguments (unused, for interface consistency)
+ * @param context - Execution context with user or env
+ * @returns Command result
+ *
+ * @example
+ * ```typescript
+ * executeWhoami([], { user: 'alice' })
+ * // => { stdout: 'alice\n', ... }
+ *
+ * executeWhoami([], { env: { USER: 'bob' } })
+ * // => { stdout: 'bob\n', ... }
+ * ```
+ */
+export function executeWhoami(_args, context = {}) {
+    // Check context.user first
+    if (context.user) {
+        return {
+            stdout: context.user + '\n',
+            stderr: '',
+            exitCode: 0,
+        };
+    }
+    // Check environment variables
+    const env = context.env || {};
+    const user = env.USER || env.LOGNAME || env.USERNAME;
+    if (user) {
+        return {
+            stdout: user + '\n',
+            stderr: '',
+            exitCode: 0,
+        };
+    }
+    // Default for Workers environment
+    return {
+        stdout: 'worker\n',
+        stderr: '',
+        exitCode: 0,
+    };
+}
+// ============================================================================
+// HOSTNAME COMMAND
+// ============================================================================
+/**
+ * Execute hostname command - print system hostname
+ *
+ * Returns the hostname from context or environment variables.
+ * In Workers environment, defaults to 'worker.local'.
+ *
+ * @param args - Command arguments (supports -s for short hostname)
+ * @param context - Execution context with hostname
+ * @returns Command result
+ *
+ * @example
+ * ```typescript
+ * executeHostname([], { hostname: 'server.example.com.ai' })
+ * // => { stdout: 'server.example.com.ai\n', ... }
+ *
+ * executeHostname(['-s'], { hostname: 'server.example.com.ai' })
+ * // => { stdout: 'server\n', ... }
+ * ```
+ */
+export function executeHostname(args, context = {}) {
+    // Parse flags
+    let shortName = false;
+    for (const arg of args) {
+        if (arg === '-s' || arg === '--short') {
+            shortName = true;
+        }
+        else if (arg === '-f' || arg === '--fqdn' || arg === '--long') {
+            shortName = false;
+        }
+        else if (arg.startsWith('-') && arg !== '-') {
+            return {
+                stdout: '',
+                stderr: `hostname: invalid option -- '${arg.slice(1)}'`,
+                exitCode: 1,
+            };
+        }
+    }
+    // Get hostname from context or environment
+    let hostname = context.hostname;
+    if (!hostname) {
+        const env = context.env || {};
+        hostname = env.HOSTNAME || env.HOST || 'worker.local';
+    }
+    // Return short name if requested
+    if (shortName && hostname.includes('.')) {
+        hostname = hostname.split('.')[0];
+    }
+    return {
+        stdout: hostname + '\n',
+        stderr: '',
+        exitCode: 0,
+    };
+}
+// ============================================================================
+// PRINTENV COMMAND
+// ============================================================================
+/**
+ * Execute printenv command - print environment variables
+ *
+ * With no arguments, prints all environment variables.
+ * With variable names as arguments, prints only those variables.
+ *
+ * @param args - Variable names to print (empty for all)
+ * @param context - Execution context with env
+ * @param options - Printenv options
+ * @returns Command result
+ *
+ * @example
+ * ```typescript
+ * executePrintenv([], { env: { FOO: 'bar', BAZ: 'qux' } })
+ * // => { stdout: 'FOO=bar\nBAZ=qux\n', ... }
+ *
+ * executePrintenv(['FOO'], { env: { FOO: 'bar', BAZ: 'qux' } })
+ * // => { stdout: 'bar\n', ... }
+ *
+ * executePrintenv(['MISSING'], { env: { FOO: 'bar' } })
+ * // => { exitCode: 1, ... }
+ * ```
+ */
+export function executePrintenv(args, context = {}, options = {}) {
+    const env = context.env || {};
+    const separator = options.null ? '\0' : '\n';
+    // Parse flags and collect variable names
+    const varNames = [];
+    for (const arg of args) {
+        if (arg === '-0' || arg === '--null') {
+            options.null = true;
+        }
+        else if (arg.startsWith('-') && arg !== '-') {
+            // Unknown flag - ignore (printenv is lenient)
+            varNames.push(arg);
+        }
+        else {
+            varNames.push(arg);
+        }
+    }
+    if (varNames.length === 0) {
+        // Print all environment variables
+        const lines = [];
+        for (const [key, value] of Object.entries(env)) {
+            if (value !== undefined) {
+                lines.push(`${key}=${value}`);
+            }
+        }
+        // Sort for consistent output
+        lines.sort();
+        return {
+            stdout: lines.join(separator) + (lines.length > 0 ? separator : ''),
+            stderr: '',
+            exitCode: 0,
+        };
+    }
+    // Print specific variables
+    const outputs = [];
+    let allFound = true;
+    for (const name of varNames) {
+        const value = env[name];
+        if (value !== undefined) {
+            outputs.push(value);
+        }
+        else {
+            allFound = false;
+        }
+    }
+    return {
+        stdout: outputs.join(separator) + (outputs.length > 0 ? separator : ''),
+        stderr: '',
+        exitCode: allFound ? 0 : 1,
+    };
+}
+// ============================================================================
+// UNIFIED EXECUTOR
+// ============================================================================
+/**
+ * Execute a system utility command
+ *
+ * Routes to the appropriate command implementation based on command name.
+ *
+ * @param command - Command name
+ * @param args - Command arguments
+ * @param context - Execution context
+ * @returns Command result or null if command not supported
+ *
+ * @example
+ * ```typescript
+ * const result = await executeSystemUtils('pwd', [], { cwd: '/home/user' })
+ * // => { stdout: '/home/user\n', stderr: '', exitCode: 0 }
+ * ```
+ */
+export async function executeSystemUtils(command, args, context = {}) {
+    if (!SYSTEM_UTILS_COMMANDS.has(command)) {
+        return null;
+    }
+    switch (command) {
+        case 'sleep':
+            return executeSleep(args);
+        case 'yes':
+            return executeYes(args);
+        case 'seq': {
+            // Parse seq-specific options
+            const seqOptions = {};
+            const numArgs = [];
+            for (let i = 0; i < args.length; i++) {
+                const arg = args[i];
+                if (arg === '-s' && args[i + 1] !== undefined) {
+                    seqOptions.separator = args[++i]
+                        .replace(/\\t/g, '\t')
+                        .replace(/\\n/g, '\n');
+                }
+                else if (arg === '-w') {
+                    seqOptions.equalWidth = true;
+                }
+                else if (arg === '-f' && args[i + 1] !== undefined) {
+                    seqOptions.format = args[++i];
+                }
+                else if (!arg.startsWith('-')) {
+                    numArgs.push(arg);
+                }
+            }
+            return executeSeq(numArgs, seqOptions);
+        }
+        case 'pwd': {
+            const pwdArgs = args.filter(a => a === '-L' || a === '-P');
+            return executePwd(pwdArgs, context);
+        }
+        case 'whoami':
+            return executeWhoami(args, context);
+        case 'hostname':
+            return executeHostname(args, context);
+        case 'printenv': {
+            const printenvOptions = {
+                null: args.includes('-0') || args.includes('--null'),
+            };
+            const varArgs = args.filter(a => a !== '-0' && a !== '--null');
+            return executePrintenv(varArgs, context, printenvOptions);
+        }
+        default:
+            return null;
+    }
+}
+//# sourceMappingURL=system-utils.js.map