command-stream 0.8.2 → 0.9.0

package/js/examples/debug-simple.mjs

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+
+import { $, getAnsiConfig } from '../src/$.mjs';
+
+console.log('=== Simple ANSI Debug ===\n');
+
+console.log('1. Config check:');
+console.log('Global config:', getAnsiConfig());
+
+console.log('\n2. Direct terminal write test:');
+const testStr = '\x1b[31mRed text\x1b[0m normal';
+console.log('Writing directly to terminal:');
+process.stdout.write(`${testStr}\n`);
+
+console.log('\n3. jq command test:');
+const result = await $`echo '{"name": "test"}' | jq --color-output .`;
+console.log('Result stdout type:', typeof result.stdout);
+console.log('Result stdout raw bytes (first 50):');
+console.log(Buffer.from(result.stdout.slice(0, 50)));
+
+console.log('\nDirect write of result.stdout:');
+process.stdout.write(result.stdout);
+
+console.log('\n4. Manual event handling test:');
+const proc = $`echo '{"name": "test"}' | jq --color-output .`;
+
+proc.on('stdout', (chunk) => {
+  console.log('Event chunk type:', typeof chunk);
+  console.log('Event chunk constructor:', chunk.constructor.name);
+  console.log(
+    'Event chunk raw (first 30 bytes):',
+    Buffer.from(chunk.slice(0, 30))
+  );
+  console.log('Writing event chunk directly:');
+  process.stdout.write('[EVENT] ');
+  process.stdout.write(chunk);
+});
+
+await proc;

package/js/examples/debug-simplified-finished.mjs

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+
+import { $ } from '../src/$.mjs';
+
+console.log('=== Simplified Finished Field Test ===');
+
+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;
+}
+
+const tests = [
+  {
+    name: 'Normal completion with cleanup',
+    test: async () => {
+      console.log('  Before:', getSigintHandlerCount(), 'handlers');
+      const result = await $`echo "test"`;
+      console.log('  After:', getSigintHandlerCount(), 'handlers');
+      return {
+        stdout: result.stdout.trim(),
+        finished: result.constructor.name === 'Object', // This means it completed normally
+      };
+    },
+  },
+
+  {
+    name: 'Multiple finish() calls (idempotent)',
+    test: async () => {
+      const runner = $`echo "idempotent"`;
+      await runner;
+
+      console.log('  finished after normal completion:', runner.finished);
+
+      // Try to finish again
+      const result2 = runner.finish({
+        code: 999,
+        stdout: 'should not overwrite',
+        stderr: '',
+        stdin: '',
+      });
+
+      return {
+        finished: runner.finished,
+        stdout: runner.result.stdout.trim(),
+        returnedStdout: result2.stdout.trim(),
+        sameResult: runner.result.stdout === result2.stdout,
+      };
+    },
+  },
+
+  {
+    name: 'Kill scenario with cleanup',
+    test: async () => {
+      console.log('  Before kill:', getSigintHandlerCount(), 'handlers');
+
+      const runner = $`sleep 0.1`;
+      const promise = runner.start();
+
+      console.log('  During execution:', getSigintHandlerCount(), 'handlers');
+
+      await new Promise((resolve) => setTimeout(resolve, 10));
+      runner.kill('SIGTERM');
+
+      try {
+        await promise;
+      } catch (error) {
+        // Expected
+      }
+
+      console.log('  After kill:', getSigintHandlerCount(), 'handlers');
+
+      return {
+        finished: runner.finished,
+        code: runner.result.code,
+        killed: runner.result.stderr.includes('killed'),
+      };
+    },
+  },
+];
+
+console.log('\nTesting simplified finished field design...\n');
+
+for (const { name, test } of tests) {
+  console.log(`🧪 ${name}:`);
+  try {
+    const result = await test();
+    console.log('  ✅ Result:', JSON.stringify(result, null, 4));
+  } catch (error) {
+    console.log('  ❌ Error:', error.message);
+  }
+  console.log('');
+}
+
+console.log('=== Test completed ===');

