command-stream 0.8.2 → 0.9.0

package/js/examples/test-async-streams.mjs

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+
+import { $ } from '../src/$.mjs';
+
+console.log('=== Test async streams interface ===');
+
+async function testAsyncStreams() {
+  try {
+    console.log('TEST 1: Basic cat with await streams.stdin');
+
+    const catCmd = $`cat`;
+
+    console.log('Awaiting stdin...');
+    const stdin = await catCmd.streams.stdin;
+    console.log('✓ Got stdin:', !!stdin);
+
+    if (stdin) {
+      stdin.write('Hello async stdin!\\n');
+      stdin.write('This is much cleaner!\\n');
+      stdin.end();
+    }
+
+    const result = await catCmd;
+    console.log('✓ Cat result:', JSON.stringify(result.stdout));
+
+    console.log('\\nTEST 2: Grep with async streams');
+
+    const grepCmd = $`grep "test"`;
+    const grepStdin = await grepCmd.streams.stdin;
+
+    if (grepStdin) {
+      grepStdin.write('no match\\n');
+      grepStdin.write('test line\\n');
+      grepStdin.write('another test\\n');
+      grepStdin.end();
+    }
+
+    const grepResult = await grepCmd;
+    console.log('✓ Grep result:', JSON.stringify(grepResult.stdout));
+
+    console.log('\\nTEST 3: Sort with async streams');
+
+    const sortCmd = $`sort`;
+    const sortStdin = await sortCmd.streams.stdin;
+
+    if (sortStdin) {
+      sortStdin.write('zebra\\n');
+      sortStdin.write('apple\\n');
+      sortStdin.write('banana\\n');
+      sortStdin.end();
+    }
+
+    const sortResult = await sortCmd;
+    console.log('✓ Sort result:', JSON.stringify(sortResult.stdout));
+
+    console.log('\\nTEST 4: Multiple streams access');
+
+    const mixedCmd = $`sh -c 'cat && echo "stderr message" >&2'`;
+    const [mixedStdin, mixedStdout] = await Promise.all([
+      mixedCmd.streams.stdin,
+      mixedCmd.streams.stdout,
+    ]);
+
+    console.log('✓ Got both stdin and stdout streams');
+
+    if (mixedStdin) {
+      mixedStdin.write('Mixed input\\n');
+      mixedStdin.end();
+    }
+
+    const mixedResult = await mixedCmd;
+    console.log(
+      '✓ Mixed result:',
+      JSON.stringify({
+        stdout: mixedResult.stdout,
+        stderr: mixedResult.stderr,
+      })
+    );
+
+    console.log('\\n🎉 SUCCESS:');
+    console.log('  ✅ Async streams interface works perfectly!');
+    console.log('  ✅ No more manual timing required');
+    console.log('  ✅ Clean, intuitive API: await cmd.streams.stdin');
+  } catch (error) {
+    console.log('\\n❌ Error:', error.message);
+    console.error(error.stack);
+  }
+}
+
+testAsyncStreams();

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

@@ -0,0 +1,74 @@
+import { $ } from '../src/$.mjs';
+
+async function getDetailedAuthStatus() {
+  try {
+    const authResult = await $`gh auth status 2>&1`.run({
+      capture: true,
+      mirror: false,
+    });
+    const output = authResult.stdout;
+
+    // Parse auth status details
+    const details = {
+      authenticated: authResult.code === 0,
+      loggedInAs: null,
+      account: null,
+      protocol: null,
+      token: null,
+      scopes: [],
+      hasGistScope: false,
+      rawOutput: output, // Include raw output for debugging
+    };
+
+    // Parse logged in account - updated pattern for new format
+    const accountMatch = output.match(
+      /Logged in to github\.com account (\S+)|Logged in to [\w\.]+ as (\S+)/
+    );
+    if (accountMatch) {
+      details.account = accountMatch[1] || accountMatch[2];
+    }
+
+    // Parse git operations protocol
+    const protocolMatch = output.match(/Git operations protocol:\s*(\w+)/);
+    if (protocolMatch) {
+      details.protocol = protocolMatch[1];
+    }
+
+    // Parse token (masked)
+    const tokenMatch = output.match(/Token:\s*(\S+)/);
+    if (tokenMatch) {
+      details.token = tokenMatch[1];
+    }
+
+    // Parse token scopes - handle both quoted and unquoted formats
+    const scopesMatch = output.match(
+      /Token scopes:\s*'([^']+)'|Token scopes:\s*([^\n]+)/
+    );
+    if (scopesMatch) {
+      const scopesStr = scopesMatch[1] || scopesMatch[2];
+      // Split by comma and/or quotes, clean up
+      details.scopes = scopesStr
+        .split(/[,']/)
+        .map((s) => s.trim())
+        .filter((s) => s && s !== '');
+      details.hasGistScope = details.scopes.includes('gist');
+    }
+
+    // Check if completely logged out
+    if (output.includes('You are not logged into any GitHub hosts')) {
+      details.authenticated = false;
+      details.account = null;
+    }
+
+    return details;
+  } catch (error) {
+    return null;
+  }
+}
+
+// Test it
+const status = await getDetailedAuthStatus();
+console.log('Auth Status Details:');
+console.log(JSON.stringify(status, null, 2));
+console.log('\nParsed scopes:', status?.scopes);
+console.log('Has gist scope:', status?.hasGistScope);

