command-stream 0.8.2 → 0.9.0

package/js/examples/test-operators.mjs

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+
+import { $, shell, enableVirtualCommands } from '../src/$.mjs';
+
+enableVirtualCommands();
+shell.verbose(true);
+
+console.log('=== Testing Shell Operators with cd ===\n');
+
+const originalCwd = process.cwd();
+
+console.log('Test 1: && operator (AND - run next if previous succeeds)');
+console.log('Command: cd /tmp && pwd');
+const result1 = await $`cd /tmp && pwd`;
+console.log('Output:', result1.stdout);
+console.log('After command, cwd is:', process.cwd());
+console.log();
+
+// Reset
+process.chdir(originalCwd);
+
+console.log('Test 2: || operator (OR - run next if previous fails)');
+console.log('Command: cd /nonexistent || echo "failed to cd"');
+const result2 = await $`cd /nonexistent || echo "failed to cd"`;
+console.log('Output:', result2.stdout);
+console.log();
+
+console.log('Test 3: ; operator (semicolon - run regardless)');
+console.log('Command: cd /tmp ; pwd ; cd /usr ; pwd');
+const result3 = await $`cd /tmp ; pwd ; cd /usr ; pwd`;
+console.log('Output:', result3.stdout);
+console.log('After command, cwd is:', process.cwd());
+console.log();
+
+// Reset
+process.chdir(originalCwd);
+
+console.log('Test 4: Subshell with ()');
+console.log('Command: (cd /tmp && pwd) ; pwd');
+const result4 = await $`(cd /tmp && pwd) ; pwd`;
+console.log('Output:', result4.stdout);
+console.log('After command, cwd is:', process.cwd());
+console.log();
+
+console.log('Test 5: Complex chain');
+console.log('Command: cd /tmp && echo "in tmp" && cd /usr && echo "in usr"');
+const result5 = await $`cd /tmp && echo "in tmp" && cd /usr && echo "in usr"`;
+console.log('Output:', result5.stdout);
+console.log('After command, cwd is:', process.cwd());
+
+// Reset to original
+process.chdir(originalCwd);
+console.log('\n=== Tests Complete ===');

package/js/examples/test-parent-continues.mjs

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+
+// Test that parent process continues after child is interrupted
+
+import { $ } from '../src/$.mjs';
+
+async function test() {
+  console.log('Testing that parent continues after child interruption...\n');
+
+  // Start first command
+  console.log('1. Starting first sleep command...');
+  const runner1 = $`sleep 5`;
+  const promise1 = runner1.start();
+
+  // Kill it after 500ms
+  setTimeout(() => {
+    console.log('   Killing first command...');
+    runner1.kill();
+  }, 500);
+
+  const result1 = await promise1;
+  console.log(`   First command finished with code: ${result1.code}`);
+
+  // Parent continues - start another command
+  console.log('\n2. Parent continues - starting second command...');
+  const runner2 = $`echo "Parent is still alive!"`;
+  const result2 = await runner2;
+  console.log(`   Second command output: ${result2.stdout.trim()}`);
+  console.log(`   Second command finished with code: ${result2.code}`);
+
+  // Start a third command to prove we're still running
+  console.log('\n3. Starting third command...');
+  const result3 = await $`echo "Still running after interruption"`;
+  console.log(`   Third command output: ${result3.stdout.trim()}`);
+
+  console.log(
+    '\n✓ SUCCESS: Parent process continued running after child interruption'
+  );
+  console.log(
+    "This is the correct behavior - parent doesn't exit on child SIGINT"
+  );
+}
+
+test().catch(console.error);

package/js/examples/test-path-interpolation.mjs

