command-stream 0.8.2 → 0.9.0

package/js/examples/test-runner-simple.mjs

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+
+/**
+ * Simple test runner that runs all tests individually and reports results
+ */
+
+import { execSync } from 'child_process';
+import { readdirSync } from 'fs';
+import { join } from 'path';
+
+const testsDir = join(process.cwd(), 'tests');
+const testFiles = readdirSync(testsDir)
+  .filter((f) => f.endsWith('.test.mjs'))
+  .sort();
+
+console.log(`🧪 Running ${testFiles.length} test files individually...\n`);
+
+let totalPass = 0;
+let totalFail = 0;
+const failedFiles = [];
+
+for (const file of testFiles) {
+  const filePath = join(testsDir, file);
+
+  try {
+    // Run test synchronously and capture output
+    const output = execSync(`bun test ${filePath} 2>&1`, { encoding: 'utf-8' });
+
+    // Parse the output to find pass/fail counts
+    const passMatch = output.match(/(\d+)\s+pass/);
+    const failMatch = output.match(/(\d+)\s+fail/);
+
+    const pass = passMatch ? parseInt(passMatch[1]) : 0;
+    const fail = failMatch ? parseInt(failMatch[1]) : 0;
+
+    totalPass += pass;
+    totalFail += fail;
+
+    if (fail > 0) {
+      console.log(`❌ ${file}: ${pass} pass, ${fail} fail`);
+      failedFiles.push(file);
+    } else {
+      console.log(`✅ ${file}: ${pass} pass`);
+    }
+  } catch (error) {
+    // Test failed to run or had non-zero exit
+    const output = error.stdout || '';
+    const passMatch = output.match(/(\d+)\s+pass/);
+    const failMatch = output.match(/(\d+)\s+fail/);
+
+    const pass = passMatch ? parseInt(passMatch[1]) : 0;
+    const fail = failMatch ? parseInt(failMatch[1]) : 0;
+
+    totalPass += pass;
+    totalFail += fail;
+
+    if (fail > 0) {
+      console.log(`❌ ${file}: ${pass} pass, ${fail} fail`);
+      failedFiles.push(file);
+    } else {
+      console.log(`⚠️  ${file}: Error running test`);
+      failedFiles.push(file);
+    }
+  }
+}
+
+console.log(`\n${'='.repeat(60)}`);
+console.log('📊 Summary:');
+console.log(`   Total tests passed: ${totalPass}`);
+console.log(`   Total tests failed: ${totalFail}`);
+console.log(`   Files with failures: ${failedFiles.length}`);
+
+if (failedFiles.length > 0) {
+  console.log('\n❌ Failed test files:');
+  failedFiles.forEach((f) => console.log(`   - ${f}`));
+  process.exit(1);
+} else {
+  console.log('\n✅ All tests passed!');
+  process.exit(0);
+}

package/js/examples/test-runner.mjs

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+
+/**
+ * Test runner that runs all tests individually and reports results
+ * This helps identify test issues and ensures all tests pass in isolation
+ */
+
+import { $ } from '../src/$.mjs';
+import { readdirSync } from 'fs';
+import { join, basename } from 'path';
+
+const testsDir = join(process.cwd(), 'tests');
+const testFiles = readdirSync(testsDir)
+  .filter((f) => f.endsWith('.test.mjs'))
+  .sort();
+
+console.log(`\n🧪 Running ${testFiles.length} test files individually...\n`);
+
+let totalPass = 0;
+let totalFail = 0;
+const failedFiles = [];
+
+for (const file of testFiles) {
+  const filePath = join(testsDir, file);
+
+  try {
+    // Run the test and capture output
+    const result = await $`bun test ${filePath}`;
+
+    // Parse the output to find pass/fail counts
+    const output = result.stdout;
+    const passMatch = output.match(/(\d+)\s+pass/);
+    const failMatch = output.match(/(\d+)\s+fail/);
+
+    const pass = passMatch ? parseInt(passMatch[1]) : 0;
+    const fail = failMatch ? parseInt(failMatch[1]) : 0;
+
+    totalPass += pass;
+    totalFail += fail;
+
+    if (fail > 0) {
+      console.log(`❌ ${file}: ${pass} pass, ${fail} fail`);
+      failedFiles.push(file);
+    } else {
+      console.log(`✅ ${file}: ${pass} pass`);
+    }
+  } catch (error) {
+    console.log(`⚠️  ${file}: Error running test`);
+    console.error(`   ${error.message}`);
+    failedFiles.push(file);
+  }
+}
+
+console.log(`\n${'='.repeat(60)}`);
+console.log('📊 Summary:');
+console.log(`   Total tests passed: ${totalPass}`);
+console.log(`   Total tests failed: ${totalFail}`);
+console.log(`   Files with failures: ${failedFiles.length}`);
+
+if (failedFiles.length > 0) {
+  console.log('\n❌ Failed test files:');
+  failedFiles.forEach((f) => console.log(`   - ${f}`));
+  process.exit(1);
+} else {
+  console.log('\n✅ All tests passed!');
+  process.exit(0);
+}