package/js/examples/test-auto-quoting.mjs

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+
+// Test: Automatic quoting when user doesn't provide quotes
+// Expected: Smart auto-quoting based on content
+
+import { $ } from '../src/$.mjs';
+
+console.log('=== Test: Automatic Smart Quoting ===\n');
+
+const testCases = [
+  {
+    name: 'Simple path without spaces',
+    value: '/usr/bin/echo',
+    shouldQuote: true, // Currently quotes everything
+  },
+  {
+    name: 'Path with spaces',
+    value: '/path with spaces/command',
+    shouldQuote: true,
+  },
+  {
+    name: 'Path with special shell chars ($)',
+    value: '/path/with$variable',
+    shouldQuote: true,
+  },
+  {
+    name: 'Path with special shell chars (&)',
+    value: '/path/with&background',
+    shouldQuote: true,
+  },
+  {
+    name: 'Simple command name',
+    value: 'echo',
+    shouldQuote: true, // Currently quotes everything
+  },
+  {
+    name: 'Empty string',
+    value: '',
+    shouldQuote: true,
+  },
+];
+
+for (const { name, value, shouldQuote } of testCases) {
+  console.log(`\nTest: ${name}`);
+  console.log('Input:', JSON.stringify(value));
+
+  const cmd = $({ mirror: false })`${value} --test`;
+  console.log('Generated:', cmd.spec.command);
+
+  const hasQuotes =
+    cmd.spec.command.startsWith("'") || cmd.spec.command.startsWith('"');
+  console.log('Has quotes:', hasQuotes);
+  console.log('Should quote:', shouldQuote);
+  console.log(
+    hasQuotes === shouldQuote ? '✅ PASS' : '⚠️  Note: Quoting behavior differs'
+  );
+}

