command-stream 0.3.0 → 0.3.2

package/src/$.utils.mjs

@@ -0,0 +1,81 @@
+import path from 'path';
+
+const VERBOSE = process.env.COMMAND_STREAM_VERBOSE === 'true';
+
+export function trace(category, messageOrFunc) {
+  if (!VERBOSE) return;
+  const message = typeof messageOrFunc === 'function' ? messageOrFunc() : messageOrFunc;
+  const timestamp = new Date().toISOString();
+  console.error(`[TRACE ${timestamp}] [${category}] ${message}`);
+}
+
+export const VirtualUtils = {
+  /**
+   * Create standardized error response for missing operands
+   */
+  missingOperandError(commandName, customMessage = null) {
+    const message = customMessage || `${commandName}: missing operand`;
+    return { stderr: message, code: 1 };
+  },
+
+  /**
+   * Create standardized error response for invalid arguments
+   */
+  invalidArgumentError(commandName, message) {
+    return { stderr: `${commandName}: ${message}`, code: 1 };
+  },
+
+  /**
+   * Create standardized success response
+   */
+  success(stdout = '', code = 0) {
+    return { stdout, stderr: '', code };
+  },
+
+  /**
+   * Create standardized error response
+   */
+  error(stderr = '', code = 1) {
+    return { stdout: '', stderr, code };
+  },
+
+  /**
+   * Validate that command has required number of arguments
+   */
+  validateArgs(args, minCount, commandName) {
+    if (args.length < minCount) {
+      if (minCount === 1) {
+        return this.missingOperandError(commandName);
+      } else {
+        return this.invalidArgumentError(commandName, `requires at least ${minCount} arguments`);
+      }
+    }
+    return null; // No error
+  },
+
+  /**
+   * Resolve file path with optional cwd parameter
+   */
+  resolvePath(filePath, cwd = null) {
+    const basePath = cwd || process.cwd();
+    return path.isAbsolute(filePath) ? filePath : path.resolve(basePath, filePath);
+  },
+
+  /**
+   * Safe file system operation wrapper
+   */
+  async safeFsOperation(operation, errorPrefix) {
+    try {
+      return await operation();
+    } catch (error) {
+      return this.error(`${errorPrefix}: ${error.message}`);
+    }
+  },
+
+  /**
+   * Create async wrapper for Promise-based operations
+   */
+  createAsyncWrapper(promiseFactory) {
+    return new Promise(promiseFactory);
+  }
+};

package/src/commands/$.basename.mjs

@@ -0,0 +1,19 @@
+import path from 'path';
+import { VirtualUtils } from '../$.utils.mjs';
+
+export default async function basename({ args }) {
+  const argError = VirtualUtils.validateArgs(args, 1, 'basename');
+  if (argError) return argError;
+
+  const filePath = args[0];
+  const suffix = args[1];
+  
+  let result = path.basename(filePath);
+  
+  // Remove suffix if provided and it matches
+  if (suffix && result.endsWith(suffix)) {
+    result = result.slice(0, -suffix.length);
+  }
+  
+  return VirtualUtils.success(result + '\n');
+}

package/src/commands/$.cat.mjs

@@ -0,0 +1,38 @@
+import fs from 'fs';
+import { trace, VirtualUtils } from '../$.utils.mjs';
+
+export default async function cat({ args, stdin, cwd }) {
+  if (args.length === 0) {
+    // Read from stdin if no files specified
+    if (stdin !== undefined && stdin !== '') {
+      return VirtualUtils.success(stdin);
+    }
+    return VirtualUtils.success();
+  }
+
+  try {
+    const outputs = [];
+    for (const file of args) {
+      trace('VirtualCommand', () => `cat: reading file | ${JSON.stringify({ file }, null, 2)}`);
+      const resolvedPath = VirtualUtils.resolvePath(file, cwd);
+      try {
+        const content = fs.readFileSync(resolvedPath, 'utf8');
+        outputs.push(content);
+      } catch (error) {
+        if (error.code === 'ENOENT') {
+          return VirtualUtils.error(`cat: ${file}: No such file or directory`);
+        } else if (error.code === 'EISDIR') {
+          return VirtualUtils.error(`cat: ${file}: Is a directory`);
+        } else {
+          return VirtualUtils.error(`cat: ${file}: ${error.message}`);
+        }
+      }
+    }
+    const output = outputs.join('');
+    trace('VirtualCommand', () => `cat: success | ${JSON.stringify({ bytesRead: output.length }, null, 2)}`);
+    return VirtualUtils.success(output);
+  } catch (error) {
+    trace('VirtualCommand', () => `cat: unexpected error | ${JSON.stringify({ error: error.message }, null, 2)}`);
+    return VirtualUtils.error(`cat: ${error.message}`);
+  }
+}