@@ -0,0 +1,86 @@
+import { $ } from '../src/$.mjs';
+
+console.log('=== Testing Path Interpolation Issues ===\n');
+
+async function testPathInterpolation() {
+  // Test 1: Simple path with no spaces
+  console.log('1. Testing simple path interpolation:');
+  const simplePath = '/bin/echo';
+  try {
+    const result1 = await $`${simplePath} "simple test"`;
+    console.log('✅ Simple path works:', result1.stdout.trim());
+  } catch (error) {
+    console.log('❌ Simple path failed:', error.message);
+  }
+
+  // Test 2: Path with spaces (like the .claude directory)
+  console.log('\n2. Testing path with spaces:');
+  const pathWithSpaces = '/usr/bin/env';
+  try {
+    const result2 = await $`${pathWithSpaces} echo "space test"`;
+    console.log('✅ Path with env works:', result2.stdout.trim());
+  } catch (error) {
+    console.log('❌ Path with env failed:', error.message);
+  }
+
+  // Test 3: Simulate the exact issue - path that might have quotes
+  console.log('\n3. Testing problematic path structure:');
+  const problematicPath = '/nonexistent/path/to/claude';
+  try {
+    const result3 = await $`${problematicPath} --version`;
+    console.log('✅ Problematic path works:', result3.stdout.trim());
+  } catch (error) {
+    console.log('❌ Problematic path failed:', error.message);
+    console.log('Error details:', error);
+  }
+
+  // Test 4: Check what command gets built
+  console.log('\n4. Testing command building:');
+  const testPath = '/Users/test/.claude/local/claude';
+  console.log('Variable value:', JSON.stringify(testPath));
+
+  try {
+    // Create command but don't execute
+    const cmd = $`${testPath} --help`;
+    console.log('Command spec:', cmd.spec);
+  } catch (error) {
+    console.log('❌ Command building failed:', error.message);
+  }
+
+  // Test 5: Environment variable usage
+  console.log('\n5. Testing environment variable:');
+  process.env.TEST_CLAUDE_PATH = '/usr/bin/echo';
+  const claudeFromEnv = process.env.TEST_CLAUDE_PATH;
+  console.log('Env var value:', JSON.stringify(claudeFromEnv));
+
+  try {
+    const result5 = await $`${claudeFromEnv} "env test"`;
+    console.log('✅ Env var path works:', result5.stdout.trim());
+  } catch (error) {
+    console.log('❌ Env var path failed:', error.message);
+  }
+
+  // Test 6: Test with stdin like the failing script
+  console.log('\n6. Testing with stdin (like failing script):');
+  try {
+    const result6 = await $({ stdin: 'test input\n', mirror: false })`/bin/cat`;
+    console.log('✅ Stdin test works:', result6.stdout.trim());
+  } catch (error) {
+    console.log('❌ Stdin test failed:', error.message);
+  }
+
+  // Test 7: Check raw command string
+  console.log('\n7. Checking command string generation:');
+  const testCmd = '/usr/bin/which';
+  console.log('Raw variable:', JSON.stringify(testCmd));
+  try {
+    const cmd = $`${testCmd} node`;
+    console.log('Generated command:', cmd.spec?.command || 'Not available');
+    const result = await cmd;
+    console.log('✅ Command string test works');
+  } catch (error) {
+    console.log('❌ Command string test failed:', error.message);
+  }
+}
+
+testPathInterpolation().catch(console.error);

package/js/examples/test-ping-kill-and-stdin.mjs

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+
+/**
+ * Simple test to verify:
+ * 1. streams.stdin can be used to send data to commands that read stdin
+ * 2. kill() method works to interrupt ping commands
+ */
+
+import { $ } from '../src/$.mjs';
+
+console.log('=== Testing ping kill() and streams.stdin ===');
+console.log('');
+
+async function testPingKillAndStdin() {
+  try {
+    console.log('TEST 1: Use kill() method to interrupt ping 8.8.8.8');
+
+    const pingCommand = $`ping 8.8.8.8`;
+
+    // Access streams.stdout to auto-start the command
+    const stdout = pingCommand.streams.stdout;
+    console.log('✓ Accessed streams.stdout - ping should start');
+    console.log('  Started?', pingCommand.started);
+
+    // Wait for ping to produce some output
+    await new Promise((resolve) => setTimeout(resolve, 1500));
+
+    // Kill the ping command
+    console.log('✓ Killing ping command...');
+    pingCommand.kill();
+
+    const result = await pingCommand;
+    console.log('✓ Ping killed with exit code:', result.code);
+    console.log('✓ Output received (length):', result.stdout.length);
+    console.log(
+      '✓ First 100 chars:',
+      JSON.stringify(result.stdout.slice(0, 100))
+    );
+
+    console.log('');
+    console.log('TEST 2: Send data via streams.stdin to cat');
+
+    const catCommand = $`cat`;
+
+    // Access stdin to auto-start and get the stream
+    const stdin = catCommand.streams.stdin;
+    console.log('✓ Accessed streams.stdin - cat should start');
+    console.log('  Started?', catCommand.started);
+
+    // Send data to cat
+    if (stdin) {
+      console.log('✓ Writing data to stdin...');
+      stdin.write('Hello from stdin!\\n');
+      stdin.write('Second line\\n');
+      stdin.end(); // Close stdin so cat finishes
+    }
+
+    const catResult = await catCommand;
+    console.log('✓ Cat completed with exit code:', catResult.code);
+    console.log('✓ Cat output:', JSON.stringify(catResult.stdout));
+
+    console.log('');
+    console.log(
+      'TEST 3: Verify stdin is available but process not started initially'
+    );
+
+    const echoCommand = $`cat`;
+    console.log('✓ Command created, started?', echoCommand.started);
+
+    // Just access streams object (should not auto-start)
+    const streams = echoCommand.streams;
+    console.log('✓ Accessed .streams object, started?', echoCommand.started);
+
+    // Now access stdin (should auto-start)
+    const echoStdin = echoCommand.streams.stdin;
+    console.log('✓ Accessed .streams.stdin, started?', echoCommand.started);
+
+    if (echoStdin) {
+      echoStdin.write('Auto-start test\\n');
+      echoStdin.end();
+    }
+
+    const echoResult = await echoCommand;
+    console.log('✓ Result:', JSON.stringify(echoResult.stdout));
+
+    console.log('');
+    console.log(
+      '✅ ALL TESTS PASSED - ping kill() and streams.stdin work correctly!'
+    );
+  } catch (error) {
+    console.log('');
+    console.error('❌ TEST FAILED:', error.message);
+    console.error(error.stack);
+    process.exit(1);
+  }
+}
+
+testPingKillAndStdin();

