command-stream 0.0.5 → 0.2.0

package/$.mjs

@@ -10,6 +10,101 @@ import { fileURLToPath } from 'url';
 
 const isBun = typeof globalThis.Bun !== 'undefined';
 
+// Verbose tracing for debugging (enabled in CI or when COMMAND_STREAM_VERBOSE is set)
+const VERBOSE = process.env.COMMAND_STREAM_VERBOSE === 'true' || process.env.CI === 'true';
+
+// Trace function for verbose logging
+function trace(category, message, data = {}) {
+  if (!VERBOSE) return;
+  
+  const timestamp = new Date().toISOString();
+  const dataStr = Object.keys(data).length > 0 ? ' | ' + JSON.stringify(data) : '';
+  console.error(`[TRACE ${timestamp}] [${category}] ${message}${dataStr}`);
+}
+
+// Trace decision branches
+function traceBranch(category, condition, branch, data = {}) {
+  if (!VERBOSE) return;
+  
+  trace(category, `BRANCH: ${condition} => ${branch}`, data);
+}
+
+// Trace function entry/exit
+function traceFunc(category, funcName, phase, data = {}) {
+  if (!VERBOSE) return;
+  
+  trace(category, `${funcName} ${phase}`, data);
+}
+
+// Track parent stream state for graceful shutdown
+let parentStreamsMonitored = false;
+const activeProcessRunners = new Set();
+
+function monitorParentStreams() {
+  if (parentStreamsMonitored) return;
+  parentStreamsMonitored = true;
+  
+  // Monitor parent stdout/stderr for closure
+  const checkParentStream = (stream, name) => {
+    if (stream && typeof stream.on === 'function') {
+      stream.on('close', () => {
+        trace('ProcessRunner', `Parent ${name} closed - triggering graceful shutdown`, {
+          activeProcesses: activeProcessRunners.size
+        });
+        // Signal all active ProcessRunners to gracefully shutdown
+        for (const runner of activeProcessRunners) {
+          runner._handleParentStreamClosure();
+        }
+      });
+    }
+  };
+  
+  checkParentStream(process.stdout, 'stdout');
+  checkParentStream(process.stderr, 'stderr');
+}
+
+// Safe write function that checks stream state and handles parent closure
+function safeWrite(stream, data, processRunner = null) {
+  // Ensure parent stream monitoring is active
+  monitorParentStreams();
+  
+  // Check if stream is writable and not destroyed/closed
+  if (!stream || !stream.writable || stream.destroyed || stream.closed) {
+    trace('ProcessRunner', 'safeWrite skipped - stream not writable', { 
+      hasStream: !!stream,
+      writable: stream?.writable,
+      destroyed: stream?.destroyed,
+      closed: stream?.closed
+    });
+    
+    // If this is a parent stream closure, signal graceful shutdown
+    if (processRunner && (stream === process.stdout || stream === process.stderr)) {
+      processRunner._handleParentStreamClosure();
+    }
+    
+    return false;
+  }
+  
+  try {
+    return stream.write(data);
+  } catch (error) {
+    trace('ProcessRunner', 'safeWrite error', { 
+      error: error.message, 
+      code: error.code,
+      writable: stream.writable,
+      destroyed: stream.destroyed
+    });
+    
+    // If this is an EPIPE on parent streams, signal graceful shutdown
+    if (error.code === 'EPIPE' && processRunner && 
+        (stream === process.stdout || stream === process.stderr)) {
+      processRunner._handleParentStreamClosure();
+    }
+    
+    return false;
+  }
+}
+
 // Global shell settings (like bash set -e / set +e)
 let globalShellSettings = {
   errexit: false,    // set -e equivalent: exit on error
@@ -50,6 +145,9 @@ class StreamEmitter {
       this.listeners.set(event, []);
     }
     this.listeners.get(event).push(listener);
+    
+    // No auto-start - explicit start() or await will start the process
+    
     return this;
   }
 
@@ -84,18 +182,28 @@ function quote(value) {
 }
 
 function buildShellCommand(strings, values) {
+  traceFunc('Utils', 'buildShellCommand', 'ENTER', { 
+    stringsLength: strings.length,
+    valuesLength: values.length
+  });
+  
   let out = '';
   for (let i = 0; i < strings.length; i++) {
     out += strings[i];
     if (i < values.length) {
       const v = values[i];
       if (v && typeof v === 'object' && Object.prototype.hasOwnProperty.call(v, 'raw')) {
+        traceBranch('Utils', 'buildShellCommand', 'RAW_VALUE', { value: String(v.raw) });
         out += String(v.raw);
       } else {
-        out += quote(v);
+        const quoted = quote(v);
+        traceBranch('Utils', 'buildShellCommand', 'QUOTED_VALUE', { original: v, quoted });
+        out += quoted;
       }
     }
   }
+  
+  traceFunc('Utils', 'buildShellCommand', 'EXIT', { command: out });
   return out;
 }
 
