command-stream 0.3.1 → 0.4.0

package/src/commands/$.sleep.mjs

@@ -0,0 +1,72 @@
+import { trace } from '../$.utils.mjs';
+
+export default async function sleep({ args, signal, isCancelled }) {
+  const seconds = parseFloat(args[0] || 0);
+  trace('VirtualCommand', () => `sleep: starting | ${JSON.stringify({ 
+    seconds,
+    hasSignal: !!signal,
+    signalAborted: signal?.aborted,
+    hasIsCancelled: !!isCancelled
+  }, null, 2)}`);
+  
+  if (isNaN(seconds) || seconds < 0) {
+    return { stderr: `sleep: invalid time interval '${args[0]}'`, code: 1 };
+  }
+  
+  // Use abort signal if available, otherwise use setTimeout
+  try {
+    await new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(resolve, seconds * 1000);
+      
+      // Handle cancellation via signal
+      if (signal) {
+        trace('VirtualCommand', () => `sleep: setting up abort signal listener | ${JSON.stringify({
+          signalAborted: signal.aborted
+        }, null, 2)}`);
+        
+        signal.addEventListener('abort', () => {
+          trace('VirtualCommand', () => `sleep: abort signal received | ${JSON.stringify({
+            seconds,
+            signalAborted: signal.aborted
+          }, null, 2)}`);
+          clearTimeout(timeoutId);
+          reject(new Error('Sleep cancelled'));
+        });
+        
+        // Check if already aborted
+        if (signal.aborted) {
+          trace('VirtualCommand', () => `sleep: signal already aborted | ${JSON.stringify({ seconds }, null, 2)}`);
+          clearTimeout(timeoutId);
+          reject(new Error('Sleep cancelled'));
+          return;
+        }
+      } else {
+        trace('VirtualCommand', () => `sleep: no signal provided | ${JSON.stringify({ seconds }, null, 2)}`);
+      }
+      
+      // Also check isCancelled periodically for quicker response
+      if (isCancelled) {
+        trace('VirtualCommand', () => `sleep: setting up isCancelled polling | ${JSON.stringify({ seconds }, null, 2)}`);
+        const checkInterval = setInterval(() => {
+          if (isCancelled()) {
+            trace('VirtualCommand', () => `sleep: isCancelled returned true | ${JSON.stringify({ seconds }, null, 2)}`);
+            clearTimeout(timeoutId);
+            clearInterval(checkInterval);
+            reject(new Error('Sleep cancelled'));
+          }
+        }, 100);
+      }
+    });
+    
+    trace('VirtualCommand', () => `sleep: completed naturally | ${JSON.stringify({ seconds }, null, 2)}`);
+    return { stdout: '', code: 0 };
+  } catch (err) {
+    trace('VirtualCommand', () => `sleep: interrupted | ${JSON.stringify({ 
+      seconds, 
+      error: err.message,
+      errorName: err.name
+    }, null, 2)}`);
+    // Let the ProcessRunner determine the appropriate exit code based on the cancellation signal
+    throw err;
+  }
+}

package/src/commands/$.test.mjs

@@ -0,0 +1,59 @@
+import fs from 'fs';
+import { VirtualUtils } from '../$.utils.mjs';
+
+export default async function test({ args }) {
+  if (args.length === 0) {
+    return { stdout: '', code: 1 };
+  }
+
+  const operator = args[0];
+  const operand = args[1];
+
+  try {
+    switch (operator) {
+      case '-e': // File exists
+        try {
+          fs.statSync(operand);
+          return { stdout: '', code: 0 };
+        } catch {
+          return { stdout: '', code: 1 };
+        }
+
+      case '-f': // Regular file
+        try {
+          const stats = fs.statSync(operand);
+          return { stdout: '', code: stats.isFile() ? 0 : 1 };
+        } catch {
+          return { stdout: '', code: 1 };
+        }
+
+      case '-d': // Directory
+        try {
+          const stats = fs.statSync(operand);
+          return { stdout: '', code: stats.isDirectory() ? 0 : 1 };
+        } catch {
+          return { stdout: '', code: 1 };
+        }
+
+      case '-s': // File exists and not empty
+        try {
+          const stats = fs.statSync(operand);
+          return { stdout: '', code: stats.size > 0 ? 0 : 1 };
+        } catch {
+          return { stdout: '', code: 1 };
+        }
+
+      case '-z': // String is empty
+        return { stdout: '', code: (!operand || operand.length === 0) ? 0 : 1 };
+
+      case '-n': // String is not empty
+        return { stdout: '', code: (operand && operand.length > 0) ? 0 : 1 };
+
+      default:
+        // Simple string test (non-empty)
+        return { stdout: '', code: (operator && operator.length > 0) ? 0 : 1 };
+    }
+  } catch (error) {
+    return VirtualUtils.error(`test: ${error.message}`);
+  }
+}

package/src/commands/$.touch.mjs

