command-stream 0.8.2 → 0.9.0

package/js/examples/events-log-processing.mjs

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+
+// Real-time log processing with events
+
+import { $ } from '../src/$.mjs';
+
+console.log('Real-time log processing:');
+const $logProcessor = $({ mirror: false });
+
+try {
+  const logScript = `
+echo "INFO: Application starting"
+sleep 0.2
+echo "DEBUG: Loading configuration"
+sleep 0.2
+echo "WARN: Deprecated API usage detected" >&2
+sleep 0.2
+echo "INFO: Server listening on port 3000"
+sleep 0.2
+echo "ERROR: Database connection failed" >&2
+sleep 0.2
+echo "INFO: Retrying database connection"
+sleep 0.2
+echo "INFO: Application ready"
+`;
+
+  const runner = $logProcessor`bash -c '${logScript}'`;
+
+  const logStats = { info: 0, debug: 0, warn: 0, error: 0 };
+
+  runner.on('stdout', (data) => {
+    const lines = data
+      .toString()
+      .split('\n')
+      .filter((line) => line.trim());
+    for (const line of lines) {
+      if (line.includes('INFO:')) {
+        logStats.info++;
+        console.log(`ℹ️  ${line}`);
+      } else if (line.includes('DEBUG:')) {
+        logStats.debug++;
+        console.log(`🐛 ${line}`);
+      }
+    }
+  });
+
+  runner.on('stderr', (data) => {
+    const lines = data
+      .toString()
+      .split('\n')
+      .filter((line) => line.trim());
+    for (const line of lines) {
+      if (line.includes('WARN:')) {
+        logStats.warn++;
+        console.log(`⚠️  ${line}`);
+      } else if (line.includes('ERROR:')) {
+        logStats.error++;
+        console.log(`❌ ${line}`);
+      }
+    }
+  });
+
+  runner.on('close', (code) => {
+    console.log(
+      `📊 Log summary: ${logStats.info} info, ${logStats.debug} debug, ${logStats.warn} warnings, ${logStats.error} errors`
+    );
+  });
+
+  await runner;
+} catch (error) {
+  console.log(`Error: ${error.message}`);
+}

package/js/examples/events-network-monitoring.mjs

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+
+// Network monitoring with multiple hosts using events
+
+import { $ } from '../src/$.mjs';
+
+console.log('Network monitoring with multiple hosts:');
+
+const hosts = ['google.com', 'github.com', 'stackoverflow.com'];
+const $networkMonitors = hosts.map(() => $({ mirror: false }));
+
+try {
+  console.log('Starting network monitoring...');
+
+  const hostResults = new Map();
+  const promises = [];
+
+  for (let i = 0; i < hosts.length; i++) {
+    const host = hosts[i];
+    const monitor = $networkMonitors[i];
+    const runner = monitor`ping -c 3 ${host}`;
+
+    hostResults.set(host, { packets: 0, avgTime: 0, times: [] });
+
+    runner.on('stdout', (data) => {
+      const lines = data
+        .toString()
+        .split('\n')
+        .filter((line) => line.trim());
+      for (const line of lines) {
+        if (line.includes('bytes from')) {
+          const timeMatch = line.match(/time=([0-9.]+)/);
+          if (timeMatch) {
+            const time = parseFloat(timeMatch[1]);
+            const result = hostResults.get(host);
+            result.packets++;
+            result.times.push(time);
+            console.log(`🌐 ${host}: packet #${result.packets} (${time}ms)`);
+          }
+        }
+      }
+    });
+
+    runner.on('close', (code) => {
+      const result = hostResults.get(host);
+      if (result.times.length > 0) {
+        result.avgTime = (
+          result.times.reduce((a, b) => a + b, 0) / result.times.length
+        ).toFixed(2);
+      }
+      console.log(`✅ ${host}: monitoring complete (avg: ${result.avgTime}ms)`);
+    });
+
+    promises.push(runner);
+  }
+
+  await Promise.all(promises);
+
+  console.log('\n📊 Network monitoring summary:');
+  for (const [host, result] of hostResults) {
+    const status = result.packets > 0 ? '🟢' : '🔴';
+    console.log(
+      `${status} ${host}: ${result.packets} packets, avg ${result.avgTime}ms`
+    );
+  }
+} catch (error) {
+  console.log(`Error: ${error.message}`);
+}

