command-stream 0.8.2 → 0.9.0

package/js/examples/debug-option-merging.mjs

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+
+// Testing option merging
+
+import { $ } from '../src/$.mjs';
+
+console.log('Testing option merging:');
+const runner = $`echo "option merge test"`;
+
+console.log('Initial options:', runner.options);
+const result = await runner.start({
+  capture: false,
+  mirror: false,
+  customOption: 'test',
+});
+console.log('Final options:', runner.options);
+console.log('Result:', { stdout: result.stdout, code: result.code });

package/js/examples/debug-options.mjs

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+
+import { $ } from '../src/$.mjs';
+
+// Enable trace to see what's happening
+process.env.COMMAND_STREAM_TRACE = 'ProcessRunner';
+
+async function debugOptions() {
+  console.log('🐛 Debugging options and spawn');
+
+  const catCmd = $`cat`;
+  console.log('1. Created cat command');
+
+  // This should trigger auto-start with pipe stdio
+  const stdinPromise = catCmd.streams.stdin;
+  console.log('2. Accessed streams.stdin (auto-start triggered)');
+
+  // Wait for start to complete
+  await new Promise((resolve) => setTimeout(resolve, 200));
+
+  console.log('3. After wait:');
+  console.log('   started:', catCmd.started);
+  console.log('   child exists:', !!catCmd.child);
+
+  if (catCmd.child) {
+    console.log('   child.stdin exists:', !!catCmd.child.stdin);
+    console.log('   child.stdin type:', typeof catCmd.child.stdin);
+  }
+
+  const stdin = await stdinPromise;
+  console.log('4. Awaited stdin:', typeof stdin, stdin);
+
+  catCmd.kill();
+}
+
+debugOptions();

package/js/examples/debug-output.mjs

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+
+import { $, shell, enableVirtualCommands } from '../src/$.mjs';
+
+enableVirtualCommands();
+shell.verbose(false);
+
+console.log('=== Debug Output Test ===\n');
+
+console.log('Test 1: Simple pwd');
+const r1 = await $`pwd`;
+console.log('Output:', JSON.stringify(r1.stdout));
+console.log('Trimmed:', JSON.stringify(r1.stdout.trim()));
+
+console.log('\nTest 2: cd /tmp ; pwd');
+const r2 = await $`cd /tmp ; pwd`;
+console.log('Output:', JSON.stringify(r2.stdout));
+console.log('Trimmed:', JSON.stringify(r2.stdout.trim()));
+
+console.log('\nTest 3: cd /tmp ; pwd ; cd /usr ; pwd');
+const r3 = await $`cd /tmp ; pwd ; cd /usr ; pwd`;
+console.log('Output:', JSON.stringify(r3.stdout));
+console.log('Split:', r3.stdout.trim().split('\n'));
+
+process.chdir('/workspace/command-stream');

package/js/examples/debug-pattern-matching.mjs

@@ -0,0 +1,69 @@
+#!/usr/bin/env bun
+// Debug script to test pattern matching in signal handler detection
+
+import { $ } from '../src/$.mjs';
+
+// Enable verbose mode
+process.env.COMMAND_STREAM_VERBOSE = 'true';
+
+function testPatternMatching() {
+  console.log('=== Pattern Matching Debug ===');
+
+  console.log('\n1. Initial state:');
+  const initialListeners = process.listeners('SIGINT');
+  console.log('Initial listeners:', initialListeners.length);
+
+  console.log('\n2. Creating a runner to install handler...');
+  const runner = $`sleep 0.01`;
+  const afterCreation = process.listeners('SIGINT');
+  console.log('After creation:', afterCreation.length);
+
+  if (afterCreation.length > 0) {
+    const handler = afterCreation[0];
+    const handlerStr = handler.toString();
+
+    console.log('\n3. Testing pattern matching on actual handler:');
+    console.log('Handler length:', handlerStr.length);
+    console.log(
+      'Contains activeProcessRunners:',
+      handlerStr.includes('activeProcessRunners')
+    );
+    console.log(
+      'Contains ProcessRunner:',
+      handlerStr.includes('ProcessRunner')
+    );
+    console.log(
+      'Contains activeChildren:',
+      handlerStr.includes('activeChildren')
+    );
+
+    const matchesPattern =
+      handlerStr.includes('activeProcessRunners') &&
+      handlerStr.includes('ProcessRunner') &&
+      handlerStr.includes('activeChildren');
+    console.log('Matches full pattern:', matchesPattern);
+
+    console.log('\n4. Handler excerpt (first 200 chars):');
+    console.log(`${handlerStr.substring(0, 200)}...`);
+  }
+
+  console.log('\n5. Testing manual cleanup simulation:');
+  // Simulate what tests do - manually remove the listener
+  const listenersToRemove = process.listeners('SIGINT');
+  listenersToRemove.forEach((l) => {
+    process.removeListener('SIGINT', l);
+  });
+
+  console.log('After manual removal:', process.listeners('SIGINT').length);
+
+  console.log('\n6. Creating another runner - should detect and reset:');
+  const runner2 = $`sleep 0.01`;
+  const afterSecondCreation = process.listeners('SIGINT');
+  console.log('After second creation:', afterSecondCreation.length);
+
+  // Clean up
+  runner.kill();
+  runner2.kill();
+}
+
+testPatternMatching();

