@curl-runner/cli 1.9.0 → 1.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@curl-runner/cli",
-  "version": "1.9.0",
+  "version": "1.10.0",
   "description": "A powerful CLI tool for HTTP request management using YAML configuration",
   "type": "module",
   "main": "./dist/cli.js",

package/src/cli.ts

@@ -3,10 +3,17 @@
 import { Glob } from 'bun';
 import { RequestExecutor } from './executor/request-executor';
 import { YamlParser } from './parser/yaml';
-import type { ExecutionSummary, GlobalConfig, RequestConfig } from './types/config';
+import type {
+  ExecutionResult,
+  ExecutionSummary,
+  GlobalConfig,
+  RequestConfig,
+  WatchConfig,
+} from './types/config';
 import { Logger } from './utils/logger';
 import { VersionChecker } from './utils/version-checker';
 import { getVersion } from './version';
+import { FileWatcher } from './watcher/file-watcher';
 
 class CurlRunnerCLI {
   private logger = new Logger();
@@ -137,6 +144,28 @@ class CurlRunnerCLI {
       }
     }
 
+    // Watch mode configuration
+    if (process.env.CURL_RUNNER_WATCH) {
+      envConfig.watch = {
+        ...envConfig.watch,
+        enabled: process.env.CURL_RUNNER_WATCH.toLowerCase() === 'true',
+      };
+    }
+
+    if (process.env.CURL_RUNNER_WATCH_DEBOUNCE) {
+      envConfig.watch = {
+        ...envConfig.watch,
+        debounce: Number.parseInt(process.env.CURL_RUNNER_WATCH_DEBOUNCE, 10),
+      };
+    }
+
+    if (process.env.CURL_RUNNER_WATCH_CLEAR) {
+      envConfig.watch = {
+        ...envConfig.watch,
+        clear: process.env.CURL_RUNNER_WATCH_CLEAR.toLowerCase() !== 'false',
+      };
+    }
+
     return envConfig;
   }
 
@@ -287,58 +316,107 @@ class CurlRunnerCLI {
         process.exit(1);
       }
 
-      const executor = new RequestExecutor(globalConfig);
-      let summary: ExecutionSummary;
+      // Check if watch mode is enabled
+      const watchEnabled = options.watch || globalConfig.watch?.enabled;
 