package/src/commands/$.cd.mjs

@@ -0,0 +1,16 @@
+import { trace, VirtualUtils } from '../$.utils.mjs';
+
+export default async function cd({ args }) {
+  const target = args[0] || process.env.HOME || process.env.USERPROFILE || '/';
+  trace('VirtualCommand', () => `cd: changing directory | ${JSON.stringify({ target }, null, 2)}`);
+
+  try {
+    process.chdir(target);
+    const newDir = process.cwd();
+    trace('VirtualCommand', () => `cd: success | ${JSON.stringify({ newDir }, null, 2)}`);
+    return VirtualUtils.success(newDir);
+  } catch (error) {
+    trace('VirtualCommand', () => `cd: failed | ${JSON.stringify({ error: error.message }, null, 2)}`);
+    return { stderr: `cd: ${error.message}`, code: 1 };
+  }
+}

package/src/commands/$.cp.mjs

@@ -0,0 +1,112 @@
+import fs from 'fs';
+import path from 'path';
+import { trace, VirtualUtils } from '../$.utils.mjs';
+
+export default async function cp({ args, stdin, cwd }) {
+  const argError = VirtualUtils.validateArgs(args, 2, 'cp');
+  if (argError) return VirtualUtils.invalidArgumentError('cp', 'missing destination file operand');
+
+  // Parse flags and paths
+  const flags = new Set();
+  const paths = [];
+  
+  for (const arg of args) {
+    if (arg === '-r' || arg === '-R' || arg === '--recursive') {
+      flags.add('r');
+    } else if (arg.startsWith('-')) {
+      for (const flag of arg.slice(1)) {
+        flags.add(flag);
+      }
+    } else {
+      paths.push(arg);
+    }
+  }
+
+  if (paths.length < 2) {
+    return VirtualUtils.invalidArgumentError('cp', 'missing destination file operand');
+  }
+
+  const recursive = flags.has('r') || flags.has('R');
+  const sources = paths.slice(0, -1);
+  const destination = paths[paths.length - 1];
+  
+  try {
+    const destPath = VirtualUtils.resolvePath(destination, cwd);
+    let destExists = false;
+    let destIsDir = false;
+    
+    try {
+      const destStats = fs.statSync(destPath);
+      destExists = true;
+      destIsDir = destStats.isDirectory();
+    } catch (error) {
+      if (error.code !== 'ENOENT') throw error;
+    }
+
+    // Copying multiple files requires destination to be a directory
+    if (sources.length > 1 && destExists && !destIsDir) {
+      return VirtualUtils.error(`cp: target '${destination}' is not a directory`);
+    }
+
+    // Helper function to copy directory recursively
+    const copyRecursive = (src, dest) => {
+      const stats = fs.statSync(src);
+      
+      if (stats.isDirectory()) {
+        fs.mkdirSync(dest, { recursive: true });
+        const entries = fs.readdirSync(src);
+        
+        for (const entry of entries) {
+          copyRecursive(
+            path.join(src, entry),
+            path.join(dest, entry)
+          );
+        }
+      } else {
+        fs.copyFileSync(src, dest);
+      }
+    };
+
+    for (const source of sources) {
+      const sourcePath = VirtualUtils.resolvePath(source, cwd);
+      
+      try {
+        const sourceStats = fs.statSync(sourcePath);
+        let finalDestPath = destPath;
+        
+        if (destIsDir || (sources.length > 1 && !destExists)) {
+          // Copying into a directory
+          if (!destExists) {
+            fs.mkdirSync(destPath, { recursive: true });
+            destIsDir = true;
+            destExists = true;
+          }
+          finalDestPath = path.join(destPath, path.basename(sourcePath));
+        }
+        
+        if (sourceStats.isDirectory()) {
+          if (!recursive) {
+            return VirtualUtils.error(`cp: -r not specified; omitting directory '${source}'`);
+          }
+          trace('VirtualCommand', () => `cp: copying directory | ${JSON.stringify({ from: sourcePath, to: finalDestPath }, null, 2)}`);
+          copyRecursive(sourcePath, finalDestPath);
+        } else {
+          trace('VirtualCommand', () => `cp: copying file | ${JSON.stringify({ from: sourcePath, to: finalDestPath }, null, 2)}`);
+          fs.copyFileSync(sourcePath, finalDestPath);
+        }
+        
+      } catch (error) {
+        if (error.code === 'ENOENT') {
+          return VirtualUtils.error(`cp: cannot stat '${source}': No such file or directory`);
+        }
+        throw error;
+      }
+    }
+    
+    trace('VirtualCommand', () => `cp: success | ${JSON.stringify({ filesCopied: sources.length }, null, 2)}`);
+    return VirtualUtils.success();
+  } catch (error) {
+    trace('VirtualCommand', () => `cp: error | ${JSON.stringify({ error: error.message }, null, 2)}`);
+    return VirtualUtils.error(`cp: ${error.message}`);
+  }
+}

