command-stream 0.8.2 → 0.9.0

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

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+
+import { $ } from '../src/$.mjs';
+
+console.log('=== Simple async streams test ===');
+
+async function simpleAsyncTest() {
+  try {
+    console.log('Test 1: bc calculator with await');
+
+    const bcCmd = $`bc -l`;
+    console.log('Awaiting stdin...');
+
+    const stdin = await bcCmd.streams.stdin;
+    console.log('Stdin available:', !!stdin);
+
+    if (stdin) {
+      console.log('Writing to stdin...');
+      stdin.write('2 + 3\\n');
+      stdin.write('quit\\n');
+    } else {
+      console.log('No stdin, killing process');
+      bcCmd.kill();
+    }
+
+    const result = await bcCmd;
+    console.log('Result:', JSON.stringify(result.stdout));
+    console.log('Exit code:', result.code);
+
+    console.log('\\nTest 2: cat with await');
+
+    const catCmd = $`cat`;
+    const catStdin = await catCmd.streams.stdin;
+    console.log('Cat stdin available:', !!catStdin);
+
+    if (catStdin) {
+      catStdin.write('Hello cat!\\n');
+      catStdin.end();
+    }
+
+    const catResult = await catCmd;
+    console.log('Cat result:', JSON.stringify(catResult.stdout));
+  } catch (error) {
+    console.error('Error:', error.message);
+    console.error(error.stack);
+  }
+}
+
+simpleAsyncTest();

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

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+// Simple Claude test with command-stream
+import { $ } from '../src/$.mjs';
+
+console.log('=== Simple Claude test with command-stream ===');
+
+let chunkCount = 0;
+
+$`claude hi`
+  .on('data', (chunk) => {
+    chunkCount++;
+    console.log(`Stream chunk ${chunkCount}:`, chunk.data.toString());
+  })
+  .on('end', (result) => {
+    console.log(`Command-stream: ${chunkCount} chunks, exit: ${result.code}`);
+  })
+  .start();

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

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+
+import { $ } from '../src/$.mjs';
+
+console.log('🧪 Simple event test');
+
+// First test with a command we know works
+$`echo "test"`
+  .on('data', (chunk) =>
+    console.log('Echo chunk:', chunk.data.toString().trim())
+  )
+  .on('end', (result) => {
+    console.log(`Echo done: ${result.code}`);
+
+    // Now test Claude
+    console.log('\n🤖 Testing Claude...');
+    const claude = 'claude';
+
+    $`${claude} -p "hi" --output-format stream-json --verbose --model sonnet`
+      .on('data', (chunk) => {
+        console.log('Claude chunk:', chunk.data.toString());
+      })
+      .on('end', (result) => {
+        console.log('Claude done:', result.code);
+        process.exit(0);
+      })
+      .on('error', (error) => {
+        console.log('Claude error:', error);
+        process.exit(1);
+      })
+      .start();
+  })
+  .start();

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

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+
+import { $ } from '../src/$.mjs';
+
+console.log('=== Simple jq Streaming Test ===\n');
+
+// Test 1: Basic JSON streaming through jq
+console.log('Test 1: Basic JSON streaming with delays:');
+const startTime = Date.now();
+
+const cmd = $`sh -c 'echo "{\\"id\\":1}"; sleep 0.5; echo "{\\"id\\":2}"; sleep 0.5; echo "{\\"id\\":3}"' | jq -c .`;
+
+let buffer = '';
+for await (const chunk of cmd.stream()) {
+  if (chunk.type === 'stdout') {
+    const elapsed = Date.now() - startTime;
+    buffer += chunk.data.toString();
+
+    const lines = buffer.split('\n');
+    buffer = lines.pop() || '';
+
+    for (const line of lines) {
+      if (line.trim()) {
+        console.log(`[${elapsed}ms] Got JSON:`, line.trim());
+      }
+    }
+  }
+}
+
+console.log('✅ Streaming completed successfully!\n');
+
+// Test 2: Multiple JSON objects at once
+console.log('Test 2: Multiple JSON objects filtered by jq:');
+const filterCmd = $`printf '{"type":"info","msg":"Hello"}\n{"type":"error","msg":"Failed"}\n{"type":"info","msg":"Done"}\n' | jq -c 'select(.type == "error")'`;
+
+const result = await filterCmd;
+console.log('Filtered result:', result.stdout.trim());
+console.log('✅ Filtering works!\n');
+
+// Test 3: Transform JSON stream
+console.log('Test 3: Transform JSON stream in realtime:');
+const transformCmd = $`printf '{"name":"Alice","age":30}\n{"name":"Bob","age":25}\n' | jq -c '{user: .name, years: .age}'`;
+
+const transformResult = await transformCmd;
+console.log('Transformed results:');
+console.log(transformResult.stdout.trim().split('\n').join('\n'));
+
+console.log('\n🎉 All tests passed! JSON streaming with jq works!');

