command-stream 0.8.2 → 0.9.0

package/js/tests/cleanup-verification.test.mjs

@@ -0,0 +1,127 @@
+#!/usr/bin/env node
+
+import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
+import {
+  beforeTestCleanup,
+  afterTestCleanup,
+  originalCwd,
+} from './test-cleanup.mjs';
+import { isWindows } from './test-helper.mjs';
+import { $ } from '../src/$.mjs';
+import { mkdtempSync, rmSync, realpathSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+
+// Helper to normalize paths (handles macOS /var -> /private/var symlink)
+const normalizePath = (p) => {
+  try {
+    return realpathSync(p);
+  } catch {
+    return p;
+  }
+};
+
+describe('Cleanup Verification', () => {
+  beforeEach(beforeTestCleanup);
+  afterEach(afterTestCleanup);
+
+  let testDirs = [];
+
+  afterEach(() => {
+    // Clean up test directories
+    for (const dir of testDirs) {
+      try {
+        rmSync(dir, { recursive: true, force: true });
+      } catch (e) {
+        // Ignore cleanup errors
+      }
+    }
+    testDirs = [];
+  });
+
+  test('should start in original directory', () => {
+    const currentCwd = process.cwd();
+    expect(currentCwd).toBe(originalCwd);
+  });
+
+  test('should restore cwd after simple cd command', async () => {
+    const tempDir = mkdtempSync(join(tmpdir(), 'cleanup-test-'));
+    testDirs.push(tempDir);
+
+    // Change directory
+    await $`cd ${tempDir}`;
+
+    // Verify we changed
+    const result = await $`pwd`;
+    expect(normalizePath(result.stdout.trim())).toBe(normalizePath(tempDir));
+
+    // Cwd should be changed within test
+    expect(normalizePath(process.cwd())).toBe(normalizePath(tempDir));
+  });
+
+  test('should be back in original directory after cd test', () => {
+    // This test verifies the previous test's cleanup worked
+    const currentCwd = process.cwd();
+    expect(currentCwd).toBe(originalCwd);
+  });
+
+  test('should restore cwd after cd with && operator', async () => {
+    const tempDir = mkdtempSync(join(tmpdir(), 'cleanup-test2-'));
+    testDirs.push(tempDir);
+
+    // Change directory with && operator
+    await $`cd ${tempDir} && echo "test"`;
+
+    // Should be in temp dir
+    expect(normalizePath(process.cwd())).toBe(normalizePath(tempDir));
+  });
+
+  test('should verify restoration after && cd test', () => {
+    const currentCwd = process.cwd();
+    expect(currentCwd).toBe(originalCwd);
+  });
+
+  // Skip on Windows - uses subshell syntax and pwd command
+  test.skipIf(isWindows)(
+    'should not affect cwd when cd is in subshell',
+    async () => {
+      const tempDir = mkdtempSync(join(tmpdir(), 'cleanup-test3-'));
+      testDirs.push(tempDir);
+
+      // Change directory in subshell - should not affect parent
+      const result = await $`(cd ${tempDir} && pwd)`;
+      expect(normalizePath(result.stdout.trim())).toBe(normalizePath(tempDir));
+
+      // Should still be in original directory
+      const currentCwd = process.cwd();
+      expect(currentCwd).toBe(originalCwd);
+    }
+  );
+
+  test('should restore cwd after multiple cd commands', async () => {
+    const tempDir1 = mkdtempSync(join(tmpdir(), 'cleanup-test4-'));
+    const tempDir2 = mkdtempSync(join(tmpdir(), 'cleanup-test5-'));
+    testDirs.push(tempDir1, tempDir2);
+
+    // Multiple cd commands
+    await $`cd ${tempDir1}`;
+    expect(normalizePath(process.cwd())).toBe(normalizePath(tempDir1));
+
+    await $`cd ${tempDir2}`;
+    expect(normalizePath(process.cwd())).toBe(normalizePath(tempDir2));
+
+    await $`cd ${tempDir1}`;
+    expect(normalizePath(process.cwd())).toBe(normalizePath(tempDir1));
+  });
+
+  test('final verification - should still be in original directory', () => {
+    // Final check that all previous tests were properly cleaned up
+    const currentCwd = process.cwd();
+    expect(currentCwd).toBe(originalCwd);
+
+    // Also verify with pwd command
+    return $`pwd`.then((result) => {
+      expect(result.stdout.trim()).toBe(originalCwd);
+    });
+  });
+});

package/js/tests/ctrl-c-baseline.test.mjs

@@ -0,0 +1,207 @@
+import { describe, it, expect, afterEach } from 'bun:test';
+import './test-helper.mjs'; // Automatically sets up beforeEach/afterEach cleanup
+import { spawn } from 'child_process';
+import { trace } from '../src/$.utils.mjs';
+
+// Platform detection - Windows handles signals differently than Unix
+const isWindows = process.platform === 'win32';
+
+/**
+ * Baseline tests for CTRL+C signal handling using native spawn
+ * These tests verify that the CI environment can handle basic process spawning and signals
+ * without using our library, providing a comparison point for debugging
+ *
+ * Note: These tests are skipped on Windows because:
+ * 1. Windows doesn't have 'sh' shell by default
+ * 2. SIGINT/signal handling works fundamentally different on Windows
+ * 3. Exit codes 130 (128+SIGINT) are Unix-specific
+ */
+describe.skipIf(isWindows)('CTRL+C Baseline Tests (Native Spawn)', () => {
+  let childProcesses = [];
+
+  afterEach(() => {
+    // Clean up any remaining child processes
+    childProcesses.forEach((child) => {
+      if (!child.killed) {
+        child.kill('SIGKILL');
+      }
+    });
+    childProcesses = [];
+  });
+
+  it('should handle SIGINT with simple shell command', async () => {
+    trace('BaselineTest', 'Testing simple shell command');
+
+    const child = spawn('sh', ['-c', 'echo "BASELINE_START" && sleep 30'], {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      detached: true,
+    });
+
+    trace('BaselineTest', () => `Child spawned, PID: ${child.pid}`);
+    childProcesses.push(child);
+
+    let stdout = '';
+    let stderr = '';
+
+    child.stdout.on('data', (data) => {
+      stdout += data.toString();
+      trace(
+        'BaselineTest',
+        () => `Received stdout: ${JSON.stringify(data.toString())}`
+      );
+    });
+
+    child.stderr.on('data', (data) => {
+      stderr += data.toString();
+      trace(
+        'BaselineTest',
+        () => `Received stderr: ${JSON.stringify(data.toString())}`
+      );
+    });
+
+    // Wait for output
+    await new Promise((resolve) => setTimeout(resolve, 500));
+
+    trace('BaselineTest', 'Sending SIGINT');
+    child.kill('SIGINT');
+
+    // Wait for exit
+    const exitCode = await new Promise((resolve) => {
+      let resolved = false;
+      child.on('exit', (code, signal) => {
+        if (!resolved) {
+          resolved = true;
+          trace(
+            'BaselineTest',
+            () => `Process exited with code: ${code} signal: ${signal}`
+          );
+          resolve(code !== null ? code : signal === 'SIGINT' ? 130 : 1);
+        }
+      });
+
+      // Timeout fallback
+      setTimeout(() => {
+        if (!resolved) {
+          resolved = true;
+          trace('BaselineTest', 'Timeout, force killing');
+          child.kill('SIGKILL');
+          resolve(137);
+        }
+      }, 3000);
+    });
+
+    trace('BaselineTest', () => `Final stdout: ${stdout}`);
+    trace('BaselineTest', () => `Final stderr: ${stderr}`);
+    trace('BaselineTest', () => `Exit code: ${exitCode}`);
+
+    expect(stdout).toContain('BASELINE_START');
+    // Accept both 130 (SIGINT) and 137 (SIGKILL) as valid
+    expect([130, 137].includes(exitCode)).toBe(true);
+  });
+
+  it('should handle Node.js inline script with SIGINT', async () => {
+    trace('BaselineTest', 'Testing Node.js inline script');
+
+    const nodeCode = `
+      console.log('NODE_START');
+      process.on('SIGINT', () => {
+        console.log('SIGINT_RECEIVED');
+        process.exit(130);
+      });
+      setTimeout(() => {
+        console.log('TIMEOUT');
+        process.exit(1);
+      }, 30000);
+    `;
+
+    const child = spawn('node', ['-e', nodeCode], {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      detached: true,
+    });
+
+    trace('BaselineTest', () => `Node child spawned, PID: ${child.pid}`);
+    childProcesses.push(child);
+
+    let stdout = '';
+    child.stdout.on('data', (data) => {
+      stdout += data.toString();
+      trace(
+        'BaselineTest',
+        () => `Node stdout: ${JSON.stringify(data.toString())}`
+      );
+    });
+
+    // Wait for startup
+    await new Promise((resolve) => setTimeout(resolve, 500));
+
+    trace('BaselineTest', 'Sending SIGINT to Node process');
+    child.kill('SIGINT');
+
+    const exitCode = await new Promise((resolve) => {
+      child.on('exit', (code) => {
+        trace('BaselineTest', () => `Node process exited with code: ${code}`);
+        resolve(code);
+      });
+    });
+
+    trace('BaselineTest', () => `Node final stdout: ${stdout}`);
+    trace('BaselineTest', () => `Node exit code: ${exitCode}`);
+
+    expect(stdout).toContain('NODE_START');
+    expect(stdout).toContain('SIGINT_RECEIVED');
+    expect(exitCode).toBe(130);
+  });
+
+  it('should handle Node.js script file', async () => {
+    trace('BaselineTest', 'Testing Node.js script file');
+
+    // Use the simple-test-sleep.js which doesn't have ES module dependencies
+    const child = spawn('node', ['js/examples/simple-test-sleep.js'], {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      detached: true,
+      cwd: process.cwd(),
+    });
+
+    trace('BaselineTest', () => `Script child spawned, PID: ${child.pid}`);
+    childProcesses.push(child);
+
+    let stdout = '';
+    let stderr = '';
+
+    child.stdout.on('data', (data) => {
+      stdout += data.toString();
+      trace(
+        'BaselineTest',
+        () => `Script stdout: ${JSON.stringify(data.toString())}`
+      );
+    });
+
+    child.stderr.on('data', (data) => {
+      stderr += data.toString();
+      trace('BaselineTest', () => `Script stderr: ${data.toString().trim()}`);
+    });
+
+    // Wait for startup
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+
+    trace('BaselineTest', 'Sending SIGINT to script');
+    child.kill('SIGINT');
+
+    const exitCode = await new Promise((resolve) => {
+      child.on('exit', (code) => {
+        trace('BaselineTest', () => `Script exited with code: ${code}`);
+        resolve(code);
+      });
+    });
+
+    trace('BaselineTest', () => `Script final stdout: ${stdout}`);
+    trace(
+      'BaselineTest',
+      () => `Script final stderr (first 200 chars): ${stderr.substring(0, 200)}`
+    );
+    trace('BaselineTest', () => `Script exit code: ${exitCode}`);
+
+    expect(stdout).toContain('STARTING_SLEEP');
+    expect(exitCode).toBe(130);
+  });
+});

package/js/tests/ctrl-c-basic.test.mjs

@@ -0,0 +1,220 @@
+import { describe, it, expect } from 'bun:test';
+import './test-helper.mjs'; // Automatically sets up beforeEach/afterEach cleanup
+import { $ } from '../src/$.mjs';
+
+// Platform detection - Windows handles signals differently than Unix
+const isWindows = process.platform === 'win32';
+
+// Skip signal tests on Windows - SIGTERM exit code 143 is Unix-specific
+describe.skipIf(isWindows)('CTRL+C Basic Handling', () => {
+  it('should be able to kill a long-running process', async () => {
+    // Start a long-running process
+    const runner = $`sleep 10`;
+
+    // Start it without awaiting completion
+    const promise = runner.start();
+
+    // Give it time to start
+    await new Promise((resolve) => setTimeout(resolve, 100));
+
+    // Kill it manually (simulating what CTRL+C would do)
+    runner.kill();
+
+    // The process should complete with a non-zero exit code
+    const result = await promise;
+
+    // Should have a non-zero exit code (143 for SIGTERM)
+    expect(result.code).toBeGreaterThan(0);
+    expect(result.code).toBe(143); // 128 + 15 (SIGTERM)
+  });
+
+  it('should spawn processes with detached flag on Unix', async () => {
+    if (process.platform === 'win32') {
+      // Skip on Windows
+      return;
+    }
+
+    // Use /bin/sleep to get a real system process, not virtual command
+    const runner = $`/bin/sleep 1`;
+
+    // Start the process
+    const promise = runner.start();
+
+    // Give it a moment to spawn
+    await new Promise((resolve) => setTimeout(resolve, 50));
+
+    // Check that the child process exists and has a PID
+    expect(runner.child).toBeDefined();
+    expect(runner.child.pid).toBeGreaterThan(0);
+
+    // Kill and wait for completion
+    runner.kill();
+
+    try {
+      await promise;
+    } catch (error) {
+      // Expected to error
+    }
+  });
+
+  it('should handle CTRL+C character in raw mode', async () => {
+    // Test that the _forwardTTYStdin method properly handles CTRL+C
+    // This is a unit test of the specific functionality
+
+    const runner = $`cat`; // Use cat to read stdin
+
+    // Start the process
+    const promise = runner.start();
+
+    // Give it time to set up
+    await new Promise((resolve) => setTimeout(resolve, 100));
+
+    // Kill the process
+    runner.kill();
+
+    // Should complete with an error
+    let errorCode = null;
+    try {
+      await promise;
+    } catch (error) {
+      errorCode = error.code;
+    }
+
+    expect(errorCode).toBeDefined();
+  });
+});
+
+// Skip on Windows - SIGTERM exit code 143 is Unix-specific
+describe.skipIf(isWindows)('CTRL+C Virtual Commands', () => {
+  it(
+    'should cancel virtual command with AbortController',
+    async () => {
+      const runner = $`sleep 5`; // Virtual sleep command
+
+      const promise = runner.start();
+
+      // Give virtual command time to start
+      await new Promise((resolve) => setTimeout(resolve, 100));
+
+      // Kill the virtual command
+      runner.kill();
+
+      const result = await promise;
+
+      // Virtual commands return SIGTERM exit code when cancelled
+      expect(result.code).toBe(143);
+    },
+    { timeout: 5000 }
+  );
+
+  it(
+    'should cancel virtual async generator',
+    async () => {
+      // Test cancelling a streaming virtual command
+      const runner = $`yes hello`;
+
+      // Start streaming
+      const streamPromise = (async () => {
+        let chunks = 0;
+        for await (const _chunk of runner.stream()) {
+          chunks++;
+          if (chunks >= 3) {
+            break; // Break should trigger cancellation
+          }
+        }
+        return chunks;
+      })();
+
+      const chunks = await streamPromise;
+      expect(chunks).toBe(3);
+      expect(runner.finished).toBe(true);
+    },
+    { timeout: 5000 }
+  );
+});
+
+// Skip on Windows - SIGTERM exit code 143 is Unix-specific
+describe.skipIf(isWindows)('CTRL+C Different stdin Modes', () => {
+  it('should handle CTRL+C with string stdin', async () => {
+    // Use a long-running command that will actually be killed
+    const runner = $({ stdin: 'test input\n' })`sleep 10`;
+
+    const promise = runner.start();
+    await new Promise((resolve) => setTimeout(resolve, 200));
+
+    runner.kill();
+    const result = await promise;
+
+    expect(result.code).toBe(143);
+  });
+
+  it('should handle CTRL+C with Buffer stdin', async () => {
+    // Use a long-running command that will actually be killed
+    const runner = $({ stdin: Buffer.from('test input\n') })`sleep 10`;
+
+    const promise = runner.start();
+    await new Promise((resolve) => setTimeout(resolve, 200));
+
+    runner.kill();
+    const result = await promise;
+
+    expect(result.code).toBe(143);
+  });
+
+  it('should handle CTRL+C with ignore stdin', async () => {
+    const runner = $({ stdin: 'ignore' })`sleep 5`;
+
+    const promise = runner.start();
+    await new Promise((resolve) => setTimeout(resolve, 100));
+
+    runner.kill();
+    const result = await promise;
+
+    expect(result.code).toBe(143);
+  });
+});
+
+// Skip on Windows - SIGTERM exit code 143 is Unix-specific
+describe.skipIf(isWindows)('CTRL+C Pipeline Interruption', () => {
+  it(
+    'should interrupt simple pipeline',
+    async () => {
+      // Use a very simple approach that we know works
+      const runner = $`sleep 10`;
+
+      const promise = runner.start();
+      await new Promise((resolve) => setTimeout(resolve, 200));
+
+      runner.kill();
+      const result = await promise;
+
+      // Should be interrupted with SIGTERM code
+      expect(result.code).toBe(143);
+    },
+    { timeout: 3000 }
+  );
+});
+
+// Skip on Windows - uses 'sh' command and Unix-specific signals
+describe.skipIf(isWindows)('CTRL+C Process Groups', () => {
+  it(
+    'should handle process group termination on Unix',
+    async () => {
+      if (process.platform === 'win32') {
+        return;
+      } // Skip on Windows
+
+      // Use a command that spawns subprocesses
+      const runner = $`sh -c 'sleep 10 & sleep 10 & wait'`;
+
+      const promise = runner.start();
+      await new Promise((resolve) => setTimeout(resolve, 200));
+
+      runner.kill();
+      const result = await promise;
+
+      expect(result.code).toBe(143);
+    },
+    { timeout: 5000 }
+  );
+});