-      // If multiple files, execute them with file separators for clarity
-      if (fileGroups.length > 1) {
-        const allResults: ExecutionResult[] = [];
-        let totalDuration = 0;
+      if (watchEnabled) {
+        // Build watch config from options and global config
+        const watchConfig: WatchConfig = {
+          enabled: true,
+          debounce:
+            (options.watchDebounce as number | undefined) ?? globalConfig.watch?.debounce ?? 300,
+          clear: (options.watchClear as boolean | undefined) ?? globalConfig.watch?.clear ?? true,
+        };
 
-        for (let i = 0; i < fileGroups.length; i++) {
-          const group = fileGroups[i];
+        const watcher = new FileWatcher({
+          files: yamlFiles,
+          config: watchConfig,
+          logger: this.logger,
+          onRun: async () => {
+            await this.executeRequests(yamlFiles, globalConfig);
+          },
+        });
+
+        await watcher.start();
+      } else {
+        // Normal execution mode
+        const summary = await this.executeRequests(yamlFiles, globalConfig);
+        const exitCode = this.determineExitCode(summary, globalConfig);
+        process.exit(exitCode);
+      }
+    } catch (error) {
+      this.logger.logError(error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  }
 
-          // Show file header for better organization
-          this.logger.logFileHeader(group.file, group.requests.length);
+  private async executeRequests(
+    yamlFiles: string[],
+    globalConfig: GlobalConfig,
+  ): Promise<ExecutionSummary> {
+    // Process YAML files and collect requests
+    const fileGroups: Array<{ file: string; requests: RequestConfig[]; config?: GlobalConfig }> =
+      [];
+    const allRequests: RequestConfig[] = [];
+
+    for (const file of yamlFiles) {
+      const { requests, config } = await this.processYamlFile(file);
+
+      const fileOutputConfig = config?.output || {};
+      const requestsWithSourceConfig = requests.map((request) => ({
+        ...request,
+        sourceOutputConfig: fileOutputConfig,
+        sourceFile: file,
+      }));
+
+      fileGroups.push({ file, requests: requestsWithSourceConfig, config });
+      allRequests.push(...requestsWithSourceConfig);
+    }
 
-          const fileSummary = await executor.execute(group.requests);
-          allResults.push(...fileSummary.results);
-          totalDuration += fileSummary.duration;
+    const executor = new RequestExecutor(globalConfig);
+    let summary: ExecutionSummary;
 
-          // Don't show individual file summaries for cleaner output
+    // If multiple files, execute them with file separators for clarity
+    if (fileGroups.length > 1) {
+      const allResults: ExecutionResult[] = [];
+      let totalDuration = 0;
 
-          // Add spacing between files (except for the last one)
-          if (i < fileGroups.length - 1) {
-            console.log();
-          }
-        }
+      for (let i = 0; i < fileGroups.length; i++) {
+        const group = fileGroups[i];
 
-        // Create combined summary
-        const successful = allResults.filter((r) => r.success).length;
-        const failed = allResults.filter((r) => !r.success).length;
+        // Show file header for better organization
+        this.logger.logFileHeader(group.file, group.requests.length);
 
-        summary = {
-          total: allResults.length,
-          successful,
-          failed,
-          duration: totalDuration,
-          results: allResults,
-        };
+        const fileSummary = await executor.execute(group.requests);
+        allResults.push(...fileSummary.results);
+        totalDuration += fileSummary.duration;
 
-        // Show final summary
-        executor.logger.logSummary(summary, true);
-      } else {
-        // Single file - use normal execution
-        summary = await executor.execute(allRequests);
+        // Add spacing between files (except for the last one)
+        if (i < fileGroups.length - 1) {
+          console.log();
+        }
       }
 
-      // Determine exit code based on CI configuration
-      const exitCode = this.determineExitCode(summary, globalConfig);
-      process.exit(exitCode);
-    } catch (error) {
-      this.logger.logError(error instanceof Error ? error.message : String(error));
-      process.exit(1);
+      // Create combined summary
+      const successful = allResults.filter((r) => r.success).length;
+      const failed = allResults.filter((r) => !r.success).length;
+
+      summary = {
+        total: allResults.length,
+        successful,
+        failed,
+        duration: totalDuration,
+        results: allResults,
+      };
+
+      // Show final summary
+      this.logger.logSummary(summary, true);
+    } else {
+      // Single file - use normal execution
+      summary = await executor.execute(allRequests);
     }
+
+    return summary;
   }
 
   private parseArguments(args: string[]): { files: string[]; options: Record<string, unknown> } {
@@ -366,6 +444,12 @@ class CurlRunnerCLI {
           options.showMetrics = true;
         } else if (key === 'strict-exit') {
           options.strictExit = true;
+        } else if (key === 'watch') {
+          options.watch = true;
+        } else if (key === 'watch-clear') {
+          options.watchClear = true;
+        } else if (key === 'no-watch-clear') {
+          options.watchClear = false;
         } else if (nextArg && !nextArg.startsWith('--')) {
           if (key === 'continue-on-error') {
             options.continueOnError = nextArg === 'true';
@@ -397,6 +481,8 @@ class CurlRunnerCLI {
             if (['minimal', 'standard', 'detailed'].includes(nextArg)) {
               options.prettyLevel = nextArg;
             }
+          } else if (key === 'watch-debounce') {
+            options.watchDebounce = Number.parseInt(nextArg, 10);
           } else {
             options[key] = nextArg;
           }
@@ -423,6 +509,9 @@ class CurlRunnerCLI {
             case 'q':
               options.quiet = true;
               break;
+            case 'w':
+              options.watch = true;
+              break;
             case 'o': {
               // Handle -o flag for output file
               const outputArg = args[i + 1];
@@ -551,6 +640,7 @@ class CurlRunnerCLI {
       output: { ...base.output, ...override.output },
       defaults: { ...base.defaults, ...override.defaults },
       ci: { ...base.ci, ...override.ci },
+      watch: { ...base.watch, ...override.watch },
     };
   }
 
@@ -633,6 +723,11 @@ ${this.logger.color('OPTIONS:', 'yellow')}
   --show-metrics                Include performance metrics in output
   --version                     Show version
 
+${this.logger.color('WATCH MODE:', 'yellow')}
+  -w, --watch                   Watch files and re-run on changes
+  --watch-debounce <ms>         Debounce delay for watch mode (default: 300)
+  --no-watch-clear              Don't clear screen between watch runs
+
 ${this.logger.color('CI/CD OPTIONS:', 'yellow')}
   --strict-exit                 Exit with code 1 if any validation fails (for CI/CD)
   --fail-on <count>             Exit with code 1 if failures exceed this count
@@ -681,6 +776,12 @@ ${this.logger.color('EXAMPLES:', 'yellow')}
   # CI/CD: Allow up to 10% failures
   curl-runner tests/ --fail-on-percentage 10
 
+  # Watch mode - re-run on file changes
+  curl-runner api.yaml --watch
+
+  # Watch with custom debounce
+  curl-runner tests/ -w --watch-debounce 500
+
 ${this.logger.color('YAML STRUCTURE:', 'yellow')}
   Single request:
     request:

package/src/executor/request-executor.ts

@@ -102,7 +102,7 @@ export class RequestExecutor {
         requestLogger.logRetry(attempt, maxAttempts - 1);
         if (config.retry?.delay) {
           const backoff = config.retry.backoff ?? 1;
-          const delay = config.retry.delay * Math.pow(backoff, attempt - 1);
+          const delay = config.retry.delay * backoff ** (attempt - 1);
           await Bun.sleep(delay);
         }
       }

package/src/types/config.ts

@@ -210,6 +210,11 @@ export interface GlobalConfig {
    * Applied to all requests unless overridden at the request level.
    */
   ssl?: SSLConfig;
+  /**
+   * Watch mode configuration.
+   * Automatically re-runs requests when YAML files change.
+   */
+  watch?: WatchConfig;
   variables?: Record<string, string>;
   output?: {
     verbose?: boolean;
@@ -262,3 +267,16 @@ export interface ExecutionSummary {
  * Values are stored as strings and can be referenced using ${store.variableName} syntax.
  */
 export type ResponseStoreContext = Record<string, string>;
+
+/**
+ * Configuration for watch mode.
+ * Watch mode automatically re-runs requests when YAML files change.
+ */
+export interface WatchConfig {
+  /** Enable watch mode. Default: false */
+  enabled?: boolean;
+  /** Debounce delay in milliseconds. Default: 300 */
+  debounce?: number;
+  /** Clear screen between runs. Default: true */
+  clear?: boolean;
+}

package/src/utils/logger.ts

@@ -645,4 +645,28 @@ export class Logger {
         this.color(` (${requestCount} request${requestCount === 1 ? '' : 's'})`, 'dim'),
     );
   }
+
+  logWatch(files: string[]): void {
+    console.log();
+    console.log(
+      `${this.color('Watching for changes...', 'cyan')} ${this.color('(press Ctrl+C to stop)', 'dim')}`,
+    );
+    const fileList = files.length <= 3 ? files.join(', ') : `${files.length} files`;
+    console.log(this.color(`   Files: ${fileList}`, 'dim'));
+    console.log();
+  }
+
+  logWatchReady(): void {
+    console.log();
+    console.log(this.color('Watching for changes...', 'cyan'));
+  }
+
+  logFileChanged(filename: string): void {
+    const timestamp = new Date().toLocaleTimeString('en-US', { hour12: false });
+    console.log(this.color('-'.repeat(50), 'dim'));
+    console.log(
+      `${this.color(`[${timestamp}]`, 'dim')} File changed: ${this.color(filename, 'yellow')}`,
+    );
+    console.log();
+  }
 }

package/src/watcher/file-watcher.test.ts

@@ -0,0 +1,186 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from 'bun:test';
+import { FileWatcher, type WatcherOptions } from './file-watcher';
+
+// Mock logger
+const createMockLogger = () => ({
+  logWatch: mock(() => {}),
+  logWatchReady: mock(() => {}),
+  logFileChanged: mock(() => {}),
+  logError: mock(() => {}),
+  logWarning: mock(() => {}),
+});
+
+// Helper to access private method for testing
+const triggerFileChange = (watcher: FileWatcher, filename: string) => {
+  // biome-ignore lint/complexity/useLiteralKeys: accessing private method for testing
+  watcher['handleFileChange'](filename);
+};
+
+describe('FileWatcher', () => {
+  let watcher: FileWatcher;
+  let mockLogger: ReturnType<typeof createMockLogger>;
+  let onRunMock: ReturnType<typeof mock>;
+
+  beforeEach(() => {
+    mockLogger = createMockLogger();
+    onRunMock = mock(() => Promise.resolve());
+  });
+
+  afterEach(() => {
+    if (watcher) {
+      watcher.stop();
+    }
+  });
+
+  test('should debounce rapid file changes', async () => {
+    const options: WatcherOptions = {
+      files: [],
+      config: { debounce: 50 },
+      onRun: onRunMock,
+      logger: mockLogger as unknown as WatcherOptions['logger'],
+    };
+
+    watcher = new FileWatcher(options);
+
+    // Simulate rapid file changes
+    triggerFileChange(watcher, 'test.yaml');
+    triggerFileChange(watcher, 'test.yaml');
+    triggerFileChange(watcher, 'test.yaml');
+
+    // Wait for debounce to settle
+    await Bun.sleep(100);
+
+    // Should only have been called once due to debouncing
+    // Initial run doesn't happen because we didn't call start()
+    expect(onRunMock).toHaveBeenCalledTimes(1);
+  });
+
+  test('should queue runs during execution', async () => {
+    let runCount = 0;
+    const slowOnRun = mock(async () => {
+      runCount++;
+      await Bun.sleep(100);
+    });
+
+    const options: WatcherOptions = {
+      files: [],
+      config: { debounce: 10, clear: false },
+      onRun: slowOnRun,
+      logger: mockLogger as unknown as WatcherOptions['logger'],
+    };
+
+    watcher = new FileWatcher(options);
+
+    // Start first run
+    triggerFileChange(watcher, 'test.yaml');
+    await Bun.sleep(20); // Let debounce fire
+
+    // Change during run (should be queued)
+    triggerFileChange(watcher, 'test.yaml');
+
+    // Wait for both runs to complete
+    await Bun.sleep(300);
+
+    expect(runCount).toBe(2);
+  });
+
+  test('should clear debounce timer on stop', () => {
+    const options: WatcherOptions = {
+      files: [],
+      config: { debounce: 1000 },
+      onRun: onRunMock,
+      logger: mockLogger as unknown as WatcherOptions['logger'],
+    };
+
+    watcher = new FileWatcher(options);
+
+    // Trigger a change to start debounce timer
+    triggerFileChange(watcher, 'test.yaml');
+
+    // Stop should clear the timer
+    watcher.stop();
+
+    // biome-ignore lint/complexity/useLiteralKeys: accessing private field for testing
+    expect(watcher['debounceTimer']).toBeNull();
+    // biome-ignore lint/complexity/useLiteralKeys: accessing private field for testing
+    expect(watcher['watchers']).toHaveLength(0);
+  });
+
+  test('should use default debounce of 300ms', async () => {
+    const options: WatcherOptions = {
+      files: [],
+      config: {}, // No debounce specified
+      onRun: onRunMock,
+      logger: mockLogger as unknown as WatcherOptions['logger'],
+    };
+
+    watcher = new FileWatcher(options);
+
+    const startTime = performance.now();
+    triggerFileChange(watcher, 'test.yaml');
+
+    // Wait less than default debounce
+    await Bun.sleep(100);
+    expect(onRunMock).not.toHaveBeenCalled();
+
+    // Wait for full debounce
+    await Bun.sleep(250);
+    expect(onRunMock).toHaveBeenCalledTimes(1);
+
+    const elapsed = performance.now() - startTime;
+    expect(elapsed).toBeGreaterThanOrEqual(300);
+  });
+
+  test('should handle onRun errors gracefully', async () => {
+    const errorOnRun = mock(async () => {
+      throw new Error('Test error');
+    });
+
+    const options: WatcherOptions = {
+      files: [],
+      config: { debounce: 10 },
+      onRun: errorOnRun,
+      logger: mockLogger as unknown as WatcherOptions['logger'],
+    };
+
+    watcher = new FileWatcher(options);
+
+    // Should not throw
+    triggerFileChange(watcher, 'test.yaml');
+    await Bun.sleep(50);
+
+    expect(mockLogger.logError).toHaveBeenCalledWith('Test error');
+  });
+
+  test('should log file changed with filename', async () => {
+    const options: WatcherOptions = {
+      files: [],
+      config: { debounce: 10, clear: false },
+      onRun: onRunMock,
+      logger: mockLogger as unknown as WatcherOptions['logger'],
+    };
+
+    watcher = new FileWatcher(options);
+
+    triggerFileChange(watcher, 'my-api.yaml');
+    await Bun.sleep(50);
+
+    expect(mockLogger.logFileChanged).toHaveBeenCalledWith('my-api.yaml');
+  });
+
+  test('should call logWatchReady after run completes', async () => {
+    const options: WatcherOptions = {
+      files: [],
+      config: { debounce: 10, clear: false },
+      onRun: onRunMock,
+      logger: mockLogger as unknown as WatcherOptions['logger'],
+    };
+
+    watcher = new FileWatcher(options);
+
+    triggerFileChange(watcher, 'test.yaml');
+    await Bun.sleep(50);
+
+    expect(mockLogger.logWatchReady).toHaveBeenCalled();
+  });
+});

package/src/watcher/file-watcher.ts

@@ -0,0 +1,140 @@
+import { type FSWatcher, watch } from 'node:fs';
+import type { WatchConfig } from '../types/config';
+import type { Logger } from '../utils/logger';
+
+export interface WatcherOptions {
+  files: string[];
+  config: WatchConfig;
+  onRun: () => Promise<void>;
+  logger: Logger;
+}
+
+export class FileWatcher {
+  private watchers: FSWatcher[] = [];
+  private debounceTimer: Timer | null = null;
+  private isRunning = false;
+  private pendingRun = false;
+  private options: WatcherOptions;
+
+  constructor(options: WatcherOptions) {
+    this.options = options;
+  }
+
+  async start(): Promise<void> {
+    const { files, logger } = this.options;
+
+    // Initial run
+    await this.runRequests();
+
+    // Setup watchers for each file
+    for (const file of files) {
+      try {
+        const watcher = watch(file, (event) => {
+          if (event === 'change') {
+            this.handleFileChange(file);
+          }
+        });
+
+        watcher.on('error', (error) => {
+          logger.logWarning(`Watch error on ${file}: ${error.message}`);
+        });
+
+        this.watchers.push(watcher);
+      } catch (error) {
+        logger.logWarning(
+          `Failed to watch ${file}: ${error instanceof Error ? error.message : String(error)}`,
+        );
+      }
+    }
+
+    // Log watching status
+    logger.logWatch(files);
+
+    // Handle graceful shutdown
+    this.setupSignalHandlers();
+
+    // Keep process alive
+    await this.keepAlive();
+  }
+
+  private handleFileChange(filename: string): void {
+    const { config, logger } = this.options;
+    const debounce = config.debounce ?? 300;
+
+    // Clear existing debounce timer
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+    }
+
+    // Debounce the run
+    this.debounceTimer = setTimeout(async () => {
+      // If already running, queue for after completion
+      if (this.isRunning) {
+        this.pendingRun = true;
+        return;
+      }
+
+      if (config.clear !== false) {
+        console.clear();
+      }
+
+      logger.logFileChanged(filename);
+      await this.runRequests();
+    }, debounce);
+  }
+
+  private async runRequests(): Promise<void> {
+    const { onRun, logger } = this.options;
+
+    this.isRunning = true;
+
+    try {
+      await onRun();
+    } catch (error) {
+      logger.logError(error instanceof Error ? error.message : String(error));
+    }
+
+    this.isRunning = false;
+
+    // Check for pending runs
+    if (this.pendingRun) {
+      this.pendingRun = false;
+      const { config } = this.options;
+      if (config.clear !== false) {
+        console.clear();
+      }
+      logger.logFileChanged('(queued change)');
+      await this.runRequests();
+    } else {
+      logger.logWatchReady();
+    }
+  }
+
+  private setupSignalHandlers(): void {
+    const cleanup = () => {
+      this.stop();
+      process.exit(0);
+    };
+
+    process.on('SIGINT', cleanup);
+    process.on('SIGTERM', cleanup);
+  }
+
+  private async keepAlive(): Promise<never> {
+    while (true) {
+      await Bun.sleep(1000);
+    }
+  }
+
+  stop(): void {
+    for (const watcher of this.watchers) {
+      watcher.close();
+    }
+    this.watchers = [];
+
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+      this.debounceTimer = null;
+    }
+  }
+}