command-stream 0.8.2 → 0.9.0

package/js/examples/debug-streaming.mjs

@@ -0,0 +1,24 @@
+#!/usr/bin/env bun
+
+import { $ } from '../src/$.mjs';
+
+console.log('=== Debug Streaming Test ===\n');
+
+// Test without pipe first
+console.log('Test 1: No pipe (should work):');
+try {
+  const result = await $`echo "hello"`;
+  console.log('Result:', result.stdout);
+} catch (e) {
+  console.error('Error:', e.message);
+}
+
+// Test with simple pipe
+console.log('\nTest 2: Simple pipe:');
+try {
+  const result = await $`echo "hello" | cat`;
+  console.log('Result:', result.stdout);
+} catch (e) {
+  console.error('Error:', e.message);
+  console.error('Stack:', e.stack);
+}

package/js/examples/debug-test-isolation.mjs

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+
+import { spawn } from 'child_process';
+import { readdirSync } from 'fs';
+
+// Get all test files
+const testFiles = readdirSync('tests').filter((f) => f.endsWith('.test.mjs'));
+
+function getSigintHandlerCount() {
+  const sigintListeners = process.listeners('SIGINT');
+  const commandStreamListeners = sigintListeners.filter((l) => {
+    const str = l.toString();
+    return (
+      str.includes('activeProcessRunners') ||
+      str.includes('ProcessRunner') ||
+      str.includes('activeChildren')
+    );
+  });
+  return commandStreamListeners.length;
+}
+
+console.log('=== Test Isolation Debug ===');
+console.log(`Initial SIGINT handlers: ${getSigintHandlerCount()}`);
+
+// Run a few key tests individually and check handler count
+const keyTests = [
+  'resource-cleanup-internals.test.mjs',
+  'cleanup-verification.test.mjs',
+  'sigint-cleanup.test.mjs',
+  'sigint-cleanup-isolated.test.mjs',
+];
+
+for (const testFile of keyTests) {
+  console.log(`\n--- Running ${testFile} ---`);
+  console.log(`Before: ${getSigintHandlerCount()} handlers`);
+
+  try {
+    const result = spawn('bun', ['test', `tests/${testFile}`, '--verbose'], {
+      stdio: ['inherit', 'pipe', 'pipe'],
+      timeout: 30000,
+    });
+
+    await new Promise((resolve, reject) => {
+      result.on('close', resolve);
+      result.on('error', reject);
+      setTimeout(() => reject(new Error('timeout')), 30000);
+    });
+
+    console.log(`After: ${getSigintHandlerCount()} handlers`);
+  } catch (error) {
+    console.log(`Error running ${testFile}:`, error.message);
+    console.log(`After (with error): ${getSigintHandlerCount()} handlers`);
+  }
+}

package/js/examples/debug-test-state.mjs

@@ -0,0 +1,27 @@
+// Debug test to understand why virtual commands get bypassed in full test suite
+import { $ } from '../src/$.mjs';
+
+async function debugTestState() {
+  console.log('=== Debug Test State ===');
+
+  // Test 1: Simple echo
+  console.log('\nTest 1: Simple echo');
+  const result1 = await $`echo simple`;
+  console.log('Result1:', JSON.stringify(result1.stdout.trim()));
+
+  // Test 2: Echo with interpolation (like the failing test)
+  console.log('\nTest 2: Echo with interpolation');
+  const name = 'World';
+  const $custom = $({ capture: true, mirror: false });
+  const result2 = await $custom`echo Hello, ${name}!`;
+  console.log('Result2:', JSON.stringify(result2.stdout.trim()));
+  console.log('Expected:', JSON.stringify("Hello, 'World'!"));
+  console.log('Test passes:', result2.stdout.trim() === "Hello, 'World'!");
+
+  // Test 3: Another echo to see if state persists
+  console.log('\nTest 3: Another echo');
+  const result3 = await $`echo test`;
+  console.log('Result3:', JSON.stringify(result3.stdout.trim()));
+}
+
+debugTestState().catch(console.error);