@@ -116,6 +224,12 @@ async function pumpReadable(readable, onChunk) {
 class ProcessRunner extends StreamEmitter {
   constructor(spec, options = {}) {
     super();
+    
+    traceFunc('ProcessRunner', 'constructor', 'ENTER', { 
+      spec: typeof spec === 'object' ? { ...spec, command: spec.command?.slice(0, 100) } : spec,
+      options 
+    });
+    
     this.spec = spec;
     this.options = {
       mirror: true,
@@ -139,27 +253,165 @@ class ProcessRunner extends StreamEmitter {
     
     // Promise for awaiting final result
     this.promise = null;
+    
+    // Track the execution mode
+    this._mode = null; // 'async' or 'sync'
+    
+    // Cancellation support for virtual commands
+    this._cancelled = false;
+    this._virtualGenerator = null;
+    this._abortController = new AbortController();
+    
+    // Register this ProcessRunner for parent stream monitoring
+    activeProcessRunners.add(this);
+    
+    // Track finished state changes to trigger cleanup
+    this._finished = false;
+  }
+  
+  // Override finished property to trigger cleanup when set to true
+  get finished() {
+    return this._finished;
+  }
+  
+  set finished(value) {
+    if (value === true && this._finished === false) {
+      this._finished = true;
+      this._cleanup(); // Trigger cleanup when process finishes
+    } else {
+      this._finished = value;
+    }
   }
 
-  async _start() {
-    if (this.started) return;
+  // Handle parent stream closure by gracefully shutting down child processes
+  _handleParentStreamClosure() {
+    if (this.finished || this._cancelled) return;
+    
+    trace('ProcessRunner', 'Handling parent stream closure', {
+      started: this.started,
+      hasChild: !!this.child,
+      command: this.spec.command?.slice(0, 50) || this.spec.file
+    });
+    
+    // Mark as cancelled to prevent further operations
+    this._cancelled = true;
+    
+    // Cancel abort controller for virtual commands
+    if (this._abortController) {
+      this._abortController.abort();
+    }
+    
+    // Gracefully close child process if it exists
+    if (this.child) {
+      try {
+        // Close stdin first to signal completion
+        if (this.child.stdin && typeof this.child.stdin.end === 'function') {
+          this.child.stdin.end();
+        } else if (isBun && this.child.stdin && typeof this.child.stdin.getWriter === 'function') {
+          const writer = this.child.stdin.getWriter();
+          writer.close().catch(() => {}); // Ignore close errors
+        }
+        
+        // Give the process a moment to exit gracefully, then terminate
+        setTimeout(() => {
+          if (this.child && !this.finished) {
+            trace('ProcessRunner', 'Terminating child process after parent stream closure', {});
+            if (typeof this.child.kill === 'function') {
+              this.child.kill('SIGTERM');
+            }
+          }
+        }, 100);
+        
+      } catch (error) {
+        trace('ProcessRunner', 'Error during graceful shutdown', { error: error.message });
+      }
+    }
+    
+    // Remove from active set
+    activeProcessRunners.delete(this);
+  }
+
+  // Cleanup method to remove from active set when process completes normally
+  _cleanup() {
+    activeProcessRunners.delete(this);
+  }
+
+  // Unified start method that can work in both async and sync modes
+  start(options = {}) {
+    const mode = options.mode || 'async';
+    
+    traceFunc('ProcessRunner', 'start', 'ENTER', { mode, options });
+    
+    if (mode === 'sync') {
+      traceBranch('ProcessRunner', 'mode', 'sync', {});
+      return this._startSync();
+    } else {
+      traceBranch('ProcessRunner', 'mode', 'async', {});
+      return this._startAsync();
+    }
+  }
+  
+  // Shortcut for sync mode
+  sync() {
+    return this.start({ mode: 'sync' });
+  }
+  
+  // Shortcut for async mode
+  async() {
+    return this.start({ mode: 'async' });
+  }
+  
+  async _startAsync() {
+    if (this.started) return this.promise;
+    if (this.promise) return this.promise;
+    
+    this.promise = this._doStartAsync();
+    return this.promise;
+  }
+  
+  async _doStartAsync() {
+    traceFunc('ProcessRunner', '_doStartAsync', 'ENTER', { 
+      mode: this.spec.mode,
+      command: this.spec.command?.slice(0, 100)
+    });
+    
     this.started = true;
+    this._mode = 'async';
 
     const { cwd, env, stdin } = this.options;
     
     // Handle programmatic pipeline mode
     if (this.spec.mode === 'pipeline') {
+      traceBranch('ProcessRunner', 'spec.mode', 'pipeline', { 
+        hasSource: !!this.spec.source,
+        hasDestination: !!this.spec.destination
+      });
       return await this._runProgrammaticPipeline(this.spec.source, this.spec.destination);
     }
     
     // Check if this is a virtual command first
     if (this.spec.mode === 'shell') {
+      traceBranch('ProcessRunner', 'spec.mode', 'shell', {});
+      
       // Parse the command to check for virtual commands or pipelines
       const parsed = this._parseCommand(this.spec.command);
+      trace('ProcessRunner', 'Parsed command', { 
+        type: parsed?.type,
+        cmd: parsed?.cmd,
+        argsCount: parsed?.args?.length
+      });
+      
       if (parsed) {
         if (parsed.type === 'pipeline') {
+          traceBranch('ProcessRunner', 'parsed.type', 'pipeline', { 
+            commandCount: parsed.commands?.length 
+          });
           return await this._runPipeline(parsed.commands);
         } else if (parsed.type === 'simple' && virtualCommandsEnabled && virtualCommands.has(parsed.cmd)) {
+          traceBranch('ProcessRunner', 'virtualCommand', parsed.cmd, { 
+            isVirtual: true,
+            args: parsed.args 
+          });
           return await this._runVirtual(parsed.cmd, parsed.args);
         }
       }
@@ -194,7 +446,7 @@ class ProcessRunner extends StreamEmitter {
     // Setup stdout streaming
     const outPump = pumpReadable(this.child.stdout, async (buf) => {
       if (this.options.capture) this.outChunks.push(buf);
-      if (this.options.mirror) process.stdout.write(buf);
+      if (this.options.mirror) safeWrite(process.stdout, buf);
       
       // Emit chunk events
       this.emit('stdout', buf);
@@ -204,7 +456,7 @@ class ProcessRunner extends StreamEmitter {
     // Setup stderr streaming  
     const errPump = pumpReadable(this.child.stderr, async (buf) => {
       if (this.options.capture) this.errChunks.push(buf);
-      if (this.options.mirror) process.stderr.write(buf);
+      if (this.options.mirror) safeWrite(process.stderr, buf);
       
       // Emit chunk events
       this.emit('stderr', buf);
@@ -236,8 +488,16 @@ class ProcessRunner extends StreamEmitter {
     const code = await exited;
     await Promise.all([outPump, errPump, stdinPumpPromise]);
 
-    const resultData = {
+    // Debug: Check the raw exit code
+    trace('ProcessRunner', 'Raw exit code from child', { 
       code,
+      codeType: typeof code,
+      childExitCode: this.child?.exitCode,
+      isBun
+    });
+
+    const resultData = {
+      code: code ?? 0,  // Default to 0 if exit code is null/undefined
       stdout: this.options.capture ? Buffer.concat(this.outChunks).toString('utf8') : undefined,
       stderr: this.options.capture ? Buffer.concat(this.errChunks).toString('utf8') : undefined,
       stdin: this.options.capture && this.inChunks ? Buffer.concat(this.inChunks).toString('utf8') : undefined,
@@ -276,7 +536,27 @@ class ProcessRunner extends StreamEmitter {
       const buf = asBuffer(chunk);
       captureChunks && captureChunks.push(buf);
       if (bunWriter) await bunWriter.write(buf);
-      else if (typeof child.stdin.write === 'function') child.stdin.write(buf);
+      else if (typeof child.stdin.write === 'function') {
+        // Add error handler to prevent unhandled error events
+        if (child.stdin && typeof child.stdin.on === 'function') {
+          child.stdin.on('error', (error) => {
+            if (error.code !== 'EPIPE') {
+              trace('ProcessRunner', 'child stdin buffer error event', { error: error.message, code: error.code });
+            }
+          });
+        }
+        
+        // Safe write to handle EPIPE errors
+        if (child.stdin && child.stdin.writable && !child.stdin.destroyed && !child.stdin.closed) {
+          try {
+            child.stdin.write(buf);
+          } catch (error) {
+            if (error.code !== 'EPIPE') {
+              trace('ProcessRunner', 'Error writing stdin buffer', { error: error.message, code: error.code });
+            }
+          }
+        }
+      }
       else if (isBun && typeof Bun.write === 'function') await Bun.write(child.stdin, buf);
     }
     if (bunWriter) await bunWriter.close();
@@ -287,8 +567,14 @@ class ProcessRunner extends StreamEmitter {
     if (isBun && this.child.stdin && typeof this.child.stdin.getWriter === 'function') {
       const w = this.child.stdin.getWriter();
       const bytes = buf instanceof Uint8Array ? buf : new Uint8Array(buf.buffer, buf.byteOffset ?? 0, buf.byteLength);
-      await w.write(bytes);
-      await w.close();
+      try {
+        await w.write(bytes);
+        await w.close();
+      } catch (error) {
+        if (error.code !== 'EPIPE') {
+          trace('ProcessRunner', 'Error writing to Bun writer', { error: error.message, code: error.code });
+        }
+      }
     } else if (this.child.stdin && typeof this.child.stdin.write === 'function') {
       this.child.stdin.end(buf);
     } else if (isBun && typeof Bun.write === 'function') {
@@ -375,11 +661,19 @@ class ProcessRunner extends StreamEmitter {
   }
 
   async _runVirtual(cmd, args) {
+    traceFunc('ProcessRunner', '_runVirtual', 'ENTER', { cmd, args });
+    
     const handler = virtualCommands.get(cmd);
     if (!handler) {
+      trace('ProcessRunner', 'Virtual command not found', { cmd });
       throw new Error(`Virtual command not found: ${cmd}`);
     }
 
+    trace('ProcessRunner', 'Found virtual command handler', { 
+      cmd,
+      isGenerator: handler.constructor.name === 'AsyncGeneratorFunction'
+    });
+
     try {
       // Prepare stdin
       let stdinData = '';
@@ -405,115 +699,820 @@ class ProcessRunner extends StreamEmitter {
       
       // Check if handler is async generator (streaming)
       if (handler.constructor.name === 'AsyncGeneratorFunction') {
-        // Handle streaming virtual command
+        // Handle streaming virtual command with cancellation support
         const chunks = [];
-        for await (const chunk of handler(argValues, stdinData, this.options)) {
+        
+        // Create options with cancellation check and abort signal
+        const commandOptions = {
+          ...this.options,
+          isCancelled: () => this._cancelled,
+          signal: this._abortController.signal
+        };
+        
+        const generator = handler({ args: argValues, stdin: stdinData, ...commandOptions });
+        this._virtualGenerator = generator;
+        
+        // Create a promise that resolves when cancelled
+        const cancelPromise = new Promise(resolve => {
+          this._cancelResolve = resolve;
+        });
+        
+        try {
+          const iterator = generator[Symbol.asyncIterator]();
+          let done = false;
+          
+          while (!done && !this._cancelled) {
+            // Race between getting next value and cancellation
+            const result = await Promise.race([
+              iterator.next(),
+              cancelPromise.then(() => ({ done: true, cancelled: true }))
+            ]);
+            
+            if (result.cancelled || this._cancelled) {
+              // Cancelled - close the generator
+              if (iterator.return) {
+                await iterator.return();
+              }
+              break;
+            }
+            
+            done = result.done;
+            
+            if (!done) {
+              const chunk = result.value;
+              const buf = Buffer.from(chunk);
+              chunks.push(buf);
+              
+              // Only output if not cancelled
+              if (!this._cancelled) {
+                if (this.options.mirror) {
+                  safeWrite(process.stdout, buf);
+                }
+                
+                this.emit('stdout', buf);
+                this.emit('data', { type: 'stdout', data: buf });
+              }
+            }
+          }
+        } finally {
+          // Clean up
+          this._virtualGenerator = null;
+          this._cancelResolve = null;
+        }
+        
+        result = {
+          code: 0,
+          stdout: this.options.capture ? Buffer.concat(chunks).toString('utf8') : undefined,
+          stderr: this.options.capture ? '' : undefined,
+          stdin: this.options.capture ? stdinData : undefined
+        };
+      } else {
+        // Regular async function
+        result = await handler({ args: argValues, stdin: stdinData, ...this.options });
+        
+        // Ensure result has required fields, respecting capture option
+        result = {
+          code: result.code ?? 0,
+          stdout: this.options.capture ? (result.stdout ?? '') : undefined,
+          stderr: this.options.capture ? (result.stderr ?? '') : undefined,
+          stdin: this.options.capture ? stdinData : undefined,
+          ...result
+        };
+        
+        // Mirror and emit output
+        if (result.stdout) {
+          const buf = Buffer.from(result.stdout);
+          if (this.options.mirror) {
+            safeWrite(process.stdout, buf);
+          }
+          this.emit('stdout', buf);
+          this.emit('data', { type: 'stdout', data: buf });
+        }
+        
+        if (result.stderr) {
+          const buf = Buffer.from(result.stderr);
+          if (this.options.mirror) {
+            safeWrite(process.stderr, buf);
+          }
+          this.emit('stderr', buf);
+          this.emit('data', { type: 'stderr', data: buf });
+        }
+      }
+
+      // Store result
+      this.result = result;
+      this.finished = true;
+      
+      // Emit completion events
+      this.emit('end', result);
+      this.emit('exit', result.code);
+      
+      // Handle shell settings
+      if (globalShellSettings.errexit && result.code !== 0) {
+        const error = new Error(`Command failed with exit code ${result.code}`);
+        error.code = result.code;
+        error.stdout = result.stdout;
+        error.stderr = result.stderr;
+        error.result = result;
+        throw error;
+      }
+      
+      return result;
+    } catch (error) {
+      // Handle errors from virtual commands
+      const result = {
+        code: error.code ?? 1,
+        stdout: error.stdout ?? '',
+        stderr: error.stderr ?? error.message,
+        stdin: ''
+      };
+      
+      this.result = result;
+      this.finished = true;
+      
+      if (result.stderr) {
+        const buf = Buffer.from(result.stderr);
+        if (this.options.mirror) {
+          safeWrite(process.stderr, buf);
+        }
+        this.emit('stderr', buf);
+        this.emit('data', { type: 'stderr', data: buf });
+      }
+      
+      this.emit('end', result);
+      this.emit('exit', result.code);
+      
+      if (globalShellSettings.errexit) {
+        throw error;
+      }
+      
+      return result;
+    }
+  }
+
+  async _runStreamingPipelineBun(commands) {
+    traceFunc('ProcessRunner', '_runStreamingPipelineBun', 'ENTER', { 
+      commandsCount: commands.length 
+    });
+    
+    // For true streaming, we need to handle virtual and real commands differently
+    // but make them work together seamlessly
+    
+    // First, analyze the pipeline to identify virtual vs real commands
+    const pipelineInfo = commands.map(command => {
+      const { cmd, args } = command;
+      const isVirtual = virtualCommandsEnabled && virtualCommands.has(cmd);
+      return { ...command, isVirtual };
+    });
+    
+    trace('ProcessRunner', 'Pipeline analysis', { 
+      virtualCount: pipelineInfo.filter(p => p.isVirtual).length,
+      realCount: pipelineInfo.filter(p => !p.isVirtual).length 
+    });
+    
+    // If pipeline contains virtual commands, use advanced streaming
+    if (pipelineInfo.some(info => info.isVirtual)) {
+      traceBranch('ProcessRunner', '_runStreamingPipelineBun', 'MIXED_PIPELINE', {});
+      return this._runMixedStreamingPipeline(commands);
+    }
+    
+    // For pipelines with commands that buffer (like jq), use tee streaming
+    const needsStreamingWorkaround = commands.some(c => 
+      c.cmd === 'jq' || c.cmd === 'grep' || c.cmd === 'sed' || c.cmd === 'cat' || c.cmd === 'awk'
+    );
+    if (needsStreamingWorkaround) {
+      traceBranch('ProcessRunner', '_runStreamingPipelineBun', 'TEE_STREAMING', { 
+        bufferedCommands: commands.filter(c => 
+          ['jq', 'grep', 'sed', 'cat', 'awk'].includes(c.cmd)
+        ).map(c => c.cmd)
+      });
+      return this._runTeeStreamingPipeline(commands);
+    }
+    
+    // All real commands - use native pipe connections
+    const processes = [];
+    let allStderr = '';
+    
+    for (let i = 0; i < commands.length; i++) {
+      const command = commands[i];
+      const { cmd, args } = command;
+      
+      // Build command string
+      const commandParts = [cmd];
+      for (const arg of args) {
+        if (arg.value !== undefined) {
+          if (arg.quoted) {
+            commandParts.push(`${arg.quoteChar}${arg.value}${arg.quoteChar}`);
+          } else if (arg.value.includes(' ')) {
+            commandParts.push(`"${arg.value}"`);
+          } else {
+            commandParts.push(arg.value);
+          }
+        } else {
+          if (typeof arg === 'string' && arg.includes(' ') && !arg.startsWith('"') && !arg.startsWith("'")) {
+            commandParts.push(`"${arg}"`);
+          } else {
+            commandParts.push(arg);
+          }
+        }
+      }
+      const commandStr = commandParts.join(' ');
+      
+      // Determine stdin for this process
+      let stdin;
+      let needsManualStdin = false;
+      let stdinData;
+      
+      if (i === 0) {
+        // First command - use provided stdin or pipe
+        if (this.options.stdin && typeof this.options.stdin === 'string') {
+          stdin = 'pipe';
+          needsManualStdin = true;
+          stdinData = Buffer.from(this.options.stdin);
+        } else if (this.options.stdin && Buffer.isBuffer(this.options.stdin)) {
+          stdin = 'pipe';
+          needsManualStdin = true;
+          stdinData = this.options.stdin;
+        } else {
+          stdin = 'ignore';
+        }
+      } else {
+        // Connect to previous process stdout
+        stdin = processes[i - 1].stdout;
+      }
+      
+      // Spawn the process directly (not through sh) for better streaming
+      // Only use sh -c for complex commands that need shell features
+      const needsShell = commandStr.includes('*') || commandStr.includes('$') || 
+                         commandStr.includes('>') || commandStr.includes('<') ||
+                         commandStr.includes('&&') || commandStr.includes('||') ||
+                         commandStr.includes(';') || commandStr.includes('`');
+      
+      const spawnArgs = needsShell 
+        ? ['sh', '-c', commandStr]
+        : [cmd, ...args.map(a => a.value !== undefined ? a.value : a)];
+      
+      const proc = Bun.spawn(spawnArgs, {
+        cwd: this.options.cwd,
+        env: this.options.env,
+        stdin: stdin,
+        stdout: 'pipe',
+        stderr: 'pipe'
+      });
+      
+      // Write stdin data if needed for first process
+      if (needsManualStdin && stdinData && proc.stdin) {
+        // Add error handler for Bun stdin
+        if (proc.stdin && typeof proc.stdin.on === 'function') {
+          proc.stdin.on('error', (error) => {
+            if (error.code !== 'EPIPE') {
+              trace('ProcessRunner', 'Bun stdin error event', { error: error.message, code: error.code });
+            }
+          });
+        }
+        
+        (async () => {
+          try {
+            // Bun's FileSink has write and end methods
+            if (proc.stdin && proc.stdin.writable && !proc.stdin.destroyed && !proc.stdin.closed) {
+              await proc.stdin.write(stdinData);
+              await proc.stdin.end();
+            }
+          } catch (e) {
+            if (e.code !== 'EPIPE') {
+              trace('ProcessRunner', 'Error writing stdin (Bun)', { error: e.message, code: e.code });
+            }
+          }
+        })();
+      }
+      
+      processes.push(proc);
+      
+      // Collect stderr from all processes
+      (async () => {
+        for await (const chunk of proc.stderr) {
           const buf = Buffer.from(chunk);
-          chunks.push(buf);
+          allStderr += buf.toString();
+          // Only emit stderr for the last command
+          if (i === commands.length - 1) {
+            if (this.options.mirror) {
+              safeWrite(process.stderr, buf);
+            }
+            this.emit('stderr', buf);
+            this.emit('data', { type: 'stderr', data: buf });
+          }
+        }
+      })();
+    }
+    
+    // Stream output from the last process
+    const lastProc = processes[processes.length - 1];
+    let finalOutput = '';
+    
+    // Stream stdout from last process
+    for await (const chunk of lastProc.stdout) {
+      const buf = Buffer.from(chunk);
+      finalOutput += buf.toString();
+      if (this.options.mirror) {
+        safeWrite(process.stdout, buf);
+      }
+      this.emit('stdout', buf);
+      this.emit('data', { type: 'stdout', data: buf });
+    }
+    
+    // Wait for all processes to complete
+    const exitCodes = await Promise.all(processes.map(p => p.exited));
+    const lastExitCode = exitCodes[exitCodes.length - 1];
+    
+    // Check for pipeline failures if pipefail is set
+    if (globalShellSettings.pipefail) {
+      const failedIndex = exitCodes.findIndex(code => code !== 0);
+      if (failedIndex !== -1) {
+        const error = new Error(`Pipeline command at index ${failedIndex} failed with exit code ${exitCodes[failedIndex]}`);
+        error.code = exitCodes[failedIndex];
+        throw error;
+      }
+    }
+    
+    const result = createResult({
+      code: lastExitCode || 0,
+      stdout: finalOutput,
+      stderr: allStderr,
+      stdin: this.options.stdin && typeof this.options.stdin === 'string' ? this.options.stdin : 
+             this.options.stdin && Buffer.isBuffer(this.options.stdin) ? this.options.stdin.toString('utf8') : ''
+    });
+    
+    this.result = result;
+    this.finished = true;
+    
+    this.emit('end', result);
+    this.emit('exit', result.code);
+    
+    if (globalShellSettings.errexit && result.code !== 0) {
+      const error = new Error(`Pipeline failed with exit code ${result.code}`);
+      error.code = result.code;
+      error.stdout = result.stdout;
+      error.stderr = result.stderr;
+      error.result = result;
+      throw error;
+    }
+    
+    return result;
+  }
+
+  async _runTeeStreamingPipeline(commands) {
+    traceFunc('ProcessRunner', '_runTeeStreamingPipeline', 'ENTER', { 
+      commandsCount: commands.length 
+    });
+    
+    // Use tee() to split streams for real-time reading
+    // This works around jq and similar commands that buffer when piped
+    
+    const processes = [];
+    let allStderr = '';
+    let currentStream = null;
+    
+    for (let i = 0; i < commands.length; i++) {
+      const command = commands[i];
+      const { cmd, args } = command;
+      
+      // Build command string
+      const commandParts = [cmd];
+      for (const arg of args) {
+        if (arg.value !== undefined) {
+          if (arg.quoted) {
+            commandParts.push(`${arg.quoteChar}${arg.value}${arg.quoteChar}`);
+          } else if (arg.value.includes(' ')) {
+            commandParts.push(`"${arg.value}"`);
+          } else {
+            commandParts.push(arg.value);
+          }
+        } else {
+          if (typeof arg === 'string' && arg.includes(' ') && !arg.startsWith('"') && !arg.startsWith("'")) {
+            commandParts.push(`"${arg}"`);
+          } else {
+            commandParts.push(arg);
+          }
+        }
+      }
+      const commandStr = commandParts.join(' ');
+      
+      // Determine stdin for this process
+      let stdin;
+      let needsManualStdin = false;
+      let stdinData;
+      
+      if (i === 0) {
+        // First command - use provided stdin or ignore
+        if (this.options.stdin && typeof this.options.stdin === 'string') {
+          stdin = 'pipe';
+          needsManualStdin = true;
+          stdinData = Buffer.from(this.options.stdin);
+        } else if (this.options.stdin && Buffer.isBuffer(this.options.stdin)) {
+          stdin = 'pipe';
+          needsManualStdin = true;
+          stdinData = this.options.stdin;
+        } else {
+          stdin = 'ignore';
+        }
+      } else {
+        // Use the stream from previous process
+        stdin = currentStream;
+      }
+      
+      // Spawn the process directly (not through sh) for better control
+      const needsShell = commandStr.includes('*') || commandStr.includes('$') || 
+                         commandStr.includes('>') || commandStr.includes('<') ||
+                         commandStr.includes('&&') || commandStr.includes('||') ||
+                         commandStr.includes(';') || commandStr.includes('`');
+      
+      const spawnArgs = needsShell 
+        ? ['sh', '-c', commandStr]
+        : [cmd, ...args.map(a => a.value !== undefined ? a.value : a)];
+      
+      const proc = Bun.spawn(spawnArgs, {
+        cwd: this.options.cwd,
+        env: this.options.env,
+        stdin: stdin,
+        stdout: 'pipe',
+        stderr: 'pipe'
+      });
+      
+      // Write stdin data if needed for first process
+      if (needsManualStdin && stdinData && proc.stdin) {
+        // Add error handler for Node stdin
+        if (proc.stdin && typeof proc.stdin.on === 'function') {
+          proc.stdin.on('error', (error) => {
+            if (error.code !== 'EPIPE') {
+              trace('ProcessRunner', 'Node stdin error event', { error: error.message, code: error.code });
+            }
+          });
+        }
+        
+        try {
+          if (proc.stdin && proc.stdin.writable && !proc.stdin.destroyed && !proc.stdin.closed) {
+            await proc.stdin.write(stdinData);
+            await proc.stdin.end();
+          }
+        } catch (e) {
+          if (e.code !== 'EPIPE') {
+            trace('ProcessRunner', 'Error writing stdin (Node stream)', { error: e.message, code: e.code });
+          }
+        }
+      }
+      
+      processes.push(proc);
+      
+      // For non-last processes, tee the output so we can both pipe and read
+      if (i < commands.length - 1) {
+        const [readStream, pipeStream] = proc.stdout.tee();
+        currentStream = pipeStream;
+        
+        // Read from the tee'd stream for real-time updates
+        // Always read from the first process for best streaming
+        if (i === 0) {
+          (async () => {
+            for await (const chunk of readStream) {
+              // Emit from the first process for real-time updates
+              const buf = Buffer.from(chunk);
+              if (this.options.mirror) {
+                safeWrite(process.stdout, buf);
+              }
+              this.emit('stdout', buf);
+              this.emit('data', { type: 'stdout', data: buf });
+            }
+          })();
+        } else {
+          // Consume other tee'd streams to prevent blocking
+          (async () => {
+            for await (const chunk of readStream) {
+              // Just consume to keep flowing
+            }
+          })();
+        }
+      } else {
+        currentStream = proc.stdout;
+      }
+      
+      // Collect stderr from all processes
+      (async () => {
+        for await (const chunk of proc.stderr) {
+          const buf = Buffer.from(chunk);
+          allStderr += buf.toString();
+          if (i === commands.length - 1) {
+            if (this.options.mirror) {
+              safeWrite(process.stderr, buf);
+            }
+            this.emit('stderr', buf);
+            this.emit('data', { type: 'stderr', data: buf });
+          }
+        }
+      })();
+    }
+    
+    // Read final output from the last process
+    const lastProc = processes[processes.length - 1];
+    let finalOutput = '';
+    
+    // If we haven't emitted stdout yet (no tee), emit from last process
+    const shouldEmitFromLast = commands.length === 1;
+    
+    for await (const chunk of lastProc.stdout) {
+      const buf = Buffer.from(chunk);
+      finalOutput += buf.toString();
+      if (shouldEmitFromLast) {
+        if (this.options.mirror) {
+          safeWrite(process.stdout, buf);
+        }
+        this.emit('stdout', buf);
+        this.emit('data', { type: 'stdout', data: buf });
+      }
+    }
+    
+    // Wait for all processes to complete
+    const exitCodes = await Promise.all(processes.map(p => p.exited));
+    const lastExitCode = exitCodes[exitCodes.length - 1];
+    
+    // Check for pipeline failures if pipefail is set
+    if (globalShellSettings.pipefail) {
+      const failedIndex = exitCodes.findIndex(code => code !== 0);
+      if (failedIndex !== -1) {
+        const error = new Error(`Pipeline command at index ${failedIndex} failed with exit code ${exitCodes[failedIndex]}`);
+        error.code = exitCodes[failedIndex];
+        throw error;
+      }
+    }
+    
+    const result = createResult({
+      code: lastExitCode || 0,
+      stdout: finalOutput,
+      stderr: allStderr,
+      stdin: this.options.stdin && typeof this.options.stdin === 'string' ? this.options.stdin : 
+             this.options.stdin && Buffer.isBuffer(this.options.stdin) ? this.options.stdin.toString('utf8') : ''
+    });
+    
+    this.result = result;
+    this.finished = true;
+    
+    this.emit('end', result);
+    this.emit('exit', result.code);
+    
+    if (globalShellSettings.errexit && result.code !== 0) {
+      const error = new Error(`Pipeline failed with exit code ${result.code}`);
+      error.code = result.code;
+      error.stdout = result.stdout;
+      error.stderr = result.stderr;
+      error.result = result;
+      throw error;
+    }
+    
+    return result;
+  }
+
+
+  async _runMixedStreamingPipeline(commands) {
+    traceFunc('ProcessRunner', '_runMixedStreamingPipeline', 'ENTER', { 
+      commandsCount: commands.length 
+    });
+    
+    // Handle pipelines with both virtual and real commands
+    // Each stage reads from previous stage's output stream
+    
+    let currentInputStream = null;
+    let finalOutput = '';
+    let allStderr = '';
+    
+    // Set up initial input stream if provided
+    if (this.options.stdin) {
+      const inputData = typeof this.options.stdin === 'string' 
+        ? this.options.stdin 
+        : this.options.stdin.toString('utf8');
+      
+      // Create a readable stream from the input
+      currentInputStream = new ReadableStream({
+        start(controller) {
+          controller.enqueue(new TextEncoder().encode(inputData));
+          controller.close();
+        }
+      });
+    }
+    
+    for (let i = 0; i < commands.length; i++) {
+      const command = commands[i];
+      const { cmd, args } = command;
+      const isLastCommand = i === commands.length - 1;
+      
+      if (virtualCommandsEnabled && virtualCommands.has(cmd)) {
+        // Handle virtual command with streaming
+        traceBranch('ProcessRunner', '_runMixedStreamingPipeline', 'VIRTUAL_COMMAND', { 
+          cmd,
+          commandIndex: i 
+        });
+        const handler = virtualCommands.get(cmd);
+        const argValues = args.map(arg => arg.value !== undefined ? arg.value : arg);
+        
+        // Read input from stream if available
+        let inputData = '';
+        if (currentInputStream) {
+          const reader = currentInputStream.getReader();
+          try {
+            while (true) {
+              const { done, value } = await reader.read();
+              if (done) break;
+              inputData += new TextDecoder().decode(value);
+            }
+          } finally {
+            reader.releaseLock();
+          }
+        }
+        
+        // Check if handler is async generator (streaming)
+        if (handler.constructor.name === 'AsyncGeneratorFunction') {
+          // Create output stream from generator
+          const chunks = [];
+          const self = this; // Capture this context
+          currentInputStream = new ReadableStream({
+            async start(controller) {
+              const { stdin: _, ...optionsWithoutStdin } = self.options;
+              for await (const chunk of handler({ args: argValues, stdin: inputData, ...optionsWithoutStdin })) {
+                const data = Buffer.from(chunk);
+                controller.enqueue(data);
+                
+                // Emit for last command
+                if (isLastCommand) {
+                  chunks.push(data);
+                  if (self.options.mirror) {
+                    safeWrite(process.stdout, data);
+                  }
+                  self.emit('stdout', data);
+                  self.emit('data', { type: 'stdout', data });
+                }
+              }
+              controller.close();
+              
+              if (isLastCommand) {
+                finalOutput = Buffer.concat(chunks).toString('utf8');
+              }
+            }
+          });
+        } else {
+          // Regular async function
+          const { stdin: _, ...optionsWithoutStdin } = this.options;
+          const result = await handler({ args: argValues, stdin: inputData, ...optionsWithoutStdin });
+          const outputData = result.stdout || '';
           
-          if (this.options.mirror) {
-            process.stdout.write(buf);
+          if (isLastCommand) {
+            finalOutput = outputData;
+            const buf = Buffer.from(outputData);
+            if (this.options.mirror) {
+              safeWrite(process.stdout, buf);
+            }
+            this.emit('stdout', buf);
+            this.emit('data', { type: 'stdout', data: buf });
           }
           
-          this.emit('stdout', buf);
-          this.emit('data', { type: 'stdout', data: buf });
+          // Create stream from output
+          currentInputStream = new ReadableStream({
+            start(controller) {
+              controller.enqueue(new TextEncoder().encode(outputData));
+              controller.close();
+            }
+          });
+          
+          if (result.stderr) {
+            allStderr += result.stderr;
+          }
         }
-        
-        result = {
-          code: 0,
-          stdout: this.options.capture ? Buffer.concat(chunks).toString('utf8') : undefined,
-          stderr: this.options.capture ? '' : undefined,
-          stdin: this.options.capture ? stdinData : undefined
-        };
       } else {
-        // Regular async function
-        result = await handler(argValues, stdinData, this.options);
+        // Handle real command - spawn with streaming
+        const commandParts = [cmd];
+        for (const arg of args) {
+          if (arg.value !== undefined) {
+            if (arg.quoted) {
+              commandParts.push(`${arg.quoteChar}${arg.value}${arg.quoteChar}`);
+            } else if (arg.value.includes(' ')) {
+              commandParts.push(`"${arg.value}"`);
+            } else {
+              commandParts.push(arg.value);
+            }
+          } else {
+            if (typeof arg === 'string' && arg.includes(' ') && !arg.startsWith('"') && !arg.startsWith("'")) {
+              commandParts.push(`"${arg}"`);
+            } else {
+              commandParts.push(arg);
+            }
+          }
+        }
+        const commandStr = commandParts.join(' ');
         
-        // Ensure result has required fields, respecting capture option
-        result = {
-          code: result.code ?? 0,
-          stdout: this.options.capture ? (result.stdout ?? '') : undefined,
-          stderr: this.options.capture ? (result.stderr ?? '') : undefined,
-          stdin: this.options.capture ? stdinData : undefined,
-          ...result
-        };
+        // Spawn the process
+        const proc = Bun.spawn(['sh', '-c', commandStr], {
+          cwd: this.options.cwd,
+          env: this.options.env,
+          stdin: currentInputStream ? 'pipe' : 'ignore',
+          stdout: 'pipe',
+          stderr: 'pipe'
+        });
         
-        // Mirror and emit output
-        if (result.stdout) {
-          const buf = Buffer.from(result.stdout);
-          if (this.options.mirror) {
-            process.stdout.write(buf);
-          }
-          this.emit('stdout', buf);
-          this.emit('data', { type: 'stdout', data: buf });
+        // Write input stream to process stdin if needed
+        if (currentInputStream && proc.stdin) {
+          const reader = currentInputStream.getReader();
+          const writer = proc.stdin.getWriter ? proc.stdin.getWriter() : proc.stdin;
+          
+          (async () => {
+            try {
+              while (true) {
+                const { done, value } = await reader.read();
+                if (done) break;
+                if (writer.write) {
+                  try {
+                    await writer.write(value);
+                  } catch (error) {
+                    if (error.code !== 'EPIPE') {
+                      trace('ProcessRunner', 'Error writing to stream writer', { error: error.message, code: error.code });
+                    }
+                    break; // Stop streaming if write fails
+                  }
+                } else if (writer.getWriter) {
+                  try {
+                    const w = writer.getWriter();
+                    await w.write(value);
+                    w.releaseLock();
+                  } catch (error) {
+                    if (error.code !== 'EPIPE') {
+                      trace('ProcessRunner', 'Error writing to stream writer (getWriter)', { error: error.message, code: error.code });
+                    }
+                    break; // Stop streaming if write fails
+                  }
+                }
+              }
+            } finally {
+              reader.releaseLock();
+              if (writer.close) await writer.close();
+              else if (writer.end) writer.end();
+            }
+          })();
         }
         
-        if (result.stderr) {
-          const buf = Buffer.from(result.stderr);
-          if (this.options.mirror) {
-            process.stderr.write(buf);
+        // Set up output stream
+        currentInputStream = proc.stdout;
+        
+        // Handle stderr
+        (async () => {
+          for await (const chunk of proc.stderr) {
+            const buf = Buffer.from(chunk);
+            allStderr += buf.toString();
+            if (isLastCommand) {
+              if (this.options.mirror) {
+                safeWrite(process.stderr, buf);
+              }
+              this.emit('stderr', buf);
+              this.emit('data', { type: 'stderr', data: buf });
+            }
           }
-          this.emit('stderr', buf);
-          this.emit('data', { type: 'stderr', data: buf });
-        }
-      }
-
-      // Store result
-      this.result = result;
-      this.finished = true;
-      
-      // Emit completion events
-      this.emit('end', result);
-      this.emit('exit', result.code);
-      
-      // Handle shell settings
-      if (globalShellSettings.errexit && result.code !== 0) {
-        const error = new Error(`Command failed with exit code ${result.code}`);
-        error.code = result.code;
-        error.stdout = result.stdout;
-        error.stderr = result.stderr;
-        error.result = result;
-        throw error;
-      }
-      
-      return result;
-    } catch (error) {
-      // Handle errors from virtual commands
-      const result = {
-        code: error.code ?? 1,
-        stdout: error.stdout ?? '',
-        stderr: error.stderr ?? error.message,
-        stdin: ''
-      };
-      
-      this.result = result;
-      this.finished = true;
-      
-      if (result.stderr) {
-        const buf = Buffer.from(result.stderr);
-        if (this.options.mirror) {
-          process.stderr.write(buf);
+        })();
+        
+        // For last command, stream output
+        if (isLastCommand) {
+          const chunks = [];
+          for await (const chunk of proc.stdout) {
+            const buf = Buffer.from(chunk);
+            chunks.push(buf);
+            if (this.options.mirror) {
+              safeWrite(process.stdout, buf);
+            }
+            this.emit('stdout', buf);
+            this.emit('data', { type: 'stdout', data: buf });
+          }
+          finalOutput = Buffer.concat(chunks).toString('utf8');
+          await proc.exited;
         }
-        this.emit('stderr', buf);
-        this.emit('data', { type: 'stderr', data: buf });
       }
-      
-      this.emit('end', result);
-      this.emit('exit', result.code);
-      
-      if (globalShellSettings.errexit) {
-        throw error;
-      }
-      
-      return result;
     }
+    
+    const result = createResult({
+      code: 0, // TODO: Track exit codes properly
+      stdout: finalOutput,
+      stderr: allStderr,
+      stdin: this.options.stdin && typeof this.options.stdin === 'string' ? this.options.stdin : 
+             this.options.stdin && Buffer.isBuffer(this.options.stdin) ? this.options.stdin.toString('utf8') : ''
+    });
+    
+    this.result = result;
+    this.finished = true;
+    
+    this.emit('end', result);
+    this.emit('exit', result.code);
+    
+    return result;
   }
 
-  async _runPipeline(commands) {
-    if (commands.length === 0) {
-      return createResult({ code: 1, stdout: '', stderr: 'No commands in pipeline', stdin: '' });
-    }
-
+  async _runPipelineNonStreaming(commands) {
+    traceFunc('ProcessRunner', '_runPipelineNonStreaming', 'ENTER', { 
+      commandsCount: commands.length 
+    });
+    
+    // Original non-streaming implementation for fallback (e.g., virtual commands)
     let currentOutput = '';
     let currentInput = '';
     
@@ -531,6 +1530,11 @@ class ProcessRunner extends StreamEmitter {
       
       // Check if this is a virtual command (only if virtual commands are enabled)
       if (virtualCommandsEnabled && virtualCommands.has(cmd)) {
+        traceBranch('ProcessRunner', '_runPipelineNonStreaming', 'VIRTUAL_COMMAND', { 
+          cmd,
+          argsCount: args.length 
+        });
+        
         // Run virtual command with current input
         const handler = virtualCommands.get(cmd);
         
@@ -550,8 +1554,9 @@ class ProcessRunner extends StreamEmitter {
           
           // Check if handler is async generator (streaming)
           if (handler.constructor.name === 'AsyncGeneratorFunction') {
+            traceBranch('ProcessRunner', '_runPipelineNonStreaming', 'ASYNC_GENERATOR', { cmd });
             const chunks = [];
-            for await (const chunk of handler(argValues, currentInput, this.options)) {
+            for await (const chunk of handler({ args: argValues, stdin: currentInput, ...this.options })) {
               chunks.push(Buffer.from(chunk));
             }
             result = {
@@ -562,7 +1567,7 @@ class ProcessRunner extends StreamEmitter {
             };
           } else {
             // Regular async function
-            result = await handler(argValues, currentInput, this.options);
+            result = await handler({ args: argValues, stdin: currentInput, ...this.options });
             result = {
               code: result.code ?? 0,
               stdout: this.options.capture ? (result.stdout ?? '') : undefined,
@@ -583,7 +1588,7 @@ class ProcessRunner extends StreamEmitter {
             if (result.stdout) {
               const buf = Buffer.from(result.stdout);
               if (this.options.mirror) {
-                process.stdout.write(buf);
+                safeWrite(process.stdout, buf);
               }
               this.emit('stdout', buf);
               this.emit('data', { type: 'stdout', data: buf });
@@ -592,7 +1597,7 @@ class ProcessRunner extends StreamEmitter {
             if (result.stderr) {
               const buf = Buffer.from(result.stderr);
               if (this.options.mirror) {
-                process.stderr.write(buf);
+                safeWrite(process.stderr, buf);
               }
               this.emit('stderr', buf);
               this.emit('data', { type: 'stderr', data: buf });
@@ -652,7 +1657,7 @@ class ProcessRunner extends StreamEmitter {
           if (result.stderr) {
             const buf = Buffer.from(result.stderr);
             if (this.options.mirror) {
-              process.stderr.write(buf);
+              safeWrite(process.stderr, buf);
             }
             this.emit('stderr', buf);
             this.emit('data', { type: 'stderr', data: buf });
@@ -703,49 +1708,131 @@ class ProcessRunner extends StreamEmitter {
             console.log(commandStr);
           }
           
-          // Execute the system command with current input as stdin
-          const spawnBun = (argv, stdin) => {
-            return Bun.spawnSync(argv, {
-              cwd: this.options.cwd,
-              env: this.options.env,
-              stdin: stdin ? Buffer.from(stdin) : undefined,
-              stdout: 'pipe',
-              stderr: 'pipe'
-            });
-          };
-          
-          const spawnNode = (argv, stdin) => {
+          // Execute the system command with current input as stdin (ASYNC VERSION)
+          const spawnNodeAsync = async (argv, stdin, isLastCommand = false) => {
             const require = createRequire(import.meta.url);
             const cp = require('child_process');
-            return cp.spawnSync(argv[0], argv.slice(1), {
-              cwd: this.options.cwd,
-              env: this.options.env,
-              input: stdin || undefined,
-              encoding: 'utf8',
-              stdio: ['pipe', 'pipe', 'pipe']
+            
+            return new Promise((resolve, reject) => {
+              const proc = cp.spawn(argv[0], argv.slice(1), {
+                cwd: this.options.cwd,
+                env: this.options.env,
+                stdio: ['pipe', 'pipe', 'pipe']
+              });
+              
+              let stdout = '';
+              let stderr = '';
+              
+              proc.stdout.on('data', (chunk) => {
+                stdout += chunk.toString();
+                // If this is the last command, emit streaming data
+                if (isLastCommand) {
+                  if (this.options.mirror) {
+                    safeWrite(process.stdout, chunk);
+                  }
+                  this.emit('stdout', chunk);
+                  this.emit('data', { type: 'stdout', data: chunk });
+                }
+              });
+              
+              proc.stderr.on('data', (chunk) => {
+                stderr += chunk.toString();
+                // If this is the last command, emit streaming data
+                if (isLastCommand) {
+                  if (this.options.mirror) {
+                    safeWrite(process.stderr, chunk);
+                  }
+                  this.emit('stderr', chunk);
+                  this.emit('data', { type: 'stderr', data: chunk });
+                }
+              });
+              
+              proc.on('close', (code) => {
+                resolve({
+                  status: code,
+                  stdout,
+                  stderr
+                });
+              });
+              
+              proc.on('error', reject);
+              
+              // Add error handler to stdin to prevent unhandled error events
+              if (proc.stdin) {
+                proc.stdin.on('error', (error) => {
+                  trace('ProcessRunner', 'stdin error event', { 
+                    error: error.message, 
+                    code: error.code,
+                    isEPIPE: error.code === 'EPIPE'
+                  });
+                  
+                  // Only reject on non-EPIPE errors
+                  if (error.code !== 'EPIPE') {
+                    reject(error);
+                  }
+                  // EPIPE errors are expected when pipe is closed, so we ignore them
+                });
+              }
+              
+              if (stdin) {
+                // Use safe write to handle potential EPIPE errors
+                trace('ProcessRunner', 'Attempting to write stdin', { 
+                  hasStdin: !!proc.stdin,
+                  writable: proc.stdin?.writable,
+                  destroyed: proc.stdin?.destroyed,
+                  closed: proc.stdin?.closed,
+                  stdinLength: stdin.length
+                });
+                
+                if (proc.stdin && proc.stdin.writable && !proc.stdin.destroyed && !proc.stdin.closed) {
+                  try {
+                    proc.stdin.write(stdin);
+                    trace('ProcessRunner', 'Successfully wrote to stdin', { stdinLength: stdin.length });
+                  } catch (error) {
+                    trace('ProcessRunner', 'Error writing to stdin', { 
+                      error: error.message, 
+                      code: error.code,
+                      isEPIPE: error.code === 'EPIPE'
+                    });
+                    if (error.code !== 'EPIPE') {
+                      throw error; // Re-throw non-EPIPE errors
+                    }
+                  }
+                } else {
+                  trace('ProcessRunner', 'Skipped writing to stdin - stream not writable', {
+                    hasStdin: !!proc.stdin,
+                    writable: proc.stdin?.writable,
+                    destroyed: proc.stdin?.destroyed,
+                    closed: proc.stdin?.closed
+                  });
+                }
+              }
+              
+              // Safely end the stdin stream
+              if (proc.stdin && typeof proc.stdin.end === 'function' && 
+                  proc.stdin.writable && !proc.stdin.destroyed && !proc.stdin.closed) {
+                try {
+                  proc.stdin.end();
+                } catch (error) {
+                  if (error.code !== 'EPIPE') {
+                    trace('ProcessRunner', 'Error ending stdin', { error: error.message });
+                  }
+                }
+              }
             });
           };
           
           // Execute using shell to handle complex commands
           const argv = ['sh', '-c', commandStr];
-          const proc = isBun ? spawnBun(argv, currentInput) : spawnNode(argv, currentInput);
+          const isLastCommand = (i === commands.length - 1);
+          const proc = await spawnNodeAsync(argv, currentInput, isLastCommand);
           
-          let result;
-          if (isBun) {
-            result = {
-              code: proc.exitCode || 0,
-              stdout: proc.stdout?.toString('utf8') || '',
-              stderr: proc.stderr?.toString('utf8') || '',
-              stdin: currentInput
-            };
-          } else {
-            result = {
-              code: proc.status || 0,
-              stdout: proc.stdout || '',
-              stderr: proc.stderr || '',
-              stdin: currentInput
-            };
-          }
+          let result = {
+            code: proc.status || 0,
+            stdout: proc.stdout || '',
+            stderr: proc.stderr || '',
+            stdin: currentInput
+          };
           
           // If command failed and pipefail is set, fail the entire pipeline
           if (globalShellSettings.pipefail && result.code !== 0) {
@@ -765,7 +1852,7 @@ class ProcessRunner extends StreamEmitter {
               this.errChunks.push(Buffer.from(result.stderr));
             }
           } else {
-            // This is the last command - emit output and store final result
+            // This is the last command - store final result (streaming already handled during execution)
             currentOutput = result.stdout;
             
             // Collect all accumulated stderr
@@ -777,25 +1864,6 @@ class ProcessRunner extends StreamEmitter {
               allStderr += result.stderr;
             }
             
-            // Mirror and emit output for final command
-            if (result.stdout) {
-              const buf = Buffer.from(result.stdout);
-              if (this.options.mirror) {
-                process.stdout.write(buf);
-              }
-              this.emit('stdout', buf);
-              this.emit('data', { type: 'stdout', data: buf });
-            }
-            
-            if (allStderr) {
-              const buf = Buffer.from(allStderr);
-              if (this.options.mirror) {
-                process.stderr.write(buf);
-              }
-              this.emit('stderr', buf);
-              this.emit('data', { type: 'stderr', data: buf });
-            }
-            
             // Store final result using createResult helper for .text() method compatibility
             const finalResult = createResult({
               code: result.code,
@@ -841,7 +1909,7 @@ class ProcessRunner extends StreamEmitter {
           if (result.stderr) {
             const buf = Buffer.from(result.stderr);
             if (this.options.mirror) {
-              process.stderr.write(buf);
+              safeWrite(process.stderr, buf);
             }
             this.emit('stderr', buf);
             this.emit('data', { type: 'stderr', data: buf });
@@ -860,26 +1928,65 @@ class ProcessRunner extends StreamEmitter {
     }
   }
 
+  async _runPipeline(commands) {
+    traceFunc('ProcessRunner', '_runPipeline', 'ENTER', { 
+      commandsCount: commands.length 
+    });
+    
+    if (commands.length === 0) {
+      traceBranch('ProcessRunner', '_runPipeline', 'NO_COMMANDS', {});
+      return createResult({ code: 1, stdout: '', stderr: 'No commands in pipeline', stdin: '' });
+    }
+
+
+    // For true streaming, we need to connect processes via pipes
+    if (isBun) {
+      traceBranch('ProcessRunner', '_runPipeline', 'BUN_STREAMING', {});
+      return this._runStreamingPipelineBun(commands);
+    }
+    
+    // For Node.js, fall back to non-streaming implementation for now
+    traceBranch('ProcessRunner', '_runPipeline', 'NODE_NON_STREAMING', {});
+    return this._runPipelineNonStreaming(commands);
+  }
+
   // Run programmatic pipeline (.pipe() method)
   async _runProgrammaticPipeline(source, destination) {
+    traceFunc('ProcessRunner', '_runProgrammaticPipeline', 'ENTER', {});
+    
     try {
       // Execute the source command first
+      trace('ProcessRunner', 'Executing source command', {});
       const sourceResult = await source;
       
       if (sourceResult.code !== 0) {
         // If source failed, return its result
+        traceBranch('ProcessRunner', '_runProgrammaticPipeline', 'SOURCE_FAILED', { 
+          code: sourceResult.code,
+          stderr: sourceResult.stderr 
+        });
         return sourceResult;
       }
       
-      // Set the destination's stdin to the source's stdout
-      destination.options = {
+      // Create a new ProcessRunner with the correct stdin for the destination
+      const destWithStdin = new ProcessRunner(destination.spec, {
         ...destination.options,
         stdin: sourceResult.stdout
-      };
+      });
       
       // Execute the destination command
-      const destResult = await destination;
+      const destResult = await destWithStdin;
       
+      // Debug: Log what destResult looks like
+      trace('ProcessRunner', 'destResult debug', { 
+        code: destResult.code, 
+        codeType: typeof destResult.code,
+        hasCode: 'code' in destResult,
+        keys: Object.keys(destResult),
+        resultType: typeof destResult,
+        fullResult: JSON.stringify(destResult, null, 2).slice(0, 200)
+      });
+
       // Return the final result with combined information
       return createResult({
         code: destResult.code,
@@ -902,7 +2009,7 @@ class ProcessRunner extends StreamEmitter {
       
       const buf = Buffer.from(result.stderr);
       if (this.options.mirror) {
-        process.stderr.write(buf);
+        safeWrite(process.stderr, buf);
       }
       this.emit('stderr', buf);
       this.emit('data', { type: 'stderr', data: buf });
@@ -916,13 +2023,20 @@ class ProcessRunner extends StreamEmitter {
 
   // Async iteration support
   async* stream() {
+    traceFunc('ProcessRunner', 'stream', 'ENTER', { 
+      started: this.started,
+      finished: this.finished 
+    });
+    
     if (!this.started) {
-      this._start(); // Start but don't await
+      trace('ProcessRunner', 'Auto-starting async process from stream()', {});
+      this._startAsync(); // Start but don't await
     }
     
     let buffer = [];
     let resolve, reject;
     let ended = false;
+    let cleanedUp = false;
 
     const onData = (chunk) => {
       buffer.push(chunk);
@@ -955,15 +2069,94 @@ class ProcessRunner extends StreamEmitter {
         }
       }
     } finally {
+      cleanedUp = true;
       this.off('data', onData);
       this.off('end', onEnd);
+      
+      // Kill the process if it's still running when iteration is stopped
+      // This happens when breaking from a for-await loop
+      if (!this.finished) {
+        this.kill();
+      }
+    }
+  }
+  
+  // Kill the running process or cancel virtual command
+  kill() {
+    traceFunc('ProcessRunner', 'kill', 'ENTER', { 
+      cancelled: this._cancelled,
+      finished: this.finished,
+      hasChild: !!this.child,
+      hasVirtualGenerator: !!this._virtualGenerator
+    });
+    
+    // Mark as cancelled for virtual commands
+    this._cancelled = true;
+    
+    // Resolve the cancel promise to break the race in virtual command execution
+    if (this._cancelResolve) {
+      trace('ProcessRunner', 'Resolving cancel promise', {});
+      this._cancelResolve();
+    }
+    
+    // Abort any async operations
+    if (this._abortController) {
+      trace('ProcessRunner', 'Aborting controller', {});
+      this._abortController.abort();
+    }
+    
+    // If it's a virtual generator, try to close it
+    if (this._virtualGenerator && this._virtualGenerator.return) {
+      trace('ProcessRunner', 'Closing virtual generator', {});
+      try {
+        this._virtualGenerator.return();
+      } catch (err) {
+        trace('ProcessRunner', 'Error closing generator', { error: err.message });
+      }
+    }
+    
+    // Kill child process if it exists
+    if (this.child && !this.finished) {
+      traceBranch('ProcessRunner', 'hasChild', 'killing', { pid: this.child.pid });
+      try {
+        // Kill the process group to ensure all child processes are terminated
+        if (this.child.pid) {
+          if (isBun) {
+            trace('ProcessRunner', 'Killing Bun process', { pid: this.child.pid });
+            this.child.kill();
+          } else {
+            // In Node.js, kill the process group
+            trace('ProcessRunner', 'Killing Node process group', { pid: this.child.pid });
+            process.kill(-this.child.pid, 'SIGTERM');
+          }
+        }
+        this.finished = true;
+      } catch (err) {
+        // Process might already be dead
+        trace('ProcessRunner', 'Error killing process', { error: err.message });
+        console.error('Error killing process:', err.message);
+      }
     }
+    
+    // Mark as finished
+    this.finished = true;
+    
+    traceFunc('ProcessRunner', 'kill', 'EXIT', { 
+      cancelled: this._cancelled,
+      finished: this.finished 
+    });
   }
 
   // Programmatic piping support
   pipe(destination) {
+    traceFunc('ProcessRunner', 'pipe', 'ENTER', { 
+      hasDestination: !!destination,
+      destinationType: destination?.constructor?.name 
+    });
+    
     // If destination is a ProcessRunner, create a pipeline
     if (destination instanceof ProcessRunner) {
+      traceBranch('ProcessRunner', 'pipe', 'PROCESS_RUNNER_DEST', {});
       // Create a new ProcessRunner that represents the piped operation
       const pipeSpec = {
         mode: 'pipeline',
@@ -971,49 +2164,64 @@ class ProcessRunner extends StreamEmitter {
         destination: destination
       };
       
-      return new ProcessRunner(pipeSpec, {
+      const pipeRunner = new ProcessRunner(pipeSpec, {
         ...this.options,
         capture: destination.options.capture ?? true
       });
+      
+      traceFunc('ProcessRunner', 'pipe', 'EXIT', { mode: 'pipeline' });
+      return pipeRunner;
     }
     
     // If destination is a template literal result (from $`command`), use its spec
     if (destination && destination.spec) {
+      traceBranch('ProcessRunner', 'pipe', 'TEMPLATE_LITERAL_DEST', {});
       const destRunner = new ProcessRunner(destination.spec, destination.options);
       return this.pipe(destRunner);
     }
     
+    traceBranch('ProcessRunner', 'pipe', 'INVALID_DEST', {});
     throw new Error('pipe() destination must be a ProcessRunner or $`command` result');
   }
 
   // Promise interface (for await)
   then(onFulfilled, onRejected) {
     if (!this.promise) {
-      this.promise = this._start();
+      this.promise = this._startAsync();
     }
     return this.promise.then(onFulfilled, onRejected);
   }
 
   catch(onRejected) {
     if (!this.promise) {
-      this.promise = this._start();
+      this.promise = this._startAsync();
     }
     return this.promise.catch(onRejected);
   }
 
   finally(onFinally) {
     if (!this.promise) {
-      this.promise = this._start();
+      this.promise = this._startAsync();
     }
     return this.promise.finally(onFinally);
   }
 
-  // Synchronous execution
-  sync() {
+  // Internal sync execution
+  _startSync() {
+    traceFunc('ProcessRunner', '_startSync', 'ENTER', { 
+      started: this.started,
+      spec: this.spec 
+    });
+    
     if (this.started) {
+      traceBranch('ProcessRunner', '_startSync', 'ALREADY_STARTED', {});
       throw new Error('Command already started - cannot run sync after async start');
     }
     
+    this.started = true;
+    this._mode = 'sync';
+    trace('ProcessRunner', 'Starting sync execution', { mode: this._mode });
+    
     const { cwd, env, stdin } = this.options;
     const argv = this.spec.mode === 'shell' ? ['sh', '-lc', this.spec.command] : [this.spec.file, ...this.spec.args];
     
@@ -1076,8 +2284,8 @@ class ProcessRunner extends StreamEmitter {
     
     // Mirror output if requested (but always capture for result)
     if (this.options.mirror) {
-      if (result.stdout) process.stdout.write(result.stdout);
-      if (result.stderr) process.stderr.write(result.stderr);
+      if (result.stdout) safeWrite(process.stdout, result.stdout);
+      if (result.stderr) safeWrite(process.stderr, result.stderr);
     }
     
     // Store chunks for events (batched after completion)
@@ -1132,34 +2340,79 @@ class ProcessRunner extends StreamEmitter {
 
 // Public APIs
 async function sh(commandString, options = {}) {
+  traceFunc('API', 'sh', 'ENTER', { 
+    command: commandString,
+    options 
+  });
+  
   const runner = new ProcessRunner({ mode: 'shell', command: commandString }, options);
-  return runner._start();
+  const result = await runner._startAsync();
+  
+  traceFunc('API', 'sh', 'EXIT', { code: result.code });
+  return result;
 }
 
 async function exec(file, args = [], options = {}) {
+  traceFunc('API', 'exec', 'ENTER', { 
+    file,
+    argsCount: args.length,
+    options 
+  });
+  
   const runner = new ProcessRunner({ mode: 'exec', file, args }, options);
-  return runner._start();
+  const result = await runner._startAsync();
+  
+  traceFunc('API', 'exec', 'EXIT', { code: result.code });
+  return result;
 }
 
 async function run(commandOrTokens, options = {}) {
+  traceFunc('API', 'run', 'ENTER', { 
+    type: typeof commandOrTokens,
+    options 
+  });
+  
   if (typeof commandOrTokens === 'string') {
+    traceBranch('API', 'run', 'STRING_COMMAND', { command: commandOrTokens });
     return sh(commandOrTokens, { ...options, mirror: false, capture: true });
   }
+  
   const [file, ...args] = commandOrTokens;
+  traceBranch('API', 'run', 'TOKEN_ARRAY', { file, argsCount: args.length });
   return exec(file, args, { ...options, mirror: false, capture: true });
 }
 
 // Enhanced tagged template that returns ProcessRunner
 function $tagged(strings, ...values) {
+  traceFunc('API', '$tagged', 'ENTER', { 
+    stringsLength: strings.length,
+    valuesLength: values.length 
+  });
+  
   const cmd = buildShellCommand(strings, values);
-  return new ProcessRunner({ mode: 'shell', command: cmd }, { mirror: true, capture: true });
+  const runner = new ProcessRunner({ mode: 'shell', command: cmd }, { mirror: true, capture: true });
+  
+  traceFunc('API', '$tagged', 'EXIT', { command: cmd });
+  return runner;
 }
 
 function create(defaultOptions = {}) {
+  traceFunc('API', 'create', 'ENTER', { defaultOptions });
+  
   const tagged = (strings, ...values) => {
+    traceFunc('API', 'create.tagged', 'ENTER', { 
+      stringsLength: strings.length,
+      valuesLength: values.length 
+    });
+    
     const cmd = buildShellCommand(strings, values);
-    return new ProcessRunner({ mode: 'shell', command: cmd }, { mirror: true, capture: true, ...defaultOptions });
+    const runner = new ProcessRunner({ mode: 'shell', command: cmd }, { mirror: true, capture: true, ...defaultOptions });
+    
+    traceFunc('API', 'create.tagged', 'EXIT', { command: cmd });
+    return runner;
   };
+  
+  traceFunc('API', 'create', 'EXIT', {});
   return tagged;
 }
 
@@ -1230,12 +2483,21 @@ const shell = {
 
 // Virtual command registration API
 function register(name, handler) {
+  traceFunc('VirtualCommands', 'register', 'ENTER', { name });
+  
   virtualCommands.set(name, handler);
+  
+  traceFunc('VirtualCommands', 'register', 'EXIT', { registered: true });
   return virtualCommands;
 }
 
 function unregister(name) {
-  return virtualCommands.delete(name);
+  traceFunc('VirtualCommands', 'unregister', 'ENTER', { name });
+  
+  const deleted = virtualCommands.delete(name);
+  
+  traceFunc('VirtualCommands', 'unregister', 'EXIT', { deleted });
+  return deleted;
 }
 
 function listCommands() {
@@ -1255,28 +2517,37 @@ function disableVirtualCommands() {
 // Built-in commands that match Bun.$ functionality
 function registerBuiltins() {
   // cd - change directory
-  register('cd', async (args) => {
+  register('cd', async ({ args }) => {
     const target = args[0] || process.env.HOME || process.env.USERPROFILE || '/';
+    trace('VirtualCommand', 'cd: changing directory', { target });
+    
     try {
       process.chdir(target);
-      return { stdout: process.cwd(), code: 0 };
+      const newDir = process.cwd();
+      trace('VirtualCommand', 'cd: success', { newDir });
+      return { stdout: newDir, code: 0 };
     } catch (error) {
+      trace('VirtualCommand', 'cd: failed', { error: error.message });
       return { stderr: `cd: ${error.message}`, code: 1 };
     }
   });
 
   // pwd - print working directory
-  register('pwd', async (args, stdin, options) => {
+  register('pwd', async ({ args, stdin, cwd }) => {
     // If cwd option is provided, return that instead of process.cwd()
-    const dir = options?.cwd || process.cwd();
+    const dir = cwd || process.cwd();
+    trace('VirtualCommand', 'pwd: getting directory', { dir });
     return { stdout: dir, code: 0 };
   });
 
   // echo - print arguments
-  register('echo', async (args) => {
+  register('echo', async ({ args }) => {
+    trace('VirtualCommand', 'echo: processing', { argsCount: args.length });
+    
     let output = args.join(' ');
     if (args.includes('-n')) {
       // Don't add newline
+      traceBranch('VirtualCommand', 'echo', 'NO_NEWLINE', {});
       output = args.filter(arg => arg !== '-n').join(' ');
     } else {
       output += '\n';
@@ -1285,12 +2556,17 @@ function registerBuiltins() {
   });
 
   // sleep - wait for specified time
-  register('sleep', async (args) => {
+  register('sleep', async ({ args }) => {
     const seconds = parseFloat(args[0] || 0);
+    trace('VirtualCommand', 'sleep: starting', { seconds });
+    
     if (isNaN(seconds) || seconds < 0) {
+      trace('VirtualCommand', 'sleep: invalid interval', { input: args[0] });
       return { stderr: 'sleep: invalid time interval', code: 1 };
     }
+    
     await new Promise(resolve => setTimeout(resolve, seconds * 1000));
+    trace('VirtualCommand', 'sleep: completed', { seconds });
     return { stdout: '', code: 0 };
   });
 
@@ -1305,7 +2581,7 @@ function registerBuiltins() {
   });
 
   // which - locate command
-  register('which', async (args) => {
+  register('which', async ({ args }) => {
     if (args.length === 0) {
       return { stderr: 'which: missing operand', code: 1 };
     }
@@ -1336,7 +2612,7 @@ function registerBuiltins() {
   });
 
   // exit - exit with code
-  register('exit', async (args) => {
+  register('exit', async ({ args }) => {
     const code = parseInt(args[0] || 0);
     if (globalShellSettings.errexit || code !== 0) {
       // For virtual commands, we simulate exit by returning the code
@@ -1346,11 +2622,11 @@ function registerBuiltins() {
   });
 
   // env - print environment variables
-  register('env', async (args, stdin, options) => {
+  register('env', async ({ args, stdin, env }) => {
     if (args.length === 0) {
       // Use custom env if provided, otherwise use process.env
-      const env = options?.env || process.env;
-      const output = Object.entries(env)
+      const envVars = env || process.env;
+      const output = Object.entries(envVars)
         .map(([key, value]) => `${key}=${value}`)
         .join('\n') + '\n';
       return { stdout: output, code: 0 };
@@ -1361,7 +2637,7 @@ function registerBuiltins() {
   });
 
   // cat - read and display file contents
-  register('cat', async (args, stdin, options) => {
+  register('cat', async ({ args, stdin, cwd }) => {
     if (args.length === 0) {
       // Read from stdin if no files specified
       return { stdout: stdin || '', code: 0 };
@@ -1378,7 +2654,7 @@ function registerBuiltins() {
         
         try {
           // Resolve path relative to cwd if provided
-          const basePath = options?.cwd || process.cwd();
+          const basePath = cwd || process.cwd();
           const fullPath = path.isAbsolute(filename) ? filename : path.join(basePath, filename);
           
           const content = fs.readFileSync(fullPath, 'utf8');
@@ -1401,7 +2677,7 @@ function registerBuiltins() {
   });
 
   // ls - list directory contents
-  register('ls', async (args, stdin, options) => {
+  register('ls', async ({ args, stdin, cwd }) => {
     try {
       const fs = await import('fs');
       const path = await import('path');
@@ -1420,7 +2696,7 @@ function registerBuiltins() {
       
       for (const targetPath of targetPaths) {
         // Resolve path relative to cwd if provided
-        const basePath = options?.cwd || process.cwd();
+        const basePath = cwd || process.cwd();
         const fullPath = path.isAbsolute(targetPath) ? targetPath : path.join(basePath, targetPath);
         
         try {
@@ -1475,7 +2751,7 @@ function registerBuiltins() {
   });
 
   // mkdir - create directories
-  register('mkdir', async (args, stdin, options) => {
+  register('mkdir', async ({ args, stdin, cwd }) => {
     if (args.length === 0) {
       return { stderr: 'mkdir: missing operand', code: 1 };
     }
@@ -1490,7 +2766,7 @@ function registerBuiltins() {
       
       for (const dir of dirs) {
         try {
-          const basePath = options?.cwd || process.cwd();
+          const basePath = cwd || process.cwd();
           const fullPath = path.isAbsolute(dir) ? dir : path.join(basePath, dir);
           
           if (recursive) {
@@ -1513,7 +2789,7 @@ function registerBuiltins() {
   });
 
   // rm - remove files and directories
-  register('rm', async (args, stdin, options) => {
+  register('rm', async ({ args, stdin, cwd }) => {
     if (args.length === 0) {
       return { stderr: 'rm: missing operand', code: 1 };
     }
@@ -1529,7 +2805,7 @@ function registerBuiltins() {
       
       for (const target of targets) {
         try {
-          const basePath = options?.cwd || process.cwd();
+          const basePath = cwd || process.cwd();
           const fullPath = path.isAbsolute(target) ? target : path.join(basePath, target);
           
           const stat = fs.statSync(fullPath);
@@ -1562,7 +2838,7 @@ function registerBuiltins() {
   });
 
   // mv - move/rename files and directories
-  register('mv', async (args, stdin, options) => {
+  register('mv', async ({ args, stdin, cwd }) => {
     if (args.length < 2) {
       return { stderr: 'mv: missing destination file operand', code: 1 };
     }
@@ -1571,7 +2847,7 @@ function registerBuiltins() {
       const fs = await import('fs');
       const path = await import('path');
       
-      const basePath = options?.cwd || process.cwd();
+      const basePath = cwd || process.cwd();
       
       if (args.length === 2) {
         // Simple rename/move
@@ -1643,7 +2919,7 @@ function registerBuiltins() {
   });
 
   // cp - copy files and directories
-  register('cp', async (args, stdin, options) => {
+  register('cp', async ({ args, stdin, cwd }) => {
     if (args.length < 2) {
       return { stderr: 'cp: missing destination file operand', code: 1 };
     }
@@ -1656,7 +2932,7 @@ function registerBuiltins() {
       const paths = args.filter(arg => !arg.startsWith('-'));
       const recursive = flags.includes('-r') || flags.includes('-R');
       
-      const basePath = options?.cwd || process.cwd();
+      const basePath = cwd || process.cwd();
       
       if (paths.length === 2) {
         // Simple copy
@@ -1740,7 +3016,7 @@ function registerBuiltins() {
   });
 
   // touch - create or update file timestamps
-  register('touch', async (args, stdin, options) => {
+  register('touch', async ({ args, stdin, cwd }) => {
     if (args.length === 0) {
       return { stderr: 'touch: missing file operand', code: 1 };
     }
@@ -1749,7 +3025,7 @@ function registerBuiltins() {
       const fs = await import('fs');
       const path = await import('path');
       
-      const basePath = options?.cwd || process.cwd();
+      const basePath = cwd || process.cwd();
       
       for (const file of args) {
         try {
@@ -1778,7 +3054,7 @@ function registerBuiltins() {
   });
 
   // basename - extract filename from path
-  register('basename', async (args) => {
+  register('basename', async ({ args }) => {
     if (args.length === 0) {
       return { stderr: 'basename: missing operand', code: 1 };
     }
@@ -1803,7 +3079,7 @@ function registerBuiltins() {
   });
 
   // dirname - extract directory from path
-  register('dirname', async (args) => {
+  register('dirname', async ({ args }) => {
     if (args.length === 0) {
       return { stderr: 'dirname: missing operand', code: 1 };
     }
@@ -1821,19 +3097,52 @@ function registerBuiltins() {
   });
 
   // yes - output a string repeatedly
-  register('yes', async function* (args) {
+  register('yes', async function* ({ args, stdin, isCancelled, signal, ...rest }) {
     const output = args.length > 0 ? args.join(' ') : 'y';
+    trace('VirtualCommand', 'yes: starting infinite generator', { output });
     
     // Generate infinite stream of the output
     while (true) {
+      // Check if cancelled via function or abort signal
+      if (isCancelled && isCancelled()) {
+        trace('VirtualCommand', 'yes: cancelled via function', {});
+        return;
+      }
+      if (signal && signal.aborted) {
+        trace('VirtualCommand', 'yes: cancelled via abort signal', {});
+        return;
+      }
+      
       yield output + '\n';
-      // Small delay to prevent overwhelming the system
-      await new Promise(resolve => setTimeout(resolve, 0));
+      
+      // Small delay with abort signal support
+      try {
+        await new Promise((resolve, reject) => {
+          const timeout = setTimeout(resolve, 0);
+          
+          // Listen for abort signal if available
+          if (signal) {
+            const abortHandler = () => {
+              clearTimeout(timeout);
+              reject(new Error('Aborted'));
+            };
+            
+            if (signal.aborted) {
+              abortHandler();
+            } else {
+              signal.addEventListener('abort', abortHandler, { once: true });
+            }
+          }
+        });
+      } catch (err) {
+        // Aborted
+        return;
+      }
     }
   });
 
   // seq - generate sequence of numbers
-  register('seq', async (args) => {
+  register('seq', async ({ args }) => {
     if (args.length === 0) {
       return { stderr: 'seq: missing operand', code: 1 };
     }
@@ -1881,7 +3190,7 @@ function registerBuiltins() {
   });
 
   // test - test file conditions (basic implementation)
-  register('test', async (args) => {
+  register('test', async ({ args }) => {
     if (args.length === 0) {
       return { stdout: '', code: 1 };
     }