command-stream 0.8.2 → 0.9.0

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

@@ -0,0 +1,38 @@
+#!/usr/bin/env bun
+// Debug the exit command specifically
+
+import { $ } from '../src/$.mjs';
+
+// Enable verbose mode
+process.env.COMMAND_STREAM_VERBOSE = 'true';
+
+async function testExitCommand() {
+  console.log('=== Exit Command Debug ===');
+
+  console.log('\n1. Testing exit 1 in isolation...');
+  try {
+    const result = await $`exit 1`;
+    console.log('Exit 1 succeeded (unexpected):', result);
+  } catch (e) {
+    console.log('Exit 1 failed (expected):');
+    console.log('- Message:', e.message);
+    console.log('- Code:', e.code);
+    console.log('- Type:', typeof e);
+    console.log('- Constructor:', e.constructor.name);
+    console.log('- Keys:', Object.keys(e));
+    console.log('- Full error:', e);
+  }
+
+  console.log('\n2. Testing echo then exit 1...');
+  try {
+    const result = await $`echo "test"; exit 1`;
+    console.log('Echo + exit 1 succeeded (unexpected):', result);
+  } catch (e) {
+    console.log('Echo + exit 1 failed (expected):');
+    console.log('- Message:', e.message);
+    console.log('- Code:', e.code);
+    console.log('- Full error:', e);
+  }
+}
+
+testExitCommand().catch(console.error);

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

@@ -0,0 +1,54 @@
+#!/usr/bin/env bun
+// Debug the virtual exit command directly
+
+import { $ } from '../src/$.mjs';
+
+// Enable verbose mode
+process.env.COMMAND_STREAM_VERBOSE = 'true';
+
+// Test just the problematic pipeline
+async function testProblematicPipeline() {
+  console.log('=== Problematic Pipeline Debug ===');
+
+  function getState() {
+    return {
+      sigintHandlers: process.listeners('SIGINT').length,
+      timestamp: new Date().toISOString(),
+    };
+  }
+
+  console.log('\n1. Initial state:', getState());
+
+  console.log('\n2. Creating runner...');
+  const runner = $`echo "test" | exit 1 | cat`;
+  console.log('After creation:', getState());
+  console.log('Runner details:', {
+    finished: runner.finished,
+    started: runner.started,
+    spec: runner.spec,
+  });
+
+  console.log('\n3. Executing pipeline...');
+  try {
+    const result = await runner;
+    console.log('Pipeline succeeded (unexpected):', result);
+    console.log('After success:', getState());
+  } catch (e) {
+    console.log('Pipeline failed (expected):', e.message);
+    console.log('Error details:', {
+      code: e.code,
+      hasResult: !!e.result,
+      keys: Object.keys(e),
+    });
+    console.log('After failure:', getState());
+  }
+
+  console.log('\n4. Runner final state:', {
+    finished: runner.finished,
+    started: runner.started,
+  });
+
+  console.log('\n5. Final state:', getState());
+}
+
+testProblematicPipeline().catch(console.error);

package/js/examples/debug-finish-consolidation.mjs

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+
+import { $ } from '../src/$.mjs';
+
+console.log('=== Finish Method Consolidation Test ===');
+
+// Test different scenarios that should all use the finish() method
+const tests = [
+  async () => {
+    console.log('\n1. Testing normal completion...');
+    const result = await $`echo "test"`;
+    console.log('Result:', result.stdout);
+  },
+
+  async () => {
+    console.log('\n2. Testing sync mode...');
+    const result = $`echo "sync test"`.sync();
+    console.log('Result:', result.stdout);
+  },
+
+  async () => {
+    console.log('\n3. Testing error handling...');
+    try {
+      await $`exit 1`;
+    } catch (error) {
+      console.log('Expected error, code:', error.code);
+    }
+  },
+
+  async () => {
+    console.log('\n4. Testing pipeline...');
+    try {
+      await $`echo "test" | exit 1`;
+    } catch (error) {
+      console.log('Expected pipeline error, code:', error.code);
+    }
+  },
+];
+
+for (const test of tests) {
+  await test();
+}
+
+console.log('\nAll tests completed successfully!');

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