package/src/commands/$.dirname.mjs

@@ -0,0 +1,12 @@
+import path from 'path';
+import { VirtualUtils } from '../$.utils.mjs';
+
+export default async function dirname({ args }) {
+  const argError = VirtualUtils.validateArgs(args, 1, 'dirname');
+  if (argError) return argError;
+
+  const filePath = args[0];
+  const result = path.dirname(filePath);
+  
+  return VirtualUtils.success(result + '\n');
+}

package/src/commands/$.echo.mjs

@@ -0,0 +1,15 @@
+import { trace, VirtualUtils } from '../$.utils.mjs';
+
+export default async function echo({ args }) {
+  trace('VirtualCommand', () => `echo: processing | ${JSON.stringify({ argsCount: args.length }, null, 2)}`);
+
+  let output = args.join(' ');
+  if (args.includes('-n')) {
+    // Don't add newline
+    trace('VirtualCommand', () => `BRANCH: echo => NO_NEWLINE | ${JSON.stringify({}, null, 2)}`);
+    output = args.filter(arg => arg !== '-n').join(' ');
+  } else {
+    output += '\n';
+  }
+  return VirtualUtils.success(output);
+}

package/src/commands/$.env.mjs

@@ -0,0 +1,14 @@
+import { VirtualUtils } from '../$.utils.mjs';
+
+export default async function env({ args, stdin, env }) {
+  if (args.length === 0) {
+    // Use custom env if provided, otherwise use process.env
+    const envVars = env || process.env;
+    const output = Object.entries(envVars)
+      .map(([key, value]) => `${key}=${value}`)
+      .join('\n') + '\n';
+    return VirtualUtils.success(output);
+  }
+  // TODO: Support setting environment variables for subsequent command
+  return VirtualUtils.error('env: setting variables not yet supported');
+}

package/src/commands/$.exit.mjs

@@ -0,0 +1,9 @@
+export default function createExitCommand(globalShellSettings) {
+  return async function exit({ args }) {
+    const code = parseInt(args[0] || 0);
+    if (globalShellSettings.errexit || code !== 0) {
+      throw { code, message: `Command failed with exit code ${code}` };
+    }
+    return { stdout: '', code };
+  };
+}

package/src/commands/$.false.mjs

@@ -0,0 +1,3 @@
+export default async function falseCommand() {
+  return { stdout: '', code: 1 };
+}

package/src/commands/$.ls.mjs

