command-stream 0.7.1 → 0.8.2

package/src/$.utils.mjs

@@ -3,8 +3,11 @@ 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;
+  if (!VERBOSE) {
+    return;
+  }
+  const message =
+    typeof messageOrFunc === 'function' ? messageOrFunc() : messageOrFunc;
   const timestamp = new Date().toISOString();
   console.error(`[TRACE ${timestamp}] [${category}] ${message}`);
 }
@@ -47,7 +50,10 @@ export const VirtualUtils = {
       if (minCount === 1) {
         return this.missingOperandError(commandName);
       } else {
-        return this.invalidArgumentError(commandName, `requires at least ${minCount} arguments`);
+        return this.invalidArgumentError(
+          commandName,
+          `requires at least ${minCount} arguments`
+        );
       }
     }
     return null; // No error
@@ -58,7 +64,9 @@ export const VirtualUtils = {
    */
   resolvePath(filePath, cwd = null) {
     const basePath = cwd || process.cwd();
-    return path.isAbsolute(filePath) ? filePath : path.resolve(basePath, filePath);
+    return path.isAbsolute(filePath)
+      ? filePath
+      : path.resolve(basePath, filePath);
   },
 
   /**
@@ -77,5 +85,5 @@ export const VirtualUtils = {
    */
   createAsyncWrapper(promiseFactory) {
     return new Promise(promiseFactory);
-  }
-};
+  },
+};

package/src/commands/$.basename.mjs

@@ -3,17 +3,19 @@ import { VirtualUtils } from '../$.utils.mjs';
 
 export default async function basename({ args }) {
   const argError = VirtualUtils.validateArgs(args, 1, 'basename');
-  if (argError) return argError;
+  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');
-}
+
+  return VirtualUtils.success(`${result}\n`);
+}

package/src/commands/$.cat.mjs

@@ -1,7 +1,13 @@
 import fs from 'fs';
 import { trace, VirtualUtils } from '../$.utils.mjs';
 
-export default async function cat({ args, stdin, cwd, isCancelled, abortSignal }) {
+export default async function cat({
+  args,
+  stdin,
+  cwd,
+  isCancelled,
+  abortSignal,
+}) {
   if (args.length === 0) {
     // Read from stdin if no files specified
     if (stdin !== undefined && stdin !== '') {
@@ -18,8 +24,11 @@ export default async function cat({ args, stdin, cwd, isCancelled, abortSignal }
         trace('VirtualCommand', () => `cat: cancelled while processing files`);
         return { code: 130, stdout: '', stderr: '' }; // SIGINT exit code
       }
-      
-      trace('VirtualCommand', () => `cat: reading file | ${JSON.stringify({ file }, null, 2)}`);
+
+      trace(
+        'VirtualCommand',
+        () => `cat: reading file | ${JSON.stringify({ file }, null, 2)}`
+      );
       const resolvedPath = VirtualUtils.resolvePath(file, cwd);
       try {
         const content = fs.readFileSync(resolvedPath, 'utf8');
@@ -35,10 +44,18 @@ export default async function cat({ args, stdin, cwd, isCancelled, abortSignal }
       }
     }
     const output = outputs.join('');
-    trace('VirtualCommand', () => `cat: success | ${JSON.stringify({ bytesRead: output.length }, null, 2)}`);
+    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)}`);
+    trace(
+      'VirtualCommand',
+      () =>
+        `cat: unexpected error | ${JSON.stringify({ error: error.message }, null, 2)}`
+    );
     return VirtualUtils.error(`cat: ${error.message}`);
   }
-}
+}

package/src/commands/$.cd.mjs

@@ -2,16 +2,25 @@ 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)}`);
+  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)}`);
+    trace(
+      'VirtualCommand',
+      () => `cd: success | ${JSON.stringify({ newDir }, null, 2)}`
+    );
     // cd command should not output anything on success, just like real cd
     return VirtualUtils.success('');
   } catch (error) {
-    trace('VirtualCommand', () => `cd: failed | ${JSON.stringify({ error: error.message }, null, 2)}`);
+    trace(
+      'VirtualCommand',
+      () => `cd: failed | ${JSON.stringify({ error: error.message }, null, 2)}`
+    );
     return { stderr: `cd: ${error.message}\n`, code: 1 };
   }
-}
+}

package/src/commands/$.cp.mjs

@@ -2,14 +2,19 @@ import fs from 'fs';
 import path from 'path';
 import { trace, VirtualUtils } from '../$.utils.mjs';
 
-export default async function cp({ args, stdin, cwd }) {
+export default async function cp({ args, stdin: _stdin, cwd }) {
   const argError = VirtualUtils.validateArgs(args, 2, 'cp');
-  if (argError) return VirtualUtils.invalidArgumentError('cp', 'missing destination file operand');
+  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');
@@ -23,44 +28,48 @@ export default async function cp({ args, stdin, cwd }) {
   }
 
   if (paths.length < 2) {
-    return VirtualUtils.invalidArgumentError('cp', 'missing destination file operand');
+    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;
+      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`);
+      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)
-          );
+          copyRecursive(path.join(src, entry), path.join(dest, entry));
         }
       } else {
         fs.copyFileSync(src, dest);
@@ -69,11 +78,11 @@ export default async function cp({ args, stdin, cwd }) {
 
     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) {
@@ -83,30 +92,48 @@ export default async function cp({ args, stdin, cwd }) {
           }
           finalDestPath = path.join(destPath, path.basename(sourcePath));
         }
-        
+
         if (sourceStats.isDirectory()) {
           if (!recursive) {
-            return VirtualUtils.error(`cp: -r not specified; omitting directory '${source}'`);
+            return VirtualUtils.error(
+              `cp: -r not specified; omitting directory '${source}'`
+            );
           }
-          trace('VirtualCommand', () => `cp: copying directory | ${JSON.stringify({ from: sourcePath, to: finalDestPath }, null, 2)}`);
+          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)}`);
+          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`);
+          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)}`);
+
+    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)}`);
+    trace(
+      'VirtualCommand',
+      () => `cp: error | ${JSON.stringify({ error: error.message }, null, 2)}`
+    );
     return VirtualUtils.error(`cp: ${error.message}`);
   }
