command-stream 0.8.2 → 0.9.0

package/js/examples/test-inherit-stdout-not-stdin.mjs

@@ -0,0 +1,133 @@
+#!/usr/bin/env node
+
+/**
+ * Test that we can inherit stdout but not stdin
+ * This allows parent process to see output, but child doesn't read from parent's stdin
+ */
+
+import { $ } from '../src/$.mjs';
+
+console.log('=== Testing inherit stdout but not stdin ===');
+console.log('');
+
+async function testInheritStdoutNotStdin() {
+  try {
+    console.log('TEST 1: Inherit stdout - output should appear directly');
+
+    // This should inherit stdout so we see the output directly
+    const inheritStdoutCmd = $`echo "This output should appear directly"`;
+
+    // Set stdout to inherit mode
+    const result1 = await inheritStdoutCmd.run({
+      stdout: 'inherit',
+      stdin: 'pipe',
+    });
+    console.log('✓ Command completed with inherit stdout');
+    console.log('  Exit code:', result1.code);
+    console.log(
+      '  Captured stdout (should be empty due to inherit):',
+      JSON.stringify(result1.stdout)
+    );
+
+    console.log('');
+    console.log('TEST 2: Control stdin independently while inheriting stdout');
+
+    // Create a command that can read from both stdin and produce stdout
+    const catCmd = $`cat`;
+
+    // Access streams to control individually
+    const stdin = catCmd.streams.stdin;
+
+    console.log('  → Sending data to stdin while stdout is inherited...');
+    if (stdin) {
+      stdin.write('Hello from controlled stdin!\\n');
+      stdin.write('This comes from our code, not the parent process stdin\\n');
+      stdin.end();
+    }
+
+    const catResult = await catCmd.run({ stdout: 'inherit' });
+    console.log('✓ Cat completed with controlled stdin and inherited stdout');
+    console.log('  Exit code:', catResult.code);
+
+    console.log('');
+    console.log('TEST 3: Verify different stdio combinations work');
+
+    console.log('  3a: Capture stdout, pipe stdin');
+    const cmd3a = $`cat`;
+    const stdin3a = cmd3a.streams.stdin;
+    if (stdin3a) {
+      stdin3a.write('Captured output test\\n');
+      stdin3a.end();
+    }
+    const result3a = await cmd3a.run({ stdout: 'pipe', stdin: 'pipe' });
+    console.log('    Result:', JSON.stringify(result3a.stdout));
+
+    console.log(
+      "  3b: Inherit stdout, ignore stdin (for commands that don't need stdin)"
+    );
+    const result3b = await $`echo "Direct output"`.run({
+      stdout: 'inherit',
+      stdin: 'ignore',
+    });
+    console.log('    Exit code:', result3b.code);
+
+    console.log('  3c: Mixed mode - inherit stdout, controlled stdin');
+    const cmd3c = $`grep "hello"`;
+    const stdin3c = cmd3c.streams.stdin;
+    if (stdin3c) {
+      stdin3c.write('hello world\\n');
+      stdin3c.write('test line\\n');
+      stdin3c.write('hello again\\n');
+      stdin3c.end();
+    }
+    await cmd3c.run({ stdout: 'inherit', stdin: 'pipe' });
+    console.log('    ✓ grep completed with inherited stdout');
+
+    console.log('');
+    console.log(
+      'TEST 4: Verify top command with inherited stdout and controlled stdin'
+    );
+
+    console.log(
+      '  → Starting top with inherited stdout, sending "q" via stdin...'
+    );
+    const topCmd = $`top -n 3`; // Limit iterations
+    const topStdin = topCmd.streams.stdin;
+
+    // Send quit command after a brief delay
+    setTimeout(() => {
+      if (topStdin) {
+        console.log('  → Sending "q" to quit top...');
+        topStdin.write('q');
+        topStdin.end();
+      }
+    }, 1000);
+
+    // Fallback kill
+    setTimeout(() => {
+      console.log('  → Fallback kill...');
+      topCmd.kill();
+    }, 3000);
+
+    const topResult = await topCmd.run({ stdout: 'inherit', stdin: 'pipe' });
+    console.log('  ✓ Top completed, exit code:', topResult.code);
+
+    console.log('');
+    console.log('✅ CONCLUSIONS:');
+    console.log('  • stdout can be inherited (appears directly in terminal)');
+    console.log('  • stdin can be controlled independently via streams.stdin');
+    console.log(
+      '  • This combination allows seeing output while controlling input'
+    );
+    console.log(
+      '  • Perfect for interactive commands that need specific input'
+    );
+  } catch (error) {
+    console.log('');
+    console.error('❌ TEST FAILED:', error.message);
+    console.error(error.stack);
+    process.exit(1);
+  }
+}
+
+testInheritStdoutNotStdin();