package/js/examples/test-auto-start-fix.mjs

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+
+/**
+ * Test to verify that auto-start only happens on actual stdin/stdout/stderr access,
+ * not when accessing the parent objects (streams, buffers, strings).
+ */
+
+import { $ } from '../src/$.mjs';
+
+console.log('=== Testing Auto-Start Behavior Fix ===');
+console.log('');
+
+async function testAutoStartBehavior() {
+  try {
+    console.log('TEST 1: Accessing parent objects should NOT auto-start');
+
+    const command1 = $`echo "test1"`;
+    console.log('✓ Command created');
+    console.log('  Started?', command1.started);
+    console.log('  Finished?', command1.finished);
+
+    // These should NOT auto-start the command
+    const streams = command1.streams;
+    console.log('✓ Accessed .streams');
+    console.log('  Started?', command1.started);
+
+    const buffers = command1.buffers;
+    console.log('✓ Accessed .buffers');
+    console.log('  Started?', command1.started);
+
+    const strings = command1.strings;
+    console.log('✓ Accessed .strings');
+    console.log('  Started?', command1.started);
+
+    console.log('');
+    console.log('TEST 2: Accessing stdin/stdout/stderr SHOULD auto-start');
+
+    const command2 = $`echo "test2"`;
+    console.log('✓ Command2 created');
+    console.log('  Started?', command2.started);
+
+    // This SHOULD auto-start the command
+    const stdout = command2.streams.stdout;
+    console.log('✓ Accessed .streams.stdout');
+    console.log('  Started?', command2.started);
+
+    // Wait for completion
+    const result2 = await command2;
+    console.log('✓ Result:', JSON.stringify(result2.stdout.trim()));
+
+    console.log('');
+    console.log('TEST 3: Buffer access should auto-start');
+
+    const command3 = $`echo "test3"`;
+    console.log('✓ Command3 created');
+    console.log('  Started?', command3.started);
+
+    // Access buffer properties - should NOT auto-start yet
+    const buffers3 = command3.buffers;
+    console.log('✓ Accessed .buffers');
+    console.log('  Started?', command3.started);
+
+    // Now access actual buffer - SHOULD auto-start
+    const stdoutBuffer = await command3.buffers.stdout;
+    console.log('✓ Accessed .buffers.stdout');
+    console.log('  Result:', stdoutBuffer.toString().trim());
+
+    console.log('');
+    console.log('TEST 4: String access should auto-start');
+
+    const command4 = $`echo "test4"`;
+    console.log('✓ Command4 created');
+    console.log('  Started?', command4.started);
+
+    // Access string properties - should NOT auto-start yet
+    const strings4 = command4.strings;
+    console.log('✓ Accessed .strings');
+    console.log('  Started?', command4.started);
+
+    // Now access actual string - SHOULD auto-start
+    const stdoutString = await command4.strings.stdout;
+    console.log('✓ Accessed .strings.stdout');
+    console.log('  Result:', JSON.stringify(stdoutString.trim()));
+
+    console.log('');
+    console.log('✅ ALL AUTO-START TESTS PASSED!');
+  } catch (error) {
+    console.log('');
+    console.error('❌ AUTO-START TEST FAILED:', error.message);
+    console.error(error.stack);
+    process.exit(1);
+  }
+}
+
+testAutoStartBehavior();

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

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+
+import { spawn } from 'child_process';
+
+console.log('Testing baseline SIGINT behavior');
+
+const child = spawn('sh', ['-c', 'echo "BASELINE_START" && sleep 30'], {
+  stdio: ['pipe', 'pipe', 'pipe'],
+  detached: true,
+});
+
+console.log('Child spawned with PID:', child.pid);
+
+let stdout = '';
+child.stdout.on('data', (data) => {
+  stdout += data.toString();
+  console.log('Received stdout:', JSON.stringify(data.toString()));
+});
+
+// Wait for output
+setTimeout(() => {
+  console.log('Sending SIGINT to child...');
+  const result = child.kill('SIGINT');
+  console.log('Kill result:', result);
+}, 500);
+
+// Wait for exit
+child.on('exit', (code, signal) => {
+  console.log('Child exited with code:', code, 'signal:', signal);
+  console.log('Total stdout:', stdout);
+  process.exit(0);
+});
+
+// Timeout safety
+setTimeout(() => {
+  console.log('Timeout reached, force killing...');
+  child.kill('SIGKILL');
+}, 5000);

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

@@ -0,0 +1,39 @@
+import { $ } from '../src/$.mjs';
+
+console.log('Testing buffer behavior in stream()...');
+
+const runner = $`yes "test"`;
+let iterations = 0;
+
+// Override emit to see when data events are fired
+const originalEmit = runner.emit.bind(runner);
+let dataEventCount = 0;
+runner.emit = function (event, ...args) {
+  if (event === 'data') {
+    dataEventCount++;
+    console.log(`  [DATA EVENT ${dataEventCount}] emitted`);
+  }
+  return originalEmit(event, ...args);
+};
+
+console.log('\nStarting iteration...');
+for await (const chunk of runner.stream()) {
+  iterations++;
+  console.log(`Iteration ${iterations}: received chunk`);
+
+  if (iterations >= 3) {
+    console.log('Breaking after iteration 3...');
+    break;
+  }
+}
+
+console.log(`\nFinal state:`);
+console.log(`  iterations: ${iterations}`);
+console.log(`  dataEventCount: ${dataEventCount}`);
+console.log(`  runner.finished: ${runner.finished}`);
+
+await new Promise((resolve) => setTimeout(resolve, 100));
+console.log(`\nAfter 100ms:`);
+console.log(`  dataEventCount: ${dataEventCount}`);
+
+process.exit(0);

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

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+
+import { $ } from '../src/$.mjs';
+
+console.log('Testing buffer access...');
+
+async function testBuffers() {
+  const cmd = $`echo "test buffer"`;
+
+  // First access - should be promise
+  console.log('Getting buffer (first access)...');
+  const buffer1 = await cmd.buffers.stdout;
+  console.log('Buffer 1:', buffer1.toString());
+
+  // Check if process is finished
+  console.log('Process finished?', cmd.finished);
+  console.log('Has outChunks?', !!cmd.outChunks);
+  console.log(
+    'OutChunks length:',
+    cmd.outChunks ? cmd.outChunks.length : 'null'
+  );
+
+  // Second access - should be immediate
+  console.log('Getting buffer (second access)...');
+  const buffer2 = cmd.buffers.stdout;
+  console.log('Buffer 2 type:', typeof buffer2);
+  console.log('Buffer 2 is Promise?', buffer2 instanceof Promise);
+  if (!(buffer2 instanceof Promise)) {
+    console.log('Buffer 2 content:', buffer2.toString());
+  } else {
+    console.log('Buffer 2 resolved:', (await buffer2).toString());
+  }
+}
+
+testBuffers().catch(console.error);