package/js/examples/events-ping-basic.mjs

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+
+// Basic event-based ping with options
+
+import { $ } from '../src/$.mjs';
+
+console.log('Basic event-based ping (silent mode):');
+const $silent = $({ mirror: false });
+
+try {
+  const runner = $silent`ping -c 5 8.8.8.8`;
+
+  let packetCount = 0;
+
+  runner.on('stdout', (data) => {
+    const output = data.toString().trim();
+    if (output.includes('bytes from')) {
+      packetCount++;
+      const timeMatch = output.match(/time=([0-9.]+)/);
+      const responseTime = timeMatch ? timeMatch[1] : 'unknown';
+      console.log(`📡 Packet #${packetCount}: ${responseTime}ms`);
+    }
+  });
+
+  runner.on('stderr', (data) => {
+    console.log(`⚠️  Error: ${data.toString().trim()}`);
+  });
+
+  runner.on('close', (code) => {
+    console.log(`✅ Ping completed with exit code: ${code}`);
+    console.log(`📊 Total packets received: ${packetCount}`);
+  });
+
+  await runner;
+} catch (error) {
+  console.log(`❌ Error: ${error.message}`);
+}

package/js/examples/events-progress-tracking.mjs

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+
+// Long-running process with progress events
+
+import { $ } from '../src/$.mjs';
+
+console.log('Long-running process with progress tracking:');
+const $progress = $({ mirror: false, capture: true });
+
+try {
+  const progressScript = `
+for i in {1..10}; do
+  echo "Progress: $i/10"
+  echo "Status: Processing item $i" >&2
+  sleep 0.3
+done
+echo "Complete!"
+`;
+
+  const runner = $progress`bash -c '${progressScript}'`;
+
+  let progressCount = 0;
+  let statusCount = 0;
+
+  runner.on('stdout', (data) => {
+    const output = data.toString().trim();
+    if (output.includes('Progress:')) {
+      progressCount++;
+      const percent = ((progressCount / 10) * 100).toFixed(0);
+      console.log(`📊 ${output} (${percent}%)`);
+    } else if (output.includes('Complete')) {
+      console.log(`✅ ${output}`);
+    }
+  });
+
+  runner.on('stderr', (data) => {
+    const output = data.toString().trim();
+    if (output.includes('Status:')) {
+      statusCount++;
+      console.log(`🔄 ${output}`);
+    }
+  });
+
+  runner.on('close', (code) => {
+    console.log(`🏁 Process completed with code: ${code}`);
+    console.log(
+      `📈 Progress events: ${progressCount}, Status events: ${statusCount}`
+    );
+  });
+
+  const result = await runner;
+  console.log(`💾 Captured output length: ${result.stdout.length} chars`);
+} catch (error) {
+  console.log(`❌ Error: ${error.message}`);
+}

package/js/examples/events-stdin-input.mjs

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+
+// Event-based with custom stdin
+
+import { $ } from '../src/$.mjs';
+
+console.log('Event-based with custom stdin:');
+const $withInput = $({ stdin: 'Hello\nWorld\nTest\n', mirror: false });
+
+try {
+  const runner = $withInput`cat -n`;
+
+  let lineCount = 0;
+
+  runner.on('stdout', (data) => {
+    const lines = data
+      .toString()
+      .split('\n')
+      .filter((line) => line.trim());
+    for (const line of lines) {
+      lineCount++;
+      console.log(`📝 Line processed: ${line}`);
+    }
+  });
+
+  runner.on('close', (code) => {
+    console.log(`✅ Input processing completed`);
+    console.log(`📊 Total lines processed: ${lineCount}`);
+  });
+
+  await runner;
+} catch (error) {
+  console.log(`❌ Error: ${error.message}`);
+}

package/js/examples/example-ansi-ls.mjs

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+
+import { $, AnsiUtils } from '../src/$.mjs';
+
+console.log('=== ANSI Color Example with ls command ===\n');
+
+// Use ls with color output
+console.log('1. Running ls --color=always (preserves ANSI colors by default):');
+try {
+  const result = await $`ls --color=always -la`;
+  console.log('Raw output with ANSI codes:');
+  console.log(result.stdout);
+
+  console.log('\n2. Same output with ANSI codes stripped:');
+  const cleanOutput = AnsiUtils.stripAnsi(result.stdout);
+  console.log(cleanOutput);
+
+  console.log('\n3. Raw bytes showing ANSI escape sequences:');
+  console.log(
+    'First 200 chars as bytes:',
+    Buffer.from(result.stdout.slice(0, 200))
+  );
+} catch (error) {
+  console.log(
+    'Note: ls --color might not be available on macOS, trying alternative...'
+  );
+
+  // Try with a different colored command
+  const result =
+    await $`printf "\033[31mRed\033[0m \033[32mGreen\033[0m \033[34mBlue\033[0m\n"`;
+  console.log('Raw output with ANSI codes:');
+  process.stdout.write(result.stdout); // Write directly to see colors
+
+  console.log('\nSame output with ANSI codes stripped:');
+  console.log(AnsiUtils.stripAnsi(result.stdout));
+
+  console.log('\nRaw bytes showing escape sequences:');
+  console.log(Buffer.from(result.stdout));
+}

