command-stream 0.8.2 → 0.9.0

package/js/tests/interactive-option.test.mjs

@@ -0,0 +1,114 @@
+import { $ } from '../src/$.mjs';
+import { test, expect, describe, beforeEach, afterEach } from 'bun:test';
+import { beforeTestCleanup, afterTestCleanup } from './test-cleanup.mjs';
+
+describe('Interactive Option Tests', () => {
+  beforeEach(beforeTestCleanup);
+  afterEach(afterTestCleanup);
+
+  test('interactive option - default behavior', async () => {
+    // Test that interactive is false by default
+    const $custom = $({ capture: true, mirror: false });
+    const cmd = $custom`echo test`;
+
+    // Interactive should be false by default
+    expect(cmd.options.interactive).toBe(false);
+  });
+
+  test('interactive option - explicit true', async () => {
+    // Test that interactive can be set to true
+    const $custom = $({ capture: true, mirror: false, interactive: true });
+    const cmd = $custom`echo test`;
+
+    // Interactive should be true when explicitly set
+    expect(cmd.options.interactive).toBe(true);
+  });
+
+  test('interactive option - explicit false', async () => {
+    // Test that interactive can be explicitly set to false
+    const $custom = $({ capture: true, mirror: false, interactive: false });
+    const cmd = $custom`echo test`;
+
+    // Interactive should be false when explicitly set
+    expect(cmd.options.interactive).toBe(false);
+  });
+
+  test('interactive option - passed through options merge', async () => {
+    // Test that interactive option is preserved when merging options
+    const $base = $({ capture: true, mirror: false });
+    const cmd = $base`echo test`;
+
+    // Start with different options to test merging
+    cmd.start({ interactive: true });
+
+    // Interactive should be true after options merge
+    expect(cmd.options.interactive).toBe(true);
+  });
+
+  test('interactive option - does not affect command execution with pipes/capture', async () => {
+    // Test that setting interactive: true doesn't interfere with normal command execution
+    // when pipes are used (which prevents TTY forwarding anyway)
+    const $interactive = $({ capture: true, mirror: false, interactive: true });
+    const result = await $interactive`echo "interactive test"`;
+
+    expect(result.code).toBe(0);
+    expect(result.stdout.trim()).toBe('interactive test');
+  });
+
+  test('interactive option - behavior with stdin inherit but no TTY', async () => {
+    // Test that interactive mode requires both interactive:true AND TTY conditions
+    // This test verifies the logic but won't actually use TTY in test environment
+    const $interactive = $({
+      capture: false,
+      mirror: false,
+      interactive: true,
+      stdin: 'inherit',
+    });
+    const cmd = $interactive`echo "tty test"`;
+
+    // Should still work even if TTY conditions aren't met
+    expect(cmd.options.interactive).toBe(true);
+    expect(cmd.options.stdin).toBe('inherit');
+  });
+
+  test('interactive option - works with template literal syntax', async () => {
+    // Test interactive option with various template literal syntaxes
+    const name = 'world';
+    const $interactive = $({ capture: true, mirror: false, interactive: true });
+    const cmd = $interactive`echo "hello ${name}"`;
+    const result = await cmd;
+
+    expect(result.code).toBe(0);
+    expect(result.stdout.trim()).toBe('hello world'); // Safe string 'world' doesn't need quotes
+    expect(cmd.options.interactive).toBe(true); // Check the command object, not the result
+  });
+
+  test('interactive option - preserved in command chaining', async () => {
+    // Test that interactive option is preserved through command operations
+    const $interactive = $({ capture: true, mirror: false, interactive: true });
+    const cmd1 = $interactive`echo "first"`;
+    const cmd2 = cmd1.pipe($interactive`tr 'a-z' 'A-Z'`);
+
+    // Both commands should preserve the interactive setting
+    expect(cmd1.options.interactive).toBe(true);
+    // Note: cmd2 (piped command) might have different options, that's expected
+  });
+
+  test('interactive option - type checking', async () => {
+    // Test that interactive option accepts boolean values properly
+    const $true = $({ interactive: true, capture: true, mirror: false });
+    const $false = $({ interactive: false, capture: true, mirror: false });
+    const $default = $({ capture: true, mirror: false });
+
+    expect($true`echo test`.options.interactive).toBe(true);
+    expect($false`echo test`.options.interactive).toBe(false);
+    expect($default`echo test`.options.interactive).toBe(false);
+
+    // Test with non-boolean values (should still work, JavaScript is flexible)
+    const $truthy = $({ interactive: 1, capture: true, mirror: false });
+    const $falsy = $({ interactive: 0, capture: true, mirror: false });
+
+    expect(Boolean($truthy`echo test`.options.interactive)).toBe(true);
+    expect(Boolean($falsy`echo test`.options.interactive)).toBe(false);
+  });
+});

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