package/js/examples/test-bun-specific-issue.mjs

@@ -0,0 +1,106 @@
+#!/usr/bin/env node
+
+// More targeted test to find the real Bun shell path issue
+import { $ } from '../src/$.mjs';
+
+const isBun = typeof globalThis.Bun !== 'undefined';
+console.log(`=== Bun Runtime Shell Path Test ===`);
+console.log(`Runtime: ${isBun ? 'Bun' : 'Node.js'}`);
+console.log(`Platform: ${process.platform}`);
+
+// Enable verbose mode to see shell detection
+process.env.COMMAND_STREAM_VERBOSE = 'true';
+
+console.log('\n=== Simple Commands ===');
+
+// Test simple commands
+const simpleCommands = [
+  'pwd',
+  'echo hello',
+  'ls /bin/sh',
+  'test -f /bin/sh && echo "sh exists"',
+];
+
+for (const cmd of simpleCommands) {
+  console.log(`\nTesting: ${cmd}`);
+  try {
+    const result = await $`${cmd}`;
+    console.log(`✓ Success: ${result.stdout.toString().trim()}`);
+  } catch (error) {
+    console.log(`✗ Failed: ${error.message}`);
+    console.log(`  Code: ${error.code}`);
+    if (error.stderr) {
+      console.log(`  Stderr: ${error.stderr.toString().trim()}`);
+    }
+  }
+}
+
+console.log('\n=== Testing Shell Detection Explicitly ===');
+
+// Import the findAvailableShell function for direct testing
+import fs from 'fs';
+import cp from 'child_process';
+
+// Test the actual shell detection logic that might be failing in Bun
+console.log('\nTesting shell existence:');
+const shellPaths = ['/bin/sh', '/usr/bin/sh', '/bin/bash', '/usr/bin/bash'];
+for (const shellPath of shellPaths) {
+  try {
+    const exists = fs.existsSync(shellPath);
+    console.log(`${shellPath}: ${exists ? '✓' : '✗'}`);
+  } catch (error) {
+    console.log(`${shellPath}: error - ${error.message}`);
+  }
+}
+
+console.log('\nTesting which command:');
+const shells = ['sh', 'bash', 'which'];
+for (const shell of shells) {
+  try {
+    const result = cp.spawnSync('which', [shell], { encoding: 'utf-8' });
+    console.log(
+      `which ${shell}: status=${result.status}, stdout="${result.stdout?.trim()}", stderr="${result.stderr?.trim()}"`
+    );
+  } catch (error) {
+    console.log(`which ${shell}: error - ${error.message}`);
+  }
+}
+
+console.log('\n=== Testing Direct Bun Spawn ===');
+if (isBun) {
+  // Test Bun.spawn directly to see if that's the issue
+  console.log('Testing Bun.spawn with /bin/sh:');
+  try {
+    const proc = Bun.spawn(['/bin/sh', '-c', 'echo "Bun spawn test"'], {
+      stdout: 'pipe',
+      stderr: 'pipe',
+    });
+
+    const text = await new Response(proc.stdout).text();
+    const exitCode = await proc.exited;
+
+    console.log(
+      `✓ Bun.spawn success: exitCode=${exitCode}, output="${text.trim()}"`
+    );
+  } catch (error) {
+    console.log(`✗ Bun.spawn failed: ${error.message}`);
+  }
+
+  console.log('Testing Bun.spawn with which sh:');
+  try {
+    const proc = Bun.spawn(['which', 'sh'], {
+      stdout: 'pipe',
+      stderr: 'pipe',
+    });
+
+    const text = await new Response(proc.stdout).text();
+    const errorText = await new Response(proc.stderr).text();
+    const exitCode = await proc.exited;
+
+    console.log(
+      `Bun.spawn which: exitCode=${exitCode}, stdout="${text.trim()}", stderr="${errorText.trim()}"`
+    );
+  } catch (error) {
+    console.log(`✗ Bun.spawn which failed: ${error.message}`);
+  }
+}

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