@@ -0,0 +1,79 @@
+import fs from 'fs';
+import path from 'path';
+import { trace, VirtualUtils } from '../$.utils.mjs';
+
+export default async function ls({ args, stdin, cwd }) {
+  try {
+    // Parse flags
+    const flags = new Set();
+    const paths = [];
+    
+    for (const arg of args) {
+      if (arg.startsWith('-')) {
+        for (const flag of arg.slice(1)) {
+          flags.add(flag);
+        }
+      } else {
+        paths.push(arg);
+      }
+    }
+
+    // Default to current directory if no paths specified
+    if (paths.length === 0) {
+      paths.push(cwd || process.cwd());
+    }
+
+    const showAll = flags.has('a');
+    const longFormat = flags.has('l');
+    
+    trace('VirtualCommand', () => `ls: listing | ${JSON.stringify({ paths, flags: Array.from(flags) }, null, 2)}`);
+
+    const outputs = [];
+    
+    for (const targetPath of paths) {
+      const resolvedPath = VirtualUtils.resolvePath(targetPath, cwd);
+      const stats = fs.statSync(resolvedPath);
+      
+      if (stats.isDirectory()) {
+        let entries = fs.readdirSync(resolvedPath);
+        
+        if (!showAll) {
+          entries = entries.filter(e => !e.startsWith('.'));
+        }
+        
+        if (longFormat) {
+          for (const entry of entries) {
+            const entryPath = path.join(resolvedPath, entry);
+            const entryStats = fs.statSync(entryPath);
+            const mode = entryStats.isDirectory() ? 'drwxr-xr-x' : '-rw-r--r--';
+            const size = entryStats.size.toString().padStart(8);
+            const mtime = entryStats.mtime.toISOString().split('T')[0];
+            outputs.push(`${mode}  1 user group ${size} ${mtime} ${entry}\n`);
+          }
+        } else {
+          outputs.push(entries.join('\n') + '\n');
+        }
+      } else {
+        // Single file
+        if (longFormat) {
+          const mode = '-rw-r--r--';
+          const size = stats.size.toString().padStart(8);
+          const mtime = stats.mtime.toISOString().split('T')[0];
+          const basename = path.basename(resolvedPath);
+          outputs.push(`${mode}  1 user group ${size} ${mtime} ${basename}\n`);
+        } else {
+          outputs.push(path.basename(resolvedPath) + '\n');
+        }
+      }
+    }
+    
+    trace('VirtualCommand', () => `ls: success | ${JSON.stringify({ entriesCount: outputs.length }, null, 2)}`);
+    return VirtualUtils.success(outputs.join(''));
+  } catch (error) {
+    trace('VirtualCommand', () => `ls: error | ${JSON.stringify({ error: error.message }, null, 2)}`);
+    if (error.code === 'ENOENT') {
+      return VirtualUtils.error(`ls: ${args[0] || '.'}: No such file or directory`);
+    }
+    return VirtualUtils.error(`ls: ${error.message}`);
+  }
+}

package/src/commands/$.mkdir.mjs

@@ -0,0 +1,45 @@
+import fs from 'fs';
+import { trace, VirtualUtils } from '../$.utils.mjs';
+
+export default async function mkdir({ args, stdin, cwd }) {
+  const argError = VirtualUtils.validateArgs(args, 1, 'mkdir');
+  if (argError) return argError;
+
+  // Parse flags and paths
+  const flags = new Set();
+  const paths = [];
+  
+  for (const arg of args) {
+    if (arg === '-p' || arg === '--parents') {
+      flags.add('p');
+    } else if (arg.startsWith('-')) {
+      for (const flag of arg.slice(1)) {
+        flags.add(flag);
+      }
+    } else {
+      paths.push(arg);
+    }
+  }
+
+  if (paths.length === 0) {
+    return VirtualUtils.missingOperandError('mkdir');
+  }
+
+  const recursive = flags.has('p');
+  
+  try {
+    for (const dir of paths) {
+      const resolvedPath = VirtualUtils.resolvePath(dir, cwd);
+      trace('VirtualCommand', () => `mkdir: creating | ${JSON.stringify({ dir: resolvedPath, recursive }, null, 2)}`);
+      fs.mkdirSync(resolvedPath, { recursive });
+    }
+    trace('VirtualCommand', () => `mkdir: success | ${JSON.stringify({ dirsCreated: paths.length }, null, 2)}`);
+    return VirtualUtils.success();
+  } catch (error) {
+    trace('VirtualCommand', () => `mkdir: error | ${JSON.stringify({ error: error.message }, null, 2)}`);
+    if (error.code === 'EEXIST') {
+      return VirtualUtils.error(`mkdir: cannot create directory '${paths[0]}': File exists`);
+    }
+    return VirtualUtils.error(`mkdir: ${error.message}`);
+  }
+}