package/js/examples/debug-user-sigint.mjs

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+
+import { $ } from '../src/$.mjs';
+
+let sigintReceived = false;
+
+process.on('SIGINT', () => {
+  sigintReceived = true;
+  console.log('USER_SIGINT_HANDLER_CALLED');
+  process.exit(42); // Custom exit code to verify user handler was called
+});
+
+console.log('Process started, waiting for SIGINT...');
+
+// Wait for SIGINT (simulate doing some work without child processes)
+setTimeout(() => {
+  console.log('TIMEOUT_REACHED - no SIGINT received');
+  process.exit(1); // Should not reach here in test
+}, 5000);

package/js/examples/debug-virtual-disable.mjs

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+
+// Enable verbose tracing
+process.env.COMMAND_STREAM_VERBOSE = 'true';
+
+import { $, disableVirtualCommands } from '../src/$.mjs';
+
+console.log('=== Virtual Disable Debug ===');
+
+console.log('1. Before disabling virtual commands:');
+const cmd1 = $`echo "test1"`;
+cmd1.start();
+console.log('Immediate child1:', !!cmd1.child);
+await cmd1;
+
+console.log('2. After disabling virtual commands:');
+disableVirtualCommands();
+const cmd2 = $`echo "test2"`;
+cmd2.start();
+console.log('Immediate child2:', !!cmd2.child);
+await cmd2;

package/js/examples/debug-virtual-vs-real.mjs

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+
+import { $, disableVirtualCommands } from '../src/$.mjs';
+
+console.log('=== Virtual vs Real Commands Debug ===');
+
+console.log('1. Testing with virtual commands enabled:');
+const cmd1 = $`echo "virtual test"`;
+
+cmd1.on('end', (result) => {
+  console.log('[VIRTUAL] end event:', result.code);
+});
+
+const result1 = await cmd1;
+console.log(
+  '[VIRTUAL] await result:',
+  result1.code,
+  JSON.stringify(result1.stdout.trim())
+);
+
+console.log('2. Testing with virtual commands disabled:');
+disableVirtualCommands();
+
+const cmd2 = $`echo "real test"`;
+
+cmd2.on('end', (result) => {
+  console.log('[REAL] end event:', result.code);
+});
+
+const result2 = await cmd2;
+console.log(
+  '[REAL] await result:',
+  result2.code,
+  JSON.stringify(result2.stdout.trim())
+);
+
+console.log('3. Testing stream with virtual commands disabled:');
+const cmd3 = $`echo "real stream test"`;
+let streamEndFired = false;
+
+cmd3.on('end', (result) => {
+  streamEndFired = true;
+  console.log('[REAL STREAM] end event:', result.code);
+});
+
+console.log('Starting stream...');
+try {
+  const chunks = [];
+  for await (const chunk of cmd3.stream()) {
+    chunks.push(chunk);
+    console.log(
+      '[REAL STREAM] chunk:',
+      chunk.type,
+      JSON.stringify(chunk.data.toString().trim())
+    );
+
+    // Break after receiving data to see if end event fires
+    if (chunks.length >= 1) {
+      console.log('[REAL STREAM] Breaking after first chunk');
+      break;
+    }
+  }
+  console.log('[REAL STREAM] Stream completed, end fired?', streamEndFired);
+} catch (error) {
+  console.log('[REAL STREAM] Error:', error.message);
+}
+
+console.log('Debug completed!');

package/js/examples/debug-with-trace.mjs

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+
+// Set trace before importing
+process.env.COMMAND_STREAM_TRACE = 'all';
+process.env.COMMAND_STREAM_VERBOSE = 'true';
+
+import { $ } from '../src/$.mjs';
+
+async function debugWithTrace() {
+  console.log('🐛 Testing with full tracing enabled');
+
+  const sortCmd = $`echo "test" | sort`;
+  console.log('Created command');
+
+  try {
+    const result = await sortCmd;
+    console.log('Result:', result);
+  } catch (error) {
+    console.log('Error:', error.message);
+  }
+}
+
+debugWithTrace();

package/js/examples/debug_parent_stream.mjs

@@ -0,0 +1,22 @@
+import { $ } from '../src/$.mjs';
+
+console.log('=== PARENT STREAM CLOSURE TEST ===');
+
+// Start a long-running command
+const runner = $`sleep 5`;
+const promise = runner.start();
+
+// Simulate parent stream closure after a delay
+setTimeout(() => {
+  console.log('SIMULATING_PARENT_STREAM_CLOSURE');
+  process.stdout.destroy(); // This should trigger cleanup
+}, 1000);
+
+try {
+  await promise;
+  console.log('COMMAND_COMPLETED');
+} catch (error) {
+  console.log('COMMAND_INTERRUPTED:', error.message);
+}
+
+console.log('=== TEST DONE ===');