@@ -0,0 +1,36 @@
+import fs from 'fs';
+import { trace, VirtualUtils } from '../$.utils.mjs';
+
+export default async function touch({ args, stdin, cwd }) {
+  const argError = VirtualUtils.validateArgs(args, 1, 'touch');
+  if (argError) return VirtualUtils.missingOperandError('touch', 'touch: missing file operand');
+
+  try {
+    for (const file of args) {
+      const resolvedPath = VirtualUtils.resolvePath(file, cwd);
+      trace('VirtualCommand', () => `touch: processing | ${JSON.stringify({ file: resolvedPath }, null, 2)}`);
+      
+      const now = new Date();
+      
+      try {
+        // Try to update existing file's timestamp
+        fs.utimesSync(resolvedPath, now, now);
+        trace('VirtualCommand', () => `touch: updated timestamp | ${JSON.stringify({ file: resolvedPath }, null, 2)}`);
+      } catch (error) {
+        if (error.code === 'ENOENT') {
+          // File doesn't exist, create it
+          fs.writeFileSync(resolvedPath, '');
+          trace('VirtualCommand', () => `touch: created file | ${JSON.stringify({ file: resolvedPath }, null, 2)}`);
+        } else {
+          throw error;
+        }
+      }
+    }
+    
+    trace('VirtualCommand', () => `touch: success | ${JSON.stringify({ filesTouched: args.length }, null, 2)}`);
+    return VirtualUtils.success();
+  } catch (error) {
+    trace('VirtualCommand', () => `touch: error | ${JSON.stringify({ error: error.message }, null, 2)}`);
+    return VirtualUtils.error(`touch: ${error.message}`);
+  }
+}

package/src/commands/$.true.mjs

@@ -0,0 +1,5 @@
+import { VirtualUtils } from '../$.utils.mjs';
+
+export default async function trueCommand() {
+  return VirtualUtils.success();
+}

package/src/commands/$.which.mjs

@@ -0,0 +1,32 @@
+import fs from 'fs';
+import path from 'path';
+import { VirtualUtils } from '../$.utils.mjs';
+
+export default function createWhichCommand(virtualCommands) {
+  return async function which({ args }) {
+    const argError = VirtualUtils.validateArgs(args, 1, 'which');
+    if (argError) return argError;
+
+    const cmd = args[0];
+
+    if (virtualCommands.has(cmd)) {
+      return VirtualUtils.success(`${cmd}: shell builtin\n`);
+    }
+
+    const paths = (process.env.PATH || '').split(process.platform === 'win32' ? ';' : ':');
+    const extensions = process.platform === 'win32' ? ['', '.exe', '.cmd', '.bat'] : [''];
+
+    for (const pathDir of paths) {
+      for (const ext of extensions) {
+        const fullPath = path.join(pathDir, cmd + ext);
+        try {
+          if (fs.statSync(fullPath).isFile()) {
+            return VirtualUtils.success(fullPath + '\n');
+          }
+        } catch { }
+      }
+    }
+
+    return VirtualUtils.error(`which: no ${cmd} in PATH`);
+  };
+}

package/src/commands/$.yes.mjs

@@ -0,0 +1,48 @@
+import { trace } from '../$.utils.mjs';
+
+export default async function* yes({ args, stdin, isCancelled, signal, ...rest }) {
+  const output = args.length > 0 ? args.join(' ') : 'y';
+  trace('VirtualCommand', () => `yes: starting infinite generator | ${JSON.stringify({ 
+    output,
+    hasIsCancelled: !!isCancelled,
+    hasSignal: !!signal
+  }, null, 2)}`);
+
+  let iteration = 0;
+  const MAX_ITERATIONS = 1000000; // Safety limit
+
+  while (!isCancelled?.() && iteration < MAX_ITERATIONS) {
+    trace('VirtualCommand', () => `yes: iteration ${iteration} starting | ${JSON.stringify({
+      isCancelled: isCancelled?.(),
+      signalAborted: signal?.aborted
+    }, null, 2)}`);
+    
+    // Check for abort signal
+    if (signal?.aborted) {
+      trace('VirtualCommand', () => `yes: aborted via signal | ${JSON.stringify({ iteration }, null, 2)}`);
+      break;
+    }
+
+    // Also check rest properties for various cancellation methods
+    if (rest.aborted || rest.cancelled || rest.stop) {
+      trace('VirtualCommand', () => `yes: stopped via property | ${JSON.stringify({ iteration }, null, 2)}`);
+      break;
+    }
+
+    trace('VirtualCommand', () => `yes: yielding output for iteration ${iteration}`);
+    yield output + '\n';
+
+    iteration++;
+
+    // Yield control after every iteration to allow cancellation
+    // This ensures the consumer can break cleanly
+    trace('VirtualCommand', () => `yes: yielding control after iteration ${iteration - 1}`);
+    await new Promise(resolve => setImmediate(resolve));
+  }
+
+  trace('VirtualCommand', () => `yes: generator completed | ${JSON.stringify({ 
+    iteration,
+    wasCancelled: isCancelled?.(),
+    wasAborted: signal?.aborted
+  }, null, 2)}`);
+}