@@ -0,0 +1,307 @@
+#!/usr/bin/env node
+
+import { describe, it, expect } from 'bun:test';
+import './test-helper.mjs'; // Automatically sets up beforeEach/afterEach cleanup
+import { $ } from '../src/$.mjs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const calcPath = path.join(__dirname, '../examples/interactive-math-calc.mjs');
+
+describe('Interactive Streaming', () => {
+  it('should support bidirectional streaming I/O while process is running', async () => {
+    // Start the interactive math calculator
+    const calc = $`node ${calcPath}`;
+
+    // Get the streams immediately (process auto-starts)
+    let stdin, stdout, stderr;
+    try {
+      stdin = await calc.streams.stdin;
+      stdout = await calc.streams.stdout;
+      stderr = await calc.streams.stderr;
+    } catch (e) {
+      console.error(`[interactive-streaming test] Error getting streams:`, e);
+      throw e;
+    }
+
+    // Verify streams are available
+    expect(stdin).toBeTruthy();
+    expect(stdout).toBeTruthy();
+    expect(stderr).toBeTruthy();
+
+    // Set up stdout reader
+    const results = [];
+    let buffer = '';
+
+    stdout.on('data', (chunk) => {
+      buffer += chunk.toString();
+      const lines = buffer.split('\n');
+      buffer = lines.pop(); // Keep incomplete line in buffer
+
+      for (const line of lines) {
+        if (line.trim()) {
+          results.push(line.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();
+    });
+
+    expect(results).toContain('READY');
+
+    // Test multiple math expressions
+    const testCases = [
+      { input: '1+2', expected: 'RESULT: 3' },
+      { input: '10*5', expected: 'RESULT: 50' },
+      { input: '100/4', expected: 'RESULT: 25' },
+      { input: '7-3', expected: 'RESULT: 4' },
+      { input: '2**8', expected: 'RESULT: 256' },
+    ];
+
+    for (const testCase of testCases) {
+      const beforeCount = results.length;
+
+      // Send expression
+      stdin.write(`${testCase.input}\n`);
+
+      // Wait for result
+      await new Promise((resolve) => {
+        const checkResult = () => {
+          if (results.length > beforeCount) {
+            resolve();
+          } else {
+            setTimeout(checkResult, 10);
+          }
+        };
+        setTimeout(checkResult, 10);
+      });
+
+      // Verify result
+      expect(results).toContain(testCase.expected);
+    }
+
+    // Send exit command
+    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);
+    });
+
+    expect(results).toContain('GOODBYE');
+
+    // Wait for process to complete
+    const result = await calc;
+    expect(result.code).toBe(0);
+
+    // Verify we received all expected results
+    const resultCount = results.filter((r) => r.includes('RESULT:')).length;
+    expect(resultCount).toBe(testCases.length);
+  }, 10000); // 10 second timeout
+
+  it('should handle errors in expressions', async () => {
+    const calc = $`node ${calcPath}`;
+
+    const stdin = await calc.streams.stdin;
+    const stdout = await calc.streams.stdout;
+    const stderr = await calc.streams.stderr;
+
+    expect(stdin).toBeTruthy();
+    expect(stdout).toBeTruthy();
+    expect(stderr).toBeTruthy();
+
+    const results = [];
+    const errors = [];
+    let stdoutBuffer = '';
+    let stderrBuffer = '';
+
+    stdout.on('data', (chunk) => {
+      stdoutBuffer += chunk.toString();
+      const lines = stdoutBuffer.split('\n');
+      stdoutBuffer = lines.pop();
+      for (const line of lines) {
+        if (line.trim()) {
+          results.push(line.trim());
+        }
+      }
+    });
+
+    stderr.on('data', (chunk) => {
+      stderrBuffer += chunk.toString();
+      const lines = stderrBuffer.split('\n');
+      stderrBuffer = lines.pop();
+      for (const line of lines) {
+        if (line.trim()) {
+          errors.push(line.trim());
+        }
+      }
+    });
+
+    // Wait for ready
+    await new Promise((resolve) => {
+      const check = () => {
+        if (results.some((r) => r.includes('READY'))) {
+          resolve();
+        } else {
+          setTimeout(check, 10);
+        }
+      };
+      check();
+    });
+
+    // Send invalid expression
+    stdin.write('invalid expression\n');
+
+    // Wait for error
+    await new Promise((resolve) => {
+      const check = () => {
+        if (errors.length > 0) {
+          resolve();
+        } else {
+          setTimeout(check, 10);
+        }
+      };
+      setTimeout(check, 10);
+    });
+
+    expect(errors[0]).toContain('ERROR: Invalid expression');
+
+    // Verify calculator still works after error
+    stdin.write('5+5\n');
+
+    const beforeCount = results.length;
+    await new Promise((resolve) => {
+      const check = () => {
+        if (results.length > beforeCount) {
+          resolve();
+        } else {
+          setTimeout(check, 10);
+        }
+      };
+      setTimeout(check, 10);
+    });
+
+    expect(results).toContain('RESULT: 10');
+
+    // Exit
+    stdin.write('exit\n');
+    const result = await calc;
+    expect(result.code).toBe(0);
+  }, 10000);
+
+  it('should auto-start process when accessing streams', async () => {
+    const calc = $`node ${calcPath}`;
+
+    // Process should not be started yet
+    expect(calc.started).toBe(false);
+
+    // Accessing streams should auto-start the process
+    const stdin = await calc.streams.stdin;
+
+    expect(calc.started).toBe(true);
+    expect(stdin).toBeTruthy();
+
+    // Clean up
+    stdin.write('exit\n');
+    await calc;
+  });
+
+  it('should return null for streams after process completes', async () => {
+    const calc = $`node ${calcPath}`;
+
+    const stdin = await calc.streams.stdin;
+    stdin.write('exit\n');
+
+    // Wait for process to complete
+    await calc;
+
+    // Streams should be null after completion
+    const stdinAfter = await calc.streams.stdin;
+    const stdoutAfter = await calc.streams.stdout;
+    const stderrAfter = await calc.streams.stderr;
+
+    expect(stdinAfter).toBeNull();
+    expect(stdoutAfter).toBeNull();
+    expect(stderrAfter).toBeNull();
+  });
+
+  it('should handle multiple simultaneous calculations', async () => {
+    const calc = $`node ${calcPath}`;
+
+    const stdin = await calc.streams.stdin;
+    const stdout = await calc.streams.stdout;
+
+    const results = [];
+    let buffer = '';
+
+    stdout.on('data', (chunk) => {
+      buffer += chunk.toString();
+      const lines = buffer.split('\n');
+      buffer = lines.pop();
+      for (const line of lines) {
+        if (line.trim()) {
+          results.push(line.trim());
+        }
+      }
+    });
+
+    // Wait for ready
+    await new Promise((resolve) => {
+      const check = () => {
+        if (results.some((r) => r.includes('READY'))) {
+          resolve();
+        } else {
+          setTimeout(check, 10);
+        }
+      };
+      check();
+    });
+
+    // Send multiple calculations rapidly
+    const expressions = ['1+1', '2+2', '3+3', '4+4', '5+5'];
+    for (const expr of expressions) {
+      stdin.write(`${expr}\n`);
+    }
+
+    // Wait for all results
+    await new Promise((resolve) => {
+      const check = () => {
+        const resultCount = results.filter((r) => r.includes('RESULT:')).length;
+        if (resultCount >= expressions.length) {
+          resolve();
+        } else {
+          setTimeout(check, 10);
+        }
+      };
+      setTimeout(check, 10);
+    });
+
+    // Verify all results
+    expect(results).toContain('RESULT: 2');
+    expect(results).toContain('RESULT: 4');
+    expect(results).toContain('RESULT: 6');
+    expect(results).toContain('RESULT: 8');
+    expect(results).toContain('RESULT: 10');
+
+    stdin.write('exit\n');
+    await calc;
+  });
+});