package/js/examples/example-top.mjs

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+
+import { $ } from '../src/$.mjs';
+
+console.log(
+  '=== Running top command with ANSI colors preserved (default behavior) ==='
+);
+
+// Run top for 3 seconds then kill it
+const proc = $`top -l 1`;
+
+// Show the output as it streams
+proc.on('stdout', (chunk) => {
+  process.stdout.write(chunk);
+});
+
+proc.on('stderr', (chunk) => {
+  process.stderr.write(chunk);
+});
+
+proc.on('end', (result) => {
+  console.log('\n=== Command completed ===');
+  console.log(`Exit code: ${result.code}`);
+});
+
+// Execute the command
+await proc;

package/js/examples/final-ping-stdin-proof.mjs

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+
+/**
+ * Final proof: ping cannot be controlled via stdin - needs kill() method
+ */
+
+import { spawn } from 'child_process';
+import { $ } from '../src/$.mjs';
+
+console.log('=== FINAL PROOF: ping stdin vs kill() ===');
+
+async function finalProof() {
+  console.log('\\n1️⃣ NATIVE SPAWN: ping ignores stdin CTRL+C');
+
+  const nativePing = spawn('ping', ['-c', '10', '8.8.8.8']); // Limit to 10 pings
+
+  nativePing.stdout.on('data', (data) => {
+    process.stdout.write(`[native] ${data}`);
+  });
+
+  // Try stdin after 1 second
+  setTimeout(() => {
+    console.log('\\n  → Sending CTRL+C via stdin...');
+    nativePing.stdin.write('\\x03');
+    nativePing.stdin.end();
+  }, 1000);
+
+  // Force kill if still running after 3 seconds
+  setTimeout(() => {
+    if (!nativePing.killed) {
+      console.log('\\n  → stdin FAILED, using SIGTERM...');
+      nativePing.kill('SIGTERM');
+    }
+  }, 3000);
+
+  const nativeResult = await new Promise((resolve) => {
+    nativePing.on('close', (code, signal) => resolve({ code, signal }));
+  });
+
+  console.log(
+    `\\n  ✓ Result: code=${nativeResult.code}, signal=${nativeResult.signal}`
+  );
+  console.log('  ✓ Proof: ping ignores stdin, needed kill signal\\n');
+
+  console.log('2️⃣ COMMAND-STREAM: kill() method works perfectly');
+
+  const streamPing = $`ping 8.8.8.8`;
+
+  // Start ping by accessing stdout stream
+  const stdout = streamPing.streams.stdout;
+  if (stdout) {
+    stdout.on('data', (data) => {
+      process.stdout.write(`[stream] ${data}`);
+    });
+  }
+
+  // Kill cleanly after 2 seconds
+  setTimeout(() => {
+    console.log('\\n  → Using command-stream kill()...');
+    streamPing.kill();
+  }, 2000);
+
+  const streamResult = await streamPing;
+  console.log(`\\n  ✓ Result: code=${streamResult.code}`);
+  console.log('  ✓ Success: kill() method worked perfectly\\n');
+
+  console.log('3️⃣ STDIN WORKS: for commands that actually read it');
+
+  const catCmd = $`cat`;
+  const stdin = catCmd.streams.stdin;
+
+  console.log('  → Sending data to cat via stdin...');
+  if (stdin) {
+    stdin.write('Hello via stdin!\\n');
+    stdin.write('This works because cat reads stdin\\n');
+    stdin.end();
+  }
+
+  const catResult = await catCmd;
+  console.log(`  ✓ cat output: ${JSON.stringify(catResult.stdout)}`);
+
+  console.log('\\n📋 CONCLUSION:');
+  console.log('✓ ping ignores stdin → use kill() method');
+  console.log('✓ cat/grep/etc read stdin → use streams.stdin');
+  console.log('✓ command-stream provides both capabilities');
+}
+
+finalProof().catch(console.error);