package/js/examples/test-injection-protection.mjs

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+
+// Test shell injection protection with the smart quoting
+import { $ } from '../src/$.mjs';
+
+console.log('=== Shell Injection Protection Test ===\n');
+
+async function testInjection() {
+  // Test 1: Command chaining attempt
+  console.log('1. Command chaining attempt:');
+  const evil1 = 'test; echo INJECTED';
+  const cmd1 = $({ mirror: false })`echo ${evil1}`;
+  console.log('Input:', evil1);
+  console.log('Command:', cmd1.spec.command);
+  const result1 = await cmd1;
+  const output1 = result1.stdout || String(result1);
+  console.log('Output:', output1.trim());
+  console.log(output1.includes('INJECTED') ? '❌ INJECTION!' : '✅ Protected');
+
+  // Test 2: Variable expansion attempt
+  console.log('\n2. Variable expansion attempt:');
+  const evil2 = '$HOME';
+  const cmd2 = $({ mirror: false })`echo ${evil2}`;
+  console.log('Input:', evil2);
+  console.log('Command:', cmd2.spec.command);
+  const result2 = await cmd2;
+  const output2 = (result2.stdout || String(result2)).trim();
+  console.log('Output:', output2);
+  console.log(
+    output2 === '$HOME'
+      ? '✅ Protected (literal $HOME)'
+      : '❌ Variable expanded!'
+  );
+
+  // Test 3: Command substitution attempt
+  console.log('\n3. Command substitution attempt:');
+  const evil3 = '$(whoami)';
+  const cmd3 = $({ mirror: false })`echo ${evil3}`;
+  console.log('Input:', evil3);
+  console.log('Command:', cmd3.spec.command);
+  const result3 = await cmd3;
+  const output3 = (result3.stdout || String(result3)).trim();
+  console.log('Output:', output3);
+  console.log(
+    output3 === '$(whoami)'
+      ? '✅ Protected (literal $(whoami))'
+      : '❌ Command executed!'
+  );
+
+  // Test 4: Safe string - no unnecessary quotes
+  console.log('\n4. Safe string (no unnecessary quotes):');
+  const safe = 'hello';
+  const cmd4 = $({ mirror: false })`echo ${safe}`;
+  console.log('Input:', safe);
+  console.log('Command:', cmd4.spec.command);
+  const result4 = await cmd4;
+  console.log('Output:', (result4.stdout || String(result4)).trim());
+  console.log(
+    !cmd4.spec.command.includes("'hello'")
+      ? '✅ No unnecessary quotes'
+      : '⚠️  Quoted when not needed'
+  );
+
+  // Test 5: Path without spaces - no unnecessary quotes
+  console.log('\n5. Safe path (no unnecessary quotes):');
+  const safePath = '/usr/bin/echo';
+  const cmd5 = $({ mirror: false })`${safePath} test`;
+  console.log('Input:', safePath);
+  console.log('Command:', cmd5.spec.command);
+  console.log(
+    !cmd5.spec.command.startsWith("'")
+      ? '✅ Path not unnecessarily quoted'
+      : '⚠️  Path quoted when not needed'
+  );
+}
+
+testInjection().catch(console.error);

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

