command-stream 0.8.2 → 0.9.0

package/js/tests/test-cleanup.mjs

@@ -0,0 +1,200 @@
+/**
+ * Test cleanup utilities for command-stream tests
+ *
+ * Provides functions to be called in beforeEach/afterEach hooks
+ * within describe blocks.
+ *
+ * Usage:
+ * ```js
+ * import { beforeTestCleanup, afterTestCleanup } from './test-cleanup.mjs';
+ * import { describe, beforeEach, afterEach } from 'bun:test';
+ *
+ * describe('Your test suite', () => {
+ *   beforeEach(beforeTestCleanup);
+ *   afterEach(afterTestCleanup);
+ *
+ *   // Your tests here
+ * });
+ * ```
+ */
+
+import { resetGlobalState } from '../src/$.mjs';
+import { existsSync } from 'fs';
+
+// Save the original working directory when module loads
+const originalCwd = process.cwd();
+
+// Trace function for debugging
+function trace(message) {
+  if (process.env.DEBUG || process.env.TRACE) {
+    const timestamp = new Date().toISOString();
+    console.error(`[TRACE ${timestamp}] [test-cleanup] ${message}`);
+  }
+}
+
+trace(`Module loaded - original working directory: ${originalCwd}`);
+
+/**
+ * Cleanup function to call in beforeEach hook
+ */
+export async function beforeTestCleanup() {
+  trace('beforeTestCleanup running');
+
+  // CRITICAL: Restore working directory first - MUST succeed for spawn to work
+  const currentDir = process.cwd();
+  if (currentDir !== originalCwd) {
+    trace(`Restoring cwd from ${currentDir} to ${originalCwd}`);
+    try {
+      // Force restoration regardless of current state
+      process.chdir(originalCwd);
+    } catch (_e) {
+      // Original directory might be gone, try fallbacks
+      try {
+        if (existsSync(originalCwd)) {
+          process.chdir(originalCwd);
+        } else if (existsSync('/workspace/command-stream')) {
+          process.chdir('/workspace/command-stream');
+        } else if (process.env.HOME && existsSync(process.env.HOME)) {
+          process.chdir(process.env.HOME);
+        } else {
+          process.chdir('/');
+        }
+      } catch (_e2) {
+        console.error(
+          '[test-cleanup] FATAL: Cannot set working directory in beforeTestCleanup'
+        );
+        trace('FATAL: Cannot set working directory');
+      }
+    }
+  }
+
+  // Call the comprehensive reset
+  resetGlobalState();
+
+  // Extra safety: ensure we're in a valid directory after reset
+  try {
+    process.cwd(); // This will throw if we're in a bad state
+  } catch (_e) {
+    // Force to a known good directory
+    process.chdir(originalCwd);
+  }
+
+  // VERIFY: Ensure we actually restored to the original directory
+  const finalCwd = process.cwd();
+  if (finalCwd !== originalCwd && existsSync(originalCwd)) {
+    console.error(
+      `[test-cleanup] WARNING: Failed to restore cwd! Expected: ${originalCwd}, Got: ${finalCwd}`
+    );
+    // Try one more time
+    try {
+      process.chdir(originalCwd);
+      const verifiedCwd = process.cwd();
+      if (verifiedCwd === originalCwd) {
+        trace('Successfully restored on second attempt');
+      } else {
+        throw new Error(
+          `[test-cleanup] CRITICAL: Cannot restore to original directory ${originalCwd}, stuck in ${verifiedCwd}`
+        );
+      }
+    } catch (_e) {
+      throw new Error(
+        `[test-cleanup] CRITICAL: Cannot restore to original directory ${originalCwd}, stuck in ${finalCwd}`
+      );
+    }
+  }
+
+  // Give a tiny bit of time for any async cleanup to complete
+  await new Promise((resolve) => setTimeout(resolve, 1));
+  trace('beforeTestCleanup completed');
+}
+
+/**
+ * Cleanup function to call in afterEach hook
+ */
+export async function afterTestCleanup() {
+  trace('afterTestCleanup running');
+
+  // CRITICAL: Clean up and restore state after each test
+  const currentDir = process.cwd();
+  if (currentDir !== originalCwd) {
+    trace(`Restoring cwd from ${currentDir} to ${originalCwd}`);
+    try {
+      // Force restoration regardless of current state
+      process.chdir(originalCwd);
+    } catch (_e) {
+      // Original directory might be gone, try fallbacks
+      try {
+        if (existsSync(originalCwd)) {
+          process.chdir(originalCwd);
+        } else if (existsSync('/workspace/command-stream')) {
+          process.chdir('/workspace/command-stream');
+        } else if (process.env.HOME && existsSync(process.env.HOME)) {
+          process.chdir(process.env.HOME);
+        } else {
+          process.chdir('/');
+        }
+      } catch (_e2) {
+        console.error(
+          '[test-cleanup] FATAL: Cannot set working directory in afterTestCleanup'
+        );
+        trace('FATAL: Cannot set working directory');
+      }
+    }
+  }
+
+  // Call the comprehensive reset
+  resetGlobalState();
+
+  // Extra safety: ensure we're in a valid directory after reset
+  try {
+    process.cwd(); // This will throw if we're in a bad state
+  } catch (_e) {
+    // Force to a known good directory
+    process.chdir(originalCwd);
+  }
+
+  // VERIFY: Ensure we actually restored to the original directory
+  const finalCwd = process.cwd();
+  if (finalCwd !== originalCwd && existsSync(originalCwd)) {
+    console.error(
+      `[test-cleanup] WARNING: Failed to restore cwd in afterEach! Expected: ${originalCwd}, Got: ${finalCwd}`
+    );
+    // Try one more time
+    try {
+      process.chdir(originalCwd);
+      const verifiedCwd = process.cwd();
+      if (verifiedCwd === originalCwd) {
+        trace('Successfully restored on second attempt in afterEach');
+      } else {
+        throw new Error(
+          `[test-cleanup] CRITICAL: Cannot restore to original directory ${originalCwd} in afterEach, stuck in ${verifiedCwd}`
+        );
+      }
+    } catch (_e) {
+      throw new Error(
+        `[test-cleanup] CRITICAL: Cannot restore to original directory ${originalCwd} in afterEach, stuck in ${finalCwd}`
+      );
+    }
+  }
+
+  // Give a tiny bit of time for any async cleanup to complete
+  await new Promise((resolve) => setTimeout(resolve, 1));
+  trace('afterTestCleanup completed');
+}
+
+// Install a process exit handler to ensure cleanup even on crash
+process.on('beforeExit', () => {
+  try {
+    if (process.cwd() !== originalCwd) {
+      process.chdir(originalCwd);
+    }
+  } catch (_e) {
+    // Ignore
+  }
+});
+
+// Export resetGlobalState for direct use if needed
+export { resetGlobalState };
+
+// Export original cwd for verification in tests
+export { originalCwd };