package/js/examples/emulate-claude-stream.mjs

@@ -0,0 +1,30 @@
+#!/usr/bin/env bun
+
+// Emulate claude's streaming JSON output
+// This simulates how claude outputs JSON objects incrementally
+
+const events = [
+  { type: 'start', message: 'Starting analysis...' },
+  { type: 'progress', step: 1, message: 'Reading files...' },
+  { type: 'data', content: 'Found main entry point' },
+  { type: 'progress', step: 2, message: 'Analyzing dependencies...' },
+  { type: 'data', content: 'Processing module imports' },
+  { type: 'progress', step: 3, message: 'Building context...' },
+  { type: 'result', summary: 'Analysis complete' },
+  { type: 'end', status: 'success' },
+];
+
+async function* streamJsonEvents() {
+  for (const event of events) {
+    // Output JSON object
+    console.log(JSON.stringify(event));
+
+    // Small delay to simulate processing
+    await new Promise((resolve) => setTimeout(resolve, 200));
+  }
+}
+
+// Main execution
+for await (const _ of streamJsonEvents()) {
+  // Events are printed in the generator
+}

package/js/examples/emulated-streaming-direct.mjs

@@ -0,0 +1,22 @@
+#!/usr/bin/env bun
+
+// Direct execution of emulator
+
+import { $ } from '../src/$.mjs';
+
+console.log('Direct execution of emulator:');
+const start = Date.now();
+
+for await (const chunk of $`bun run js/examples/emulate-claude-stream.mjs`.stream()) {
+  if (chunk.type === 'stdout') {
+    const elapsed = Date.now() - start;
+    const lines = chunk.data
+      .toString()
+      .trim()
+      .split('\n')
+      .filter((l) => l);
+    for (const line of lines) {
+      console.log(`[${elapsed}ms] ${line}`);
+    }
+  }
+}

package/js/examples/emulated-streaming-jq-pipe.mjs

@@ -0,0 +1,22 @@
+#!/usr/bin/env bun
+
+// Emulator piped through jq
+
+import { $ } from '../src/$.mjs';
+
+console.log('Emulator piped through jq:');
+const start = Date.now();
+
+for await (const chunk of $`bun run js/examples/emulate-claude-stream.mjs | jq .`.stream()) {
+  if (chunk.type === 'stdout') {
+    const elapsed = Date.now() - start;
+    const lines = chunk.data
+      .toString()
+      .trim()
+      .split('\n')
+      .filter((l) => l);
+    for (const line of lines) {
+      console.log(`[${elapsed}ms] ${line}`);
+    }
+  }
+}

package/js/examples/emulated-streaming-sh-pipe.mjs

@@ -0,0 +1,23 @@
+#!/usr/bin/env bun
+
+// Using sh -c with pipe
+
+import { $ } from '../src/$.mjs';
+
+console.log('Using sh -c with pipe:');
+const start = Date.now();
+
+const cmd = $`sh -c 'bun run js/examples/emulate-claude-stream.mjs | jq .'`;
+for await (const chunk of cmd.stream()) {
+  if (chunk.type === 'stdout') {
+    const elapsed = Date.now() - start;
+    const lines = chunk.data
+      .toString()
+      .trim()
+      .split('\n')
+      .filter((l) => l);
+    for (const line of lines) {
+      console.log(`[${elapsed}ms] ${line}`);
+    }
+  }
+}