package/js/examples/simple-stream-demo.mjs

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+
+import { $ } from '../src/$.mjs';
+
+console.log('Testing simple streaming without jq...\n');
+
+// First test: direct echo with delays
+const startTime = Date.now();
+const cmd = $`sh -c 'echo "line1"; sleep 0.5; echo "line2"; sleep 0.5; echo "line3"'`;
+
+console.log('Starting stream...');
+
+for await (const chunk of cmd.stream()) {
+  if (chunk.type === 'stdout') {
+    const elapsed = Date.now() - startTime;
+    console.log(`[${elapsed}ms] Got:`, chunk.data.toString().trim());
+  }
+}
+
+console.log('\nNow testing with jq...');
+
+// Now test with jq
+const startTime2 = Date.now();
+const cmd2 = $`echo '{"id":1}'`.pipe($`jq -c .`);
+
+console.log('Starting jq stream...');
+
+for await (const chunk of cmd2.stream()) {
+  if (chunk.type === 'stdout') {
+    const elapsed = Date.now() - startTime2;
+    console.log(`[${elapsed}ms] Got from jq:`, chunk.data.toString().trim());
+  }
+}
+
+console.log('\nTest complete');

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

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+
+// Simple test script for CI without ES module dependencies
+console.log('STARTING_SLEEP');
+console.error('[simple-test-sleep] Process started, PID:', process.pid);
+console.error('[simple-test-sleep] Node version:', process.version);
+
+// Force flush stdout in non-TTY environments
+if (process.stdout.isTTY === false) {
+  process.stdout.write('', () => {
+    console.error('[simple-test-sleep] Stdout flushed');
+  });
+}
+
+// Set up SIGINT handler
+process.on('SIGINT', () => {
+  console.error('[simple-test-sleep] Received SIGINT');
+  process.exit(130);
+});
+
+// Simple sleep using setTimeout
+console.error('[simple-test-sleep] Starting 30 second sleep');
+setTimeout(() => {
+  console.log('SLEEP_COMPLETED');
+  console.error('[simple-test-sleep] Sleep completed');
+  process.exit(0);
+}, 30000);
+
+// Keep process alive
+process.stdin.resume();

package/js/examples/simple-working-stdin.mjs

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+
+import { $ } from '../src/$.mjs';
+
+async function simpleWorkingStdin() {
+  console.log('Simple working stdin test');
+
+  // Example 1: Basic approach with manual timing
+  const cmd = $`cat`;
+
+  // Trigger start
+  cmd.streams.stdout;
+
+  // Wait for process to spawn
+  await new Promise((resolve) => setTimeout(resolve, 100));
+
+  // Now get stdin
+  const stdin = cmd.streams.stdin;
+  console.log('Stdin available?', !!stdin);
+
+  if (stdin) {
+    stdin.write('Hello!\\n');
+    stdin.end();
+  }
+
+  const result = await cmd;
+  console.log('Result:', result.stdout);
+}
+
+simpleWorkingStdin().catch(console.error);

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