package/js/tests/test-helper-fixed.mjs

@@ -0,0 +1,148 @@
+/**
+ * Test Helper for command-stream tests
+ *
+ * IMPORTANT: Due to Bun's test runner limitations, beforeEach/afterEach hooks
+ * MUST be within describe() blocks to work properly.
+ *
+ * Usage:
+ * ```js
+ * import { setupTestHooks } from './test-helper-fixed.mjs';
+ * import { describe } from 'bun:test';
+ *
+ * describe('Your test suite', () => {
+ *   setupTestHooks();
+ *
+ *   // Your tests here
+ * });
+ * ```
+ */
+
+import { beforeEach, afterEach } from 'bun:test';
+import { resetGlobalState } from '../src/$.mjs';
+import { existsSync } from 'fs';
+
+// Save the original working directory when tests start
+const originalCwd = process.cwd();
+
+// Trace function for debugging
+function trace(message) {
+  if (process.env.DEBUG || process.env.TRACE) {
+    const timestamp = new Date().toISOString();
+    console.error(`[TRACE ${timestamp}] [test-helper] ${message}`);
+  }
+}
+
+trace(`Original working directory: ${originalCwd}`);
+
+/**
+ * Sets up beforeEach and afterEach hooks to restore working directory
+ * and reset global state between tests.
+ *
+ * MUST be called inside a describe() block!
+ */
+export function setupTestHooks() {
+  beforeEach(async () => {
+    trace('beforeEach hook running');
+    // CRITICAL: Restore working directory first - MUST succeed for spawn to work
+    const currentDir = process.cwd();
+    if (currentDir !== originalCwd) {
+      trace(`beforeEach: Restoring cwd from ${currentDir} to ${originalCwd}`);
+      try {
+        // Force restoration regardless of current state
+        process.chdir(originalCwd);
+      } catch (_e) {
+        // Original directory might be gone, try fallbacks
+        try {
+          if (existsSync(originalCwd)) {
+            process.chdir(originalCwd);
+          } else if (existsSync('/workspace/command-stream')) {
+            process.chdir('/workspace/command-stream');
+          } else if (process.env.HOME && existsSync(process.env.HOME)) {
+            process.chdir(process.env.HOME);
+          } else {
+            process.chdir('/');
+          }
+        } catch (_e2) {
+          console.error(
+            '[test-helper] FATAL: Cannot set working directory in beforeEach'
+          );
+          trace('FATAL: Cannot set working directory in beforeEach');
+        }
+      }
+    }
+
+    // Call the comprehensive reset
+    resetGlobalState();
+
+    // Extra safety: ensure we're in a valid directory after reset
+    try {
+      process.cwd(); // This will throw if we're in a bad state
+    } catch (_e) {
+      // Force to a known good directory
+      process.chdir(originalCwd);
+    }
+
+    // Give a tiny bit of time for any async cleanup to complete
+    await new Promise((resolve) => setTimeout(resolve, 1));
+    trace('beforeEach hook completed');
+  });
+
+  afterEach(async () => {
+    trace('afterEach hook running');
+    // CRITICAL: Clean up and restore state after each test
+    const currentDir = process.cwd();
+    if (currentDir !== originalCwd) {
+      trace(`afterEach: Restoring cwd from ${currentDir} to ${originalCwd}`);
+      try {
+        // Force restoration regardless of current state
+        process.chdir(originalCwd);
+      } catch (_e) {
+        // Original directory might be gone, try fallbacks
+        try {
+          if (existsSync(originalCwd)) {
+            process.chdir(originalCwd);
+          } else if (existsSync('/workspace/command-stream')) {
+            process.chdir('/workspace/command-stream');
+          } else if (process.env.HOME && existsSync(process.env.HOME)) {
+            process.chdir(process.env.HOME);
+          } else {
+            process.chdir('/');
+          }
+        } catch (_e2) {
+          console.error(
+            '[test-helper] FATAL: Cannot set working directory in afterEach'
+          );
+          trace('FATAL: Cannot set working directory in afterEach');
+        }
+      }
+    }
+
+    // Call the comprehensive reset
+    resetGlobalState();
+
+    // Extra safety: ensure we're in a valid directory after reset
+    try {
+      process.cwd(); // This will throw if we're in a bad state
+    } catch (_e) {
+      // Force to a known good directory
+      process.chdir(originalCwd);
+    }
+
+    // Give a tiny bit of time for any async cleanup to complete
+    await new Promise((resolve) => setTimeout(resolve, 1));
+    trace('afterEach hook completed');
+  });
+}
+
+// Install a process exit handler to ensure cleanup even on crash
+process.on('beforeExit', () => {
+  try {
+    if (process.cwd() !== originalCwd) {
+      process.chdir(originalCwd);
+    }
+  } catch (_e) {
+    // Ignore
+  }
+});
+
+export { resetGlobalState };

