command-stream 0.8.2 → 0.9.0

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

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+
+import { $ } from '../src/$.mjs';
+
+async function debugChildProcess() {
+  console.log('🐛 Debugging child process creation');
+
+  const catCmd = $`cat`;
+  console.log('1. Created cat command');
+  console.log('   started:', catCmd.started);
+  console.log('   finished:', catCmd.finished);
+  console.log('   child:', !!catCmd.child);
+
+  console.log('2. Accessing streams.stdin (should trigger auto-start)...');
+  const stdinPromise = catCmd.streams.stdin;
+  console.log('   stdinPromise:', typeof stdinPromise);
+  console.log('   started after access:', catCmd.started);
+  console.log('   child after access:', !!catCmd.child);
+
+  // Wait a bit for the process to start
+  await new Promise((resolve) => setTimeout(resolve, 100));
+
+  console.log('3. After 100ms wait:');
+  console.log('   started:', catCmd.started);
+  console.log('   child:', !!catCmd.child);
+  console.log(
+    '   child.stdin:',
+    catCmd.child ? typeof catCmd.child.stdin : 'no child'
+  );
+
+  console.log('4. Awaiting stdin promise...');
+  const stdin = await stdinPromise;
+
+  console.log('5. Stdin resolved:');
+  console.log('   stdin type:', typeof stdin);
+  console.log('   stdin value:', stdin);
+  console.log('   has write method:', !!(stdin && stdin.write));
+
+  // Clean up
+  catCmd.kill();
+}
+
+debugChildProcess();

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

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+
+import { $ } from '../src/$.mjs';
+
+async function debugChildState() {
+  const cmd = $`cat`;
+
+  console.log('0ms - Initial state:');
+  console.log(
+    '  started:',
+    cmd.started,
+    'finished:',
+    cmd.finished,
+    'child:',
+    !!cmd.child
+  );
+
+  // Trigger start
+  cmd.streams.stdout;
+
+  console.log('0ms - After triggering start:');
+  console.log(
+    '  started:',
+    cmd.started,
+    'finished:',
+    cmd.finished,
+    'child:',
+    !!cmd.child
+  );
+
+  // Check state every 25ms
+  for (let i = 1; i <= 10; i++) {
+    await new Promise((resolve) => setTimeout(resolve, 25));
+    console.log(`${i * 25}ms - state:`, {
+      started: cmd.started,
+      finished: cmd.finished,
+      child: !!cmd.child,
+      stdin: !!(cmd.child && cmd.child.stdin),
+    });
+
+    if (cmd.finished) {
+      console.log('Process finished early!');
+      break;
+    }
+  }
+
+  // Try one final time
+  const stdin = cmd.streams.stdin;
+  console.log('Final stdin check:', !!stdin);
+
+  const result = await cmd;
+  console.log('Final result:', result.stdout, 'code:', result.code);
+}
+
+debugChildState().catch(console.error);