@@ -0,0 +1,140 @@
+#!/usr/bin/env node
+
+import { $ } from '../src/$.mjs';
+
+async function testInteractiveStreaming() {
+  console.log('Testing Interactive Streaming I/O\n');
+  console.log('This test demonstrates real-time bidirectional streaming:');
+  console.log('- Send math expressions to stdin');
+  console.log('- Receive results from stdout');
+  console.log('- Multiple iterations while process is running\n');
+
+  // Start the interactive math calculator
+  // Use relative path that works from any directory
+  const calcPath = new URL('./interactive-math-calc.mjs', import.meta.url)
+    .pathname;
+  const calc = $`node ${calcPath}`;
+
+  // Get the streams immediately (process auto-starts)
+  const stdin = await calc.streams.stdin;
+  const stdout = await calc.streams.stdout;
+  const stderr = await calc.streams.stderr;
+
+  console.log('Streams obtained:');
+  console.log('  stdin:', stdin ? 'ready' : 'not available');
+  console.log('  stdout:', stdout ? 'ready' : 'not available');
+  console.log('  stderr:', stderr ? 'ready' : 'not available');
+  console.log('');
+
+  if (!stdin || !stdout) {
+    console.error('Failed to get streams!');
+    return;
+  }
+
+  // Set up stdout reader
+  const results = [];
+  let currentResult = '';
+
+  stdout.on('data', (chunk) => {
+    const text = chunk.toString();
+    console.log('  <- Received:', text.trim());
+    currentResult += text;
+
+    // Check if we got a complete result
+    if (
+      text.includes('RESULT:') ||
+      text.includes('READY') ||
+      text.includes('GOODBYE')
+    ) {
+      results.push(text.trim());
+      currentResult = '';
+    }
+  });
+
+  // Set up stderr reader
+  stderr.on('data', (chunk) => {
+    console.error('  <- Error:', chunk.toString().trim());
+  });
+
+  // Wait for calculator to be ready
+  await new Promise((resolve) => {
+    const checkReady = () => {
+      if (results.some((r) => r.includes('READY'))) {
+        resolve();
+      } else {
+        setTimeout(checkReady, 10);
+      }
+    };
+    checkReady();
+  });
+
+  console.log('\n--- Starting Interactive Math Session ---\n');
+
+  // Test cases
+  const expressions = [
+    '1+2',
+    '10*5',
+    '100/4',
+    '7-3',
+    '2**8', // Power of 2
+  ];
+
+  for (const expr of expressions) {
+    console.log(`  -> Sending: ${expr}`);
+    stdin.write(`${expr}\n`);
+
+    // Wait for result
+    const startResults = results.length;
+    await new Promise((resolve) => {
+      const checkResult = () => {
+        if (results.length > startResults) {
+          resolve();
+        } else {
+          setTimeout(checkResult, 10);
+        }
+      };
+      setTimeout(checkResult, 10);
+    });
+
+    // Small delay between calculations
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+
+  console.log('\n--- Ending Session ---\n');
+
+  // Send exit command
+  console.log('  -> Sending: exit');
+  stdin.write('exit\n');
+
+  // Wait for goodbye message
+  await new Promise((resolve) => {
+    const checkGoodbye = () => {
+      if (results.some((r) => r.includes('GOODBYE'))) {
+        resolve();
+      } else {
+        setTimeout(checkGoodbye, 10);
+      }
+    };
+    setTimeout(checkGoodbye, 10);
+  });
+
+  // Wait for process to complete
+  const result = await calc;
+
+  console.log('\n--- Summary ---');
+  console.log('Process exited with code:', result.code);
+  console.log(
+    'Total results received:',
+    results.filter((r) => r.includes('RESULT:')).length
+  );
+  console.log('\nAll results:');
+  results.forEach((r) => {
+    if (r.includes('RESULT:')) {
+      console.log(`  ${r}`);
+    }
+  });
+
+  console.log('\n✅ Interactive streaming test completed successfully!');
+}
+
+testInteractiveStreaming().catch(console.error);

package/js/examples/test-interactive-top.md

@@ -0,0 +1,24 @@
+# Testing Interactive Top Example
+
+To test the interactive top example:
+
+```bash
+node js/examples/interactive-top.mjs
+```
+
+**Expected behavior:**
+
+- The `top` command starts immediately
+- ANSI colors and formatting are preserved
+- Full interactivity is maintained (you can press keys like 'q' to quit)
+- No time limits - runs until you manually quit
+- Process cleanup happens properly when you exit
+
+**Key features demonstrated:**
+
+- ✅ ANSI colors preserved (addresses GitHub issue #10)
+- ✅ Interactive I/O not interfered with (addresses GitHub issue #11)
+- ✅ Manual control - no automatic timeouts
+- ✅ Proper process management and cleanup
+
+**Note:** Press 'q' to quit top when you're ready. The example will show the exit code when top terminates.

package/js/examples/test-interactive.mjs

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+
+import { $ } from '../src/$.mjs';
+
+console.log('Testing interactive command detection...');
+
+// Test 1: Check if top is detected as interactive
+const isTop = $`top`;
+
+console.log('Created top command process');
+
+// Test 2: Check if ls is detected as non-interactive
+const isLs = $`ls`;
+
+console.log('Created ls command process');
+
+console.log('Interactive command detection test completed');

package/js/examples/test-interpolation.mjs

@@ -0,0 +1,14 @@
+import { $ } from '../src/$.mjs';
+
+async function testInterpolation() {
+  const name = 'World';
+  const $custom = $({ capture: true, mirror: false });
+  const result = await $custom`echo Hello, ${name}!`;
+
+  console.log('Expected:', "Hello, 'World'!");
+  console.log('Actual:  ', result.stdout.trim());
+  console.log('Match:', result.stdout.trim() === "Hello, 'World'!");
+  console.log('Code:', result.code);
+}
+
+testInterpolation().catch(console.error);

package/js/examples/test-interrupt.mjs

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+
+// Automated test for interruption handling
+
+import { $ } from '../src/$.mjs';
+
+async function test() {
+  console.log('Testing interruption of virtual sleep command...');
+
+  // Start a long sleep
+  const runner = $`sleep 10`;
+  const promise = runner.start();
+
+  // Kill it after 500ms
+  setTimeout(() => {
+    console.log('Sending kill signal...');
+    runner.kill();
+  }, 500);
+
+  // Wait for result
+  const result = await promise;
+
+  console.log('Result:', {
+    code: result.code,
+    stdout: result.stdout,
+    stderr: result.stderr,
+  });
+
+  if (result.code === 143) {
+    console.log(
+      '✓ SUCCESS: Virtual command was properly interrupted with SIGTERM exit code'
+    );
+    process.exit(0);
+  } else {
+    console.log('✗ FAIL: Unexpected exit code:', result.code);
+    process.exit(1);
+  }
+}
+
+test().catch(console.error);

package/js/examples/test-issue-135-comprehensive.mjs

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+// Comprehensive test for issue #135: Trace logs interfere with output
+
+import { $ } from '../src/$.mjs';
+
+console.log(
+  '=== Test 1: Default (no env vars, mirror:false, capture:true) ==='
+);
+const $silent = $({ mirror: false, capture: true });
+const result1 = await $silent`echo test1`;
+console.log('Output:', result1.stdout);
+console.log('Expected: just "test1"\n');
+
+console.log('=== Test 2: CI=true (should NOT produce trace logs) ===');
+process.env.CI = 'true';
+const $silent2 = $({ mirror: false, capture: true });
+const result2 = await $silent2`echo test2`;
+console.log('Output:', result2.stdout);
+console.log('Expected: just "test2"\n');
+
+console.log(
+  '=== Test 3: CI=true + COMMAND_STREAM_TRACE=true (should produce trace logs) ==='
+);
+process.env.COMMAND_STREAM_TRACE = 'true';
+const $silent3 = $({ mirror: false, capture: true });
+const result3 = await $silent3`echo test3`;
+console.log('Output:', result3.stdout);
+console.log('Expected: "test3" (trace logs should appear in stderr above)\n');
+
+console.log(
+  '=== Test 4: COMMAND_STREAM_TRACE=false overrides COMMAND_STREAM_VERBOSE=true ==='
+);
+process.env.COMMAND_STREAM_VERBOSE = 'true';
+process.env.COMMAND_STREAM_TRACE = 'false';
+const result4 = await $silent`echo test4`;
+console.log('Output:', result4.stdout);
+console.log(
+  'Expected: just "test4" (no trace logs even though VERBOSE=true)\n'
+);
+
+console.log('=== All tests completed ===');

package/js/examples/test-issue12-detailed.mjs

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+
+// Detailed test for issue #12 - checking error messages and command construction
+// Original issue: https://github.com/link-foundation/command-stream/issues/12
+// Original error: ENOENT: no such file or directory, posix_spawn ''/Users/konard/.claude/local/claude''
+
+import { $ } from '../src/$.mjs';
+
+const claude = process.env.CLAUDE_PATH || '/Users/konard/.claude/local/claude';
+
+console.log('=== Detailed Issue #12 Testing ===\n');
+console.log('Testing path:', claude);
+
+async function testScenarios() {
+  console.log('\n1. Test direct command (no pipe):');
+  console.log('-----------------------------------');
+  try {
+    const cmd = $({ capture: true, mirror: false })`${claude} --version`;
+    console.log('Generated command:', cmd.spec.command);
+    const result = await cmd;
+    console.log('Exit code:', result.code);
+    console.log('Stderr:', result.stderr.trim());
+
+    // Check for double quotes in stderr
+    if (result.stderr.includes("''")) {
+      console.log('❌ Double quotes found in stderr!');
+    } else {
+      console.log('✅ No double quotes in error');
+    }
+  } catch (error) {
+    console.log('Exception:', error.message);
+  }
+
+  console.log('\n2. Test with pipe (original issue):');
+  console.log('------------------------------------');
+  try {
+    const cmd = $({
+      capture: true,
+      mirror: false,
+    })`${claude} -p "hi" --output-format stream-json --model sonnet | jq .`;
+    console.log('Generated command:', cmd.spec.command);
+    const result = await cmd;
+    console.log('Exit code:', result.code);
+    console.log('Output:', result.stdout || '(empty)');
+  } catch (error) {
+    console.log('Exception:', error.message);
+  }
+
+  console.log('\n3. Test command construction:');
+  console.log('------------------------------');
+
+  // Check different interpolation positions
+  const testCases = [
+    {
+      desc: 'First position',
+      template: (p) => $({ mirror: false })`${p} --test`,
+    },
+    {
+      desc: 'Middle position',
+      template: (p) => $({ mirror: false })`echo ${p} test`,
+    },
+    { desc: 'With pipe', template: (p) => $({ mirror: false })`${p} | cat` },
+  ];
+
+  for (const { desc, template } of testCases) {
+    const cmd = template(claude);
+    console.log(`${desc}: ${cmd.spec.command}`);
+  }
+
+  console.log('\n4. Check if pre-quoted paths work:');
+  console.log('-----------------------------------');
+
+  // Test if already-quoted paths are handled correctly
+  const quotedPath = `'${claude}'`;
+  console.log('Input (pre-quoted):', quotedPath);
+  const quotedCmd = $({ mirror: false })`${quotedPath} --test`;
+  console.log('Generated command:', quotedCmd.spec.command);
+
+  if (
+    quotedCmd.spec.command.includes("'''") ||
+    quotedCmd.spec.command.includes("''")
+  ) {
+    console.log('⚠️  Potential issue with pre-quoted path handling');
+  } else {
+    console.log('✅ Pre-quoted path handled correctly');
+  }
+}
+
+testScenarios().catch(console.error);

package/js/examples/test-issue12-exact.mjs

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+
+// Exact test for issue #12 from deep-assistant/hive-mind
+// Original issue: https://github.com/link-foundation/command-stream/issues/12
+// Original error: ENOENT: no such file or directory, posix_spawn ''/Users/konard/.claude/local/claude''
+
+import { $ } from '../src/$.mjs';
+
+const claude = process.env.CLAUDE_PATH || '/Users/konard/.claude/local/claude';
+
+console.log('Testing exact issue #12 scenario:');
+console.log('Path:', claude);
+console.log();
+
+// This is the exact failing line from the original issue
+try {
+  const result =
+    await $`${claude} -p "hi" --output-format stream-json --model sonnet | jq .`;
+  console.log('Success! Result:', result.stdout);
+} catch (error) {
+  console.log('Error message:', error.message);
+  console.log();
+
+  // Check if the error contains the problematic double quotes
+  if (error.message.includes("''") && error.message.includes('posix_spawn')) {
+    console.log('❌ BUG STILL PRESENT: Double quotes in posix_spawn error');
+  } else if (error.message.includes('posix_spawn')) {
+    console.log('⚠️  posix_spawn error but no double quotes - partial fix');
+  } else {
+    console.log('✅ BUG FIXED: No double quotes in error message');
+    console.log('   Error is now properly formatted');
+  }
+}

package/js/examples/test-jq-color.mjs

@@ -0,0 +1,57 @@
+import { $ } from '../src/$.mjs';
+
+console.log('=== Testing jq Color Output ===\n');
+
+async function testJqColors() {
+  const testJson =
+    '{"message": "hello world", "number": 42, "active": true, "data": null}';
+
+  console.log(
+    '1. Testing jq with default options (should show colors if TTY):'
+  );
+  console.log('Input JSON:', testJson);
+  console.log(
+    '\n--- Output with pretty printing (should be colored in TTY) ---'
+  );
+
+  try {
+    // Test 1: Default behavior - should show colors in TTY
+    const result1 = await $`echo ${testJson} | jq .`;
+    console.log('Result code:', result1.code);
+    console.log('Stdout length:', result1.stdout.length);
+    console.log('Contains ANSI codes:', /\u001b\[/.test(result1.stdout));
+    console.log('Raw stdout:', JSON.stringify(result1.stdout));
+
+    console.log('\n2. Testing jq with explicit color output:');
+    const result2 = await $`echo ${testJson} | jq --color-output .`;
+    console.log('Result code:', result2.code);
+    console.log('Contains ANSI codes:', /\u001b\[/.test(result2.stdout));
+    console.log('Raw stdout:', JSON.stringify(result2.stdout));
+
+    console.log('\n3. Testing jq with no color output:');
+    const result3 = await $`echo ${testJson} | jq --color-output=never .`;
+    console.log('Result code:', result3.code);
+    console.log('Contains ANSI codes:', /\u001b\[/.test(result3.stdout));
+    console.log('Raw stdout:', JSON.stringify(result3.stdout));
+
+    console.log('\n4. Testing jq with capture=false (pure mirror mode):');
+    const $mirror = $({ capture: false, mirror: true });
+    console.log('About to run jq with pure mirror mode (output below):');
+    const result4 = await $mirror`echo ${testJson} | jq .`;
+    console.log('Result code (mirror mode):', result4.code);
+
+    console.log('\n5. Testing individual field extraction:');
+    const result5 = await $`echo ${testJson} | jq -r .message`;
+    console.log('Extracted message:', JSON.stringify(result5.stdout.trim()));
+  } catch (error) {
+    console.error('Error testing jq:', error.message);
+  }
+}
+
+console.log('TTY Status:');
+console.log('- process.stdout.isTTY:', process.stdout.isTTY);
+console.log('- process.stderr.isTTY:', process.stderr.isTTY);
+console.log('- process.stdin.isTTY:', process.stdin.isTTY);
+console.log();
+
+testJqColors().catch(console.error);