package/src/commands/$.mv.mjs

@@ -0,0 +1,89 @@
+import fs from 'fs';
+import path from 'path';
+import { trace, VirtualUtils } from '../$.utils.mjs';
+
+export default async function mv({ args, stdin, cwd }) {
+  const argError = VirtualUtils.validateArgs(args, 2, 'mv');
+  if (argError) return VirtualUtils.invalidArgumentError('mv', 'missing destination file operand');
+
+  // Parse flags and paths
+  const flags = new Set();
+  const paths = [];
+  
+  for (const arg of args) {
+    if (arg.startsWith('-')) {
+      for (const flag of arg.slice(1)) {
+        flags.add(flag);
+      }
+    } else {
+      paths.push(arg);
+    }
+  }
+
+  if (paths.length < 2) {
+    return VirtualUtils.invalidArgumentError('mv', 'missing destination file operand');
+  }
+
+  const force = flags.has('f');
+  const sources = paths.slice(0, -1);
+  const destination = paths[paths.length - 1];
+  
+  try {
+    const destPath = VirtualUtils.resolvePath(destination, cwd);
+    let destExists = false;
+    let destIsDir = false;
+    
+    try {
+      const destStats = fs.statSync(destPath);
+      destExists = true;
+      destIsDir = destStats.isDirectory();
+    } catch (error) {
+      if (error.code !== 'ENOENT') throw error;
+    }
+
+    // Moving multiple files requires destination to be a directory
+    if (sources.length > 1 && destExists && !destIsDir) {
+      return VirtualUtils.error(`mv: target '${destination}' is not a directory`);
+    }
+
+    for (const source of sources) {
+      const sourcePath = VirtualUtils.resolvePath(source, cwd);
+      
+      try {
+        const sourceStats = fs.statSync(sourcePath);
+        let finalDestPath = destPath;
+        
+        if (destIsDir) {
+          // Moving into a directory
+          finalDestPath = path.join(destPath, path.basename(sourcePath));
+        }
+        
+        // Check if destination exists and handle force flag
+        if (!force) {
+          try {
+            fs.statSync(finalDestPath);
+            // Destination exists and no force flag
+            return VirtualUtils.error(`mv: cannot move '${source}': File exists`);
+          } catch (error) {
+            if (error.code !== 'ENOENT') throw error;
+          }
+        }
+        
+        trace('VirtualCommand', () => `mv: moving | ${JSON.stringify({ from: sourcePath, to: finalDestPath }, null, 2)}`);
+        fs.renameSync(sourcePath, finalDestPath);
+        
+      } catch (error) {
+        if (error.code === 'ENOENT') {
+          return VirtualUtils.error(`mv: cannot stat '${source}': No such file or directory`);
+        }
+        throw error;
+      }
+    }
+    
+    trace('VirtualCommand', () => `mv: success | ${JSON.stringify({ filesMoved: sources.length }, null, 2)}`);
+    return VirtualUtils.success();
+  } catch (error) {
+    trace('VirtualCommand', () => `mv: error | ${JSON.stringify({ error: error.message }, null, 2)}`);
+    return VirtualUtils.error(`mv: ${error.message}`);
+  }
+}

package/src/commands/$.pwd.mjs

@@ -0,0 +1,8 @@
+import { trace, VirtualUtils } from '../$.utils.mjs';
+
+export default async function pwd({ args, stdin, cwd }) {
+  // If cwd option is provided, return that instead of process.cwd()
+  const dir = cwd || process.cwd();
+  trace('VirtualCommand', () => `pwd: getting directory | ${JSON.stringify({ dir }, null, 2)}`);
+  return VirtualUtils.success(dir);
+}

package/src/commands/$.rm.mjs