package/js/examples/debug-chunking.mjs

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+
+import { $ } from '../src/$.mjs';
+
+const claude = 'claude';
+console.log('🐛 Debug chunking test');
+
+let events = 0;
+let totalData = '';
+
+const command = $`${claude} -p "hi" --output-format stream-json --verbose --model sonnet`;
+
+command
+  .on('data', (chunk) => {
+    events++;
+    const data = chunk.data.toString();
+    console.log(`\n📦 Chunk ${events} (${data.length} bytes):`);
+    console.log(`"${data}"`);
+    totalData += data;
+  })
+  .on('end', (result) => {
+    console.log(
+      `\n✅ Done: ${events} chunks, ${totalData.length} total bytes, exit: ${result.code}`
+    );
+    process.exit(0);
+  })
+  .on('error', (error) => {
+    console.log('❌ Error:', error);
+    process.exit(1);
+  });
+
+// Timeout after 15 seconds
+setTimeout(() => {
+  console.log(`\n⏰ Timeout: ${events} chunks received so far`);
+  process.exit(0);
+}, 15000);
+
+command.start();

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

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+
+// Debug command parsing
+import { $ } from '../src/$.mjs';
+
+// Enable verbose mode
+process.env.COMMAND_STREAM_VERBOSE = 'true';
+
+console.log('=== Command Parsing Debug ===');
+console.log(
+  `Runtime: ${typeof globalThis.Bun !== 'undefined' ? 'Bun' : 'Node.js'}`
+);
+
+// Test different command formats
+const testCommands = [
+  'echo hello',
+  'echo "hello world"',
+  'ls -la',
+  'pwd',
+  'cat /etc/passwd | head -5', // This should trigger needsShell=true
+];
+
+for (const cmdStr of testCommands) {
+  console.log(`\n--- Testing: ${cmdStr} ---`);
+
+  // Let's manually check what parseShellCommand returns
+  const { parseShellCommand, needsRealShell } =
+    await import('../src/shell-parser.mjs');
+
+  const parsed = parseShellCommand(cmdStr);
+  const needsRealShellResult = needsRealShell(cmdStr);
+
+  console.log(`Parsed result:`, JSON.stringify(parsed, null, 2));
+  console.log(`needsRealShell:`, needsRealShellResult);
+
+  // Check needsShell logic from the main code
+  const needsShell =
+    cmdStr.includes('*') ||
+    cmdStr.includes('$') ||
+    cmdStr.includes('>') ||
+    cmdStr.includes('<') ||
+    cmdStr.includes('&&') ||
+    cmdStr.includes('||') ||
+    cmdStr.includes(';') ||
+    cmdStr.includes('`');
+
+  console.log(`needsShell (from main logic):`, needsShell);
+
+  try {
+    const result = await $`${cmdStr}`;
+    console.log(`✓ Success: ${result.stdout.toString().trim()}`);
+  } catch (error) {
+    console.log(`✗ Failed: ${error.message}`);
+    if (error.code) {
+      console.log(`  Code: ${error.code}`);
+    }
+    if (error.stderr) {
+      console.log(`  Stderr: ${error.stderr.toString().trim()}`);
+    }
+  }
+}

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

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+
+import { $ } from '../src/$.mjs';
+
+console.log('=== Complete Finish Method Consolidation Test ===');
+
+const tests = [
+  {
+    name: 'Normal completion',
+    test: async () => {
+      const result = await $`echo "normal"`;
+      return { stdout: result.stdout.trim(), code: result.code };
+    },
+  },
+
+  {
+    name: 'Sync mode',
+    test: async () => {
+      const result = $`echo "sync"`.sync();
+      return { stdout: result.stdout.trim(), code: result.code };
+    },
+  },
+
+  {
+    name: 'Error handling',
+    test: async () => {
+      try {
+        await $`exit 1`;
+        return { error: 'Expected error but got success' };
+      } catch (error) {
+        return { code: error.code, stdout: error.stdout.trim() };
+      }
+    },
+  },
+
+  {
+    name: 'Pipeline with error',
+    test: async () => {
+      try {
+        await $`echo "test" | exit 1`;
+        return { error: 'Expected error but got success' };
+      } catch (error) {
+        return { code: error.code, stdout: error.stdout.trim() };
+      }
+    },
+  },
+
+  {
+    name: 'Kill scenario',
+    test: async () => {
+      const runner = $`sleep 0.1`;
+      const promise = runner.start();
+
+      // Let it start
+      await new Promise((resolve) => setTimeout(resolve, 10));
+
+      runner.kill('SIGTERM');
+
+      try {
+        await promise;
+        return { error: 'Expected error but got success' };
+      } catch (error) {
+        return { code: error.code, stderr: error.stderr.trim() };
+      }
+    },
+  },
+
+  {
+    name: 'Finally handler',
+    test: async () => {
+      let finallyExecuted = false;
+
+      const result = await $`echo "finally"`.finally(() => {
+        finallyExecuted = true;
+      });
+
+      return {
+        stdout: result.stdout.trim(),
+        code: result.code,
+        finallyExecuted,
+      };
+    },
+  },
+];
+
+console.log('\nRunning comprehensive tests...\n');
+
+for (const { name, test } of tests) {
+  try {
+    const result = await test();
+    console.log(`✅ ${name}:`, JSON.stringify(result, null, 2));
+  } catch (error) {
+    console.log(`❌ ${name}:`, error.message);
+  }
+}
+
+console.log('\n=== All tests completed ===');

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