package/js/examples/debug-stack-overflow.mjs

@@ -0,0 +1,25 @@
+import { $ } from '../src/$.mjs';
+
+async function debugStackOverflow() {
+  console.log('Testing simple echo command...');
+
+  try {
+    const result = await $`echo "test"`;
+    console.log('Success! Result:', JSON.stringify(result.stdout.trim()));
+  } catch (error) {
+    console.log('Error:', error.message);
+    console.log('Stack:', error.stack?.slice(0, 500));
+  }
+
+  console.log('\nTesting with strings.stdout access...');
+  try {
+    const cmd = $`echo "String test"`;
+    const str = await cmd.strings.stdout;
+    console.log('Success! String result:', JSON.stringify(str.trim()));
+  } catch (error) {
+    console.log('Error:', error.message);
+    console.log('Stack:', error.stack?.slice(0, 500));
+  }
+}
+
+debugStackOverflow().catch(console.error);

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

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+
+import { $ } from '../src/$.mjs';
+
+console.log('=== Debug: Simple stdin test ===');
+
+async function debugStdinSimple() {
+  console.log('Testing cat with explicit options...');
+
+  const cmd = $`cat`;
+  const stdin = cmd.streams.stdin;
+
+  console.log('Stdin available?', !!stdin);
+  console.log('Command started?', cmd.started);
+
+  if (stdin) {
+    console.log('Writing to stdin...');
+    stdin.write('test data\\n');
+    console.log('Ending stdin...');
+    stdin.end();
+  }
+
+  console.log('Waiting for result...');
+  const result = await cmd;
+  console.log('Result:', result);
+}
+
+debugStdinSimple().catch(console.error);

package/js/examples/debug-stdin.mjs

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+
+import { $ } from '../src/$.mjs';
+
+async function debugStdin() {
+  console.log('🐛 Debugging stdin streams');
+
+  const catCmd = $`cat`;
+  console.log('Created cat command');
+
+  console.log('Awaiting stdin...');
+  const stdin = await catCmd.streams.stdin;
+
+  console.log('stdin type:', typeof stdin);
+  console.log('stdin constructor:', stdin ? stdin.constructor.name : 'null');
+  console.log('has write method:', !!(stdin && stdin.write));
+  console.log('is writable:', stdin ? stdin.writable : 'N/A');
+  console.log('is destroyed:', stdin ? stdin.destroyed : 'N/A');
+
+  if (stdin) {
+    console.log('stdin keys:', Object.keys(stdin));
+  }
+
+  // Kill the process to clean up
+  catCmd.kill();
+}
+
+debugStdin();