package/js/tests/test-helper-v2.mjs

@@ -0,0 +1,118 @@
+import { beforeEach, afterEach } from 'bun:test';
+import { resetGlobalState } from '../src/$.mjs';
+import { existsSync } from 'fs';
+
+// Save the original working directory when tests start
+const originalCwd = process.cwd();
+
+// Trace function for debugging
+function trace(message) {
+  if (process.env.DEBUG || process.env.TRACE) {
+    const timestamp = new Date().toISOString();
+    console.error(`[TRACE ${timestamp}] [test-helper-v2] ${message}`);
+  }
+}
+
+trace(`Original working directory: ${originalCwd}`);
+
+// Function to set up test hooks
+export function setupTestHooks() {
+  trace('Setting up test hooks');
+
+  beforeEach(async () => {
+    trace('beforeEach hook running');
+    // CRITICAL: Restore working directory first - MUST succeed for spawn to work
+    const currentDir = process.cwd();
+    if (currentDir !== originalCwd) {
+      trace(`beforeEach: Restoring cwd from ${currentDir} to ${originalCwd}`);
+      try {
+        // Force restoration regardless of current state
+        process.chdir(originalCwd);
+      } catch (_e) {
+        // Original directory might be gone, try fallbacks
+        try {
+          if (existsSync(originalCwd)) {
+            process.chdir(originalCwd);
+          } else if (existsSync('/workspace/command-stream')) {
+            process.chdir('/workspace/command-stream');
+          } else if (process.env.HOME && existsSync(process.env.HOME)) {
+            process.chdir(process.env.HOME);
+          } else {
+            process.chdir('/');
+          }
+        } catch (_e2) {
+          console.error(
+            '[test-helper-v2] FATAL: Cannot set working directory in beforeEach'
+          );
+          trace('FATAL: Cannot set working directory in beforeEach');
+        }
+      }
+    }
+
+    // Call the comprehensive reset
+    resetGlobalState();
+
+    // Extra safety: ensure we're in a valid directory after reset
+    try {
+      process.cwd(); // This will throw if we're in a bad state
+    } catch (_e) {
+      // Force to a known good directory
+      process.chdir(originalCwd);
+    }
+
+    // Give a tiny bit of time for any async cleanup to complete
+    await new Promise((resolve) => setTimeout(resolve, 1));
+    trace('beforeEach hook completed');
+  });
+
+  afterEach(async () => {
+    trace('afterEach hook running');
+    // CRITICAL: Clean up and restore state after each test
+    const currentDir = process.cwd();
+    if (currentDir !== originalCwd) {
+      trace(`afterEach: Restoring cwd from ${currentDir} to ${originalCwd}`);
+      try {
+        // Force restoration regardless of current state
+        process.chdir(originalCwd);
+      } catch (_e) {
+        // Original directory might be gone, try fallbacks
+        try {
+          if (existsSync(originalCwd)) {
+            process.chdir(originalCwd);
+          } else if (existsSync('/workspace/command-stream')) {
+            process.chdir('/workspace/command-stream');
+          } else if (process.env.HOME && existsSync(process.env.HOME)) {
+            process.chdir(process.env.HOME);
+          } else {
+            process.chdir('/');
+          }
+        } catch (_e2) {
+          console.error(
+            '[test-helper-v2] FATAL: Cannot set working directory in afterEach'
+          );
+          trace('FATAL: Cannot set working directory in afterEach');
+        }
+      }
+    }
+
+    // Call the comprehensive reset
+    resetGlobalState();
+
+    // Extra safety: ensure we're in a valid directory after reset
+    try {
+      process.cwd(); // This will throw if we're in a bad state
+    } catch (_e) {
+      // Force to a known good directory
+      process.chdir(originalCwd);
+    }
+
+    // Give a tiny bit of time for any async cleanup to complete
+    await new Promise((resolve) => setTimeout(resolve, 1));
+    trace('afterEach hook completed');
+  });
+}
+
+// Auto-setup hooks when imported
+setupTestHooks();
+
+export { resetGlobalState };

