command-stream 0.8.2 → 0.9.0

package/js/examples/debug-resource-cleanup.mjs

@@ -0,0 +1,83 @@
+#!/usr/bin/env bun
+// Debug script to test resource cleanup behavior
+
+import { $ } from '../src/$.mjs';
+
+// Enable verbose mode
+process.env.COMMAND_STREAM_VERBOSE = 'true';
+
+// Function to access internal state for debugging
+function getInternalDebugInfo() {
+  try {
+    // This is a hack to access module internals for debugging
+    // We'll try to get the activeProcessRunners set
+    const moduleText = Bun.file(import.meta.resolve('../src/$.mjs')).text();
+
+    return {
+      sigintListeners: process.listeners('SIGINT').length,
+      timestamp: new Date().toISOString(),
+    };
+  } catch (e) {
+    return {
+      sigintListeners: process.listeners('SIGINT').length,
+      timestamp: new Date().toISOString(),
+      error: e.message,
+    };
+  }
+}
+
+async function testResourceCleanup() {
+  console.log('=== Resource Cleanup Debug ===');
+
+  console.log('\n1. Initial state:', getInternalDebugInfo());
+
+  console.log('\n2. Creating and running multiple commands sequentially...');
+
+  // Test 1: Single command
+  console.log('\nTest 1: Single command');
+  console.log('Before:', getInternalDebugInfo());
+  const result1 = await $`echo "test1"`;
+  console.log('After single command:', getInternalDebugInfo());
+  console.log('Result:', result1.stdout);
+
+  // Test 2: Multiple concurrent commands
+  console.log('\nTest 2: Multiple concurrent commands');
+  console.log('Before:', getInternalDebugInfo());
+
+  const runners = [$`sleep 0.05`, $`sleep 0.05`, $`sleep 0.05`];
+
+  const promises = runners.map((r) => r.start());
+  console.log('During concurrent execution:', getInternalDebugInfo());
+
+  await Promise.all(promises);
+  console.log('After concurrent commands:', getInternalDebugInfo());
+
+  // Test 3: Virtual commands (built-in commands)
+  console.log('\nTest 3: Virtual commands');
+  console.log('Before:', getInternalDebugInfo());
+
+  const virtualResult = await $`ls /tmp`;
+  console.log('After virtual command:', getInternalDebugInfo());
+  console.log('Virtual result length:', virtualResult.stdout.length);
+
+  // Test 4: Mixed real and virtual commands
+  console.log('\nTest 4: Mixed commands');
+  console.log('Before:', getInternalDebugInfo());
+
+  const mixedPromises = [
+    $`echo "real1"`.start(),
+    $`pwd`.start(),
+    $`echo "real2"`.start(),
+  ];
+
+  console.log('During mixed execution:', getInternalDebugInfo());
+  const mixedResults = await Promise.all(mixedPromises);
+  console.log('After mixed commands:', getInternalDebugInfo());
+
+  console.log('\n5. Final cleanup verification');
+  // Give a small delay for any async cleanup
+  await new Promise((resolve) => setTimeout(resolve, 10));
+  console.log('Final state:', getInternalDebugInfo());
+}
+
+testResourceCleanup().catch(console.error);