-}
+}

package/src/commands/$.dirname.mjs

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

package/src/commands/$.echo.mjs

@@ -1,15 +1,22 @@
 import { trace, VirtualUtils } from '../$.utils.mjs';
 
 export default async function echo({ args }) {
-  trace('VirtualCommand', () => `echo: processing | ${JSON.stringify({ argsCount: args.length }, null, 2)}`);
+  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(' ');
+    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

@@ -1,14 +1,14 @@
 import { VirtualUtils } from '../$.utils.mjs';
 
-export default async function env({ args, stdin, env }) {
+export default async function env({ args, stdin: _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)
+    const output = `${Object.entries(envVars)
       .map(([key, value]) => `${key}=${value}`)
-      .join('\n') + '\n';
+      .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

@@ -6,4 +6,4 @@ export default function createExitCommand(globalShellSettings) {
     }
     return { stdout: '', code };
   };
-}
+}

package/src/commands/$.false.mjs

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

package/src/commands/$.ls.mjs

@@ -2,12 +2,12 @@ import fs from 'fs';
 import path from 'path';
 import { trace, VirtualUtils } from '../$.utils.mjs';
 
-export default async function ls({ args, stdin, cwd }) {
+export default async function ls({ args, stdin: _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)) {
@@ -25,22 +25,26 @@ export default async function ls({ args, stdin, cwd }) {
 
     const showAll = flags.has('a');
     const longFormat = flags.has('l');
-    
-    trace('VirtualCommand', () => `ls: listing | ${JSON.stringify({ paths, flags: Array.from(flags) }, null, 2)}`);
+
+    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('.'));
+          entries = entries.filter((e) => !e.startsWith('.'));
         }
-        
+
         if (longFormat) {
           for (const entry of entries) {
             const entryPath = path.join(resolvedPath, entry);
@@ -51,7 +55,7 @@ export default async function ls({ args, stdin, cwd }) {
             outputs.push(`${mode}  1 user group ${size} ${mtime} ${entry}\n`);
           }
         } else {
-          outputs.push(entries.join('\n') + '\n');
+          outputs.push(`${entries.join('\n')}\n`);
         }
       } else {
         // Single file
@@ -62,18 +66,27 @@ export default async function ls({ args, stdin, cwd }) {
           const basename = path.basename(resolvedPath);
           outputs.push(`${mode}  1 user group ${size} ${mtime} ${basename}\n`);
         } else {
-          outputs.push(path.basename(resolvedPath) + '\n');
+          outputs.push(`${path.basename(resolvedPath)}\n`);
         }
       }
     }
-    
-    trace('VirtualCommand', () => `ls: success | ${JSON.stringify({ entriesCount: outputs.length }, null, 2)}`);
+
+    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)}`);
+    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: ${args[0] || '.'}: No such file or directory`
+      );
     }
     return VirtualUtils.error(`ls: ${error.message}`);
   }
-}
+}

package/src/commands/$.mkdir.mjs

@@ -1,14 +1,16 @@
 import fs from 'fs';
 import { trace, VirtualUtils } from '../$.utils.mjs';
 
-export default async function mkdir({ args, stdin, cwd }) {
+export default async function mkdir({ args, stdin: _stdin, cwd }) {
   const argError = VirtualUtils.validateArgs(args, 1, 'mkdir');
-  if (argError) return argError;
+  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');
@@ -26,20 +28,34 @@ export default async function mkdir({ args, stdin, cwd }) {
   }
 
   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)}`);
+      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)}`);
+    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)}`);
+    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: cannot create directory '${paths[0]}': File exists`
+      );
     }
     return VirtualUtils.error(`mkdir: ${error.message}`);
   }
-}
+}

package/src/commands/$.mv.mjs

@@ -2,14 +2,19 @@ import fs from 'fs';
 import path from 'path';
 import { trace, VirtualUtils } from '../$.utils.mjs';
 
-export default async function mv({ args, stdin, cwd }) {
+export default async function mv({ args, stdin: _stdin, cwd }) {
   const argError = VirtualUtils.validateArgs(args, 2, 'mv');
-  if (argError) return VirtualUtils.invalidArgumentError('mv', 'missing destination file operand');
+  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)) {
@@ -21,69 +26,92 @@ export default async function mv({ args, stdin, cwd }) {
   }
 
   if (paths.length < 2) {
-    return VirtualUtils.invalidArgumentError('mv', 'missing destination file operand');
+    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;
+      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`);
+      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);
+        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`);
+            return VirtualUtils.error(
+              `mv: cannot move '${source}': File exists`
+            );
           } catch (error) {
-            if (error.code !== 'ENOENT') throw error;
+            if (error.code !== 'ENOENT') {
+              throw error;
+            }
           }
         }
-        
-        trace('VirtualCommand', () => `mv: moving | ${JSON.stringify({ from: sourcePath, to: finalDestPath }, null, 2)}`);
+
+        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`);
+          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)}`);
+
+    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)}`);
+    trace(
+      'VirtualCommand',
+      () => `mv: error | ${JSON.stringify({ error: error.message }, null, 2)}`
+    );
     return VirtualUtils.error(`mv: ${error.message}`);
   }
-}
+}