package/js/examples/test-scope-parse.mjs

@@ -0,0 +1,31 @@
+const testOutput = "Token scopes: 'gist', 'read:org', 'repo'";
+
+// Try the current regex
+const scopesMatch = testOutput.match(
+  /Token scopes:\s*'([^']+)'|Token scopes:\s*([^\n]+)/
+);
+console.log('Match result:', scopesMatch);
+
+if (scopesMatch) {
+  const scopesStr = scopesMatch[1] || scopesMatch[2];
+  console.log('Captured string:', scopesStr);
+
+  // The issue: we're only capturing the first quoted item
+  // We need to capture the entire line after "Token scopes:"
+}
+
+// Better approach - capture everything after Token scopes:
+const betterMatch = testOutput.match(/Token scopes:\s*(.+)/);
+console.log('\nBetter match:', betterMatch);
+if (betterMatch) {
+  const scopesLine = betterMatch[1];
+  console.log('Full scopes line:', scopesLine);
+
+  // Extract all quoted strings
+  const scopes = scopesLine.match(/'([^']+)'/g);
+  console.log('All quoted strings:', scopes);
+
+  // Clean them up
+  const cleanScopes = scopes ? scopes.map((s) => s.replace(/'/g, '')) : [];
+  console.log('Clean scopes:', cleanScopes);
+}

package/js/examples/test-sh-pipeline.mjs

@@ -0,0 +1,24 @@
+#!/usr/bin/env bun
+
+import { $ } from '../src/$.mjs';
+
+console.log('Testing pipeline executed via sh -c:');
+console.log('This should stream in real-time\n');
+
+const start = Date.now();
+
+// Execute the entire pipeline as a single shell command
+const cmd = $`sh -c 'bun run js/examples/emulate-claude-stream.mjs | jq .'`;
+
+for await (const chunk of cmd.stream()) {
+  if (chunk.type === 'stdout') {
+    const elapsed = Date.now() - start;
+    const lines = chunk.data
+      .toString()
+      .split('\n')
+      .filter((l) => l.trim());
+    for (const line of lines) {
+      console.log(`[${elapsed}ms] ${line}`);
+    }
+  }
+}

package/js/examples/test-shell-detection.mjs

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+
+// Test script to reproduce Bun shell path detection issues
+import { $ } from '../src/$.mjs';
+
+console.log('=== Shell Detection Test ===');
+console.log(
+  `Runtime: ${typeof globalThis.Bun !== 'undefined' ? 'Bun' : 'Node.js'}`
+);
+console.log(`Platform: ${process.platform}`);
+
+const testCommands = [
+  { cmd: 'echo "Hello, World!"', desc: 'Simple echo' },
+  { cmd: 'pwd', desc: 'Print working directory' },
+  { cmd: 'date', desc: 'Current date' },
+  { cmd: 'which sh', desc: 'Find sh location' },
+  { cmd: 'which bash', desc: 'Find bash location' },
+];
+
+console.log('\n=== Testing Commands ===');
+for (const { cmd, desc } of testCommands) {
+  console.log(`\nTest: ${desc}`);
+  console.log(`Command: ${cmd}`);
+  try {
+    const result = await $`${cmd}`;
+    console.log('✓ Success:', result.stdout.toString().trim());
+  } catch (error) {
+    console.log('✗ Failed:', error.message);
+    if (error.code === 'ENOENT') {
+      console.log('  Error: ENOENT - Command/Shell not found');
+      console.log('  This indicates shell path resolution issues!');
+    }
+    if (error.stderr) {
+      console.log('  Stderr:', error.stderr.toString().trim());
+    }
+  }
+}
+
+console.log('\n=== Testing Shell Detection Directly ===');
+// Test shell detection by importing the function directly
+import fs from 'fs';
+import cp from 'child_process';
+
+const isBun = typeof globalThis.Bun !== 'undefined';
+
+console.log('\nTesting individual shell paths:');
+const shellsToTest = ['/bin/sh', '/usr/bin/sh', '/bin/bash', '/usr/bin/bash'];
+
+for (const shellPath of shellsToTest) {
+  const exists = fs.existsSync(shellPath);
+  console.log(`${shellPath}: ${exists ? '✓ exists' : '✗ not found'}`);
+}
+
+console.log('\nTesting `which` command in both runtimes:');
+const shellNames = ['sh', 'bash', 'zsh'];
+
+for (const shellName of shellNames) {
+  try {
+    const result = cp.spawnSync('which', [shellName], { encoding: 'utf-8' });
+    if (result.status === 0 && result.stdout) {
+      console.log(`which ${shellName}: ✓ ${result.stdout.trim()}`);
+    } else {
+      console.log(`which ${shellName}: ✗ not found (status: ${result.status})`);
+      if (result.stderr) {
+        console.log(`  stderr: ${result.stderr.trim()}`);
+      }
+    }
+  } catch (error) {
+    console.log(`which ${shellName}: ✗ error - ${error.message}`);
+  }
+}

package/js/examples/test-shell-parser.mjs

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+
+import { parseShellCommand, needsRealShell } from '../src/shell-parser.mjs';
+
+const testCases = [
+  'cd /tmp',
+  'cd /tmp && pwd',
+  'cd /tmp || echo "failed"',
+  'cd /tmp ; pwd ; cd /usr',
+  '(cd /tmp && pwd)',
+  '(cd /tmp && pwd) ; pwd',
+  'cd /tmp && echo "hello" && cd /usr',
+  'ls -la | grep test | wc -l',
+  'cd "/path with spaces" && pwd',
+  'echo "hello world" > file.txt',
+  'cat < input.txt > output.txt',
+  'cd /tmp && (cd /usr && pwd) && pwd',
+  'false || echo "failed" && echo "success"',
+];
+
+console.log('=== Shell Parser Test ===\n');
+
+for (const cmd of testCases) {
+  console.log(`Command: ${cmd}`);
+
+  if (needsRealShell(cmd)) {
+    console.log('  Needs real shell: YES');
+  } else {
+    console.log('  Needs real shell: NO');
+  }
+
+  const parsed = parseShellCommand(cmd);
+  console.log('  Parsed:', JSON.stringify(parsed, null, 2));
+  console.log();
+}
+
+console.log('=== Test Complete ===');

package/js/examples/test-sigint-behavior.mjs

@@ -0,0 +1,241 @@
+#!/usr/bin/env node
+
+/**
+ * Example: Testing SIGINT behavior across different scenarios
+ *
+ * This helps debug why SIGINT tests might fail in different environments
+ */
+
+import { spawn } from 'child_process';
+import { $ } from '../src/$.mjs';
+
+console.log('Testing SIGINT behavior');
+
+// Test 1: Basic shell command with SIGINT
+async function testBasicShellSigint() {
+  console.log('\nTEST 1: Basic shell command with SIGINT');
+
+  return new Promise((resolve) => {
+    const child = spawn('sh', ['-c', 'echo "START" && sleep 30'], {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      detached: true,
+    });
+
+    console.log(`Started process with PID: ${child.pid}`);
+
+    let stdout = '';
+    child.stdout.on('data', (data) => {
+      stdout += data.toString();
+      console.log('Received stdout:', data.toString().trim());
+    });
+
+    // Wait for initial output
+    setTimeout(() => {
+      console.log('Sending SIGINT...');
+      child.kill('SIGINT');
+    }, 500);
+
+    child.on('exit', (code, signal) => {
+      console.log(`Process exited with code: ${code}, signal: ${signal}`);
+      console.log(`Total stdout received: ${stdout}`);
+
+      // Expected: code=null, signal='SIGINT' OR code=130, signal=null
+      const exitCode = code !== null ? code : signal === 'SIGINT' ? 130 : 1;
+      console.log(`Effective exit code: ${exitCode}`);
+
+      resolve({ stdout, exitCode, signal });
+    });
+  });
+}
+
+// Test 2: Shell with trap for SIGINT
+async function testShellWithTrap() {
+  console.log('\nTEST 2: Shell with trap for SIGINT');
+
+  const script = `
+    echo "START_WITH_TRAP"
+    trap 'echo "Caught SIGINT"; exit 130' INT
+    sleep 30
+  `;
+
+  return new Promise((resolve) => {
+    const child = spawn('sh', ['-c', script], {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      detached: true,
+    });
+
+    console.log(`Started process with PID: ${child.pid}`);
+
+    let stdout = '';
+    child.stdout.on('data', (data) => {
+      stdout += data.toString();
+      console.log('Received stdout:', data.toString().trim());
+    });
+
+    setTimeout(() => {
+      console.log('Sending SIGINT...');
+      child.kill('SIGINT');
+    }, 500);
+
+    child.on('exit', (code, signal) => {
+      console.log(`Process exited with code: ${code}, signal: ${signal}`);
+      resolve({ stdout, code, signal });
+    });
+  });
+}
+
+// Test 3: Process group handling
+async function testProcessGroup() {
+  console.log('\nTEST 3: Process group SIGINT');
+
+  return new Promise((resolve) => {
+    const child = spawn('sh', ['-c', 'echo "GROUP_START" && sleep 30'], {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      detached: true, // Creates new process group
+    });
+
+    const pgid = -child.pid;
+    console.log(`Started process with PID: ${child.pid}, PGID: ${pgid}`);
+
+    let stdout = '';
+    child.stdout.on('data', (data) => {
+      stdout += data.toString();
+      console.log('Received stdout:', data.toString().trim());
+    });
+
+    setTimeout(() => {
+      console.log('Killing entire process group...');
+      try {
+        process.kill(pgid, 'SIGINT');
+      } catch (err) {
+        console.log('Failed to kill process group, killing child directly');
+        child.kill('SIGINT');
+      }
+    }, 500);
+
+    child.on('exit', (code, signal) => {
+      console.log(`Process exited with code: ${code}, signal: ${signal}`);
+      resolve({ stdout, code, signal });
+    });
+  });
+}
+
+// Test 4: Command-stream library SIGINT handling
+async function testCommandStreamSigint() {
+  console.log('\nTEST 4: Command-stream library SIGINT');
+
+  const runner = $`echo "LIBRARY_START" && sleep 30`;
+  const promise = runner.start();
+
+  let output = '';
+  runner.on('data', (chunk) => {
+    output += chunk.data.toString();
+    console.log('Received data:', chunk.data.toString().trim());
+  });
+
+  setTimeout(() => {
+    console.log('Killing runner...');
+    runner.kill();
+  }, 500);
+
+  try {
+    const result = await promise;
+    console.log('Command completed normally:', result);
+    return { output, result };
+  } catch (error) {
+    console.log('Command was interrupted:', error.message);
+    return { output, error: error.message };
+  }
+}
+
+// Test 5: Different kill signals
+async function testDifferentSignals() {
+  console.log('\nTEST 5: Different signals (SIGINT vs SIGTERM vs SIGKILL)');
+
+  const signals = ['SIGINT', 'SIGTERM', 'SIGKILL'];
+
+  for (const signal of signals) {
+    console.log(`\nTesting ${signal}:`);
+
+    await new Promise((resolve) => {
+      const child = spawn('sh', ['-c', 'sleep 30'], {
+        stdio: 'ignore',
+        detached: true,
+      });
+
+      console.log(`Started PID ${child.pid}`);
+
+      setTimeout(() => {
+        console.log(`Sending ${signal}...`);
+        child.kill(signal);
+      }, 100);
+
+      child.on('exit', (code, sig) => {
+        console.log(`Exit: code=${code}, signal=${sig}`);
+        resolve();
+      });
+    });
+  }
+}
+
+// Test 6: Platform-specific behavior
+async function testPlatformSpecific() {
+  console.log('\nTEST 6: Platform-specific SIGINT behavior');
+
+  console.log('Platform:', process.platform);
+  console.log('Node version:', process.version);
+
+  // macOS vs Linux might handle signals differently
+  if (process.platform === 'darwin') {
+    console.log('macOS: Testing with /bin/sleep');
+    const child = spawn('/bin/sleep', ['30'], {
+      stdio: 'ignore',
+    });
+
+    setTimeout(() => {
+      child.kill('SIGINT');
+    }, 100);
+
+    await new Promise((resolve) => {
+      child.on('exit', (code, signal) => {
+        console.log(`macOS /bin/sleep exit: code=${code}, signal=${signal}`);
+        resolve();
+      });
+    });
+  } else {
+    console.log('Linux: Testing with sleep command');
+    const child = spawn('sleep', ['30'], {
+      stdio: 'ignore',
+    });
+
+    setTimeout(() => {
+      child.kill('SIGINT');
+    }, 100);
+
+    await new Promise((resolve) => {
+      child.on('exit', (code, signal) => {
+        console.log(`Linux sleep exit: code=${code}, signal=${signal}`);
+        resolve();
+      });
+    });
+  }
+}
+
+// Main execution
+async function main() {
+  try {
+    await testBasicShellSigint();
+    await testShellWithTrap();
+    await testProcessGroup();
+    await testCommandStreamSigint();
+    await testDifferentSignals();
+    await testPlatformSpecific();
+
+    console.log('\n✅ All SIGINT tests completed');
+  } catch (error) {
+    console.error('❌ Test failed:', error);
+    process.exit(1);
+  }
+}
+
+main();

package/js/examples/test-sigint-handling.sh

@@ -0,0 +1,14 @@
+#!/bin/sh
+
+# Example: Test SIGINT handling in shell scripts
+# This script demonstrates proper SIGINT handling with trap
+
+echo "BASELINE_START"
+
+# Set up signal handler
+trap 'echo "Got SIGINT"; exit 130' INT
+
+echo "Sleeping for 30 seconds (send SIGINT to interrupt)..."
+sleep 30
+
+echo "Sleep completed normally"

package/js/examples/test-simple-pipe.mjs

@@ -0,0 +1,12 @@
+#!/usr/bin/env bun
+
+import { $ } from '../src/$.mjs';
+
+console.log('Simple pipe test:');
+
+const result = await $`echo hello | cat`;
+console.log('Result:', result.stdout);
+
+console.log('\nPipe with jq:');
+const result2 = await $`echo '{"x":1}' | jq .`;
+console.log('Result:', result2.stdout);

package/js/examples/test-simple-streaming.mjs

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+
+import { $ } from '../src/$.mjs';
+import { trace } from '../src/$.utils.mjs';
+
+async function testSimpleStreaming() {
+  trace('TestExample', '🧪 Testing simple streaming after fix');
+
+  // Test 1: Basic stdin control
+  const sortCmd = $`sort`;
+  const stdin = await sortCmd.streams.stdin;
+
+  stdin.write('zebra\n');
+  stdin.write('apple\n');
+  stdin.end();
+
+  const result = await sortCmd;
+  trace('TestExample', () => `✅ Sort result: ${result.stdout}`);
+
+  // Test 2: Grep filter
+  const grepCmd = $`grep "test"`;
+  const grepStdin = await grepCmd.streams.stdin;
+
+  grepStdin.write('no match\n');
+  grepStdin.write('this is test\n');
+  grepStdin.end();
+
+  const grepResult = await grepCmd;
+  trace('TestExample', () => `✅ Grep result: ${grepResult.stdout}`);
+}
+
+testSimpleStreaming();

package/js/examples/test-sleep-stdin.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+
+// Test script that reads the module code from stdin
+// This avoids ES module import issues in CI
+
+console.error('[test-sleep-stdin] Process started, PID:', process.pid);
+console.error('[test-sleep-stdin] Node version:', process.version);
+
+// Read the module code to eval from stdin
+let moduleCode = '';
+process.stdin.on('data', (chunk) => {
+  moduleCode += chunk.toString();
+});
+
+process.stdin.on('end', async () => {
+  try {
+    console.error('[test-sleep-stdin] Evaluating module code...');
+    // Create an async function to evaluate the code
+    const AsyncFunction = Object.getPrototypeOf(async () => {}).constructor;
+    const runTest = new AsyncFunction('require', 'process', moduleCode);
+    await runTest(require, process);
+  } catch (error) {
+    console.error('[test-sleep-stdin] Error:', error.message);
+    console.log('STARTING_SLEEP'); // Still output for test
+    process.exit(1);
+  }
+});