package/js/examples/debug-pipeline-cat.mjs

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+// Debug pipeline with cat
+
+import { $ } from '../src/$.mjs';
+
+process.env.COMMAND_STREAM_VERBOSE = 'true';
+
+console.log('=== Debug pipeline with cat ===');
+
+console.log('1. Test simple echo:');
+const r1 = await $`echo "test"`;
+console.log('Simple echo result:', JSON.stringify(r1.stdout));
+
+console.log('2. Test simple cat with stdin:');
+const r2 = $`cat`;
+r2.options.stdin = 'test';
+await r2;
+console.log('Cat with stdin result:', JSON.stringify(r2.result.stdout));
+
+console.log('3. Test pipeline echo | cat:');
+const r3 = await $`echo "test" | cat`;
+console.log('Pipeline result:', JSON.stringify(r3.stdout));
+
+console.log('4. Test pipeline echo | cat | cat:');
+const r4 = await $`echo "test" | cat | cat`;
+console.log('Double pipeline result:', JSON.stringify(r4.stdout));
+
+console.log('=== Complete ===');

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

@@ -0,0 +1,71 @@
+#!/usr/bin/env bun
+// Debug script to test pipeline cleanup issues
+
+import { $ } from '../src/$.mjs';
+
+// Enable verbose mode
+process.env.COMMAND_STREAM_VERBOSE = 'true';
+
+async function testPipelineCleanup() {
+  console.log('=== Pipeline Cleanup Debug ===');
+
+  console.log('\n1. Testing basic pipeline...');
+  try {
+    const result1 = await $`echo "test"`.pipe($`cat`);
+    console.log('Basic pipeline result:', result1.stdout);
+  } catch (error) {
+    console.log('Basic pipeline error:', error.message);
+  }
+
+  console.log('\n2. Testing pipeline with virtual commands...');
+  try {
+    const result2 = await $`ls`.pipe($`cat`);
+    console.log('Virtual pipeline result length:', result2.stdout.length);
+  } catch (error) {
+    console.log('Virtual pipeline error:', error.message);
+  }
+
+  console.log('\n3. Testing multi-stage pipeline...');
+  try {
+    const result3 = await $`echo "line1\\nline2\\nline3"`
+      .pipe($`grep "line"`)
+      .pipe($`wc -l`);
+    console.log('Multi-stage pipeline result:', result3.stdout.trim());
+  } catch (error) {
+    console.log('Multi-stage pipeline error:', error.message);
+  }
+
+  console.log('\n4. Testing pipeline with error...');
+  try {
+    const result4 = await $`echo "test"`.pipe($`nonexistent-command`);
+    console.log('Error pipeline result:', result4.stdout);
+  } catch (error) {
+    console.log('Expected error pipeline error:', error.message);
+  }
+
+  console.log('\n5. Testing pipeline interruption...');
+  const longPipeline = $`yes`.pipe($`head -1000`);
+  const pipelinePromise = longPipeline.start();
+
+  // Interrupt after a short delay
+  setTimeout(() => {
+    console.log('Interrupting pipeline...');
+    longPipeline.kill('SIGINT');
+  }, 50);
+
+  try {
+    const result5 = await pipelinePromise;
+    console.log('Interrupted pipeline result length:', result5.stdout.length);
+  } catch (error) {
+    console.log(
+      'Interrupted pipeline error:',
+      error.message,
+      'code:',
+      error.code
+    );
+  }
+
+  console.log('\nPipeline tests completed');
+}
+
+testPipelineCleanup().catch(console.error);