package/js/examples/debug-stream-emitter-isolated.mjs

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+
+import { $ } from '../src/$.mjs';
+
+console.log('=== Isolated StreamEmitter Debug ===');
+
+const cmd = $`echo "test"`;
+
+// Let's debug the listeners map directly
+console.log('Initial listeners map:', cmd.listeners);
+
+cmd.on('data', () => console.log('DATA listener called'));
+console.log('After data listener:', cmd.listeners);
+
+cmd.on('end', () => console.log('END listener called'));
+console.log('After end listener:', cmd.listeners);
+
+cmd.on('exit', () => console.log('EXIT listener called'));
+console.log('After exit listener:', cmd.listeners);
+
+// Override emit to debug the listener lookup
+const originalEmit = cmd.emit.bind(cmd);
+cmd.emit = function (event, ...args) {
+  const listeners = this.listeners.get(event);
+  console.log(
+    `EMIT ${event}: found ${listeners ? listeners.length : 0} listeners`
+  );
+  if (listeners) {
+    console.log(`Listeners array:`, listeners);
+    for (let i = 0; i < listeners.length; i++) {
+      console.log(`Calling listener ${i} for ${event}`);
+      try {
+        listeners[i](...args);
+        console.log(`Listener ${i} for ${event} completed`);
+      } catch (e) {
+        console.log(`Listener ${i} for ${event} error:`, e.message);
+      }
+    }
+  }
+  return this;
+};
+
+console.log('\nStarting command...');
+await cmd;
+console.log('Command completed');

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

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+
+process.env.COMMAND_STREAM_VERBOSE = 'true';
+
+import { $ } from '../src/$.mjs';
+
+console.log('=== StreamEmitter Debug ===');
+
+const cmd = $`echo "test"`;
+
+cmd.on('data', (chunk) => {
+  console.log('[LISTENER] data received:', chunk.type);
+});
+
+cmd.on('end', (result) => {
+  console.log('[LISTENER] end received:', result.code);
+});
+
+cmd.on('exit', (code) => {
+  console.log('[LISTENER] exit received:', code);
+});
+
+console.log('Starting await...');
+await cmd;
+console.log('Await completed');

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

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+
+import { $ } from '../src/$.mjs';
+
+console.log('=== Stream Events Debug ===');
+
+console.log('Testing with manual event handlers:');
+const cmd = $`echo "hello world"`;
+
+cmd.on('data', (chunk) => {
+  console.log(
+    'Event: data',
+    chunk.type,
+    JSON.stringify(chunk.data.toString().trim())
+  );
+});
+
+cmd.on('stdout', (chunk) => {
+  console.log('Event: stdout', JSON.stringify(chunk.toString().trim()));
+});
+
+cmd.on('stderr', (chunk) => {
+  console.log('Event: stderr', JSON.stringify(chunk.toString().trim()));
+});
+
+cmd.on('end', (result) => {
+  console.log('Event: end', {
+    code: result.code,
+    stdout: JSON.stringify(result.stdout.trim()),
+    stderr: JSON.stringify(result.stderr.trim()),
+  });
+});
+
+cmd.on('exit', (code) => {
+  console.log('Event: exit', code);
+});
+
+console.log('Starting command...');
+const result = await cmd;
+console.log('Command completed with code:', result.code);
+
+console.log('=== Stream Iterator Debug ===');
+console.log('Now testing stream iterator:');
+
+const cmd2 = $`echo "test stream"`;
+let chunkCount = 0;
+const startTime = Date.now();
+
+try {
+  for await (const chunk of cmd2.stream()) {
+    chunkCount++;
+    const elapsed = Date.now() - startTime;
+    console.log(
+      `Stream chunk ${chunkCount} at ${elapsed}ms:`,
+      chunk.type,
+      JSON.stringify(chunk.data.toString().trim())
+    );
+
+    // Safety break to prevent infinite loop
+    if (chunkCount >= 5) {
+      console.log('Safety break activated');
+      break;
+    }
+  }
+  console.log('Stream iterator completed naturally');
+} catch (error) {
+  console.log('Stream iterator error:', error.message);
+}
+
+console.log('Debug completed!');

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

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+
+import { $ } from '../src/$.mjs';
+
+console.log('=== Stream Generator Debug ===');
+
+const cmd = $`echo "test"`;
+
+cmd.on('data', () => console.log('DATA listener called'));
+cmd.on('end', () => console.log('END listener called'));
+cmd.on('exit', () => console.log('EXIT listener called'));
+
+console.log('Listeners before getting stream generator:', cmd.listeners.size);
+
+// Get the stream generator (this is what might be triggering the issue)
+const streamGenerator = cmd.stream();
+
+console.log('Listeners after getting stream generator:', cmd.listeners.size);
+
+// Don't iterate the generator, just await the command
+await cmd;
+
+console.log('Listeners after await:', cmd.listeners.size);