package/js/examples/events-build-process.mjs

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+
+// Build process simulation with events
+
+import { $ } from '../src/$.mjs';
+
+console.log('Build process simulation:');
+const $buildProcess = $({ mirror: false });
+
+try {
+  const buildScript = `
+echo "Build started"
+echo "Compiling TypeScript..." >&2
+sleep 0.5
+echo "✓ TypeScript compilation complete"
+echo "Running tests..." >&2
+sleep 0.8
+echo "✓ All tests passed (15/15)"
+echo "Bundling assets..." >&2
+sleep 0.6
+echo "✓ Assets bundled successfully"
+echo "Optimizing..." >&2
+sleep 0.4
+echo "✓ Optimization complete"
+echo "Build finished successfully"
+`;
+
+  const runner = $buildProcess`bash -c '${buildScript}'`;
+
+  const buildSteps = [];
+  const startTime = Date.now();
+
+  runner.on('stdout', (data) => {
+    const lines = data
+      .toString()
+      .split('\n')
+      .filter((line) => line.trim());
+    for (const line of lines) {
+      const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+
+      if (line.startsWith('✓')) {
+        buildSteps.push(line);
+        console.log(`[${elapsed}s] ✅ ${line.substring(2)}`);
+      } else if (line.includes('Build started')) {
+        console.log(`[${elapsed}s] 🚀 ${line}`);
+      } else if (line.includes('Build finished')) {
+        console.log(`[${elapsed}s] 🎉 ${line}`);
+      }
+    }
+  });
+
+  runner.on('stderr', (data) => {
+    const lines = data
+      .toString()
+      .split('\n')
+      .filter((line) => line.trim());
+    for (const line of lines) {
+      const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+      console.log(`[${elapsed}s] ⏳ ${line}`);
+    }
+  });
+
+  runner.on('close', (code) => {
+    const totalTime = ((Date.now() - startTime) / 1000).toFixed(1);
+    console.log(
+      `🏁 Build completed in ${totalTime}s with ${buildSteps.length} successful steps`
+    );
+  });
+
+  await runner;
+} catch (error) {
+  console.log(`Error: ${error.message}`);
+}

package/js/examples/events-concurrent-streams.mjs

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+
+// Multiple concurrent event streams
+
+import { $ } from '../src/$.mjs';
+
+console.log('Multiple concurrent event streams:');
+
+const $concurrent1 = $({ mirror: false });
+const $concurrent2 = $({ mirror: false });
+const $concurrent3 = $({ mirror: false });
+
+try {
+  console.log('Starting concurrent ping streams...');
+
+  const runners = [
+    { runner: $concurrent1`ping -c 3 8.8.8.8`, name: 'Google DNS' },
+    { runner: $concurrent2`ping -c 3 1.1.1.1`, name: 'Cloudflare DNS' },
+    { runner: $concurrent3`ping -c 3 127.0.0.1`, name: 'Localhost' },
+  ];
+
+  const results = {};
+
+  for (const { runner, name } of runners) {
+    results[name] = { packets: 0, completed: false };
+
+    runner.on('stdout', (data) => {
+      const output = data.toString().trim();
+      if (output.includes('bytes from')) {
+        results[name].packets++;
+        console.log(`🌐 ${name}: packet #${results[name].packets}`);
+      }
+    });
+
+    runner.on('close', (code) => {
+      results[name].completed = true;
+      console.log(`✅ ${name}: completed (${results[name].packets} packets)`);
+    });
+  }
+
+  // Wait for all to complete
+  await Promise.all(runners.map(({ runner }) => runner));
+
+  console.log('\n📊 Final results:');
+  for (const [name, data] of Object.entries(results)) {
+    const status = data.completed ? '✅' : '❌';
+    console.log(`${status} ${name}: ${data.packets} packets received`);
+  }
+} catch (error) {
+  console.log(`❌ Error: ${error.message}`);
+}

package/js/examples/events-error-handling.mjs

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+
+// Error handling and recovery with events
+
+import { $ } from '../src/$.mjs';
+
+console.log('Error handling and recovery:');
+const $errorTest = $({ mirror: false });
+
+try {
+  // First try a command that will fail
+  console.log('Testing error handling...');
+  const failRunner = $errorTest`ping -c 2 invalid.host.name.that.does.not.exist`;
+
+  const errorMessages = [];
+
+  failRunner.on('stdout', (data) => {
+    console.log(`📤 Stdout: ${data.toString().trim()}`);
+  });
+
+  failRunner.on('stderr', (data) => {
+    const error = data.toString().trim();
+    errorMessages.push(error);
+    console.log(`🚨 Stderr: ${error}`);
+  });
+
+  failRunner.on('close', (code) => {
+    console.log(`🔚 Failed command exit code: ${code}`);
+    console.log(`📝 Error messages collected: ${errorMessages.length}`);
+  });
+
+  try {
+    await failRunner;
+  } catch (error) {
+    console.log(`⚠️  Caught error: ${error.message}`);
+  }
+
+  // Then try a command that succeeds
+  console.log('\nTesting successful recovery...');
+  const successRunner = $errorTest`ping -c 2 127.0.0.1`;
+
+  let successCount = 0;
+
+  successRunner.on('stdout', (data) => {
+    const output = data.toString().trim();
+    if (output.includes('bytes from')) {
+      successCount++;
+      console.log(`✅ Success #${successCount}: Local ping OK`);
+    }
+  });
+
+  successRunner.on('close', (code) => {
+    console.log(`🎯 Recovery successful with code: ${code}`);
+  });
+
+  await successRunner;
+} catch (error) {
+  console.log(`❌ Unexpected error: ${error.message}`);
+}