@@ -0,0 +1,116 @@
+#!/usr/bin/env bun
+
+import { $, register } from '../src/$.mjs';
+
+console.log('=== Comprehensive Streaming Behavior Test ===\n');
+console.log(
+  'This test demonstrates streaming behavior in different scenarios.\n'
+);
+
+// Register a streaming virtual command
+register('delay-echo', async function* (args) {
+  const items = args[0] ? args[0].split(',') : ['1', '2', '3'];
+  const delay = parseInt(args[1] || '300');
+
+  for (let i = 0; i < items.length; i++) {
+    yield `${items[i]}\n`;
+    if (i < items.length - 1) {
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+  }
+});
+
+async function runTest(name, command, description) {
+  console.log(`\n${name}`);
+  console.log(`${description}`);
+  console.log('Expected: Output appears incrementally');
+  console.log('Actual:');
+
+  const start = Date.now();
+  const chunks = [];
+
+  for await (const chunk of command.stream()) {
+    if (chunk.type === 'stdout') {
+      const elapsed = Date.now() - start;
+      const lines = chunk.data
+        .toString()
+        .trim()
+        .split('\n')
+        .filter((l) => l);
+      for (const line of lines) {
+        chunks.push({ time: elapsed, data: line });
+        console.log(`  [${elapsed}ms] ${line}`);
+      }
+    }
+  }
+
+  // Analyze streaming behavior
+  if (chunks.length > 1) {
+    const firstTime = chunks[0].time;
+    const lastTime = chunks[chunks.length - 1].time;
+    const spread = lastTime - firstTime;
+
+    if (spread < 100) {
+      console.log('  ❌ All output arrived at once (buffered)');
+    } else {
+      console.log('  ✅ Output streamed incrementally');
+    }
+  }
+}
+
+// Test cases
+console.log('='.repeat(60));
+
+await runTest(
+  'Test 1: Shell command without pipe',
+  $`sh -c 'echo "A"; sleep 0.3; echo "B"; sleep 0.3; echo "C"'`,
+  'Direct shell execution should stream line by line'
+);
+
+await runTest(
+  'Test 2: Virtual command without pipe',
+  $`delay-echo A,B,C 300`,
+  'Virtual commands should stream incrementally'
+);
+
+await runTest(
+  'Test 3: Shell piped to cat',
+  $`sh -c 'echo "A"; sleep 0.3; echo "B"; sleep 0.3; echo "C"' | cat`,
+  'Pipe to cat may buffer (depends on system)'
+);
+
+await runTest(
+  'Test 4: Virtual piped to cat',
+  $`delay-echo X,Y,Z 300 | cat`,
+  'Virtual command through pipe may buffer'
+);
+
+await runTest(
+  'Test 5: Shell piped to virtual pass-through',
+  $`sh -c 'echo "1"; sleep 0.3; echo "2"; sleep 0.3; echo "3"' | delay-echo`,
+  'Real to virtual pipeline'
+);
+
+// Register a pass-through virtual command
+register('passthrough', async function* ({ args, stdin }) {
+  if (stdin) {
+    yield stdin;
+  }
+});
+
+await runTest(
+  'Test 6: Virtual to virtual pipeline',
+  $`delay-echo P,Q,R 300 | passthrough`,
+  'Virtual to virtual should maintain streaming if properly implemented'
+);
+
+console.log(`\n${'='.repeat(60)}`);
+console.log('\nSummary:');
+console.log('- Direct command execution (no pipes) streams properly');
+console.log('- Pipes may introduce buffering depending on the commands');
+console.log('- Virtual commands can stream when used alone');
+console.log('- Mixed pipelines depend on how data flows between stages');
+console.log('\nTo achieve true streaming through pipes, commands need to:');
+console.log('1. Flush output after each line');
+console.log('2. Use line-buffered or unbuffered mode');
+console.log('3. Or be specifically designed for streaming');

package/js/examples/streaming-direct-command.mjs

@@ -0,0 +1,21 @@
+#!/usr/bin/env bun
+
+// Basic streaming without pipes
+
+import { $ } from '../src/$.mjs';
+
+console.log('Direct command streaming test:');
+
+const start = Date.now();
+let chunkCount = 0;
+for await (const chunk of $`bun run js/examples/emulate-claude-stream.mjs`.stream()) {
+  if (chunk.type === 'stdout') {
+    chunkCount++;
+    const elapsed = Date.now() - start;
+    if (chunkCount <= 3) {
+      console.log(`[${elapsed}ms] Chunk ${chunkCount}`);
+    }
+  }
+}
+console.log(`Total: ${chunkCount} chunks`);
+console.log(chunkCount >= 5 ? '✅ Streaming works' : '❌ Not streaming');

package/js/examples/streaming-filtered-output.mjs

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+
+// Stream processing with filtering (only error-like output)
+
+import { $ } from '../src/$.mjs';
+
+console.log('Filtered streaming (only error-like output):');
+const $filtered = $({ mirror: false });
+
+try {
+  const testScript = `
+echo "INFO: Starting process"
+echo "WARNING: This is a warning" >&2
+echo "DEBUG: Processing data"
+echo "ERROR: Something went wrong" >&2
+echo "INFO: Process completed"
+`;
+
+  for await (const chunk of $filtered`bash -c '${testScript}'`.stream()) {
+    const output = chunk.data.toString().trim();
+
+    if (
+      chunk.type === 'stderr' ||
+      output.includes('ERROR') ||
+      output.includes('WARNING')
+    ) {
+      const prefix = chunk.type === 'stderr' ? '🚨' : '⚠️';
+      console.log(`${prefix} ${output}`);
+    }
+  }
+} catch (error) {
+  console.log(`Error: ${error.message}`);
+}

package/js/examples/streaming-grep-pipeline.mjs

@@ -0,0 +1,21 @@
+#!/usr/bin/env bun
+
+// grep pipeline streaming
+
+import { $ } from '../src/$.mjs';
+
+console.log('grep pipeline streaming test:');
+
+const start = Date.now();
+let chunkCount = 0;
+for await (const chunk of $`bun run js/examples/emulate-claude-stream.mjs | grep -E '"type"'`.stream()) {
+  if (chunk.type === 'stdout') {
+    chunkCount++;
+    const elapsed = Date.now() - start;
+    if (chunkCount <= 3) {
+      console.log(`[${elapsed}ms] Chunk ${chunkCount}`);
+    }
+  }
+}
+console.log(`Total: ${chunkCount} chunks`);
+console.log(chunkCount >= 5 ? '✅ grep streaming works' : '❌ grep buffered');

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

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+
+// Interactive-style streaming with custom stdin
+
+import { $ } from '../src/$.mjs';
+
+console.log('Interactive streaming with pre-filled input:');
+const commands = 'ls -la\necho "Current directory listing"\nexit\n';
+const $interactive = $({ stdin: commands, mirror: false });
+
+try {
+  for await (const chunk of $interactive`bash`.stream()) {
+    if (chunk.type === 'stdout') {
+      const lines = chunk.data.toString().split('\n');
+      for (const line of lines) {
+        if (line.trim()) {
+          console.log(`🖥️  ${line}`);
+        }
+      }
+    }
+  }
+} catch (error) {
+  console.log(`Error: ${error.message}`);
+}

package/js/examples/streaming-jq-pipeline.mjs

@@ -0,0 +1,23 @@
+#!/usr/bin/env bun
+
+// jq pipeline streaming (critical test)
+
+import { $ } from '../src/$.mjs';
+
+console.log('jq pipeline streaming test:');
+
+const start = Date.now();
+let chunkCount = 0;
+for await (const chunk of $`bun run js/examples/emulate-claude-stream.mjs | jq .`.stream()) {
+  if (chunk.type === 'stdout') {
+    chunkCount++;
+    const elapsed = Date.now() - start;
+    if (chunkCount <= 3) {
+      console.log(`[${elapsed}ms] Chunk ${chunkCount}`);
+    }
+  }
+}
+console.log(`Total: ${chunkCount} chunks`);
+console.log(
+  chunkCount >= 5 ? '✅ Streaming works with jq!' : '❌ jq buffered output'
+);

package/js/examples/streaming-multistage-pipeline.mjs

@@ -0,0 +1,23 @@
+#!/usr/bin/env bun
+
+// Multi-stage pipeline streaming (cat | jq)
+
+import { $ } from '../src/$.mjs';
+
+console.log('Multi-stage pipeline streaming test:');
+
+const start = Date.now();
+let chunkCount = 0;
+for await (const chunk of $`bun run js/examples/emulate-claude-stream.mjs | cat | jq .`.stream()) {
+  if (chunk.type === 'stdout') {
+    chunkCount++;
+    const elapsed = Date.now() - start;
+    if (chunkCount <= 3) {
+      console.log(`[${elapsed}ms] Chunk ${chunkCount}`);
+    }
+  }
+}
+console.log(`Total: ${chunkCount} chunks`);
+console.log(
+  chunkCount >= 5 ? '✅ Multi-stage streaming works' : '❌ Multi-stage buffered'
+);

package/js/examples/streaming-pipes-event-pattern.mjs

@@ -0,0 +1,27 @@
+#!/usr/bin/env bun
+
+// EventEmitter pattern with pipes
+
+import { $ } from '../src/$.mjs';
+
+console.log('EventEmitter pattern with pipes:');
+const start = Date.now();
+
+await new Promise((resolve) => {
+  $`sh -c 'echo "{\\"event\\":1}"; sleep 0.2; echo "{\\"event\\":2}"; sleep 0.2; echo "{\\"event\\":3}"' | jq -c .`
+    .on('data', (chunk) => {
+      if (chunk.type === 'stdout') {
+        const elapsed = Date.now() - start;
+        const data = chunk.data.toString().trim();
+        if (data) {
+          console.log(`[${elapsed}ms] Event: ${data}`);
+        }
+      }
+    })
+    .on('end', (result) => {
+      console.log(`Exit code: ${result.code}`);
+      resolve();
+    });
+});
+
+console.log('\n✅ Test complete');

package/js/examples/streaming-pipes-multistage.mjs

@@ -0,0 +1,22 @@
+#!/usr/bin/env bun
+
+// Multi-stage pipeline with streaming
+
+import { $ } from '../src/$.mjs';
+
+console.log('Multi-stage pipeline with streaming:');
+const start = Date.now();
+
+const cmd = $`sh -c 'for i in 1 2 3; do echo "{\\"value\\":$i}"; sleep 0.3; done' | jq -c '{data: .value}' | jq -c '{result: (.data * 2)}'`;
+
+for await (const chunk of cmd.stream()) {
+  if (chunk.type === 'stdout') {
+    const elapsed = Date.now() - start;
+    const data = chunk.data.toString().trim();
+    if (data) {
+      console.log(`[${elapsed}ms] Pipeline result: ${data}`);
+    }
+  }
+}
+
+console.log('\n✅ Test complete');

package/js/examples/streaming-pipes-realtime-jq.mjs

@@ -0,0 +1,23 @@
+#!/usr/bin/env bun
+
+// Real-time streaming through jq pipe
+
+import { $ } from '../src/$.mjs';
+
+console.log('Real-time streaming with delays through jq:');
+console.log('Each line should appear immediately, not all at once\n');
+
+const start = Date.now();
+const cmd = $`sh -c 'echo "{\\"n\\":1}"; sleep 0.5; echo "{\\"n\\":2}"; sleep 0.5; echo "{\\"n\\":3}"' | jq -c .`;
+
+for await (const chunk of cmd.stream()) {
+  if (chunk.type === 'stdout') {
+    const elapsed = Date.now() - start;
+    const data = chunk.data.toString().trim();
+    if (data) {
+      console.log(`[${elapsed}ms] Received: ${data}`);
+    }
+  }
+}
+
+console.log('\n✅ Test complete');

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

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+
+// Streaming with progress tracking
+
+import { $ } from '../src/$.mjs';
+
+console.log('Progress tracking with streaming:');
+const $progress = $({ mirror: false });
+
+try {
+  let progressCount = 0;
+  const progressScript = `
+for i in {1..5}; do
+  echo "Progress: $i/5"
+  sleep 0.5
+done
+echo "Complete!"
+`;
+
+  for await (const chunk of $progress`bash -c '${progressScript}'`.stream()) {
+    if (chunk.type === 'stdout') {
+      const output = chunk.data.toString().trim();
+      if (output.includes('Progress:')) {
+        progressCount++;
+        const percent = ((progressCount / 5) * 100).toFixed(0);
+        console.log(`📊 ${output} (${percent}%)`);
+      } else if (output.includes('Complete')) {
+        console.log(`✅ ${output}`);
+      }
+    }
+  }
+} catch (error) {
+  console.log(`Error: ${error.message}`);
+}

package/js/examples/streaming-reusable-configs.mjs

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+
+// Reusable streaming configurations
+
+import { $ } from '../src/$.mjs';
+
+console.log('Reusable streaming configurations:');
+
+// Create different "profiles" for streaming
+const $json = $({ mirror: false });
+const $quiet = $({ mirror: false, capture: true });
+const $verbose = $({ mirror: true });
+
+try {
+  // JSON-like structured output
+  console.log('JSON-style output:');
+  for await (const chunk of $json`echo '{"status":"running","progress":50}'`.stream()) {
+    if (chunk.type === 'stdout') {
+      try {
+        const data = JSON.parse(chunk.data.toString());
+        console.log(`📋 Status: ${data.status}, Progress: ${data.progress}%`);
+      } catch {
+        console.log(`📋 Raw: ${chunk.data.toString().trim()}`);
+      }
+    }
+  }
+
+  // Quiet mode with post-processing
+  console.log('\nQuiet mode with result capture:');
+  const runner = $quiet`echo "Result: $(date)"`;
+
+  let streamOutput = '';
+  for await (const chunk of runner.stream()) {
+    if (chunk.type === 'stdout') {
+      streamOutput += chunk.data.toString();
+    }
+  }
+
+  const result = await runner;
+  console.log(`🤫 Streamed: "${streamOutput.trim()}"`);
+  console.log(`💾 Captured: "${result.stdout.trim()}"`);
+
+  // Verbose mode (will show in terminal too)
+  console.log('\nVerbose mode (also shows in terminal):');
+  for await (const chunk of $verbose`echo "This appears both in terminal and here"`.stream()) {
+    if (chunk.type === 'stdout') {
+      console.log(`📢 Processed: ${chunk.data.toString().trim()}`);
+    }
+  }
+} catch (error) {
+  console.log(`Error: ${error.message}`);
+}