@@ -0,0 +1,81 @@
+#!/usr/bin/env bun
+
+// Test if Bun's process stdout streaming works properly
+
+console.log('Test 1: Direct command that outputs with delays');
+const proc1 = Bun.spawn(
+  ['sh', '-c', 'echo "1"; sleep 0.3; echo "2"; sleep 0.3; echo "3"'],
+  {
+    stdout: 'pipe',
+    stderr: 'pipe',
+  }
+);
+
+const start1 = Date.now();
+for await (const chunk of proc1.stdout) {
+  const elapsed = Date.now() - start1;
+  console.log(
+    `[${elapsed}ms] Got chunk:`,
+    Buffer.from(chunk).toString().trim()
+  );
+}
+
+console.log('\nTest 2: Command with jq pipeline');
+const proc2 = Bun.spawn(
+  ['sh', '-c', './js/examples/emulate-claude-stream.mjs | jq .'],
+  {
+    stdout: 'pipe',
+    stderr: 'pipe',
+  }
+);
+
+const start2 = Date.now();
+let chunkCount = 0;
+for await (const chunk of proc2.stdout) {
+  chunkCount++;
+  const elapsed = Date.now() - start2;
+  const text = Buffer.from(chunk).toString();
+  const lines = text
+    .split('\n')
+    .filter((l) => l.trim())
+    .slice(0, 3); // Show first 3 lines
+  console.log(
+    `[${elapsed}ms] Chunk ${chunkCount}: ${lines.length} lines, first few:`,
+    lines
+  );
+}
+
+console.log('\nTest 3: Read stdout using different method');
+const proc3 = Bun.spawn(
+  ['sh', '-c', './js/examples/emulate-claude-stream.mjs | jq .'],
+  {
+    stdout: 'pipe',
+    stderr: 'pipe',
+  }
+);
+
+const start3 = Date.now();
+const reader = proc3.stdout.getReader();
+let chunkCount3 = 0;
+
+try {
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) {
+      break;
+    }
+    chunkCount3++;
+    const elapsed = Date.now() - start3;
+    const text = Buffer.from(value).toString();
+    const lines = text
+      .split('\n')
+      .filter((l) => l.trim())
+      .slice(0, 3);
+    console.log(
+      `[${elapsed}ms] Reader chunk ${chunkCount3}: ${lines.length} lines, first few:`,
+      lines
+    );
+  }
+} finally {
+  reader.releaseLock();
+}

package/js/examples/test-cat-direct.mjs

@@ -0,0 +1,41 @@
+#!/usr/bin/env bun
+
+console.log('=== Test cat | jq directly ===\n');
+
+// Direct Bun test
+const proc1 = Bun.spawn(
+  ['bun', 'run', 'js/examples/emulate-claude-stream.mjs'],
+  {
+    stdout: 'pipe',
+    stderr: 'pipe',
+  }
+);
+
+const proc2 = Bun.spawn(['cat'], {
+  stdin: proc1.stdout,
+  stdout: 'pipe',
+  stderr: 'pipe',
+});
+
+const proc3 = Bun.spawn(['jq', '.'], {
+  stdin: proc2.stdout,
+  stdout: 'pipe',
+  stderr: 'pipe',
+});
+
+const start = Date.now();
+let chunkCount = 0;
+
+console.log('Reading from jq output:');
+for await (const chunk of proc3.stdout) {
+  chunkCount++;
+  const elapsed = Date.now() - start;
+  console.log(`[${elapsed}ms] Chunk ${chunkCount}: ${chunk.length} bytes`);
+}
+
+await proc1.exited;
+await proc2.exited;
+await proc3.exited;
+
+console.log(`\nTotal chunks: ${chunkCount}`);
+console.log(chunkCount === 1 ? '❌ Buffered' : '✅ Streaming');

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

@@ -0,0 +1,34 @@
+#!/usr/bin/env bun
+
+// Test with cat instead of jq
+
+console.log('Test: Piping through cat (should not buffer)\n');
+
+// First process: emulator
+const proc1 = Bun.spawn(['./js/examples/emulate-claude-stream.mjs'], {
+  stdout: 'pipe',
+  stderr: 'pipe',
+});
+
+// Second process: cat (should be unbuffered)
+const proc2 = Bun.spawn(['cat'], {
+  stdin: proc1.stdout,
+  stdout: 'pipe',
+  stderr: 'pipe',
+});
+
+const start = Date.now();
+let chunkCount = 0;
+
+for await (const chunk of proc2.stdout) {
+  chunkCount++;
+  const elapsed = Date.now() - start;
+  const text = Buffer.from(chunk).toString().trim();
+
+  console.log(`[${elapsed}ms] Chunk ${chunkCount}: ${text}`);
+}
+
+console.log(`\nTotal chunks received: ${chunkCount}`);
+
+await proc1.exited;
+await proc2.exited;