@@ -0,0 +1,47 @@
+#!/usr/bin/env bun
+// Test the forceCleanupAll function
+
+import { $, forceCleanupAll } from '../src/$.mjs';
+
+// Enable verbose mode
+process.env.COMMAND_STREAM_VERBOSE = 'true';
+
+async function testForceCleanup() {
+  console.log('=== Force Cleanup Test ===');
+
+  console.log('\n1. Initial state:');
+  console.log('SIGINT handlers:', process.listeners('SIGINT').length);
+
+  console.log('\n2. Create some runners to install handlers...');
+  const runner1 = $`sleep 0.1`;
+  const runner2 = $`echo "test"`;
+
+  console.log('After creating runners:', process.listeners('SIGINT').length);
+
+  console.log('\n3. Start them to activate handlers...');
+  const promise1 = runner1.start();
+  const promise2 = runner2.start();
+
+  console.log('After starting:', process.listeners('SIGINT').length);
+
+  console.log('\n4. Test forceCleanupAll...');
+  forceCleanupAll();
+  console.log('After forceCleanupAll:', process.listeners('SIGINT').length);
+
+  console.log('\n5. Try to create a new runner...');
+  const runner3 = $`echo "after cleanup"`;
+  console.log('After creating new runner:', process.listeners('SIGINT').length);
+
+  console.log('\n6. Cleanup again...');
+  forceCleanupAll();
+  console.log('Final state:', process.listeners('SIGINT').length);
+
+  // Clean exit
+  try {
+    await Promise.allSettled([promise1, promise2]);
+  } catch (e) {
+    // Ignore errors from killed processes
+  }
+}
+
+testForceCleanup().catch(console.error);

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

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+
+import { $ } from '../src/$.mjs';
+
+console.log('=== Basic Getter Debug ===');
+
+const cmd = $`echo "test"`;
+
+console.log('Testing testGetter:');
+console.log('cmd.testGetter:', cmd.testGetter);
+
+console.log('Testing stdout getter:');
+console.log('cmd.stdout:', cmd.stdout);

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

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+
+import { $ } from '../src/$.mjs';
+
+console.log('=== Direct Getter Debug ===');
+
+const cmd = $`echo "test"`;
+
+console.log('Before calling stdout getter');
+console.log('cmd.child:', cmd.child);
+
+// Get the getter directly
+const proto = Object.getPrototypeOf(cmd);
+const descriptor = Object.getOwnPropertyDescriptor(proto, 'stdout');
+console.log('Getter descriptor:', descriptor);
+
+console.log('Calling getter directly:');
+const result = descriptor.get.call(cmd);
+console.log('Direct getter result:', result);
+
+console.log('Calling via property access:');
+const result2 = cmd.stdout;
+console.log('Property access result:', result2);

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

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+
+import { $, disableVirtualCommands } from '../src/$.mjs';
+
+console.log('=== Getter Internals Debug ===');
+
+// Test virtual command
+disableVirtualCommands();
+const virtualCmd = $`echo "virtual test"`;
+virtualCmd.start();
+
+await new Promise((resolve) => setTimeout(resolve, 50));
+
+console.log('\n--- Virtual Command ---');
+console.log('virtualCmd.child:', virtualCmd.child);
+console.log('virtualCmd.child === null:', virtualCmd.child === null);
+
+// Get the actual getter function
+const proto = Object.getPrototypeOf(virtualCmd);
+const stdoutDescriptor = Object.getOwnPropertyDescriptor(proto, 'stdout');
+console.log('stdout descriptor exists:', !!stdoutDescriptor);
+console.log('stdout descriptor.get:', stdoutDescriptor?.get);
+
+// Try calling the getter function directly with explicit context
+console.log('\n--- Direct getter call ---');
+try {
+  const directResult = stdoutDescriptor.get.call(virtualCmd);
+  console.log('Direct call result:', directResult);
+  console.log('Direct call result === null:', directResult === null);
+  console.log('Direct call result === undefined:', directResult === undefined);
+} catch (e) {
+  console.log('Error calling getter directly:', e);
+}
+
+// Check if there are any property descriptors on the instance
+console.log('\n--- Instance properties ---');
+console.log(
+  'Own property descriptor on instance:',
+  Object.getOwnPropertyDescriptor(virtualCmd, 'stdout')
+);
+
+// Check the prototype chain
+console.log('\n--- Prototype chain ---');
+let currentProto = virtualCmd;
+let level = 0;
+while (currentProto && level < 5) {
+  console.log(`Level ${level}:`, currentProto.constructor.name);
+  const desc = Object.getOwnPropertyDescriptor(currentProto, 'stdout');
+  if (desc) {
+    console.log(`  Found stdout descriptor at level ${level}:`, desc);
+  }
+  currentProto = Object.getPrototypeOf(currentProto);
+  level++;
+}
+
+// Property access
+console.log('\n--- Property access ---');
+console.log('virtualCmd.stdout:', virtualCmd.stdout);
+console.log('virtualCmd["stdout"]:', virtualCmd['stdout']);
+
+await virtualCmd;