package/js/examples/debug-shell-args.mjs

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+
+// Debug shell argument construction
+import fs from 'fs';
+
+// Recreate the findAvailableShell logic
+function findAvailableShell() {
+  const shellsToTry = [
+    { cmd: '/bin/sh', args: ['-l', '-c'], checkPath: true },
+    { cmd: '/usr/bin/sh', args: ['-l', '-c'], checkPath: true },
+    { cmd: '/bin/bash', args: ['-l', '-c'], checkPath: true },
+    { cmd: '/usr/bin/bash', args: ['-l', '-c'], checkPath: true },
+  ];
+
+  for (const shell of shellsToTry) {
+    if (shell.checkPath) {
+      if (fs.existsSync(shell.cmd)) {
+        console.log(`Found shell at absolute path: ${shell.cmd}`);
+        return { cmd: shell.cmd, args: shell.args };
+      }
+    }
+  }
+
+  return { cmd: '/bin/sh', args: ['-l', '-c'] };
+}
+
+const shell = findAvailableShell();
+const commandStr = 'echo hello';
+
+console.log('Shell detection result:');
+console.log(`  cmd: ${shell.cmd}`);
+console.log(`  args: ${JSON.stringify(shell.args)}`);
+
+console.log('\nOriginal spawn args:');
+const spawnArgs1 = [
+  shell.cmd,
+  ...shell.args.filter((arg) => arg !== '-l'),
+  commandStr,
+];
+console.log(`  ${JSON.stringify(spawnArgs1)}`);
+
+console.log('\nCorrected spawn args (should include -c):');
+const spawnArgs2 = [shell.cmd, '-c', commandStr];
+console.log(`  ${JSON.stringify(spawnArgs2)}`);
+
+console.log('\nTesting both approaches:');
+
+const isBun = typeof globalThis.Bun !== 'undefined';
+console.log(`Runtime: ${isBun ? 'Bun' : 'Node.js'}`);
+
+if (isBun) {
+  console.log('\nTesting with original args:');
+  try {
+    const proc1 = Bun.spawn(spawnArgs1, { stdout: 'pipe', stderr: 'pipe' });
+    const stdout1 = await new Response(proc1.stdout).text();
+    const stderr1 = await new Response(proc1.stderr).text();
+    const code1 = await proc1.exited;
+    console.log(`  Exit code: ${code1}`);
+    console.log(`  Stdout: "${stdout1.trim()}"`);
+    console.log(`  Stderr: "${stderr1.trim()}"`);
+  } catch (error) {
+    console.log(`  Error: ${error.message}`);
+  }
+
+  console.log('\nTesting with corrected args:');
+  try {
+    const proc2 = Bun.spawn(spawnArgs2, { stdout: 'pipe', stderr: 'pipe' });
+    const stdout2 = await new Response(proc2.stdout).text();
+    const stderr2 = await new Response(proc2.stderr).text();
+    const code2 = await proc2.exited;
+    console.log(`  Exit code: ${code2}`);
+    console.log(`  Stdout: "${stdout2.trim()}"`);
+    console.log(`  Stderr: "${stderr2.trim()}"`);
+  } catch (error) {
+    console.log(`  Error: ${error.message}`);
+  }
+} else {
+  const cp = await import('child_process');
+
+  console.log('\nTesting with original args:');
+  try {
+    const result1 = cp.spawnSync(spawnArgs1[0], spawnArgs1.slice(1), {
+      encoding: 'utf-8',
+    });
+    console.log(`  Exit code: ${result1.status}`);
+    console.log(`  Stdout: "${result1.stdout?.trim() || ''}"`);
+    console.log(`  Stderr: "${result1.stderr?.trim() || ''}"`);
+  } catch (error) {
+    console.log(`  Error: ${error.message}`);
+  }
+
+  console.log('\nTesting with corrected args:');
+  try {
+    const result2 = cp.spawnSync(spawnArgs2[0], spawnArgs2.slice(1), {
+      encoding: 'utf-8',
+    });
+    console.log(`  Exit code: ${result2.status}`);
+    console.log(`  Stdout: "${result2.stdout?.trim() || ''}"`);
+    console.log(`  Stderr: "${result2.stderr?.trim() || ''}"`);
+  } catch (error) {
+    console.log(`  Error: ${error.message}`);
+  }
+}

package/js/examples/debug-sigint-child-handler.mjs

@@ -0,0 +1,44 @@
+#!/usr/bin/env bun
+// Debug script to test SIGINT handler interaction
+
+import { $ } from '../src/$.mjs';
+
+// Enable verbose mode
+process.env.COMMAND_STREAM_VERBOSE = 'true';
+
+// Simulate the child process scenario from the failing test
+let cleanupDone = false;
+
+// Add user SIGINT handler FIRST (like the test does)
+process.on('SIGINT', async () => {
+  console.log('USER_SIGINT_HANDLER_START');
+  // Simulate cleanup work
+  await new Promise((resolve) => setTimeout(resolve, 50));
+  cleanupDone = true;
+  console.log('USER_SIGINT_HANDLER_DONE');
+  process.exit(0); // Exit cleanly after cleanup
+});
+
+console.log('CHILD_READY');
+console.log('Initial SIGINT handlers:', process.listeners('SIGINT').length);
+
+// Now start a command that will cause the command-stream SIGINT handler to be installed
+console.log('Starting sleep command...');
+const sleepPromise = $`sleep 2`.start();
+
+console.log(
+  'After starting command, SIGINT handlers:',
+  process.listeners('SIGINT').length
+);
+
+// Simulate SIGINT being sent after a short delay
+setTimeout(() => {
+  console.log('Sending SIGINT to self...');
+  process.kill(process.pid, 'SIGINT');
+}, 100);
+
+try {
+  await sleepPromise;
+} catch (error) {
+  console.log('Sleep interrupted:', error.message);
+}

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

