command-stream 0.3.2 → 0.4.0

package/src/commands/$.cat.mjs

@@ -1,7 +1,7 @@
 import fs from 'fs';
 import { trace, VirtualUtils } from '../$.utils.mjs';
 
-export default async function cat({ args, stdin, cwd }) {
+export default async function cat({ args, stdin, cwd, isCancelled, signal }) {
   if (args.length === 0) {
     // Read from stdin if no files specified
     if (stdin !== undefined && stdin !== '') {
@@ -13,6 +13,12 @@ export default async function cat({ args, stdin, cwd }) {
   try {
     const outputs = [];
     for (const file of args) {
+      // Check for cancellation before processing each file
+      if (isCancelled?.() || signal?.aborted) {
+        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)}`);
       const resolvedPath = VirtualUtils.resolvePath(file, cwd);
       try {

package/src/commands/$.sleep.mjs

@@ -1,15 +1,72 @@
 import { trace } from '../$.utils.mjs';
 
-export default async function sleep({ args }) {
+export default async function sleep({ args, signal, isCancelled }) {
   const seconds = parseFloat(args[0] || 0);
-  trace('VirtualCommand', () => `sleep: starting | ${JSON.stringify({ seconds }, null, 2)}`);
+  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 };
   }
   
-  await new Promise(resolve => setTimeout(resolve, seconds * 1000));
-  trace('VirtualCommand', () => `sleep: completed | ${JSON.stringify({ seconds }, null, 2)}`);
-  
-  return { stdout: '', code: 0 };
+  // 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/$.yes.mjs

@@ -2,12 +2,21 @@ 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 }, null, 2)}`);
+  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)}`);
@@ -20,15 +29,20 @@ export default async function* yes({ args, stdin, isCancelled, signal, ...rest }
       break;
     }
 
+    trace('VirtualCommand', () => `yes: yielding output for iteration ${iteration}`);
     yield output + '\n';
 
     iteration++;
 
-    // Yield control periodically to prevent blocking
-    if (iteration % 1000 === 0) {
-      await new Promise(resolve => setImmediate(resolve));
-    }
+    // 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 }, null, 2)}`);
+  trace('VirtualCommand', () => `yes: generator completed | ${JSON.stringify({ 
+    iteration,
+    wasCancelled: isCancelled?.(),
+    wasAborted: signal?.aborted
+  }, null, 2)}`);
 }