package/js/examples/debug-pipeline-error-detailed.mjs

@@ -0,0 +1,78 @@
+#!/usr/bin/env bun
+// Detailed debug script for pipeline error cleanup
+
+import { $ } from '../src/$.mjs';
+
+// Enable verbose mode for tracing
+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,
+  };
+}
+
+async function testPipelineErrorDetailed() {
+  console.log('=== Pipeline Error Detailed Debug ===');
+
+  console.log('\n1. Initial state:', getInternalState());
+
+  console.log('\n2. Creating pipeline runner...');
+  const runner = $`echo "test" | exit 1 | cat`;
+  console.log('After creating runner:', getInternalState());
+
+  console.log('\n3. Starting pipeline...');
+  let result, error;
+  try {
+    result = await runner;
+    console.log('Pipeline succeeded (unexpected):', result);
+  } catch (e) {
+    error = e;
+    console.log('Pipeline failed (expected):', e.message, 'code:', e.code);
+  }
+
+  console.log('\n4. Immediately after pipeline completion/failure:');
+  console.log('State:', getInternalState());
+  console.log('Runner finished?', runner.finished);
+  console.log('Runner started?', runner.started);
+
+  console.log('\n5. After 10ms:');
+  await new Promise((resolve) => setTimeout(resolve, 10));
+  console.log('State:', getInternalState());
+
+  console.log('\n6. After 50ms:');
+  await new Promise((resolve) => setTimeout(resolve, 40));
+  console.log('State:', getInternalState());
+
+  console.log('\n7. After 100ms:');
+  await new Promise((resolve) => setTimeout(resolve, 50));
+  console.log('State:', getInternalState());
+
+  // Manually cleanup if needed
+  console.log('\n8. Manual cleanup test...');
+  if (typeof runner._cleanup === 'function') {
+    runner._cleanup();
+    console.log('After manual cleanup:', getInternalState());
+  }
+
+  // Check if runner can be killed
+  console.log('\n9. Kill test...');
+  if (!runner.finished) {
+    runner.kill();
+    console.log('After kill:', getInternalState());
+    console.log('Runner finished after kill?', runner.finished);
+  }
+}
+
+testPipelineErrorDetailed().catch(console.error);

package/js/examples/debug-pipeline-error.mjs