@@ -0,0 +1,22 @@
+import { $ } from '../src/$.mjs';
+
+async function debugEchoArgs() {
+  console.log('=== Debug Echo Args ===');
+
+  // Test the exact same interpolation as the failing test
+  const name = 'World';
+  const $custom = $({ capture: true, mirror: false });
+
+  console.log('About to run: echo Hello, ${name}!');
+  console.log('Where name =', JSON.stringify(name));
+  console.log("This should build command: echo Hello, 'World'!");
+
+  const result = await $custom`echo Hello, ${name}!`;
+
+  console.log('Result stdout:', JSON.stringify(result.stdout));
+  console.log('Result stdout trimmed:', JSON.stringify(result.stdout.trim()));
+  console.log('Expected by test:', JSON.stringify('Hello, World!'));
+  console.log('Test passes:', result.stdout.trim() === 'Hello, World!');
+}
+
+debugEchoArgs().catch(console.error);

package/js/examples/debug-emit-timing.mjs

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+
+import { $ } from '../src/$.mjs';
+
+console.log('=== Emit Timing Debug ===');
+
+const cmd = $`echo "test"`;
+
+// Track when listeners are called
+cmd.on('data', () => console.log('LISTENER: data event at', Date.now()));
+cmd.on('end', () => console.log('LISTENER: end event at', Date.now()));
+cmd.on('exit', () => console.log('LISTENER: exit event at', Date.now()));
+
+// Override emit to see exact timing
+const originalEmit = cmd.emit.bind(cmd);
+cmd.emit = function (event, ...args) {
+  console.log(`EMIT: ${event} event at ${Date.now()}`);
+  return originalEmit(event, ...args);
+};
+
+console.log('Starting await at', Date.now());
+const result = await cmd;
+console.log('Await completed at', Date.now(), 'with code', result.code);
+
+// Wait a bit to see if events come later
+setTimeout(() => {
+  console.log('Timeout check at', Date.now());
+}, 100);

package/js/examples/debug-end-event.mjs

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+
+import { $ } from '../src/$.mjs';
+
+console.log('=== End Event Debug ===');
+
+console.log('1. Testing await pattern with events:');
+const cmd1 = $`echo "test1"`;
+let endEventFired = false;
+
+cmd1.on('end', (result) => {
+  endEventFired = true;
+  console.log('END event fired for await pattern');
+});
+
+const result1 = await cmd1;
+console.log('Await completed. End event fired?', endEventFired);
+
+console.log('2. Testing stream pattern with events:');
+const cmd2 = $`echo "test2"`;
+let streamEndEventFired = false;
+const streamChunks = [];
+
+cmd2.on('end', (result) => {
+  streamEndEventFired = true;
+  console.log('END event fired for stream pattern');
+});
+
+console.log('Starting stream iteration...');
+try {
+  // Set a timeout to break out of infinite loop
+  const timeoutPromise = new Promise((_, reject) => {
+    setTimeout(() => reject(new Error('Stream timeout')), 2000);
+  });
+
+  const streamPromise = (async () => {
+    for await (const chunk of cmd2.stream()) {
+      streamChunks.push(chunk);
+      console.log('Stream chunk received:', chunk.type);
+
+      // Check if end event fired after receiving chunks
+      console.log('End event fired yet?', streamEndEventFired);
+    }
+  })();
+
+  await Promise.race([streamPromise, timeoutPromise]);
+  console.log('Stream completed normally');
+} catch (error) {
+  console.log('Stream timed out:', error.message);
+}
+
+console.log('Final state:');
+console.log('- Stream chunks received:', streamChunks.length);
+console.log('- End event fired?', streamEndEventFired);
+
+console.log('Debug completed!');

package/js/examples/debug-errexit.mjs

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+
+import { $, enableErrExit } from '../src/$.mjs';
+
+console.log('=== Errexit Test ===');
+
+enableErrExit();
+
+try {
+  await $`exit 1`;
+  console.log('ERROR: Should have thrown');
+} catch (error) {
+  console.log('✅ Properly caught error:', error.code);
+}
+
+console.log('Errexit test completed.');