package/js/tests/issue-135-final.test.mjs

@@ -0,0 +1,58 @@
+// Final test for issue #135: CI environment should not auto-enable trace
+// This test verifies the main fix: CI=true should NOT cause trace logs
+import { describe, it, beforeEach } from 'bun:test';
+import assert from 'assert';
+import { $ } from '../src/$.mjs';
+
+describe('Issue #135: CI environment no longer auto-enables trace logs', () => {
+  beforeEach(() => {
+    // Clean up environment before each test
+    delete process.env.COMMAND_STREAM_VERBOSE;
+    delete process.env.COMMAND_STREAM_TRACE;
+    delete process.env.CI;
+  });
+
+  it('should NOT emit trace logs when CI=true (main fix)', async () => {
+    process.env.CI = 'true';
+
+    const $silent = $({ mirror: false, capture: true });
+    const result = await $silent`echo '{"status":"ok"}'`;
+
+    // Output should be clean JSON without trace logs
+    assert.strictEqual(result.stdout.trim(), '{"status":"ok"}');
+
+    // Should be parseable as JSON
+    const parsed = JSON.parse(result.stdout);
+    assert.deepStrictEqual(parsed, { status: 'ok' });
+  });
+
+  it('should allow JSON parsing in CI environment', async () => {
+    process.env.CI = 'true';
+
+    const $silent = $({ mirror: false, capture: true });
+    const result = await $silent`echo '{"count":42,"items":["a","b","c"]}'`;
+
+    // Should be able to parse complex JSON
+    const parsed = JSON.parse(result.stdout);
+    assert.strictEqual(parsed.count, 42);
+    assert.deepStrictEqual(parsed.items, ['a', 'b', 'c']);
+  });
+
+  it('should NOT produce trace logs by default (no env vars)', async () => {
+    const $silent = $({ mirror: false, capture: true });
+    const result = await $silent`echo test`;
+
+    // Simple text output should be clean
+    assert.strictEqual(result.stdout.trim(), 'test');
+  });
+
+  it('should work with mirror:false in CI environment', async () => {
+    process.env.CI = 'true';
+
+    const $silent = $({ mirror: false, capture: true });
+    const result = await $silent`echo hello`;
+
+    assert.strictEqual(result.stdout.trim(), 'hello');
+    assert.strictEqual(result.code, 0);
+  });
+});