@@ -0,0 +1,65 @@
+#!/usr/bin/env bun
+// Debug script to test the specific pipeline error scenario
+
+import { $ } from '../src/$.mjs';
+
+// Enable verbose mode
+process.env.COMMAND_STREAM_VERBOSE = 'true';
+
+async function testPipelineError() {
+  console.log('=== Pipeline Error Debug ===');
+
+  console.log('\n1. Initial state:');
+  const initialListeners = process.listeners('SIGINT').length;
+  console.log('Initial SIGINT listeners:', initialListeners);
+
+  console.log('\n2. Running failing pipeline: echo "test" | exit 1 | cat');
+
+  try {
+    await $`echo "test" | exit 1 | cat`;
+    console.log('Pipeline succeeded (unexpected)');
+  } catch (e) {
+    console.log('Pipeline failed as expected:', e.message, 'code:', e.code);
+  }
+
+  console.log('\n3. Immediately after pipeline:');
+  console.log('SIGINT listeners:', process.listeners('SIGINT').length);
+
+  console.log('\n4. After 50ms wait:');
+  await new Promise((resolve) => setTimeout(resolve, 50));
+  console.log('SIGINT listeners:', process.listeners('SIGINT').length);
+
+  console.log('\n5. After 100ms total:');
+  await new Promise((resolve) => setTimeout(resolve, 50));
+  console.log('SIGINT listeners:', process.listeners('SIGINT').length);
+
+  console.log('\n6. After 200ms total:');
+  await new Promise((resolve) => setTimeout(resolve, 100));
+  console.log('SIGINT listeners:', process.listeners('SIGINT').length);
+
+  console.log('\nFinal result:');
+  console.log('Expected:', initialListeners);
+  console.log('Actual:', process.listeners('SIGINT').length);
+  console.log(
+    'Cleaned up properly:',
+    process.listeners('SIGINT').length === initialListeners
+  );
+
+  // Show any remaining handlers
+  const remaining = process.listeners('SIGINT');
+  if (remaining.length > initialListeners) {
+    console.log('\nRemaining handlers:');
+    remaining.forEach((handler, i) => {
+      const str = handler.toString();
+      const isCommandStream =
+        str.includes('activeProcessRunners') ||
+        str.includes('ProcessRunner') ||
+        str.includes('activeChildren');
+      console.log(
+        `Handler ${i}: ${isCommandStream ? 'COMMAND-STREAM' : 'OTHER'} (${str.length} chars)`
+      );
+    });
+  }
+}
+
+testPipelineError().catch(console.error);

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

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+
+import { $ } from '../src/$.mjs';
+
+console.log('=== Pipeline Debug ===\n');
+
+// Add some debug tracing
+process.env.COMMAND_STREAM_VERBOSE = 'true';
+
+console.log('1. Simple non-pipeline jq test:');
+const simple = await $`jq --color-output . <<< '{"test": "simple"}'`;
+console.log('Simple result:');
+process.stdout.write(simple.stdout);
+console.log('Simple raw bytes:', Buffer.from(simple.stdout.slice(0, 30)));
+
+console.log('\n2. Pipeline jq test:');
+const pipeline = await $`echo '{"test": "pipeline"}' | jq --color-output .`;
+console.log('Pipeline result:');
+process.stdout.write(pipeline.stdout);
+console.log('Pipeline raw bytes:', Buffer.from(pipeline.stdout.slice(0, 30)));
+
+console.log('\n3. Testing printf pipeline:');
+const printf = await $`printf '{"test": "printf"}' | jq --color-output .`;
+console.log('Printf result:');
+process.stdout.write(printf.stdout);
+console.log('Printf raw bytes:', Buffer.from(printf.stdout.slice(0, 30)));

package/js/examples/debug-pipeline-method.mjs

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+
+import { $ } from '../src/$.mjs';
+
+console.log('=== Debug Which Pipeline Method is Used ===\n');
+
+// Enable verbose tracing to see which pipeline method is called
+process.env.COMMAND_STREAM_VERBOSE = 'true';
+
+console.log('Testing pipeline command:');
+const proc = $`printf '{"test": "data"}' | jq --color-output .`;
+
+proc.on('stdout', (chunk) => {
+  console.log('STDOUT EVENT - Type:', typeof chunk, chunk.constructor.name);
+  console.log('STDOUT EVENT - Bytes:', Buffer.from(chunk.slice(0, 30)));
+  console.log('STDOUT EVENT - Content:');
+  process.stdout.write(chunk);
+  console.log('--- END STDOUT EVENT ---');
+});
+
+const result = await proc;
+console.log('\nFinal result complete.');

package/js/examples/debug-pipeline-stream.mjs

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+
+import { $ } from '../src/$.mjs';
+
+console.log('=== Pipeline Stream Debug ===');
+
+const cmd = $`sh -c 'echo "test"' | jq -c .`;
+
+// Instrument the stream method
+const originalStream = cmd.stream.bind(cmd);
+cmd.stream = function () {
+  console.log('stream() called for pipeline');
+
+  const generator = originalStream();
+
+  const originalNext = generator.next.bind(generator);
+  generator.next = function () {
+    console.log('pipeline generator.next() called');
+    const promise = originalNext();
+
+    promise
+      .then((result) => {
+        console.log('pipeline generator.next() resolved:', {
+          done: result.done,
+          hasValue: !!result.value,
+          valueType: result.value?.type,
+        });
+      })
+      .catch((err) => {
+        console.log('pipeline generator.next() error:', err.message);
+      });
+
+    return promise;
+  };
+
+  return generator;
+};
+
+const timeout = setTimeout(() => {
+  console.log('TIMEOUT: Pipeline stream took too long');
+  process.exit(1);
+}, 5000);
+
+try {
+  let count = 0;
+  console.log('Starting pipeline stream...');
+  for await (const chunk of cmd.stream()) {
+    count++;
+    console.log(
+      `Pipeline chunk ${count}:`,
+      chunk.type,
+      JSON.stringify(chunk.data.toString().trim())
+    );
+
+    if (count >= 3) {
+      console.log('Breaking after 3 chunks');
+      break;
+    }
+  }
+
+  clearTimeout(timeout);
+  console.log('Pipeline stream completed with', count, 'chunks');
+} catch (error) {
+  clearTimeout(timeout);
+  console.log('Pipeline stream error:', error.message);
+}