package/js/examples/debug-stream-getter-issue.mjs

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+
+import { $, disableVirtualCommands } from '../src/$.mjs';
+
+console.log('=== Stream Getter Issue Debug ===');
+
+// Test the exact same scenario as the failing test
+disableVirtualCommands();
+
+const process = $`echo "stream test"`;
+process.start();
+
+// Wait longer for child process initialization
+await new Promise((resolve) => setTimeout(resolve, 100));
+
+console.log('process.child:', process.child);
+console.log('process.child === null:', process.child === null);
+console.log('process.child === undefined:', process.child === undefined);
+
+console.log('Checking getter logic step by step:');
+console.log('this.child ? this.child.stdout : null');
+
+if (process.child) {
+  console.log('Branch: this.child is truthy');
+  console.log('this.child.stdout:', process.child.stdout);
+  console.log('returning this.child.stdout');
+} else {
+  console.log('Branch: this.child is falsy');
+  console.log('returning null');
+}
+
+console.log('process.stdout:', process.stdout);
+console.log('process.stdout === null:', process.stdout === null);
+console.log('process.stdout === undefined:', process.stdout === undefined);
+console.log('typeof process.stdout:', typeof process.stdout);
+
+await process;

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

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+
+import { $, disableVirtualCommands } from '../src/$.mjs';
+
+console.log('=== Stream Getter Debug ===');
+
+disableVirtualCommands();
+const cmd = $`echo "test"`;
+cmd.start();
+await new Promise((resolve) => setTimeout(resolve, 100));
+
+console.log('child:', cmd.child);
+console.log('child type:', typeof cmd.child);
+console.log('stdout:', cmd.stdout);
+console.log('stdout type:', typeof cmd.stdout);
+console.log('stdout === null:', cmd.stdout === null);
+console.log('stdout === undefined:', cmd.stdout === undefined);
+
+await cmd;

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

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+
+import { $ } from '../src/$.mjs';
+
+console.log('=== Stream Internals Debug ===');
+
+const cmd = $`sh -c 'echo "test"'`;
+
+// Instrument the stream method to see internal state
+const originalStream = cmd.stream.bind(cmd);
+cmd.stream = function () {
+  console.log('stream() called');
+
+  const generator = originalStream();
+
+  // Override the generator's next method to log state changes
+  const originalNext = generator.next.bind(generator);
+  generator.next = function () {
+    console.log('generator.next() called');
+    const promise = originalNext();
+
+    promise
+      .then((result) => {
+        console.log('generator.next() resolved:', {
+          done: result.done,
+          hasValue: !!result.value,
+          valueType: result.value?.type,
+        });
+      })
+      .catch((err) => {
+        console.log('generator.next() error:', err.message);
+      });
+
+    return promise;
+  };
+
+  return generator;
+};
+
+console.log('Starting stream test...');
+
+const timeout = setTimeout(() => {
+  console.log('TIMEOUT: Stream test took too long');
+  process.exit(1);
+}, 3000);
+
+try {
+  let count = 0;
+  for await (const chunk of cmd.stream()) {
+    count++;
+    console.log(`Received chunk ${count}:`, chunk.type);
+
+    if (count >= 2) {
+      console.log('Breaking after 2 chunks');
+      break;
+    }
+  }
+
+  clearTimeout(timeout);
+  console.log('Stream test completed with', count, 'chunks');
+} catch (error) {
+  clearTimeout(timeout);
+  console.log('Stream test error:', error.message);
+}

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

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+
+import { $ } from '../src/$.mjs';
+
+console.log('=== Stream Method Debug ===');
+
+const cmd = $`echo "test"`;
+
+console.log('Getting stream generator...');
+const stream = cmd.stream();
+
+console.log('Starting iteration...');
+let chunkCount = 0;
+
+// Set a timeout to prevent infinite hang
+const timeout = setTimeout(() => {
+  console.log('TIMEOUT: Stream iteration took too long');
+  process.exit(1);
+}, 5000);
+
+try {
+  for await (const chunk of stream) {
+    chunkCount++;
+    console.log(
+      `Chunk ${chunkCount}:`,
+      chunk.type,
+      JSON.stringify(chunk.data.toString().trim())
+    );
+
+    // Safety break
+    if (chunkCount >= 3) {
+      console.log('Safety break after 3 chunks');
+      break;
+    }
+  }
+
+  clearTimeout(timeout);
+  console.log(
+    'Stream iteration completed naturally with',
+    chunkCount,
+    'chunks'
+  );
+} catch (error) {
+  clearTimeout(timeout);
+  console.log('Stream iteration error:', error.message);
+}

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

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+
+import { $ } from '../src/$.mjs';
+
+async function debugStreamObject() {
+  console.log('=== Debug stream object details ===');
+
+  const cmd = $`cat`;
+
+  console.log('Before accessing streams:');
+  console.log('  started:', cmd.started);
+  console.log('  child:', !!cmd.child);
+
+  const stdin = await cmd.streams.stdin;
+
+  console.log('\\nAfter accessing streams:');
+  console.log('  started:', cmd.started);
+  console.log('  child:', !!cmd.child);
+  console.log('  stdin type:', typeof stdin);
+  console.log('  stdin is null?', stdin === null);
+  console.log('  stdin constructor:', stdin ? stdin.constructor.name : 'N/A');
+
+  if (stdin) {
+    console.log(
+      '  stdin methods:',
+      Object.getOwnPropertyNames(stdin)
+        .filter((name) => typeof stdin[name] === 'function')
+        .slice(0, 10)
+    );
+    console.log('  writable?', stdin.writable);
+    console.log('  destroyed?', stdin.destroyed);
+  }
+
+  if (cmd.child) {
+    console.log('\\nChild process details:');
+    console.log('  child.stdin type:', typeof cmd.child.stdin);
+    console.log('  child.stdin === stdin?', cmd.child.stdin === stdin);
+    console.log(
+      '  child.stdin writable?',
+      cmd.child.stdin ? cmd.child.stdin.writable : 'N/A'
+    );
+  }
+
+  // Try to write anyway
+  if (stdin && stdin.write) {
+    console.log('\\nWriting to stdin...');
+    stdin.write('test data\\n');
+    stdin.end();
+  } else {
+    console.log('\\nCannot write to stdin, ending command');
+    cmd.kill();
+  }
+
+  const result = await cmd;
+  console.log('\\nResult:', result);
+}
+
+debugStreamObject().catch(console.error);

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

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+
+import { $, disableVirtualCommands } from '../src/$.mjs';
+
+console.log('=== Stream Properties Debug ===');
+
+console.log('1. Testing with virtual commands (default):');
+const cmd1 = $`echo "test1"`;
+cmd1.start();
+await new Promise((resolve) => setTimeout(resolve, 20));
+console.log(
+  'Virtual - stdout:',
+  !!cmd1.stdout,
+  'stderr:',
+  !!cmd1.stderr,
+  'stdin:',
+  !!cmd1.stdin
+);
+console.log('Virtual - child:', !!cmd1.child);
+await cmd1;
+
+console.log('\n2. Testing with real commands:');
+disableVirtualCommands();
+const cmd2 = $`echo "test2"`;
+cmd2.start();
+await new Promise((resolve) => setTimeout(resolve, 20));
+console.log(
+  'Real - stdout:',
+  !!cmd2.stdout,
+  'stderr:',
+  !!cmd2.stderr,
+  'stdin:',
+  !!cmd2.stdin
+);
+console.log('Real - child:', !!cmd2.child);
+console.log('Real - child.stdout:', !!cmd2.child?.stdout);
+await cmd2;

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

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+
+import { $, disableVirtualCommands } from '../src/$.mjs';
+
+console.log('=== Stream Timing Debug ===');
+
+disableVirtualCommands();
+const cmd = $`echo "test"`;
+cmd.start();
+
+console.log('Immediately after start:');
+console.log('child:', cmd.child);
+console.log('stdout:', cmd.stdout);
+
+await new Promise((resolve) => setTimeout(resolve, 50));
+console.log('After 50ms:');
+console.log('child:', cmd.child);
+console.log('stdout:', cmd.stdout);
+
+await new Promise((resolve) => setTimeout(resolve, 100));
+console.log('After 150ms total:');
+console.log('child:', cmd.child);
+console.log('stdout:', cmd.stdout);
+
+await cmd;
+console.log('After await:');
+console.log('child:', cmd.child);
+console.log('stdout:', cmd.stdout);