package/js/examples/debug-handler-detection.mjs

@@ -0,0 +1,65 @@
+#!/usr/bin/env bun
+// Debug script to test the exact pattern matching used by the tests
+
+import { $ } from '../src/$.mjs';
+
+// Enable verbose mode
+process.env.COMMAND_STREAM_VERBOSE = 'true';
+
+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,
+    allListeners: sigintListeners.map((l) => ({
+      length: l.toString().length,
+      contains: {
+        activeProcessRunners: l.toString().includes('activeProcessRunners'),
+        ProcessRunner: l.toString().includes('ProcessRunner'),
+        activeChildren: l.toString().includes('activeChildren'),
+      },
+    })),
+  };
+}
+
+async function testHandlerDetection() {
+  console.log('=== Handler Detection Debug ===');
+
+  console.log('\n1. Initial state:');
+  console.log(JSON.stringify(getInternalState(), null, 2));
+
+  console.log('\n2. Creating runner...');
+  const runner = $`sleep 0.1`;
+  console.log(
+    'After creating runner:',
+    JSON.stringify(getInternalState(), null, 2)
+  );
+
+  console.log('\n3. Starting runner...');
+  const promise = runner.start();
+  console.log(
+    'Immediately after start():',
+    JSON.stringify(getInternalState(), null, 2)
+  );
+
+  // Small delay to let any async operations complete
+  await new Promise((resolve) => setTimeout(resolve, 10));
+  console.log('After 10ms delay:', JSON.stringify(getInternalState(), null, 2));
+
+  console.log('\n4. Waiting for completion...');
+  await promise;
+
+  console.log('\n5. Final state:');
+  console.log(JSON.stringify(getInternalState(), null, 2));
+}
+
+testHandlerDetection().catch(console.error);

package/js/examples/debug-idempotent-finish.mjs

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+
+import { $ } from '../src/$.mjs';
+
+console.log('=== Idempotent Finish Method Test ===');
+
+// Test that finish() is now idempotent (safe to call multiple times)
+const runner = $`echo "test"`;
+
+let eventCount = 0;
+let endEventCount = 0;
+let exitEventCount = 0;
+
+runner.on('end', (result) => {
+  endEventCount++;
+  console.log(`End event #${endEventCount}, result: ${result.stdout.trim()}`);
+});
+
+runner.on('exit', (code) => {
+  exitEventCount++;
+  console.log(`Exit event #${exitEventCount}, code: ${code}`);
+});
+
+runner.on('data', () => {
+  eventCount++;
+});
+
+// Start and await the process
+await runner;
+
+console.log(`\nAfter normal completion:`);
+console.log(`- finished: ${runner.finished}`);
+console.log(`- result: ${runner.result.stdout.trim()}`);
+console.log(`- end events: ${endEventCount}`);
+console.log(`- exit events: ${exitEventCount}`);
+
+// Now try to finish again (should be idempotent)
+console.log(`\nTrying to finish again (should be safe now)...`);
+
+const result2 = runner.finish({
+  code: 0,
+  stdout: 'different output',
+  stderr: '',
+  stdin: '',
+});
+
+console.log(`\nAfter second finish() call:`);
+console.log(`- finished: ${runner.finished}`);
+console.log(`- result: ${runner.result.stdout.trim()} (should be original)`);
+console.log(`- returned result: ${result2.stdout.trim()} (should be original)`);
+console.log(`- end events: ${endEventCount} (should still be 1)`);
+console.log(`- exit events: ${exitEventCount} (should still be 1)`);
+
+console.log('\nIdempotent finish test completed!');