package/js/examples/debug-event-emission.mjs

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+
+import { $, disableVirtualCommands } from '../src/$.mjs';
+
+console.log('=== Event Emission Debug ===');
+
+// Override emit to trace when events are emitted
+function instrumentEmitter(cmd, label) {
+  const originalEmit = cmd.emit.bind(cmd);
+  cmd.emit = function (event, ...args) {
+    console.log(`[${label}] EMIT: ${event}`, args.length > 0 ? args[0] : '');
+    return originalEmit(event, ...args);
+  };
+}
+
+async function testWithInstrumentation() {
+  console.log('\n1. Virtual echo with emit tracing:');
+  const virtualCmd = $`echo "virtual"`;
+  instrumentEmitter(virtualCmd, 'VIRTUAL');
+
+  virtualCmd.on('data', () => console.log('[VIRTUAL] RECEIVED: data'));
+  virtualCmd.on('end', () => console.log('[VIRTUAL] RECEIVED: end'));
+  virtualCmd.on('exit', () => console.log('[VIRTUAL] RECEIVED: exit'));
+
+  await virtualCmd;
+
+  console.log('\n2. Real echo with emit tracing:');
+  disableVirtualCommands();
+  const realCmd = $`echo "real"`;
+  instrumentEmitter(realCmd, 'REAL');
+
+  realCmd.on('data', () => console.log('[REAL] RECEIVED: data'));
+  realCmd.on('end', () => console.log('[REAL] RECEIVED: end'));
+  realCmd.on('exit', () => console.log('[REAL] RECEIVED: exit'));
+
+  await realCmd;
+}
+
+await testWithInstrumentation();
+console.log('\nDebug completed!');

package/js/examples/debug-event-timing.mjs

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+
+import { $, disableVirtualCommands } from '../src/$.mjs';
+
+console.log('=== Event Timing Debug ===');
+
+// Enable verbose tracing to see what's happening inside
+process.env.COMMAND_STREAM_VERBOSE = 'true';
+
+async function testVirtualCommand() {
+  console.log('\n1. Testing VIRTUAL echo command:');
+  const cmd = $`echo "virtual test"`;
+
+  const events = [];
+  cmd.on('data', (chunk) => events.push(`data:${chunk.type}`));
+  cmd.on('end', (result) => events.push(`end:${result.code}`));
+  cmd.on('exit', (code) => events.push(`exit:${code}`));
+
+  console.log('Events before await:', events);
+  const result = await cmd;
+  console.log('Events after await:', events);
+  console.log(
+    'Result:',
+    result.code,
+    JSON.stringify(result.stdout?.trim() || '')
+  );
+
+  return events;
+}
+
+async function testRealCommand() {
+  console.log('\n2. Testing REAL echo command:');
+  disableVirtualCommands();
+  const cmd = $`echo "real test"`;
+
+  const events = [];
+  cmd.on('data', (chunk) => events.push(`data:${chunk.type}`));
+  cmd.on('end', (result) => events.push(`end:${result.code}`));
+  cmd.on('exit', (code) => events.push(`exit:${code}`));
+
+  console.log('Events before await:', events);
+  const result = await cmd;
+  console.log('Events after await:', events);
+  console.log(
+    'Result:',
+    result.code,
+    JSON.stringify(result.stdout?.trim() || '')
+  );
+
+  return events;
+}
+
+const virtualEvents = await testVirtualCommand();
+const realEvents = await testRealCommand();
+
+console.log('\n=== COMPARISON ===');
+console.log('Virtual events:', virtualEvents);
+console.log('Real events:', realEvents);
+
+const match = JSON.stringify(virtualEvents) === JSON.stringify(realEvents);
+console.log('Events match:', match);
+
+if (!match) {
+  console.log('❌ Virtual and real commands emit different events!');
+} else {
+  console.log('✅ Virtual and real commands emit same events!');
+}