@@ -0,0 +1,61 @@
+#!/usr/bin/env bun
+// Debug script to test SIGINT forwarding behavior
+
+import { $ } from '../src/$.mjs';
+
+// Enable verbose mode
+process.env.COMMAND_STREAM_VERBOSE = 'true';
+
+async function testSigintForwarding() {
+  console.log('=== SIGINT Forwarding Debug ===');
+
+  console.log(
+    '\n1. Initial SIGINT listeners:',
+    process.listeners('SIGINT').length
+  );
+
+  console.log('\n2. Starting a long-running command...');
+  const runner = $`sleep 5`;
+  const promise = runner.start();
+
+  console.log(
+    'SIGINT listeners after starting:',
+    process.listeners('SIGINT').length
+  );
+
+  // Send SIGINT after a short delay
+  setTimeout(() => {
+    console.log('\n3. Sending SIGINT to parent process...');
+    console.log(
+      'Active listeners before SIGINT:',
+      process.listeners('SIGINT').length
+    );
+    process.kill(process.pid, 'SIGINT');
+  }, 100);
+
+  try {
+    const result = await promise;
+    console.log('\n4. Command completed with result:', result);
+  } catch (error) {
+    console.log('\n4. Command failed with error:', error.message);
+    console.log('Exit code:', error.code);
+  }
+
+  console.log('\nFinal SIGINT listeners:', process.listeners('SIGINT').length);
+}
+
+// Install a test SIGINT handler to see if it gets called
+let parentSigintReceived = false;
+const testHandler = () => {
+  parentSigintReceived = true;
+  console.log('TEST: Parent SIGINT handler called');
+};
+
+process.on('SIGINT', testHandler);
+
+testSigintForwarding()
+  .then(() => {
+    console.log('TEST: Parent received SIGINT:', parentSigintReceived);
+    process.removeListener('SIGINT', testHandler);
+  })
+  .catch(console.error);

package/js/examples/debug-sigint-handler-install.mjs

@@ -0,0 +1,79 @@
+#!/usr/bin/env bun
+// Debug script to trace SIGINT handler installation and removal
+
+import { $ } from '../src/$.mjs';
+
+// Enable verbose mode
+process.env.COMMAND_STREAM_VERBOSE = 'true';
+
+function getSigintListenerCount() {
+  return process.listeners('SIGINT').length;
+}
+
+function getInternalState() {
+  // Access internal state for debugging
+  const activeProcessRunners = eval(`
+    import('../src/$.mjs').then(m => {
+      // Get internal state from the module
+      const moduleScope = m;
+      // This is a hack to access internal variables - only for debugging
+      return {
+        activeProcessRunners: globalThis.__activeProcessRunners || null,
+        sigintHandlerInstalled: globalThis.__sigintHandlerInstalled || null
+      };
+    })
+  `);
+
+  return {
+    sigintHandlerCount: getSigintListenerCount(),
+    activeProcessRunners,
+  };
+}
+
+async function testSigintHandlerInstall() {
+  console.log('=== SIGINT Handler Installation Debug ===');
+
+  console.log('\n1. Initial state:');
+  console.log('Initial SIGINT listeners:', getSigintListenerCount());
+
+  console.log('\n2. Creating first command runner...');
+  const runner1 = $`sleep 0.01`;
+  console.log(
+    'After creating runner1, SIGINT listeners:',
+    getSigintListenerCount()
+  );
+
+  console.log('\n3. Starting first command...');
+  const promise1 = runner1.start();
+  console.log(
+    'After starting runner1, SIGINT listeners:',
+    getSigintListenerCount()
+  );
+
+  console.log('\n4. Creating second command runner while first is running...');
+  const runner2 = $`sleep 0.01`;
+  const promise2 = runner2.start();
+  console.log(
+    'After starting runner2, SIGINT listeners:',
+    getSigintListenerCount()
+  );
+
+  console.log('\n5. Waiting for both commands to finish...');
+  await Promise.all([promise1, promise2]);
+
+  console.log('\n6. Final state after both commands finished:');
+  console.log('Final SIGINT listeners:', getSigintListenerCount());
+
+  console.log(
+    '\n7. Testing cleanup - creating and finishing another command...'
+  );
+  const runner3 = $`echo "test"`;
+  await runner3;
+  console.log(
+    'After third command finished, SIGINT listeners:',
+    getSigintListenerCount()
+  );
+}
+
+// Run the test
+testSigintHandlerInstall().catch(console.error);

package/js/examples/debug-sigint-handler-order.mjs