package/js/tests/test-helper.mjs

@@ -0,0 +1,171 @@
+import { beforeEach, afterEach } from 'bun:test';
+import { resetGlobalState } from '../src/$.mjs';
+import { existsSync } from 'fs';
+
+// Platform detection helpers
+export const isWindows = process.platform === 'win32';
+export const isUnix = process.platform !== 'win32';
+
+// Save the original working directory when tests start
+const originalCwd = process.cwd();
+
+// Trace function for debugging
+function trace(message) {
+  if (process.env.DEBUG || process.env.TRACE) {
+    const timestamp = new Date().toISOString();
+    console.error(`[TRACE ${timestamp}] [test-helper] ${message}`);
+  }
+}
+
+trace(`Original working directory: ${originalCwd}`);
+
+// Install a process exit handler to ensure cleanup even on crash
+process.on('beforeExit', () => {
+  try {
+    if (process.cwd() !== originalCwd) {
+      process.chdir(originalCwd);
+    }
+  } catch (_e) {
+    // Ignore
+  }
+});
+
+// Reset global state before and after each test to prevent interference
+// Use async to ensure cleanup completes
+beforeEach(async () => {
+  // CRITICAL: Restore working directory first - MUST succeed for spawn to work
+  const currentDir = process.cwd();
+  if (currentDir !== originalCwd) {
+    trace(`beforeEach: Restoring cwd from ${currentDir} to ${originalCwd}`);
+  }
+  try {
+    // Force restoration regardless of current state
+    process.chdir(originalCwd);
+  } catch (_e) {
+    // Original directory might be gone, try fallbacks
+    try {
+      if (existsSync(originalCwd)) {
+        process.chdir(originalCwd);
+      } else if (existsSync('/workspace/command-stream')) {
+        process.chdir('/workspace/command-stream');
+      } else if (process.env.HOME && existsSync(process.env.HOME)) {
+        process.chdir(process.env.HOME);
+      } else {
+        process.chdir('/');
+      }
+    } catch (_e2) {
+      console.error(
+        '[test-helper] FATAL: Cannot set working directory in beforeEach'
+      );
+      trace('FATAL: Cannot set working directory in beforeEach');
+    }
+  }
+
+  // Call the comprehensive reset
+  resetGlobalState();
+
+  // Extra safety: ensure we're in a valid directory after reset
+  try {
+    process.cwd(); // This will throw if we're in a bad state
+  } catch (_e) {
+    // Force to a known good directory
+    process.chdir(originalCwd);
+  }
+
+  // VERIFY: Ensure we actually restored to the original directory
+  const finalCwd = process.cwd();
+  if (finalCwd !== originalCwd && existsSync(originalCwd)) {
+    console.error(
+      `[test-helper] WARNING: Failed to restore cwd! Expected: ${originalCwd}, Got: ${finalCwd}`
+    );
+    // Try one more time
+    try {
+      process.chdir(originalCwd);
+      const verifiedCwd = process.cwd();
+      if (verifiedCwd === originalCwd) {
+        trace('Successfully restored on second attempt');
+      } else {
+        throw new Error(
+          `[test-helper] CRITICAL: Cannot restore to original directory ${originalCwd}, stuck in ${verifiedCwd}`
+        );
+      }
+    } catch (_e) {
+      throw new Error(
+        `[test-helper] CRITICAL: Cannot restore to original directory ${originalCwd}, stuck in ${finalCwd}`
+      );
+    }
+  }
+
+  // Give a tiny bit of time for any async cleanup to complete
+  await new Promise((resolve) => setTimeout(resolve, 1));
+});
+
+afterEach(async () => {
+  // CRITICAL: Clean up and restore state after each test
+  const currentDir = process.cwd();
+  if (currentDir !== originalCwd) {
+    trace(`afterEach: Restoring cwd from ${currentDir} to ${originalCwd}`);
+  }
+  try {
+    // Force restoration regardless of current state
+    process.chdir(originalCwd);
+  } catch (_e) {
+    // Original directory might be gone, try fallbacks
+    try {
+      if (existsSync(originalCwd)) {
+        process.chdir(originalCwd);
+      } else if (existsSync('/workspace/command-stream')) {
+        process.chdir('/workspace/command-stream');
+      } else if (process.env.HOME && existsSync(process.env.HOME)) {
+        process.chdir(process.env.HOME);
+      } else {
+        process.chdir('/');
+      }
+    } catch (_e2) {
+      console.error(
+        '[test-helper] FATAL: Cannot set working directory in afterEach'
+      );
+      trace('FATAL: Cannot set working directory in afterEach');
+    }
+  }
+
+  // Call the comprehensive reset
+  resetGlobalState();
+
+  // Extra safety: ensure we're in a valid directory after reset
+  try {
+    process.cwd(); // This will throw if we're in a bad state
+  } catch (_e) {
+    // Force to a known good directory
+    process.chdir(originalCwd);
+  }
+
+  // VERIFY: Ensure we actually restored to the original directory
+  const finalCwd = process.cwd();
+  if (finalCwd !== originalCwd && existsSync(originalCwd)) {
+    console.error(
+      `[test-helper] WARNING: Failed to restore cwd! Expected: ${originalCwd}, Got: ${finalCwd}`
+    );
+    // Try one more time
+    try {
+      process.chdir(originalCwd);
+      const verifiedCwd = process.cwd();
+      if (verifiedCwd === originalCwd) {
+        trace('Successfully restored on second attempt');
+      } else {
+        throw new Error(
+          `[test-helper] CRITICAL: Cannot restore to original directory ${originalCwd}, stuck in ${verifiedCwd}`
+        );
+      }
+    } catch (_e) {
+      throw new Error(
+        `[test-helper] CRITICAL: Cannot restore to original directory ${originalCwd}, stuck in ${finalCwd}`
+      );
+    }
+  }
+
+  // Give a tiny bit of time for any async cleanup to complete
+  await new Promise((resolve) => setTimeout(resolve, 1));
+});
+
+export { resetGlobalState };

package/js/tests/test-sigint-child.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+let sigintReceived = false;
+process.on('SIGINT', () => {
+  console.log('CHILD_SIGINT_RECEIVED');
+  sigintReceived = true;
+  process.exit(130);
+});
+
+// Keep running until interrupted
+console.log('CHILD_STARTED');
+setInterval(() => {
+  if (!sigintReceived) {
+    console.log('CHILD_RUNNING');
+  }
+}, 100);