package/js/examples/test-ping.mjs

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+
+// Test ping example similar to hive-mind/claude-pipe/test-ping.mjs
+import { $ } from '../src/$.mjs';
+
+console.log('STARTING_PING');
+try {
+  await $`ping 8.8.8.8`;
+} catch (error) {
+  console.error('❌ Test failed:', error.message);
+  process.exit(1);
+}

package/js/examples/test-pty-spawn.mjs

@@ -0,0 +1,101 @@
+#!/usr/bin/env bun
+
+// Test if Bun has PTY support or if we can fake it
+
+console.log('=== Testing PTY/TTY Solutions ===\n');
+
+// Check if Bun has PTY support
+console.log('Checking Bun APIs for PTY support:');
+console.log(
+  '  Bun.spawn options:',
+  Object.keys(Bun.spawn(['echo'], { stdout: 'pipe' }))
+);
+
+// Try using script command as a PTY wrapper
+console.log('\nUsing script command as PTY wrapper:');
+{
+  const start = Date.now();
+  let chunkCount = 0;
+
+  // Use script to create a PTY
+  // -q: quiet mode (no script started/done messages)
+  // /dev/null: don't save typescript file
+  const proc = Bun.spawn(
+    [
+      'script',
+      '-q',
+      '/dev/null',
+      'sh',
+      '-c',
+      'bun run js/examples/emulate-claude-stream.mjs | jq .',
+    ],
+    {
+      stdout: 'pipe',
+      stderr: 'pipe',
+      env: {
+        ...process.env,
+        // Force color/TTY detection
+        FORCE_COLOR: '1',
+        TERM: 'xterm-256color',
+      },
+    }
+  );
+
+  for await (const chunk of proc.stdout) {
+    chunkCount++;
+    const elapsed = Date.now() - start;
+    const text = Buffer.from(chunk).toString();
+
+    // Script adds control characters, let's see what we get
+    const cleanText = text.replace(/\x1b\[[0-9;]*m/g, ''); // Remove ANSI codes
+    const lines = cleanText
+      .split('\n')
+      .filter((l) => l.trim())
+      .slice(0, 2);
+
+    console.log(`  [${elapsed}ms] Chunk ${chunkCount}: ${chunk.length} bytes`);
+    if (lines.length > 0) {
+      console.log(`    First lines:`, lines);
+    }
+  }
+
+  await proc.exited;
+  console.log(`  Total chunks: ${chunkCount}`);
+}
+
+// Alternative: Try to use COLUMNS/LINES env vars to fake TTY
+console.log('\nTrying with TTY environment variables:');
+{
+  const start = Date.now();
+  let chunkCount = 0;
+
+  const proc = Bun.spawn(
+    ['sh', '-c', 'bun run js/examples/emulate-claude-stream.mjs | jq .'],
+    {
+      stdout: 'pipe',
+      stderr: 'pipe',
+      env: {
+        ...process.env,
+        COLUMNS: '80',
+        LINES: '24',
+        TERM: 'xterm-256color',
+        FORCE_COLOR: '1',
+      },
+    }
+  );
+
+  for await (const chunk of proc.stdout) {
+    chunkCount++;
+    const elapsed = Date.now() - start;
+    const text = Buffer.from(chunk).toString();
+    const lines = text
+      .split('\n')
+      .filter((l) => l.trim())
+      .slice(0, 2);
+
+    console.log(`  [${elapsed}ms] Chunk ${chunkCount}: first lines:`, lines);
+  }
+
+  await proc.exited;
+  console.log(`  Total chunks: ${chunkCount}`);
+}

package/js/examples/test-pty.mjs

@@ -0,0 +1,38 @@
+#!/usr/bin/env bun
+
+// Test using unbuffer or script to create a pseudo-TTY
+
+console.log('Test: Using unbuffer to force line buffering\n');
+
+const proc1 = Bun.spawn(['./js/examples/emulate-claude-stream.mjs'], {
+  stdout: 'pipe',
+  stderr: 'pipe',
+});
+
+// Try using unbuffer (if available) to force line buffering
+// unbuffer is part of the expect package
+const proc2 = Bun.spawn(['unbuffer', 'jq', '.'], {
+  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();
+  const lines = text
+    .split('\n')
+    .filter((l) => l.trim())
+    .slice(0, 2);
+
+  console.log(`[${elapsed}ms] Chunk ${chunkCount}: First lines:`, lines);
+}
+
+console.log(`\nTotal chunks received: ${chunkCount}`);
+
+await proc1.exited;
+await proc2.exited;

package/js/examples/test-quote-behavior-summary.mjs

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+
+// Comprehensive test of the smart quoting behavior
+import { $ } from '../src/$.mjs';
+
+console.log('=== Smart Quoting Behavior Summary ===\n');
+
+const tests = [
+  {
+    category: 'SAFE STRINGS (No quotes needed)',
+    tests: [
+      { input: 'hello', expected: 'hello' },
+      { input: '/usr/bin/echo', expected: '/usr/bin/echo' },
+      { input: 'file.txt', expected: 'file.txt' },
+      { input: 'user@host.com', expected: 'user@host.com' },
+      { input: 'key=value', expected: 'key=value' },
+      { input: '192.168.1.1', expected: '192.168.1.1' },
+      { input: 'v1.2.3-beta', expected: 'v1.2.3-beta' },
+    ],
+  },
+
+  {
+    category: 'UNSAFE STRINGS (Auto-quoted)',
+    tests: [
+      { input: 'hello world', expected: "'hello world'" },
+      { input: '$HOME', expected: "'$HOME'" },
+      { input: '$(whoami)', expected: "'$(whoami)'" },
+      { input: '`date`', expected: "'`date`'" },
+      { input: 'test; ls', expected: "'test; ls'" },
+      { input: 'a|b', expected: "'a|b'" },
+      { input: 'a&b', expected: "'a&b'" },
+      { input: 'a>b', expected: "'a>b'" },
+      { input: '*.txt', expected: "'*.txt'" },
+      { input: 'a b c', expected: "'a b c'" },
+    ],
+  },
+
+  {
+    category: 'USER-PROVIDED SINGLE QUOTES (Preserved)',
+    tests: [
+      { input: "'hello'", expected: "'hello'" },
+      { input: "'hello world'", expected: "'hello world'" },
+      { input: "'$HOME'", expected: "'$HOME'" },
+      { input: "'/path with spaces/cmd'", expected: "'/path with spaces/cmd'" },
+      { input: "'test; echo BAD'", expected: "'test; echo BAD'" },
+    ],
+  },
+
+  {
+    category: 'USER-PROVIDED DOUBLE QUOTES (Wrapped)',
+    tests: [
+      { input: '"hello"', expected: '\'"hello"\'' },
+      { input: '"hello world"', expected: '\'"hello world"\'' },
+      { input: '"$HOME"', expected: '\'"$HOME"\'' },
+      {
+        input: '"/path with spaces/cmd"',
+        expected: '\'"/path with spaces/cmd"\'',
+      },
+      { input: '"test; echo BAD"', expected: '\'"test; echo BAD"\'' },
+    ],
+  },
+
+  {
+    category: 'COMPLEX CASES',
+    tests: [
+      { input: "it's", expected: "'it'\\''s'" },
+      { input: "'it's'", expected: "''\\''it'\\''s'\\'''" }, // Invalid quoted string, needs re-escaping
+      { input: '""', expected: '\'""\'' },
+      { input: "''", expected: "''" },
+      { input: "'", expected: "''\\'''" },
+      { input: '"', expected: "'\"'" },
+    ],
+  },
+];
+
+let totalPassed = 0;
+let totalFailed = 0;
+
+tests.forEach(({ category, tests: categoryTests }) => {
+  console.log(`\n${category}`);
+  console.log('='.repeat(category.length));
+
+  categoryTests.forEach(({ input, expected }) => {
+    const cmd = $({ mirror: false })`echo ${input}`;
+    const actual = cmd.spec.command.replace('echo ', '');
+    const passed = actual === expected;
+
+    if (passed) {
+      console.log(`✅ ${input.padEnd(25)} → ${actual}`);
+      totalPassed++;
+    } else {
+      console.log(`❌ ${input.padEnd(25)} → ${actual} (expected: ${expected})`);
+      totalFailed++;
+    }
+  });
+});
+
+console.log(`\n${'='.repeat(50)}`);
+console.log(`TOTAL: ${totalPassed} passed, ${totalFailed} failed`);
+
+if (totalFailed === 0) {
+  console.log('\n🎉 All quoting behaviors work as expected!');
+  console.log('\nKey features:');
+  console.log('✓ No unnecessary quoting for safe strings');
+  console.log('✓ Automatic quoting for strings with special characters');
+  console.log('✓ User-provided single quotes are preserved');
+  console.log('✓ User-provided double quotes are preserved (wrapped)');
+  console.log('✓ No double-quoting when user already quoted');
+  console.log('✓ Shell injection protection maintained');
+}

package/js/examples/test-quote-edge-cases.mjs

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+
+// Test quoting edge cases for issue #12
+import { $ } from '../src/$.mjs';
+
+console.log('=== Testing Quote Edge Cases for Issue #12 ===\n');
+
+async function testCommands() {
+  // Test 1: Path as command (should NOT be quoted)
+  console.log('1. Testing path as command:');
+  const path = '/bin/echo';
+  try {
+    const result = await $`${path} "hello from echo"`;
+    console.log('✓ Success:', String(result).trim());
+  } catch (error) {
+    console.error('✗ Failed:', error.message);
+  }
+
+  // Test 2: Path with spaces (needs special handling)
+  console.log('\n2. Testing path with spaces:');
+  const spacePath = '/path with spaces/bin/echo';
+  try {
+    // This should fail since the path doesn't exist, but check the error message
+    const result = await $`${spacePath} "test"`;
+    console.log('Result:', String(result).trim());
+  } catch (error) {
+    console.error('Expected failure:', error.message);
+    // Check if quotes are doubled in the error
+    if (error.message.includes("''")) {
+      console.log('⚠️  Double quotes detected in error!');
+    }
+  }
+
+  // Test 3: Command with arguments
+  console.log('\n3. Testing command with multiple interpolations:');
+  const cmd = 'echo';
+  const arg1 = 'hello';
+  const arg2 = 'world';
+  try {
+    const result = await $`${cmd} ${arg1} ${arg2}`;
+    console.log('✓ Success:', String(result).trim());
+  } catch (error) {
+    console.error('✗ Failed:', error.message);
+  }
+
+  // Test 4: First interpolation is command, should not be quoted
+  console.log('\n4. Testing first interpolation as command:');
+  const ls = 'ls';
+  try {
+    const result = await $`${ls} -la`.pipe($`head -n 3`);
+    console.log('✓ Success, got listing');
+  } catch (error) {
+    console.error('✗ Failed:', error.message);
+  }
+
+  // Test 5: Complex command construction
+  console.log('\n5. Testing complex command:');
+  const executable = '/usr/bin/env';
+  const program = 'node';
+  const flag = '--version';
+  try {
+    const result = await $`${executable} ${program} ${flag}`;
+    console.log('✓ Success:', String(result).trim());
+  } catch (error) {
+    console.error('✗ Failed:', error.message);
+  }
+}
+
+testCommands().catch(console.error);

package/js/examples/test-quote-parsing.mjs

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+
+import { parseShellCommand } from '../src/shell-parser.mjs';
+
+const tests = [
+  'cd "/tmp/my dir"',
+  'cd /tmp/my\\ dir',
+  "cd '/tmp/my dir'",
+  'echo "hello world"',
+];
+
+console.log('=== Testing quote parsing ===\n');
+
+for (const cmd of tests) {
+  console.log(`Command: ${cmd}`);
+  const parsed = parseShellCommand(cmd);
+  console.log('Parsed:', JSON.stringify(parsed, null, 2));
+
+  if (parsed && parsed.type === 'simple' && parsed.args.length > 0) {
+    console.log('First arg value:', parsed.args[0].value);
+  }
+  console.log();
+}