@@ -0,0 +1,60 @@
+import fs from 'fs';
+import { trace, VirtualUtils } from '../$.utils.mjs';
+
+export default async function rm({ args, stdin, cwd }) {
+  const argError = VirtualUtils.validateArgs(args, 1, 'rm');
+  if (argError) return argError;
+
+  // Parse flags and paths
+  const flags = new Set();
+  const paths = [];
+  
+  for (const arg of args) {
+    if (arg.startsWith('-')) {
+      for (const flag of arg.slice(1)) {
+        flags.add(flag);
+      }
+    } else {
+      paths.push(arg);
+    }
+  }
+
+  if (paths.length === 0) {
+    return VirtualUtils.missingOperandError('rm');
+  }
+
+  const recursive = flags.has('r') || flags.has('R');
+  const force = flags.has('f');
+  
+  try {
+    for (const file of paths) {
+      const resolvedPath = VirtualUtils.resolvePath(file, cwd);
+      trace('VirtualCommand', () => `rm: removing | ${JSON.stringify({ file: resolvedPath, recursive, force }, null, 2)}`);
+      
+      try {
+        const stats = fs.statSync(resolvedPath);
+        if (stats.isDirectory() && !recursive) {
+          return VirtualUtils.error(`rm: cannot remove '${file}': Is a directory`);
+        }
+        
+        if (stats.isDirectory()) {
+          fs.rmSync(resolvedPath, { recursive: true, force });
+        } else {
+          fs.unlinkSync(resolvedPath);
+        }
+      } catch (error) {
+        if (error.code === 'ENOENT' && !force) {
+          return VirtualUtils.error(`rm: cannot remove '${file}': No such file or directory`);
+        } else if (error.code !== 'ENOENT') {
+          throw error;
+        }
+      }
+    }
+    
+    trace('VirtualCommand', () => `rm: success | ${JSON.stringify({ filesRemoved: paths.length }, null, 2)}`);
+    return VirtualUtils.success();
+  } catch (error) {
+    trace('VirtualCommand', () => `rm: error | ${JSON.stringify({ error: error.message }, null, 2)}`);
+    return VirtualUtils.error(`rm: ${error.message}`);
+  }
+}

package/src/commands/$.seq.mjs

@@ -0,0 +1,48 @@
+import { VirtualUtils } from '../$.utils.mjs';
+
+export default async function seq({ args }) {
+  const argError = VirtualUtils.validateArgs(args, 1, 'seq');
+  if (argError) return argError;
+
+  let start, step, end;
+  
+  if (args.length === 1) {
+    // seq END
+    start = 1;
+    step = 1;
+    end = parseFloat(args[0]);
+  } else if (args.length === 2) {
+    // seq START END
+    start = parseFloat(args[0]);
+    step = 1;
+    end = parseFloat(args[1]);
+  } else {
+    // seq START STEP END
+    start = parseFloat(args[0]);
+    step = parseFloat(args[1]);
+    end = parseFloat(args[2]);
+  }
+  
+  // Validate numbers
+  if (isNaN(start) || isNaN(step) || isNaN(end)) {
+    return VirtualUtils.error('seq: invalid number');
+  }
+  
+  if (step === 0) {
+    return VirtualUtils.error('seq: step cannot be zero');
+  }
+  
+  const output = [];
+  
+  if (step > 0) {
+    for (let i = start; i <= end; i += step) {
+      output.push(i.toString());
+    }
+  } else {
+    for (let i = start; i >= end; i += step) {
+      output.push(i.toString());
+    }
+  }
+  
+  return VirtualUtils.success(output.join('\n') + (output.length > 0 ? '\n' : ''));
+}

package/src/commands/$.sleep.mjs

@@ -0,0 +1,15 @@
+import { trace } from '../$.utils.mjs';
+
+export default async function sleep({ args }) {
+  const seconds = parseFloat(args[0] || 0);
+  trace('VirtualCommand', () => `sleep: starting | ${JSON.stringify({ seconds }, null, 2)}`);
+  
+  if (isNaN(seconds) || seconds < 0) {
+    return { stderr: `sleep: invalid time interval '${args[0]}'`, code: 1 };
+  }
+  
+  await new Promise(resolve => setTimeout(resolve, seconds * 1000));
+  trace('VirtualCommand', () => `sleep: completed | ${JSON.stringify({ seconds }, null, 2)}`);
+  
+  return { stdout: '', code: 0 };
+}