@@ -0,0 +1,85 @@
+#!/usr/bin/env bun
+// Debug script to test SIGINT handler order and execution
+
+import { $ } from '../src/$.mjs';
+
+// Enable verbose mode
+process.env.COMMAND_STREAM_VERBOSE = 'true';
+
+let userHandlerCalled = false;
+let userHandlerFinished = false;
+
+// Add user SIGINT handler FIRST
+process.on('SIGINT', async () => {
+  userHandlerCalled = true;
+  console.log('🔥 USER_HANDLER_START');
+  console.log(
+    '🔥 Current SIGINT handlers when user handler runs:',
+    process.listeners('SIGINT').length
+  );
+
+  // Simulate cleanup work
+  await new Promise((resolve) => setTimeout(resolve, 100));
+
+  userHandlerFinished = true;
+  console.log('🔥 USER_HANDLER_DONE');
+  console.log('🔥 About to call process.exit(0)');
+  process.exit(0); // Exit cleanly after cleanup
+});
+
+console.log('CHILD_READY');
+console.log('Initial SIGINT handlers:', process.listeners('SIGINT').length);
+
+// Show all handlers
+const initialHandlers = process.listeners('SIGINT');
+initialHandlers.forEach((handler, i) => {
+  console.log(`Handler ${i}:`, `${handler.toString().substring(0, 100)}...`);
+});
+
+// Start a command to install command-stream handler
+console.log('Starting sleep command...');
+const sleepPromise = $`sleep 3`.start();
+
+console.log(
+  'After starting command, SIGINT handlers:',
+  process.listeners('SIGINT').length
+);
+
+// Show all handlers again
+const afterHandlers = process.listeners('SIGINT');
+afterHandlers.forEach((handler, i) => {
+  const str = handler.toString();
+  const isCommandStream =
+    str.includes('activeProcessRunners') || str.includes('ProcessRunner');
+  console.log(
+    `Handler ${i} (${isCommandStream ? 'COMMAND-STREAM' : 'USER'}):`,
+    `${str.substring(0, 80)}...`
+  );
+});
+
+// Send SIGINT after delay
+setTimeout(() => {
+  console.log('\n=== SENDING SIGINT ===');
+  console.log('User handler called before SIGINT?', userHandlerCalled);
+  console.log(
+    'Handlers at time of SIGINT:',
+    process.listeners('SIGINT').length
+  );
+  process.kill(process.pid, 'SIGINT');
+}, 200);
+
+try {
+  await sleepPromise;
+} catch (error) {
+  console.log('Sleep interrupted:', error.message);
+}
+
+// This should never be reached if handlers work correctly
+console.log(
+  'This should not print - handlers should have called process.exit()'
+);
+setTimeout(() => {
+  console.log('Final state:');
+  console.log('User handler called:', userHandlerCalled);
+  console.log('User handler finished:', userHandlerFinished);
+}, 500);

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

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+
+import { $ } from '../src/$.mjs';
+
+console.log('=== SIGINT Listeners Debug ===');
+
+function logSigintListeners(label) {
+  const listeners = process.listeners('SIGINT');
+  console.log(`\n--- ${label} ---`);
+  console.log('Total SIGINT listeners:', listeners.length);
+
+  listeners.forEach((listener, i) => {
+    const str = listener.toString();
+    const isCommandStream =
+      str.includes('activeProcessRunners') ||
+      str.includes('ProcessRunner') ||
+      str.includes('activeChildren');
+    console.log(
+      `Listener ${i}: ${isCommandStream ? 'COMMAND-STREAM' : 'OTHER'}`
+    );
+    if (isCommandStream) {
+      console.log(`  Source preview: ${str.substring(0, 200)}...`);
+    }
+  });
+}
+
+logSigintListeners('Initial state');
+
+console.log('\nRunning a simple command...');
+const cmd1 = $`echo "test1"`;
+await cmd1;
+
+logSigintListeners('After first command');
+
+console.log('\nRunning another command...');
+const cmd2 = $`echo "test2"`;
+await cmd2;
+
+logSigintListeners('After second command');
+
+console.log('\nRunning a concurrent command...');
+const cmd3 = $`sleep 0.1`;
+const cmd4 = $`echo "test3"`;
+await Promise.all([cmd3, cmd4]);
+
+logSigintListeners('After concurrent commands');
+
+console.log('\nTest completed.');