package/js/examples/debug-pipeline.mjs

@@ -0,0 +1,14 @@
+#!/usr/bin/env bun
+
+import { $ } from '../src/$.mjs';
+
+console.log('=== Debug Pipeline Selection ===\n');
+
+// Add debug output to see which pipeline method is being used
+const originalRunPipeline = $.prototype._runPipeline;
+
+// Simple test
+console.log('Testing: echo "test" | cat');
+const cmd = $`echo "test" | cat`;
+const result = await cmd;
+console.log('Result:', result.stdout);

package/js/examples/debug-process-exit-trace.mjs

@@ -0,0 +1,41 @@
+#!/usr/bin/env bun
+// Debug script to trace process.exit calls
+
+import { $ } from '../src/$.mjs';
+
+// Enable verbose mode
+process.env.COMMAND_STREAM_VERBOSE = 'true';
+
+// Monkey patch process.exit to trace calls
+const originalExit = process.exit;
+process.exit = function (code) {
+  console.log(`🚨 process.exit(${code}) called`);
+  console.log('Stack trace:', new Error().stack);
+  return originalExit.call(this, code);
+};
+
+let cleanupDone = false;
+
+// User handler
+process.on('SIGINT', async () => {
+  console.log('CHILD_CLEANUP_START');
+  await new Promise((resolve) => setTimeout(resolve, 100));
+  cleanupDone = true;
+  console.log('CHILD_CLEANUP_DONE - calling process.exit(0)');
+  process.exit(0);
+});
+
+console.log('CHILD_READY');
+
+try {
+  const sleepPromise = $`sleep 5`.start();
+
+  setTimeout(() => {
+    console.log('Sending SIGINT...');
+    process.kill(process.pid, 'SIGINT');
+  }, 500);
+
+  await sleepPromise;
+} catch (error) {
+  console.log('SLEEP_INTERRUPTED:', error.message);
+}

package/js/examples/debug-process-path.mjs

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+
+import { $ } from '../src/$.mjs';
+
+console.log('=== Process Path Debug ===');
+
+// Enable verbose tracing to see which code path is taken
+process.env.COMMAND_STREAM_VERBOSE = 'true';
+
+console.log('Testing simple echo command path...');
+const cmd = $`echo "test"`;
+
+// Add event listeners to track what happens
+cmd.on('data', (chunk) => {
+  console.log(
+    '[EVENT] data:',
+    chunk.type,
+    JSON.stringify(chunk.data.toString().trim())
+  );
+});
+
+cmd.on('end', (result) => {
+  console.log(
+    '[EVENT] end:',
+    result.code,
+    JSON.stringify(result.stdout.trim())
+  );
+});
+
+cmd.on('exit', (code) => {
+  console.log('[EVENT] exit:', code);
+});
+
+console.log('Awaiting result...');
+const result = await cmd;
+console.log('Final result:', result.code, JSON.stringify(result.stdout.trim()));
+
+console.log('Process path debug completed!');

package/js/examples/debug-property-check.mjs

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+
+import { $ } from '../src/$.mjs';
+
+console.log('=== Property Check Debug ===');
+
+const cmd = $`echo "test"`;
+
+console.log(
+  'Object.getOwnPropertyDescriptor(cmd, "stdout"):',
+  Object.getOwnPropertyDescriptor(cmd, 'stdout')
+);
+
+console.log(
+  'Object.getOwnPropertyDescriptor(Object.getPrototypeOf(cmd), "stdout"):',
+  Object.getOwnPropertyDescriptor(Object.getPrototypeOf(cmd), 'stdout')
+);
+
+console.log('cmd.hasOwnProperty("stdout"):', cmd.hasOwnProperty('stdout'));
+
+console.log('cmd.stdout:', cmd.stdout);
+
+console.log('Getting property names:');
+console.log('Object.getOwnPropertyNames(cmd):');
+Object.getOwnPropertyNames(cmd).forEach((name) => {
+  if (name.includes('std')) {
+    console.log('  ', name, ':', cmd[name]);
+  }
+});