package/js/examples/debug-idempotent-kill.mjs

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+
+import { $ } from '../src/$.mjs';
+
+console.log('=== Idempotent Kill Test ===');
+
+// Test that kill now works without conditional checks
+const runner = $`sleep 1`;
+
+let endEventCount = 0;
+let exitEventCount = 0;
+
+runner.on('end', (result) => {
+  endEventCount++;
+  console.log(
+    `End event #${endEventCount}, code: ${result.code}, stderr: ${result.stderr.trim()}`
+  );
+});
+
+runner.on('exit', (code) => {
+  exitEventCount++;
+  console.log(`Exit event #${exitEventCount}, code: ${code}`);
+});
+
+const promise = runner.start();
+
+// Give it a moment to start
+await new Promise((resolve) => setTimeout(resolve, 50));
+
+console.log('Killing process...');
+runner.kill('SIGTERM');
+
+try {
+  await promise;
+} catch (error) {
+  console.log(`Expected error: ${error.message}`);
+}
+
+console.log(`\nAfter kill:`);
+console.log(`- finished: ${runner.finished}`);
+console.log(`- result code: ${runner.result.code}`);
+console.log(`- result stderr: ${runner.result.stderr.trim()}`);
+console.log(`- end events: ${endEventCount}`);
+console.log(`- exit events: ${exitEventCount}`);
+
+// Try to kill again (should be safe due to idempotent finish)
+console.log('\nTrying to kill again (should be safe)...');
+runner.kill('SIGKILL');
+
+console.log(`\nAfter second kill:`);
+console.log(`- finished: ${runner.finished}`);
+console.log(
+  `- result code: ${runner.result.code} (should still be 143 for SIGTERM)`
+);
+console.log(`- end events: ${endEventCount} (should still be 1)`);
+console.log(`- exit events: ${exitEventCount} (should still be 1)`);
+
+console.log('\nIdempotent kill test completed!');

package/js/examples/debug-interpolation-individual.mjs

@@ -0,0 +1,88 @@
+import { $ } from '../src/$.mjs';
+
+console.log('=== Individual Debugging for Quoting Issue ===\n');
+
+// Let's trace exactly what happens in the command building process
+async function debugIndividualSteps() {
+  const claudePath = '/Users/konard/.claude/local/claude';
+
+  console.log('1. Path value:', JSON.stringify(claudePath));
+
+  // Step-by-step debugging
+  console.log('\n2. Creating command with exact options from issue:');
+  const options = { stdin: 'hi\n', mirror: false };
+  console.log('Options:', JSON.stringify(options));
+
+  // Create the command but don't execute yet
+  const cmd = $({
+    ...options,
+  })`${claudePath} --output-format stream-json --verbose --model sonnet`;
+
+  console.log('\n3. Command object details:');
+  console.log('- Command spec:', JSON.stringify(cmd.spec, null, 2));
+  console.log('- Command string:', cmd.spec?.command);
+  console.log('- Options:', JSON.stringify(cmd.options, null, 2));
+
+  // Check if there are any differences in how the template is being processed
+  console.log('\n4. Manual template testing:');
+  const manualTemplate = `${claudePath} --output-format stream-json --verbose --model sonnet`;
+  console.log('Manual template result:', JSON.stringify(manualTemplate));
+
+  // Test what happens if we try to access internal command processing
+  console.log('\n5. Testing command processing internals:');
+  try {
+    // Let's see what the internal command string looks like
+    if (cmd._command) {
+      console.log('Internal _command:', cmd._command);
+    }
+    if (cmd.command) {
+      console.log('Internal command:', cmd.command);
+    }
+
+    // Try to start the command to see exactly what gets passed to spawn
+    console.log('\n6. Attempting command execution to see spawn details:');
+    await cmd;
+  } catch (error) {
+    console.log('Execution error:', error.message);
+    console.log('Error stack:', error.stack);
+
+    // Check for the specific posix_spawn pattern mentioned in the issue
+    const spawnMatch = error.message.match(/posix_spawn '([^']*)''/);
+    if (spawnMatch) {
+      console.log('🔍 Found posix_spawn with double quotes!');
+      console.log('Captured path:', spawnMatch[1]);
+    }
+
+    // Also check for any double-quote patterns
+    const doubleQuoteMatch = error.message.match(/''/g);
+    if (doubleQuoteMatch) {
+      console.log(
+        '🔍 Found double-quote patterns:',
+        doubleQuoteMatch.length,
+        'instances'
+      );
+    }
+  }
+
+  console.log('\n7. Testing different path formats:');
+  const testPaths = [
+    '/Users/konard/.claude/local/claude',
+    '"/Users/konard/.claude/local/claude"',
+    "'/Users/konard/.claude/local/claude'",
+    '/Users/user with spaces/.claude/local/claude',
+    '/nonexistent/path',
+  ];
+
+  for (const testPath of testPaths) {
+    console.log(`\nTesting path: ${JSON.stringify(testPath)}`);
+    try {
+      const testCmd = $({ mirror: false })`${testPath} --version`;
+      console.log('Generated command:', testCmd.spec?.command);
+      // Don't actually execute, just check the generated command
+    } catch (error) {
+      console.log('Command creation error:', error.message);
+    }
+  }
+}
+
+debugIndividualSteps().catch(console.error);