package/js/examples/debug-event-vs-result.mjs

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+
+import { $ } from '../src/$.mjs';
+
+console.log('=== Event vs Result Comparison ===\n');
+
+console.log('1. Using await result (final result):');
+const result1 = await $`echo '{"test": "result"}' | jq --color-output .`;
+console.log('Final result:');
+process.stdout.write(result1.stdout);
+console.log('Result bytes:', Buffer.from(result1.stdout.slice(0, 30)));
+
+console.log('\n2. Using stdout events (streaming):');
+const proc2 = $`echo '{"test": "events"}' | jq --color-output .`;
+
+console.log('Event output:');
+proc2.on('stdout', (chunk) => {
+  console.log('Event chunk type:', typeof chunk, chunk.constructor.name);
+  console.log('Event chunk bytes:', Buffer.from(chunk.slice(0, 30)));
+  console.log('Event chunk content:');
+  process.stdout.write(chunk);
+  console.log('---');
+});
+
+const result2 = await proc2;
+
+console.log('\n3. Comparison:');
+console.log('Final result from streaming proc:');
+process.stdout.write(result2.stdout);
+console.log('Final result bytes:', Buffer.from(result2.stdout.slice(0, 30)));

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

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+
+import { $ } from '../src/$.mjs';
+
+console.log('=== Testing Exact Command from jq-colors-streaming.mjs ===\n');
+
+const coloredCmd = $`printf '{"name":"Alice","status":"active","score":95}\n{"name":"Bob","status":"inactive","score":87}\n{"name":"Carol","status":"active","score":92}\n' | jq --color-output .`;
+
+console.log('Raw streaming output:');
+coloredCmd.on('stdout', (chunk) => {
+  console.log('CHUNK TYPE:', typeof chunk, chunk.constructor.name);
+  console.log('CHUNK BYTES (first 50):', Buffer.from(chunk.slice(0, 50)));
+  console.log('CHUNK CONTENT:');
+  process.stdout.write('>>> ');
+  process.stdout.write(chunk);
+  console.log('<<<');
+});
+
+const result = await coloredCmd;
+
+console.log('\nFinal result:');
+console.log('RESULT TYPE:', typeof result.stdout);
+console.log(
+  'RESULT BYTES (first 50):',
+  Buffer.from(result.stdout.slice(0, 50))
+);
+console.log('RESULT CONTENT:');
+process.stdout.write(result.stdout);

package/js/examples/debug-exact-test-scenario.mjs

@@ -0,0 +1,44 @@
+#!/usr/bin/env bun
+// Exact replica of the failing test scenario
+
+import { $ } from '../src/$.mjs';
+
+// Enable verbose mode
+process.env.COMMAND_STREAM_VERBOSE = 'true';
+
+let cleanupDone = false;
+
+// Exact same handler as in the test
+process.on('SIGINT', async () => {
+  console.log('CHILD_CLEANUP_START');
+  // Simulate cleanup work
+  await new Promise((resolve) => setTimeout(resolve, 100));
+  cleanupDone = true;
+  console.log('CHILD_CLEANUP_DONE');
+  process.exit(0); // Exit cleanly after cleanup
+});
+
+console.log('CHILD_READY');
+
+// Run a command that will receive SIGINT forwarding
+try {
+  const sleepPromise = $`sleep 5`.start();
+
+  // Send SIGINT to ourselves after a short delay (simulating the test)
+  setTimeout(() => {
+    console.log('Sending SIGINT...');
+    process.kill(process.pid, 'SIGINT');
+  }, 500);
+
+  await sleepPromise;
+} catch (error) {
+  console.log('SLEEP_INTERRUPTED');
+  console.log('Error details:', {
+    message: error.message,
+    code: error.code,
+    constructor: error.constructor.name,
+  });
+}
+
+// This should not be reached
+console.log('End of script reached (should not happen)');

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

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+
+// Debug execution path to see exactly what's happening
+import { $ } from '../src/$.mjs';
+
+// Enable verbose mode to see detailed tracing
+process.env.COMMAND_STREAM_VERBOSE = 'true';
+
+console.log('=== Execution Path Debug ===');
+console.log(
+  `Runtime: ${typeof globalThis.Bun !== 'undefined' ? 'Bun' : 'Node.js'}`
+);
+
+console.log('\n--- Testing simple command: echo hello ---');
+
+try {
+  const result = await $`echo hello`;
+  console.log(`✓ Success: "${result.stdout.toString().trim()}"`);
+} catch (error) {
+  console.log(`✗ Failed: ${error.message}`);
+  if (error.code) {
+    console.log(`  Code: ${error.code}`);
+  }
+  if (error.stderr) {
+    console.log(`  Stderr: ${error.stderr.toString().trim()}`);
+  }
+}