package/js/examples/debug-sigint-start-pattern.mjs

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+
+import { $ } from '../src/$.mjs';
+
+console.log('=== SIGINT Listeners Start Pattern Debug ===');
+
+function getInternalState() {
+  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 {
+    sigintHandlerCount: commandStreamListeners.length,
+    totalSigintListeners: sigintListeners.length,
+  };
+}
+
+function logState(label) {
+  const state = getInternalState();
+  console.log(
+    `${label}: sigintHandlerCount=${state.sigintHandlerCount}, total=${state.totalSigintListeners}`
+  );
+}
+
+logState('Initial state');
+
+console.log('\nTesting start() pattern like failing test...');
+const runner = $`sleep 0.01`;
+const promise = runner.start();
+
+logState('After calling start() but before await');
+
+await promise;
+
+logState('After awaiting promise');
+
+console.log('\nTesting direct await pattern...');
+const runner2 = $`sleep 0.01`;
+
+logState('Before direct await');
+
+await runner2;
+
+logState('After direct await');
+
+console.log('\nTesting multiple start() calls...');
+const runner3 = $`sleep 0.01`;
+const runner4 = $`sleep 0.01`;
+const promise3 = runner3.start();
+const promise4 = runner4.start();
+
+logState('After multiple start() calls');
+
+await Promise.all([promise3, promise4]);
+
+logState('After awaiting all promises');

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

@@ -0,0 +1,40 @@
+#!/usr/bin/env bun
+// Debug script to see if our timer fix is working
+
+import { $ } from '../src/$.mjs';
+
+// Enable verbose mode
+process.env.COMMAND_STREAM_VERBOSE = 'true';
+
+let userHandlerCalled = false;
+
+// Add user SIGINT handler FIRST
+process.on('SIGINT', () => {
+  userHandlerCalled = true;
+  console.log('🔥 USER_HANDLER_START (sync)');
+
+  // Use synchronous delay to see if that changes anything
+  const start = Date.now();
+  while (Date.now() - start < 50) {
+    // Busy wait for 50ms
+  }
+
+  console.log('🔥 USER_HANDLER_DONE (sync)');
+  console.log('🔥 About to call process.exit(0)');
+  process.exit(0); // Exit cleanly after cleanup
+});
+
+console.log('Starting sleep command...');
+const sleepPromise = $`sleep 3`.start();
+
+// Send SIGINT after delay
+setTimeout(() => {
+  console.log('\n=== SENDING SIGINT ===');
+  process.kill(process.pid, 'SIGINT');
+}, 200);
+
+try {
+  await sleepPromise;
+} catch (error) {
+  console.log('Sleep interrupted:', error.message);
+}

package/js/examples/debug-simple-command.mjs

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+
+import { $ } from '../src/$.mjs';
+
+async function debugSimpleCommand() {
+  console.log('🐛 Testing with a simple non-builtin command');
+
+  // Use sort instead of cat
+  const sortCmd = $`sort`;
+  console.log('1. Created sort command');
+
+  const stdinPromise = sortCmd.streams.stdin;
+  console.log('2. Accessed streams.stdin');
+
+  // Wait longer
+  await new Promise((resolve) => setTimeout(resolve, 500));
+
+  console.log('3. After 500ms wait:');
+  console.log('   started:', sortCmd.started);
+  console.log('   child exists:', !!sortCmd.child);
+
+  if (sortCmd.child) {
+    console.log('   child.stdin exists:', !!sortCmd.child.stdin);
+    console.log(
+      '   child.stdin writable:',
+      sortCmd.child.stdin ? sortCmd.child.stdin.writable : 'N/A'
+    );
+  }
+
+  const stdin = await stdinPromise;
+  console.log('4. Awaited stdin:');
+  console.log('   type:', typeof stdin);
+  console.log('   is null:', stdin === null);
+  console.log('   has write:', !!(stdin && stdin.write));
+
+  // Try to write if we have a real stream
+  if (stdin && stdin.write) {
+    console.log('5. Trying to write...');
+    stdin.write('test\n');
+    stdin.end();
+
+    const result = await sortCmd;
+    console.log('   Result:', JSON.stringify(result.stdout));
+  } else {
+    sortCmd.kill();
+  }
+}
+
+debugSimpleCommand();

package/js/examples/debug-simple-getter.mjs

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+
+// Test if the ProcessRunner class is working correctly
+class TestClass {
+  constructor() {
+    this.child = null;
+  }
+
+  get stdout() {
+    return this.child ? this.child.stdout : null;
+  }
+}
+
+const test = new TestClass();
+console.log('TestClass stdout:', test.stdout);
+console.log('Should be null:', test.stdout === null);
+
+// Now test with actual ProcessRunner
+import { $ } from '../src/$.mjs';
+
+const cmd = $`echo "test"`;
+console.log('ProcessRunner stdout:', cmd.stdout);
+console.log('Should be null:', cmd.stdout === null);
+
+// Check if the object is really a ProcessRunner
+console.log('cmd constructor name:', cmd.constructor.name);
+console.log(
+  'cmd instanceof ProcessRunner:',
+  cmd.constructor.name === 'ProcessRunner'
+);