package/js/examples/debug-interpolation-issue.mjs

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+
+// EXACT reproduction of issue #12 from deep-assistant/hive-mind
+// Original file: https://github.com/deep-assistant/hive-mind/blob/ff005fa5/claude-pipe/test-pipe.mjs
+// Issue: https://github.com/link-foundation/command-stream/issues/12
+// Error: ENOENT: no such file or directory, posix_spawn ''/Users/konard/.claude/local/claude''
+
+import { $ } from '../src/$.mjs';
+
+const claude = process.env.CLAUDE_PATH || '/Users/konard/.claude/local/claude';
+
+console.log('=== Reproducing Issue #12: Path with quotes in posix_spawn ===\n');
+console.log('Using path:', claude);
+console.log();
+
+async function reproduceOriginalIssue() {
+  console.log('1. EXACT CODE FROM ISSUE (test-pipe.mjs):');
+  console.log('------------------------------------------');
+
+  try {
+    // This is the EXACT line that was failing
+    const result =
+      await $`${claude} -p "hi" --output-format stream-json --model sonnet | jq .`;
+    console.log('Result:');
+    console.log(result.stdout);
+  } catch (error) {
+    console.error('❌ Error reproduced:', error.message);
+
+    // Check if this is the exact error from the issue
+    if (error.message.includes("''") && error.message.includes('ENOENT')) {
+      console.log('\n✓ THIS IS THE EXACT ERROR FROM ISSUE #12!');
+      console.log("  The path has extra quotes: ''...''");
+    }
+  }
+}
+
+async function testSimplifiedCase() {
+  console.log('\n2. SIMPLIFIED TEST CASE:');
+  console.log('------------------------');
+
+  try {
+    // Simplify to just the command without pipe
+    console.log(`Trying: ${claude} --version`);
+    const result = await $`${claude} --version`;
+    console.log('Result:', result);
+  } catch (error) {
+    console.error('❌ Error:', error.message);
+
+    if (error.message.includes("''")) {
+      console.log('✓ Double quotes still present in error!');
+    }
+  }
+}
+
+async function testQuotingPatterns() {
+  console.log('\n3. TESTING QUOTE PATTERNS:');
+  console.log('---------------------------');
+
+  // Test what happens with already-quoted paths
+  const patterns = [
+    { desc: 'Plain path', path: claude },
+    { desc: 'Single-quoted', path: `'${claude}'` },
+    { desc: 'Double-quoted', path: `"${claude}"` },
+  ];
+
+  for (const { desc, path } of patterns) {
+    console.log(`\n${desc}: ${path}`);
+    try {
+      // Use echo to avoid actual execution
+      const result = await $`echo "Would execute: ${path}"`;
+      console.log('Echo result:', String(result).trim());
+    } catch (error) {
+      console.error('Error:', error.message);
+    }
+  }
+}
+
+async function showWorkingPattern() {
+  console.log('\n4. CORRECT PATTERN (should work):');
+  console.log('----------------------------------');
+
+  try {
+    // Using a valid command to show proper interpolation
+    const testCmd = 'echo';
+    const args = `"Testing path: ${claude}"`;
+    console.log(`Command: ${testCmd} ${args}`);
+
+    const result = await $`${testCmd} ${args}`;
+    console.log('✓ Result:', String(result).trim());
+  } catch (error) {
+    console.error('Error:', error.message);
+  }
+}
+
+// Run all tests
+(async () => {
+  await reproduceOriginalIssue();
+  await testSimplifiedCase();
+  await testQuotingPatterns();
+  await showWorkingPattern();
+})().catch(console.error);