package/js/examples/final-test-shell-operators.mjs

@@ -0,0 +1,123 @@
+#!/usr/bin/env node
+
+import { $, shell, enableVirtualCommands } from '../src/$.mjs';
+import { mkdtempSync, rmSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+
+enableVirtualCommands();
+shell.verbose(false);
+
+console.log('=== Final Shell Operators Test ===\n');
+
+const testResults = [];
+
+async function test(name, fn) {
+  try {
+    await fn();
+    testResults.push({ name, status: '✓' });
+    console.log(`✓ ${name}`);
+  } catch (error) {
+    testResults.push({ name, status: '✗', error: error.message });
+    console.log(`✗ ${name}: ${error.message}`);
+  }
+}
+
+const originalCwd = process.cwd();
+
+// Test 1: && operator
+await test('&& operator works', async () => {
+  const result = await $`cd /tmp && pwd`;
+  if (result.stdout.trim() !== '/tmp') {
+    throw new Error(`Expected /tmp, got ${result.stdout.trim()}`);
+  }
+  process.chdir(originalCwd);
+});
+
+// Test 2: || operator
+await test('|| operator works', async () => {
+  const result = await $`cd /nonexistent 2>/dev/null || echo "failed"`;
+  if (!result.stdout.includes('failed')) {
+    throw new Error('Expected "failed" in output');
+  }
+});
+
+// Test 3: ; operator
+await test('; operator works', async () => {
+  const result = await $`cd /tmp ; pwd ; cd /usr ; pwd`;
+  const lines = result.stdout.trim().split('\n');
+  if (lines[0] !== '/tmp' || lines[1] !== '/usr') {
+    throw new Error(`Expected /tmp and /usr, got ${lines.join(', ')}`);
+  }
+  process.chdir(originalCwd);
+});
+
+// Test 4: Subshell ()
+await test('Subshell isolation works', async () => {
+  await $`cd /tmp`;
+  const result = await $`(cd /usr && pwd) ; pwd`;
+  const lines = result.stdout.trim().split('\n');
+  if (lines[0] !== '/usr' || lines[1] !== '/tmp') {
+    throw new Error(`Expected /usr then /tmp, got ${lines.join(', ')}`);
+  }
+  process.chdir(originalCwd);
+});
+
+// Test 5: Complex chain
+await test('Complex chain works', async () => {
+  const tempDir = mkdtempSync(join(tmpdir(), 'test-'));
+  try {
+    const result =
+      await $`cd ${tempDir} && echo "file1" > a.txt && echo "file2" > b.txt && ls | wc -l`;
+    const fileCount = parseInt(result.stdout.trim());
+    if (fileCount !== 2) {
+      throw new Error(`Expected 2 files, got ${fileCount}`);
+    }
+  } finally {
+    rmSync(tempDir, { recursive: true, force: true });
+    process.chdir(originalCwd);
+  }
+});
+
+// Test 6: cd persists across commands
+await test('cd persists in session', async () => {
+  await $`cd /var`;
+  const pwd = await $`pwd`;
+  if (pwd.stdout.trim() !== '/var') {
+    throw new Error(`Expected /var, got ${pwd.stdout.trim()}`);
+  }
+  process.chdir(originalCwd);
+});
+
+// Test 7: Nested subshells
+await test('Nested subshells work', async () => {
+  const result = await $`(cd /tmp && (cd /usr && pwd) && pwd)`;
+  const lines = result.stdout.trim().split('\n');
+  if (lines[0] !== '/usr' || lines[1] !== '/tmp') {
+    throw new Error(`Expected /usr then /tmp, got ${lines.join(', ')}`);
+  }
+});
+
+// Test 8: Virtual commands in chains
+await test('Virtual commands work in chains', async () => {
+  const result = await $`echo "hello" && pwd && echo "world"`;
+  if (!result.stdout.includes('hello') || !result.stdout.includes('world')) {
+    throw new Error('Expected both hello and world in output');
+  }
+});
+
+// Summary
+console.log('\n=== Test Summary ===');
+const passed = testResults.filter((r) => r.status === '✓').length;
+const failed = testResults.filter((r) => r.status === '✗').length;
+console.log(`Passed: ${passed}/${testResults.length}`);
+if (failed > 0) {
+  console.log('\nFailed tests:');
+  testResults
+    .filter((r) => r.status === '✗')
+    .forEach((r) => {
+      console.log(`  - ${r.name}: ${r.error}`);
+    });
+}
+
+process.exit(failed > 0 ? 1 : 0);