@curl-runner/cli 1.16.0 → 1.16.2

package/src/utils/version-checker.ts

@@ -1,158 +0,0 @@
-import { getVersion } from '../version';
-import { color } from './colors';
-
-interface VersionCheckCache {
-  lastCheck: number;
-  latestVersion: string;
-}
-
-const CACHE_FILE = `${process.env.HOME}/.curl-runner-version-cache.json`;
-const CACHE_DURATION = 24 * 60 * 60 * 1000; // 24 hours
-const NPM_REGISTRY_URL = 'https://registry.npmjs.org/@curl-runner/cli/latest';
-
-export class VersionChecker {
-  async checkForUpdates(skipCache = false): Promise<void> {
-    try {
-      // Don't check in CI environments
-      if (process.env.CI) {
-        return;
-      }
-
-      const currentVersion = getVersion();
-
-      // Don't check for development versions
-      if (currentVersion === '0.0.0') {
-        return;
-      }
-
-      // Check cache first
-      if (!skipCache) {
-        const cached = await this.getCachedVersion();
-        if (cached && Date.now() - cached.lastCheck < CACHE_DURATION) {
-          this.compareVersions(currentVersion, cached.latestVersion);
-          return;
-        }
-      }
-
-      // Fetch latest version from npm registry
-      const latestVersion = await this.fetchLatestVersion();
-      if (latestVersion) {
-        // Update cache
-        await this.setCachedVersion(latestVersion);
-
-        // Compare versions
-        this.compareVersions(currentVersion, latestVersion);
-      }
-    } catch {
-      // Silently fail - we don't want to interrupt the CLI usage
-      // due to version check failures
-    }
-  }
-
-  private async fetchLatestVersion(): Promise<string | null> {
-    try {
-      const response = await fetch(NPM_REGISTRY_URL, {
-        signal: AbortSignal.timeout(3000), // 3 second timeout
-      });
-
-      if (!response.ok) {
-        return null;
-      }
-
-      const data = (await response.json()) as { version: string };
-      return data.version;
-    } catch {
-      return null;
-    }
-  }
-
-  private compareVersions(current: string, latest: string): void {
-    if (this.isNewerVersion(current, latest)) {
-      console.log();
-      console.log(color('╭───────────────────────────────────────────────╮', 'yellow'));
-      console.log(
-        color('│', 'yellow') +
-          '                                               ' +
-          color('│', 'yellow'),
-      );
-      console.log(
-        color('│', 'yellow') +
-          '  ' +
-          color('Update available!', 'bright') +
-          ` ${color(current, 'red')} → ${color(latest, 'green')}` +
-          '        ' +
-          color('│', 'yellow'),
-      );
-      console.log(
-        color('│', 'yellow') +
-          '                                               ' +
-          color('│', 'yellow'),
-      );
-      console.log(
-        color('│', 'yellow') +
-          '  Run ' +
-          color('curl-runner upgrade', 'cyan') +
-          ' to update          ' +
-          color('│', 'yellow'),
-      );
-      console.log(
-        color('│', 'yellow') +
-          '                                               ' +
-          color('│', 'yellow'),
-      );
-      console.log(color('╰───────────────────────────────────────────────╯', 'yellow'));
-      console.log();
-    }
-  }
-
-  private isNewerVersion(current: string, latest: string): boolean {
-    try {
-      // Remove 'v' prefix if present
-      const currentVersion = current.replace(/^v/, '');
-      const latestVersion = latest.replace(/^v/, '');
-
-      const currentParts = currentVersion.split('.').map(Number);
-      const latestParts = latestVersion.split('.').map(Number);
-
-      for (let i = 0; i < Math.max(currentParts.length, latestParts.length); i++) {
-        const currentPart = currentParts[i] || 0;
-        const latestPart = latestParts[i] || 0;
-
-        if (latestPart > currentPart) {
-          return true;
-        }
-        if (latestPart < currentPart) {
-          return false;
-        }
-      }
-
-      return false;
-    } catch {
-      return false;
-    }
-  }
-
-  private async getCachedVersion(): Promise<VersionCheckCache | null> {
-    try {
-      const file = Bun.file(CACHE_FILE);
-      if (await file.exists()) {
-        return JSON.parse(await file.text());
-      }
-    } catch {
-      // Ignore cache read errors
-    }
-    return null;
-  }
-
-  private async setCachedVersion(latestVersion: string): Promise<void> {
-    try {
-      const cache: VersionCheckCache = {
-        lastCheck: Date.now(),
-        latestVersion,
-      };
-      await Bun.write(CACHE_FILE, JSON.stringify(cache));
-    } catch {
-      // Ignore cache write errors
-    }
-  }
-}

package/src/version.ts

@@ -1,43 +0,0 @@
-// Version management for curl-runner CLI
-// This file handles version detection for both development and compiled binaries
-
-declare const BUILD_VERSION: string | undefined;
-
-export function getVersion(): string {
-  // Check compile-time constant first (set by --define flag during build)
-  if (typeof BUILD_VERSION !== 'undefined') {
-    return BUILD_VERSION;
-  }
-
-  // Check environment variable (for local builds with our script)
-  if (process.env.CURL_RUNNER_VERSION) {
-    return process.env.CURL_RUNNER_VERSION;
-  }
-
-  // In development or npm installation, try to read from package.json
-  try {
-    // Try multiple paths to find package.json
-    const possiblePaths = [
-      '../package.json', // Development or npm installation
-      './package.json', // In case we're at root
-      '../../package.json', // In case of different directory structure
-    ];
-
-    for (const path of possiblePaths) {
-      try {
-        const packageJson = require(path);
-        if (packageJson.name === '@curl-runner/cli' && packageJson.version) {
-          return packageJson.version;
-        }
-      } catch {
-        // Try next path
-      }
-    }
-
-    // If no package.json found, return default
-    return '0.0.0';
-  } catch {
-    // If all else fails, return a default version
-    return '0.0.0';
-  }
-}

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

@@ -1,186 +0,0 @@
-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

@@ -1,140 +0,0 @@
-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;
-    }
-  }
-}