command-stream 0.8.2 → 0.9.0

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

@@ -0,0 +1,412 @@
+import { $ } from '../src/$.mjs';
+import { test, expect } from 'bun:test';
+import './test-helper.mjs'; // Automatically sets up beforeEach/afterEach cleanup
+
+test('path interpolation - basic unquoted path', () => {
+  const path = '/bin/echo';
+  const cmd = $({ mirror: false })`${path} hello`;
+
+  // With smart quoting, safe paths don't need quotes
+  expect(cmd.spec.command).toBe('/bin/echo hello');
+});
+
+test('path interpolation - path with spaces gets quoted', () => {
+  const path = '/path with spaces/command';
+  const cmd = $({ mirror: false })`${path} hello`;
+
+  expect(cmd.spec.command).toBe("'/path with spaces/command' hello");
+});
+
+test('path interpolation - path already wrapped in double quotes', () => {
+  const path = '"/path/to/command"';
+  const cmd = $({ mirror: false })`${path} hello`;
+
+  // Should preserve the double quotes by wrapping in single quotes
+  expect(cmd.spec.command).toBe('\'"/path/to/command"\' hello');
+});
+
+test('path interpolation - path already wrapped in single quotes', () => {
+  const path = "'/path/to/command'";
+  const cmd = $({ mirror: false })`${path} hello`;
+
+  // With the fix, already-quoted paths should be used as-is when they don't contain internal quotes
+  expect(cmd.spec.command).toBe("'/path/to/command' hello");
+});
+
+test('path interpolation - environment variable inheritance works', () => {
+  const originalEnv = process.env.TEST_PATH;
+
+  try {
+    process.env.TEST_PATH = '/usr/bin/echo';
+    const path = process.env.TEST_PATH;
+    const cmd = $({ mirror: false })`${path} hello`;
+
+    // Safe path doesn't need quotes
+    expect(cmd.spec.command).toBe('/usr/bin/echo hello');
+  } finally {
+    if (originalEnv !== undefined) {
+      process.env.TEST_PATH = originalEnv;
+    } else {
+      delete process.env.TEST_PATH;
+    }
+  }
+});
+
+test('path interpolation - complex path scenarios', () => {
+  const testCases = [
+    {
+      name: 'Simple path',
+      path: '/Users/konard/.claude/local/claude',
+      expectedCommand: '/Users/konard/.claude/local/claude --version', // No quotes needed
+    },
+    {
+      name: 'Path with spaces',
+      path: '/Users/user name/.claude/local/claude',
+      expectedCommand: "'/Users/user name/.claude/local/claude' --version", // Quotes needed
+    },
+    {
+      name: 'Path with special characters',
+      path: '/Users/user-name_123/.claude/local/claude',
+      expectedCommand: '/Users/user-name_123/.claude/local/claude --version', // No quotes needed (dash and underscore are safe)
+    },
+  ];
+
+  testCases.forEach(({ name, path, expectedCommand }) => {
+    const cmd = $({ mirror: false })`${path} --version`;
+    expect(cmd.spec.command).toBe(expectedCommand);
+  });
+});
+
+test('path interpolation - stdin option with path works', () => {
+  const path = '/bin/cat';
+  const cmd = $({ stdin: 'test input\n', mirror: false })`${path}`;
+
+  expect(cmd.spec.command).toBe('/bin/cat'); // Safe path, no quotes needed
+  expect(cmd.options.stdin).toBe('test input\n');
+});
+
+test('path interpolation - command building works correctly', () => {
+  const nonExistentPath = '/nonexistent/command';
+  const cmd = $({ mirror: false })`${nonExistentPath} --version`;
+
+  // Verify the command is built correctly (safe path, no quotes)
+  expect(cmd.spec.command).toBe('/nonexistent/command --version');
+  expect(cmd.spec.mode).toBe('shell');
+});
+
+test('path interpolation - fixed escaping for simple pre-quoted paths', () => {
+  // This test verifies the fix for excessive escaping of pre-quoted paths
+  // The issue was that paths like "'/path/to/command'" would get double-escaped
+
+  const preQuotedPath = "'/path/to/command'"; // Already has single quotes
+  const cmd = $({ mirror: false })`${preQuotedPath} --version`;
+
+  // Fixed behavior: no excessive escaping for simple pre-quoted paths
+  const generated = cmd.spec.command;
+  expect(generated).not.toContain("\\'"); // Should NOT contain escaped quotes
+  expect(generated).toBe("'/path/to/command' --version"); // Should use path as-is
+
+  // The generated command should be valid shell syntax
+  expect(generated).toMatch(/^'.*' --version$/);
+});
+
+test('path interpolation - environment variable scenario from GitHub issue', () => {
+  const originalEnv = process.env.CLAUDE_PATH;
+
+  try {
+    // Simulate the exact scenario from the GitHub issue
+    process.env.CLAUDE_PATH = '/Users/konard/.claude/local/claude';
+    const claude =
+      process.env.CLAUDE_PATH || '/Users/konard/.claude/local/claude';
+
+    const cmd = $({
+      stdin: 'hi\n',
+      mirror: false,
+    })`${claude} --output-format stream-json --verbose --model sonnet`;
+
+    // Safe path, no quotes needed
+    expect(cmd.spec.command).toBe(
+      '/Users/konard/.claude/local/claude --output-format stream-json --verbose --model sonnet'
+    );
+    expect(cmd.options.stdin).toBe('hi\n');
+    expect(cmd.options.mirror).toBe(false);
+
+    // The command should be properly formatted for shell execution
+    expect(cmd.spec.mode).toBe('shell');
+  } finally {
+    if (originalEnv !== undefined) {
+      process.env.CLAUDE_PATH = originalEnv;
+    } else {
+      delete process.env.CLAUDE_PATH;
+    }
+  }
+});
+
+test('path interpolation - improved handling of pre-quoted paths', () => {
+  // Test that the improved quoting logic handles pre-quoted paths better
+  const preQuotedPath = "'/path/to/claude'"; // Already has single quotes
+  const cmd = $({ mirror: false })`${preQuotedPath} --version`;
+
+  // With the fix, already-quoted paths should be used as-is when they don't contain internal quotes
+  expect(cmd.spec.command).toBe("'/path/to/claude' --version");
+
+  // Should not contain excessive escaping
+  expect(cmd.spec.command).not.toContain("\\'");
+  expect(cmd.spec.mode).toBe('shell');
+});
+
+test('path interpolation - handles complex quoting edge cases', () => {
+  // Test various edge cases for the improved quoting logic
+
+  // Case 1: Path with single quotes inside (should still escape properly)
+  const pathWithInternalQuotes = "'/path/with'quotes/command'";
+  const cmd1 = $({ mirror: false })`${pathWithInternalQuotes} --version`;
+  // This should still use escaping because it has internal quotes
+  expect(cmd1.spec.command).toContain("\\'");
+
+  // Case 2: Empty quotes should be handled
+  const emptyQuoted = "''";
+  const cmd2 = $({ mirror: false })`echo ${emptyQuoted}`;
+  expect(cmd2.spec.command).toBe("echo ''");
+
+  // Case 3: Just quotes with no content
+  const justQuotes = "'";
+  const cmd3 = $({ mirror: false })`echo ${justQuotes}`;
+  expect(cmd3.spec.command).toBe("echo ''\\'\'\'");
+
+  // Case 4: Double-quoted paths should be wrapped in single quotes
+  const doubleQuotedPath = '"/path/with spaces/command"';
+  const cmd4 = $({ mirror: false })`${doubleQuotedPath} --version`;
+  expect(cmd4.spec.command).toBe('\'"/path/with spaces/command"\' --version');
+});
+
+// Shell injection prevention tests
+test('shell injection - command substitution attempt', () => {
+  const malicious = '$(rm -rf /)';
+  const cmd = $({ mirror: false })`echo ${malicious}`;
+
+  // Should be safely quoted to prevent execution
+  expect(cmd.spec.command).toBe("echo '$(rm -rf /)'");
+});
+
+test('shell injection - backtick command substitution', () => {
+  const malicious = '`cat /etc/passwd`';
+  const cmd = $({ mirror: false })`echo ${malicious}`;
+
+  // Should be safely quoted
+  expect(cmd.spec.command).toBe("echo '`cat /etc/passwd`'");
+});
+
+test('shell injection - semicolon command chaining', () => {
+  const malicious = 'test; rm -rf /';
+  const cmd = $({ mirror: false })`echo ${malicious}`;
+
+  // Should be safely quoted to prevent command chaining
+  expect(cmd.spec.command).toBe("echo 'test; rm -rf /'");
+});
+
+test('shell injection - pipe attempt', () => {
+  const malicious = 'test | cat /etc/passwd';
+  const cmd = $({ mirror: false })`echo ${malicious}`;
+
+  // Should be safely quoted to prevent piping
+  expect(cmd.spec.command).toBe("echo 'test | cat /etc/passwd'");
+});
+
+test('shell injection - AND operator attempt', () => {
+  const malicious = 'test && malicious_command';
+  const cmd = $({ mirror: false })`echo ${malicious}`;
+
+  // Should be safely quoted
+  expect(cmd.spec.command).toBe("echo 'test && malicious_command'");
+});
+
+test('shell injection - OR operator attempt', () => {
+  const malicious = 'test || malicious_command';
+  const cmd = $({ mirror: false })`echo ${malicious}`;
+
+  // Should be safely quoted
+  expect(cmd.spec.command).toBe("echo 'test || malicious_command'");
+});
+
+test('shell injection - background process attempt', () => {
+  const malicious = 'test & malicious_command';
+  const cmd = $({ mirror: false })`echo ${malicious}`;
+
+  // Should be safely quoted
+  expect(cmd.spec.command).toBe("echo 'test & malicious_command'");
+});
+
+test('shell injection - variable expansion attempt', () => {
+  const malicious = '$PATH';
+  const cmd = $({ mirror: false })`echo ${malicious}`;
+
+  // Should be safely quoted to prevent variable expansion
+  expect(cmd.spec.command).toBe("echo '$PATH'");
+});
+
+test('shell injection - glob expansion attempt', () => {
+  const malicious = '*.txt';
+  const cmd = $({ mirror: false })`echo ${malicious}`;
+
+  // Should be safely quoted to prevent glob expansion
+  expect(cmd.spec.command).toBe("echo '*.txt'");
+});
+
+test('shell injection - redirect attempt', () => {
+  const malicious = '> /etc/passwd';
+  const cmd = $({ mirror: false })`echo test ${malicious}`;
+
+  // Should be safely quoted to prevent redirection
+  expect(cmd.spec.command).toBe("echo test '> /etc/passwd'");
+});
+
+test('shell injection - newline injection', () => {
+  const malicious = 'test\nmalicious_command';
+  const cmd = $({ mirror: false })`echo ${malicious}`;
+
+  // Should be safely quoted with newline preserved
+  expect(cmd.spec.command).toBe("echo 'test\nmalicious_command'");
+});
+
+test('shell injection - complex injection attempt', () => {
+  const malicious = '$(echo "pwned" > /tmp/pwned.txt)';
+  const cmd = $({ mirror: false })`ls ${malicious}`;
+
+  // Should be safely quoted
+  expect(cmd.spec.command).toBe('ls \'$(echo "pwned" > /tmp/pwned.txt)\'');
+});
+
+test('safe strings - no unnecessary quoting', () => {
+  const testCases = [
+    { input: 'hello', expected: 'echo hello' },
+    { input: 'test123', expected: 'echo test123' },
+    { input: '/usr/bin/node', expected: 'echo /usr/bin/node' },
+    { input: 'file.txt', expected: 'echo file.txt' },
+    { input: 'user@host.com', expected: 'echo user@host.com' },
+    { input: 'key=value', expected: 'echo key=value' },
+    { input: 'path/to/file', expected: 'echo path/to/file' },
+    { input: 'v1.2.3', expected: 'echo v1.2.3' },
+  ];
+
+  testCases.forEach(({ input, expected }) => {
+    const cmd = $({ mirror: false })`echo ${input}`;
+    expect(cmd.spec.command).toBe(expected);
+  });
+});
+
+test('double-quoting prevention - user quotes with spaces', () => {
+  // User quotes a path that actually needs quotes (has spaces)
+  const pathWithSpaces = '/path with spaces/cmd';
+
+  // User provides single quotes
+  const singleQuoted = `'${pathWithSpaces}'`;
+  const cmd1 = $({ mirror: false })`${singleQuoted} --test`;
+  expect(cmd1.spec.command).toBe("'/path with spaces/cmd' --test");
+
+  // User provides double quotes
+  const doubleQuoted = `"${pathWithSpaces}"`;
+  const cmd2 = $({ mirror: false })`${doubleQuoted} --test`;
+  expect(cmd2.spec.command).toBe('\'"/path with spaces/cmd"\' --test');
+});
+
+test('double-quoting prevention - user quotes with special chars', () => {
+  // User quotes a string with special characters
+  const dangerous = 'test; echo INJECTED';
+
+  // User provides single quotes
+  const singleQuoted = `'${dangerous}'`;
+  const cmd1 = $({ mirror: false })`echo ${singleQuoted}`;
+  expect(cmd1.spec.command).toBe("echo 'test; echo INJECTED'");
+
+  // User provides double quotes
+  const doubleQuoted = `"${dangerous}"`;
+  const cmd2 = $({ mirror: false })`echo ${doubleQuoted}`;
+  expect(cmd2.spec.command).toBe('echo \'"test; echo INJECTED"\'');
+});
+
+test('double-quoting prevention - user unnecessarily quotes safe strings', () => {
+  // User quotes a safe string that doesn't need quotes
+  const safe = 'hello';
+
+  // User provides single quotes (unnecessary)
+  const singleQuoted = `'${safe}'`;
+  const cmd1 = $({ mirror: false })`echo ${singleQuoted}`;
+  expect(cmd1.spec.command).toBe("echo 'hello'");
+
+  // User provides double quotes (unnecessary)
+  const doubleQuoted = `"${safe}"`;
+  const cmd2 = $({ mirror: false })`echo ${doubleQuoted}`;
+  expect(cmd2.spec.command).toBe('echo \'"hello"\'');
+});
+
+test('double-quoting prevention - mixed scenarios', () => {
+  const testCases = [
+    {
+      desc: 'Already single-quoted safe string',
+      input: "'safe'",
+      expected: "echo 'safe'",
+    },
+    {
+      desc: 'Already double-quoted safe string',
+      input: '"safe"',
+      expected: 'echo \'"safe"\'',
+    },
+    {
+      desc: 'Already single-quoted dangerous string',
+      input: "'rm -rf /'",
+      expected: "echo 'rm -rf /'",
+    },
+    {
+      desc: 'Already double-quoted dangerous string',
+      input: '"rm -rf /"',
+      expected: 'echo \'"rm -rf /"\'',
+    },
+    {
+      desc: 'Single-quoted path with spaces',
+      input: "'/usr/local bin/app'",
+      expected: "echo '/usr/local bin/app'",
+    },
+    {
+      desc: 'Double-quoted path with spaces',
+      input: '"/usr/local bin/app"',
+      expected: 'echo \'"/usr/local bin/app"\'',
+    },
+  ];
+
+  testCases.forEach(({ desc, input, expected }) => {
+    const cmd = $({ mirror: false })`echo ${input}`;
+    expect(cmd.spec.command).toBe(expected);
+  });
+});
+
+test('strings requiring quotes - proper quoting applied', () => {
+  const testCases = [
+    { input: 'hello world', expected: "echo 'hello world'" },
+    { input: 'test$var', expected: "echo 'test$var'" },
+    { input: 'cmd;ls', expected: "echo 'cmd;ls'" },
+    { input: 'a|b', expected: "echo 'a|b'" },
+    { input: 'a&b', expected: "echo 'a&b'" },
+    { input: 'a>b', expected: "echo 'a>b'" },
+    { input: 'a<b', expected: "echo 'a<b'" },
+    { input: 'a*b', expected: "echo 'a*b'" },
+    { input: 'a?b', expected: "echo 'a?b'" },
+    { input: 'a[b]c', expected: "echo 'a[b]c'" },
+    { input: 'a{b}c', expected: "echo 'a{b}c'" },
+    { input: 'a(b)c', expected: "echo 'a(b)c'" },
+    { input: 'a!b', expected: "echo 'a!b'" },
+    { input: 'a#b', expected: "echo 'a#b'" },
+    { input: 'a%b', expected: "echo 'a%b'" },
+    { input: 'a^b', expected: "echo 'a^b'" },
+    { input: 'a~b', expected: "echo 'a~b'" },
+    { input: 'a`b', expected: "echo 'a`b'" },
+    { input: "a'b", expected: "echo 'a'\\''b'" },
+    { input: 'a"b', expected: "echo 'a\"b'" },
+    { input: 'a\\b', expected: "echo 'a\\b'" },
+  ];
+
+  testCases.forEach(({ input, expected }) => {
+    const cmd = $({ mirror: false })`echo ${input}`;
+    expect(cmd.spec.command).toBe(expected);
+  });
+});