package/js/examples/events-file-monitoring.mjs

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+
+// File monitoring simulation with events
+
+import { $ } from '../src/$.mjs';
+
+console.log('File monitoring simulation:');
+const $fileMonitor = $({ mirror: false, capture: true });
+
+try {
+  const monitorScript = `
+echo "File: config.json - CREATED"
+sleep 0.3
+echo "File: config.json - MODIFIED"
+sleep 0.3
+echo "File: app.log - CREATED"
+sleep 0.3
+echo "File: temp.txt - CREATED"
+sleep 0.3
+echo "File: temp.txt - DELETED"
+sleep 0.3
+echo "File: config.json - MODIFIED"
+`;
+
+  const runner = $fileMonitor`bash -c '${monitorScript}'`;
+
+  const fileEvents = new Map();
+
+  runner.on('stdout', (data) => {
+    const lines = data
+      .toString()
+      .split('\n')
+      .filter((line) => line.trim());
+    for (const line of lines) {
+      const match = line.match(/File: (.+) - (.+)/);
+      if (match) {
+        const [, filename, action] = match;
+
+        if (!fileEvents.has(filename)) {
+          fileEvents.set(filename, []);
+        }
+        fileEvents.get(filename).push(action);
+
+        const emoji =
+          {
+            CREATED: '📄',
+            MODIFIED: '✏️',
+            DELETED: '🗑️',
+          }[action] || '📋';
+
+        console.log(`${emoji} ${filename}: ${action.toLowerCase()}`);
+      }
+    }
+  });
+
+  runner.on('close', (code) => {
+    console.log(`📊 File activity summary:`);
+    for (const [filename, events] of fileEvents) {
+      console.log(`  ${filename}: ${events.join(' → ')}`);
+    }
+  });
+
+  await runner;
+} catch (error) {
+  console.log(`Error: ${error.message}`);
+}

package/js/examples/events-interactive-simulation.mjs

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+
+// Interactive command simulation with events
+
+import { $ } from '../src/$.mjs';
+
+console.log('Interactive command simulation:');
+const $interactive = $({ stdin: 'John\n25\nDeveloper\ny\n', mirror: false });
+
+try {
+  const interactiveScript = `
+echo "Please enter your name:"
+read name
+echo "Hello $name!"
+echo "Please enter your age:"
+read age
+echo "You are $age years old."
+echo "Please enter your job:"
+read job
+echo "So you work as a $job."
+echo "Is this correct? (y/n):"
+read confirm
+if [ "$confirm" = "y" ]; then
+  echo "Profile saved successfully!"
+else
+  echo "Profile cancelled."
+fi
+`;
+
+  const runner = $interactive`bash -c '${interactiveScript}'`;
+
+  let questionCount = 0;
+  let responseCount = 0;
+
+  runner.on('stdout', (data) => {
+    const lines = data
+      .toString()
+      .split('\n')
+      .filter((line) => line.trim());
+    for (const line of lines) {
+      if (line.includes('Please enter') || line.includes('Is this correct')) {
+        questionCount++;
+        console.log(`❓ Question #${questionCount}: ${line}`);
+      } else if (
+        line.includes('Hello') ||
+        line.includes('You are') ||
+        line.includes('So you work')
+      ) {
+        responseCount++;
+        console.log(`💬 Response #${responseCount}: ${line}`);
+      } else if (
+        line.includes('Profile saved') ||
+        line.includes('Profile cancelled')
+      ) {
+        console.log(`✅ Result: ${line}`);
+      }
+    }
+  });
+
+  runner.on('close', (code) => {
+    console.log(
+      `📝 Interactive session completed: ${questionCount} questions, ${responseCount} responses`
+    );
+  });
+
+  await runner;
+} catch (error) {
+  console.log(`Error: ${error.message}`);
+}