package/js/tests/jq-color-behavior.test.mjs

@@ -0,0 +1,140 @@
+import { $ } from '../src/$.mjs';
+import { test, expect } from 'bun:test';
+import './test-helper.mjs'; // Automatically sets up beforeEach/afterEach cleanup
+
+const testJson =
+  '{"message": "hello", "number": 42, "active": true, "data": null}';
+
+test('jq behavior - default mirror mode shows output automatically', async () => {
+  // Test that with default settings (mirror: true), jq output appears automatically
+  // User doesn't need to manually console.log the result
+  const result = await $`echo ${testJson} | jq .`;
+
+  expect(result.code).toBe(0);
+  expect(result.stdout).toContain('"message"');
+  expect(result.stdout).toContain('"hello"');
+  expect(result.stdout).toContain('42');
+  expect(result.stdout).toContain('true');
+  expect(result.stdout).toContain('null');
+});
+
+test('jq behavior - explicit color output contains ANSI codes', async () => {
+  // Test that jq -C produces colored output with ANSI escape codes
+  const result = await $`echo ${testJson} | jq -C .`;
+
+  expect(result.code).toBe(0);
+  expect(result.stdout).toMatch(/\u001b\[\d+/); // Contains ANSI escape sequences
+  expect(result.stdout).toContain('"message"');
+  expect(result.stdout).toContain('"hello"');
+});
+
+test('jq behavior - monochrome output has no ANSI codes', async () => {
+  // Test that jq -M produces clean output without colors
+  const result = await $`echo ${testJson} | jq -M .`;
+
+  expect(result.code).toBe(0);
+  expect(result.stdout).not.toMatch(/\u001b\[\d+/); // No ANSI escape sequences
+  expect(result.stdout).toContain('"message"');
+  expect(result.stdout).toContain('"hello"');
+});
+
+test('jq behavior - field extraction works correctly', async () => {
+  // Test extracting specific fields with -r flag
+  const result = await $`echo ${testJson} | jq -r .message`;
+
+  expect(result.code).toBe(0);
+  expect(result.stdout.trim()).toBe('hello');
+});
+
+test('jq behavior - complex JSON processing', async () => {
+  const complexJson =
+    '{"users": [{"name": "Alice", "age": 30}, {"name": "Bob", "age": 25}]}';
+
+  // Test extracting array elements
+  const result = await $`echo ${complexJson} | jq '.users[0].name'`;
+
+  expect(result.code).toBe(0);
+  expect(result.stdout.trim()).toBe('"Alice"');
+});
+
+test('jq behavior - mirror mode vs capture mode', async () => {
+  // Test that mirror mode (default) automatically shows output
+  const $default = $({ capture: true, mirror: true });
+  const result1 = await $default`echo ${testJson} | jq .message`;
+
+  expect(result1.code).toBe(0);
+  expect(result1.stdout.trim()).toBe('"hello"');
+
+  // Test capture-only mode
+  const $captureOnly = $({ capture: true, mirror: false });
+  const result2 = await $captureOnly`echo ${testJson} | jq .message`;
+
+  expect(result2.code).toBe(0);
+  expect(result2.stdout.trim()).toBe('"hello"');
+});
+
+test('jq behavior - TTY detection and automatic coloring', async () => {
+  // IMPORTANT: Understanding jq's color behavior
+  //
+  // When jq is used in a pipeline (echo ... | jq), it detects that its
+  // output is being piped and disables colors by default, EVEN if the
+  // parent process has a TTY (process.stdout.isTTY = true).
+  //
+  // This is smart behavior by jq:
+  // - Direct to terminal: jq enables colors (if TTY detected)
+  // - In a pipeline: jq disables colors (to avoid ANSI codes in pipes)
+  // - With -C flag: forces colors even in pipelines
+  // - With -M flag: disables colors even with TTY
+  //
+  // Since command-stream uses pipes internally, jq will typically NOT
+  // output colors by default, regardless of the TTY status.
+
+  const result = await $`echo ${testJson} | jq .`;
+
+  expect(result.code).toBe(0);
+  expect(result.stdout).toContain('"message"');
+
+  const hasColors = /\u001b\[\d+/.test(result.stdout);
+
+  // Log the actual behavior for debugging
+  if (process.env.DEBUG_JQ_TEST) {
+    console.log('jq default behavior:', {
+      hasColors,
+      isTTY: process.stdout.isTTY,
+      outputSample: result.stdout.substring(0, 50),
+    });
+  }
+
+  // In most cases, jq in a pipeline won't have colors
+  // But we accept both cases since it can vary by environment
+  expect(typeof hasColors).toBe('boolean');
+
+  // Verify we got valid JSON output regardless of colors
+  expect(result.stdout).toContain('"message"');
+  expect(result.stdout).toContain('"hello"');
+  expect(result.stdout).toContain('42');
+  expect(result.stdout).toContain('true');
+  expect(result.stdout).toContain('null');
+});
+
+test('jq behavior - force colors work in any environment', async () => {
+  // Test that explicit -C flag produces colors even in non-TTY environments
+  const result = await $`echo ${testJson} | jq -C .`;
+
+  expect(result.code).toBe(0);
+  expect(result.stdout).toMatch(/\u001b\[\d+/); // Should have ANSI codes
+  expect(result.stdout).toContain('"message"');
+
+  // The color codes should make the output longer than the plain version
+  const plainResult = await $`echo ${testJson} | jq -M .`;
+  expect(result.stdout.length).toBeGreaterThan(plainResult.stdout.length);
+});
+
+test('jq behavior - streaming with colors works', async () => {
+  // Test that jq colors work with streaming/piping
+  const result = await $`echo ${testJson} | jq -C . | cat`;
+
+  expect(result.code).toBe(0);
+  expect(result.stdout).toMatch(/\u001b\[\d+/); // Colors preserved through pipe
+  expect(result.stdout).toContain('"message"');
+});