package/js/tests/pipe.test.mjs

@@ -0,0 +1,291 @@
+import { test, expect, describe, beforeEach, afterEach } from 'bun:test';
+import './test-helper.mjs'; // Automatically sets up beforeEach/afterEach cleanup
+import {
+  $,
+  register,
+  unregister,
+  enableVirtualCommands,
+  disableVirtualCommands,
+} from '../src/$.mjs';
+import { rmSync, existsSync, mkdirSync, writeFileSync } from 'fs';
+import { join } from 'path';
+
+// Test directory for safe file operations
+const TEST_DIR = 'test-pipe';
+
+beforeEach(() => {
+  // Enable virtual commands for these tests
+  enableVirtualCommands();
+
+  // Create clean test directory
+  if (existsSync(TEST_DIR)) {
+    rmSync(TEST_DIR, { recursive: true, force: true });
+  }
+  mkdirSync(TEST_DIR);
+});
+
+afterEach(() => {
+  // Clean up test directory
+  if (existsSync(TEST_DIR)) {
+    rmSync(TEST_DIR, { recursive: true, force: true });
+  }
+});
+
+describe('Programmatic .pipe() Method', () => {
+  describe('Basic Piping', () => {
+    test('should pipe between built-in commands', async () => {
+      register('add-prefix', async ({ args, stdin }) => {
+        const prefix = args[0] || 'PREFIX:';
+        return { stdout: `${prefix} ${stdin.trim()}\n`, code: 0 };
+      });
+
+      const result = await $`echo "Hello World"`.pipe($`add-prefix "Piped:"`);
+
+      expect(result.code).toBe(0);
+      expect(result.stdout).toBe('Piped: Hello World\n');
+
+      // Cleanup
+      unregister('add-prefix');
+    });
+
+    test('should pipe virtual commands', async () => {
+      register('double', async ({ args, stdin }) => {
+        const lines = stdin.split('\n').filter(Boolean);
+        const doubled = `${lines.map((line) => line + line).join('\n')}\n`;
+        return { stdout: doubled, code: 0 };
+      });
+
+      register('count-chars', async ({ args, stdin }) => {
+        const charCount = stdin.replace(/\n/g, '').length;
+        return { stdout: `${charCount}\n`, code: 0 };
+      });
+
+      const result = await $`echo "hello"`.pipe($`double`).pipe($`count-chars`);
+
+      expect(result.code).toBe(0);
+      expect(result.stdout).toBe('10\n'); // "hellohello" = 10 chars
+
+      // Cleanup
+      unregister('double');
+      unregister('count-chars');
+    });
+
+    test('should handle stdin properly in pipe chain', async () => {
+      register('prefix', async ({ args, stdin }) => {
+        const prefix = args[0] || 'PREFIX:';
+        const lines = stdin.split('\n').filter(Boolean);
+        const prefixed = `${lines.map((line) => `${prefix} ${line}`).join('\n')}\n`;
+        return { stdout: prefixed, code: 0 };
+      });
+
+      const result = await $`echo "test"`.pipe($`prefix "[PIPED]"`);
+
+      expect(result.code).toBe(0);
+      expect(result.stdout).toBe('[PIPED] test\n');
+
+      // Cleanup
+      unregister('prefix');
+    });
+  });
+
+  describe('Error Handling', () => {
+    test('should propagate errors from source command', async () => {
+      const result = await $`cat nonexistent-file.txt`.pipe(
+        $`echo "Should not reach here"`
+      );
+
+      expect(result.code).toBe(1);
+      // More flexible error message checking - different systems may format differently
+      expect(result.stderr).toMatch(
+        /No such file or directory|nonexistent-file\.txt|cannot access|Command failed with exit code 1/i
+      );
+      expect(result.stdout).toBe(''); // Destination should not execute
+    });
+
+    test('should handle errors in destination command', async () => {
+      register('fail', async ({ args, stdin }) => ({
+        stdout: '',
+        stderr: 'Virtual command failed',
+        code: 42,
+      }));
+
+      const result = await $`echo "hello"`.pipe($`fail`);
+
+      expect(result.code).toBe(42);
+      // More flexible error checking - the pipe implementation may wrap errors
+      expect(result.stderr).toMatch(
+        /Virtual command failed|Command failed with exit code 42/i
+      );
+
+      // Cleanup
+      unregister('fail');
+    });
+
+    test('should handle exceptions in virtual commands', async () => {
+      register('throw-error', async ({ args, stdin }) => {
+        throw new Error('Something went wrong');
+      });
+
+      const result = await $`echo "hello"`.pipe($`throw-error`);
+
+      expect(result.code).toBe(1);
+      expect(result.stderr).toContain('Something went wrong');
+
+      // Cleanup
+      unregister('throw-error');
+    });
+  });
+
+  describe('Complex Pipelines', () => {
+    test('should support multiple pipe operations', async () => {
+      register('uppercase', async ({ args, stdin }) => ({
+        stdout: stdin.toUpperCase(),
+        code: 0,
+      }));
+
+      register('reverse', async ({ args, stdin }) => {
+        const reversed = stdin.split('').reverse().join('');
+        return { stdout: reversed, code: 0 };
+      });
+
+      register('add-brackets', async ({ args, stdin }) => ({
+        stdout: `[${stdin.trim()}]\n`,
+        code: 0,
+      }));
+
+      const result = await $`echo "hello"`
+        .pipe($`uppercase`)
+        .pipe($`reverse`)
+        .pipe($`add-brackets`);
+
+      expect(result.code).toBe(0);
+      expect(result.stdout).toBe('[OLLEH]\n');
+
+      // Cleanup
+      unregister('uppercase');
+      unregister('reverse');
+      unregister('add-brackets');
+    });
+
+    test('should preserve stderr from all commands', async () => {
+      register('warn-and-pass', async ({ args, stdin }) => ({
+        stdout: stdin,
+        stderr: `Warning from ${args[0]}\n`,
+        code: 0,
+      }));
+
+      const result = await $`echo "data"`
+        .pipe($`warn-and-pass cmd1`)
+        .pipe($`warn-and-pass cmd2`);
+
+      expect(result.code).toBe(0);
+      expect(result.stdout).toBe('data\n');
+      expect(result.stderr).toContain('Warning from cmd1');
+      expect(result.stderr).toContain('Warning from cmd2');
+
+      // Cleanup
+      unregister('warn-and-pass');
+    });
+  });
+
+  describe('Mixed Command Types', () => {
+    test('should pipe from built-in to virtual command', async () => {
+      const testFile = join(TEST_DIR, 'pipe-test.txt');
+      writeFileSync(testFile, 'Line 1\nLine 2\nLine 3\n');
+
+      register('count-lines', async ({ args, stdin }) => {
+        const lines = stdin.split('\n').filter(Boolean);
+        return { stdout: `${lines.length}\n`, code: 0 };
+      });
+
+      const result = await $`cat ${testFile}`.pipe($`count-lines`);
+
+      expect(result.code).toBe(0);
+      expect(result.stdout).toBe('3\n');
+
+      // Cleanup
+      unregister('count-lines');
+    });
+
+    test('should pipe from virtual to built-in command', async () => {
+      register('generate-sequence', async ({ args }) => {
+        const count = parseInt(args[0] || 3);
+        const sequence = `${Array.from({ length: count }, (_, i) => i + 1).join('\n')}\n`;
+        return { stdout: sequence, code: 0 };
+      });
+
+      register('capture-lines', async ({ args, stdin }) => {
+        const lines = stdin.split('\n').filter(Boolean);
+        return { stdout: `Got ${lines.length} lines\n`, code: 0 };
+      });
+
+      const result = await $`generate-sequence 5`.pipe($`capture-lines`);
+
+      expect(result.code).toBe(0);
+      expect(result.stdout).toBe('Got 5 lines\n');
+
+      // Cleanup
+      unregister('generate-sequence');
+      unregister('capture-lines');
+    });
+  });
+
+  describe('Performance and Memory', () => {
+    test('should handle large data efficiently', async () => {
+      register('generate-large', async ({ args }) => {
+        const lines = parseInt(args[0] || 1000);
+        let output = '';
+        for (let i = 1; i <= lines; i++) {
+          output += `Line ${i}\n`;
+        }
+        return { stdout: output, code: 0 };
+      });
+
+      register('count-occurrences', async ({ args, stdin }) => {
+        const pattern = args[0] || 'Line';
+        const matches = (stdin.match(new RegExp(pattern, 'g')) || []).length;
+        return { stdout: `${matches}\n`, code: 0 };
+      });
+
+      const start = Date.now();
+      const result = await $`generate-large 100`.pipe(
+        $`count-occurrences Line`
+      );
+      const elapsed = Date.now() - start;
+
+      expect(result.code).toBe(0);
+      expect(result.stdout).toBe('100\n');
+      expect(elapsed).toBeLessThan(2000); // Should complete within 2 seconds
+
+      // Cleanup
+      unregister('generate-large');
+      unregister('count-occurrences');
+    });
+  });
+
+  describe('Compatibility with Shell Piping', () => {
+    test('should work alongside shell pipe syntax', async () => {
+      register('format-output', async ({ args, stdin }) => ({
+        stdout: `Formatted: ${stdin.trim()}\n`,
+        code: 0,
+      }));
+
+      register('simple-pipe', async ({ args, stdin }) => ({
+        stdout: `${stdin.trim()} processed\n`,
+        code: 0,
+      }));
+
+      // Test that programmatic .pipe() works after shell pipe operations
+      const result = await $`echo "hello"`
+        .pipe($`simple-pipe`)
+        .pipe($`format-output`);
+
+      expect(result.code).toBe(0);
+      expect(result.stdout).toBe('Formatted: hello processed\n');
+
+      // Cleanup
+      unregister('format-output');
+      unregister('simple-pipe');
+    });
+  });
+});