@curl-runner/cli 1.14.0 → 1.16.0

package/src/commands/upgrade.ts

@@ -0,0 +1,262 @@
+// Upgrade command for curl-runner
+// Automatically detects installation source and upgrades to latest version
+
+import { color } from '../utils/colors';
+import {
+  type DetectionResult,
+  detectInstallationSource,
+  getUpgradeCommand,
+  getUpgradeCommandWindows,
+  type InstallationSource,
+  isWindows,
+} from '../utils/installation-detector';
+import { getVersion } from '../version';
+
+const NPM_REGISTRY_URL = 'https://registry.npmjs.org/@curl-runner/cli/latest';
+const GITHUB_API_URL = 'https://api.github.com/repos/alexvcasillas/curl-runner/releases/latest';
+
+interface UpgradeOptions {
+  dryRun?: boolean;
+  force?: boolean;
+}
+
+export class UpgradeCommand {
+  async run(args: string[]): Promise<void> {
+    const options = this.parseArgs(args);
+
+    console.log();
+    console.log(color('curl-runner upgrade', 'bright'));
+    console.log();
+
+    // Detect installation source
+    const detection = detectInstallationSource();
+    console.log(`${color('Installation:', 'cyan')} ${this.formatSource(detection.source)}`);
+    console.log(`${color('Current version:', 'cyan')} ${getVersion()}`);
+
+    // Fetch latest version
+    const latestVersion = await this.fetchLatestVersion(detection.source);
+    if (!latestVersion) {
+      console.log(color('Failed to fetch latest version', 'red'));
+      process.exit(1);
+    }
+    console.log(`${color('Latest version:', 'cyan')} ${latestVersion}`);
+    console.log();
+
+    // Compare versions
+    const currentVersion = getVersion();
+    if (!options.force && !this.isNewerVersion(currentVersion, latestVersion)) {
+      console.log(color('Already up to date!', 'green'));
+      return;
+    }
+
+    // Get upgrade command
+    const upgradeCmd = isWindows()
+      ? getUpgradeCommandWindows(detection.source)
+      : getUpgradeCommand(detection.source);
+
+    if (options.dryRun) {
+      console.log(color('Dry run - would execute:', 'yellow'));
+      console.log(`  ${color(upgradeCmd, 'cyan')}`);
+      return;
+    }
+
+    // Execute upgrade
+    console.log(`${color('Upgrading...', 'yellow')}`);
+    console.log();
+
+    await this.executeUpgrade(detection, upgradeCmd);
+  }
+
+  private parseArgs(args: string[]): UpgradeOptions {
+    const options: UpgradeOptions = {};
+
+    for (const arg of args) {
+      if (arg === '--dry-run' || arg === '-n') {
+        options.dryRun = true;
+      } else if (arg === '--force' || arg === '-f') {
+        options.force = true;
+      }
+    }
+
+    return options;
+  }
+
+  private formatSource(source: InstallationSource): string {
+    switch (source) {
+      case 'bun':
+        return 'bun (global)';
+      case 'npm':
+        return 'npm (global)';
+      case 'curl':
+        return 'curl installer';
+      case 'standalone':
+        return 'standalone binary';
+    }
+  }
+
+  private async fetchLatestVersion(source: InstallationSource): Promise<string | null> {
+    try {
+      // For npm/bun, use npm registry
+      if (source === 'bun' || source === 'npm') {
+        const response = await fetch(NPM_REGISTRY_URL, {
+          signal: AbortSignal.timeout(5000),
+        });
+        if (!response.ok) {
+          return null;
+        }
+        const data = (await response.json()) as { version: string };
+        return data.version;
+      }
+
+      // For curl/standalone, use GitHub releases
+      const response = await fetch(GITHUB_API_URL, {
+        signal: AbortSignal.timeout(5000),
+        headers: {
+          Accept: 'application/vnd.github.v3+json',
+        },
+      });
+      if (!response.ok) {
+        return null;
+      }
+      const data = (await response.json()) as { tag_name: string };
+      return data.tag_name.replace(/^v/, '');
+    } catch {
+      return null;
+    }
+  }
+
+  private isNewerVersion(current: string, latest: string): boolean {
+    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;
+  }
+
+  private async executeUpgrade(detection: DetectionResult, upgradeCmd: string): Promise<void> {
+    const { source } = detection;
+
+    try {
+      if (source === 'bun') {
+        await this.runBunUpgrade();
+      } else if (source === 'npm') {
+        await this.runNpmUpgrade();
+      } else {
+        // curl or standalone - run shell command
+        await this.runShellUpgrade(upgradeCmd);
+      }
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+
+      // Check for permission errors
+      if (errorMsg.includes('EACCES') || errorMsg.includes('permission')) {
+        console.log();
+        console.log(color('Permission denied. Try running with sudo:', 'yellow'));
+        console.log(`  ${color(`sudo ${upgradeCmd}`, 'cyan')}`);
+        process.exit(1);
+      }
+
+      console.log(color(`Upgrade failed: ${errorMsg}`, 'red'));
+      console.log();
+      console.log(color('Manual upgrade:', 'yellow'));
+      console.log(`  ${color(upgradeCmd, 'cyan')}`);
+      process.exit(1);
+    }
+  }
+
+  private async runBunUpgrade(): Promise<void> {
+    const proc = Bun.spawn(['bun', 'install', '-g', '@curl-runner/cli@latest'], {
+      stdout: 'inherit',
+      stderr: 'inherit',
+    });
+
+    const exitCode = await proc.exited;
+    if (exitCode !== 0) {
+      throw new Error(`bun install failed with exit code ${exitCode}`);
+    }
+
+    this.showSuccess();
+  }
+
+  private async runNpmUpgrade(): Promise<void> {
+    const proc = Bun.spawn(['npm', 'install', '-g', '@curl-runner/cli@latest'], {
+      stdout: 'inherit',
+      stderr: 'inherit',
+    });
+
+    const exitCode = await proc.exited;
+    if (exitCode !== 0) {
+      throw new Error(`npm install failed with exit code ${exitCode}`);
+    }
+
+    this.showSuccess();
+  }
+
+  private async runShellUpgrade(cmd: string): Promise<void> {
+    let proc: ReturnType<typeof Bun.spawn>;
+
+    if (isWindows()) {
+      // PowerShell for Windows
+      proc = Bun.spawn(['powershell', '-Command', cmd], {
+        stdout: 'inherit',
+        stderr: 'inherit',
+      });
+    } else {
+      // Bash for Unix
+      proc = Bun.spawn(['bash', '-c', cmd], {
+        stdout: 'inherit',
+        stderr: 'inherit',
+      });
+    }
+
+    const exitCode = await proc.exited;
+    if (exitCode !== 0) {
+      throw new Error(`Upgrade script failed with exit code ${exitCode}`);
+    }
+
+    this.showSuccess();
+  }
+
+  private showSuccess(): void {
+    console.log();
+    console.log(color('Upgrade complete!', 'green'));
+    console.log();
+    console.log('Run `curl-runner --version` to verify.');
+  }
+}
+
+export function showUpgradeHelp(): void {
+  console.log(`
+${color('curl-runner upgrade', 'bright')}
+
+Automatically upgrade curl-runner to the latest version.
+Detects installation source (bun, npm, curl) and uses appropriate method.
+
+${color('USAGE:', 'yellow')}
+  curl-runner upgrade [options]
+
+${color('OPTIONS:', 'yellow')}
+  -n, --dry-run    Show what would be executed without running
+  -f, --force      Force upgrade even if already on latest version
+  -h, --help       Show this help message
+
+${color('EXAMPLES:', 'yellow')}
+  curl-runner upgrade           # Upgrade to latest
+  curl-runner upgrade --dry-run # Preview upgrade command
+  curl-runner upgrade --force   # Force reinstall latest
+`);
+}

package/src/diff/baseline-manager.test.ts

@@ -0,0 +1,181 @@
+import { describe, expect, test } from 'bun:test';
+import type { ExecutionResult } from '../types/config';
+import { BaselineManager } from './baseline-manager';
+
+describe('BaselineManager', () => {
+  describe('getBaselinePath', () => {
+    test('should generate correct baseline path', () => {
+      const manager = new BaselineManager({});
+      expect(manager.getBaselinePath('tests/api.yaml', 'staging')).toBe(
+        'tests/__baselines__/api.staging.baseline.json',
+      );
+    });
+
+    test('should use custom directory', () => {
+      const manager = new BaselineManager({ dir: '.baselines' });
+      expect(manager.getBaselinePath('api.yaml', 'prod')).toBe('.baselines/api.prod.baseline.json');
+    });
+
+    test('should handle nested paths', () => {
+      const manager = new BaselineManager({});
+      expect(manager.getBaselinePath('tests/integration/users.yaml', 'staging')).toBe(
+        'tests/integration/__baselines__/users.staging.baseline.json',
+      );
+    });
+
+    test('should handle labels with special characters', () => {
+      const manager = new BaselineManager({});
+      expect(manager.getBaselinePath('api.yaml', 'v1.0.0')).toBe(
+        '__baselines__/api.v1.0.0.baseline.json',
+      );
+    });
+  });
+
+  describe('getBaselineDir', () => {
+    test('should return correct directory', () => {
+      const manager = new BaselineManager({});
+      expect(manager.getBaselineDir('tests/api.yaml')).toBe('tests/__baselines__');
+    });
+
+    test('should use custom directory', () => {
+      const manager = new BaselineManager({ dir: 'snapshots' });
+      expect(manager.getBaselineDir('api.yaml')).toBe('snapshots');
+    });
+  });
+
+  describe('createBaseline', () => {
+    const mockResult: ExecutionResult = {
+      request: { url: 'https://api.example.com', name: 'Get Users' },
+      success: true,
+      status: 200,
+      headers: {
+        'Content-Type': 'application/json',
+        'X-Request-Id': 'abc123',
+      },
+      body: {
+        id: 1,
+        name: 'Test',
+        timestamp: '2024-01-01',
+      },
+      metrics: {
+        duration: 150,
+      },
+    };
+
+    test('should create baseline with all fields', () => {
+      const manager = new BaselineManager({});
+      const baseline = manager.createBaseline(mockResult, {});
+
+      expect(baseline.status).toBe(200);
+      expect(baseline.body).toEqual(mockResult.body);
+      expect(baseline.headers).toBeDefined();
+      expect(baseline.hash).toBeDefined();
+      expect(baseline.capturedAt).toBeDefined();
+      expect(baseline.timing).toBeUndefined();
+    });
+
+    test('should include timing when configured', () => {
+      const manager = new BaselineManager({});
+      const baseline = manager.createBaseline(mockResult, { includeTimings: true });
+
+      expect(baseline.timing).toBe(150);
+    });
+
+    test('should normalize headers (lowercase, sorted)', () => {
+      const manager = new BaselineManager({});
+      const baseline = manager.createBaseline(mockResult, {});
+
+      expect(baseline.headers).toEqual({
+        'content-type': 'application/json',
+        'x-request-id': 'abc123',
+      });
+    });
+  });
+
+  describe('hash', () => {
+    test('should generate consistent hashes', () => {
+      const manager = new BaselineManager({});
+      const content = { id: 1, name: 'test' };
+
+      const hash1 = manager.hash(content);
+      const hash2 = manager.hash(content);
+
+      expect(hash1).toBe(hash2);
+    });
+
+    test('should generate different hashes for different content', () => {
+      const manager = new BaselineManager({});
+
+      const hash1 = manager.hash({ id: 1 });
+      const hash2 = manager.hash({ id: 2 });
+
+      expect(hash1).not.toBe(hash2);
+    });
+
+    test('should produce 8 character hash', () => {
+      const manager = new BaselineManager({});
+      const hash = manager.hash({ data: 'test' });
+
+      expect(hash).toHaveLength(8);
+    });
+  });
+
+  describe('mergeConfig', () => {
+    test('should return null if not enabled', () => {
+      const config = BaselineManager.mergeConfig({}, undefined);
+      expect(config).toBeNull();
+    });
+
+    test('should return null if explicitly disabled', () => {
+      const config = BaselineManager.mergeConfig({}, { enabled: false });
+      expect(config).toBeNull();
+    });
+
+    test('should handle boolean true', () => {
+      const config = BaselineManager.mergeConfig({}, true);
+      expect(config).toEqual({
+        enabled: true,
+        exclude: [],
+        match: {},
+        includeTimings: false,
+      });
+    });
+
+    test('should merge global and request excludes', () => {
+      const config = BaselineManager.mergeConfig(
+        { exclude: ['*.timestamp'] },
+        { enabled: true, exclude: ['body.id'] },
+      );
+      expect(config?.exclude).toEqual(['*.timestamp', 'body.id']);
+    });
+
+    test('should merge match rules', () => {
+      const config = BaselineManager.mergeConfig(
+        { match: { 'body.id': '*' } },
+        { enabled: true, match: { 'body.token': 'regex:^[a-z]+$' } },
+      );
+      expect(config?.match).toEqual({
+        'body.id': '*',
+        'body.token': 'regex:^[a-z]+$',
+      });
+    });
+
+    test('should use global enabled', () => {
+      const config = BaselineManager.mergeConfig({ enabled: true }, undefined);
+      expect(config?.enabled).toBe(true);
+    });
+
+    test('should inherit includeTimings from global', () => {
+      const config = BaselineManager.mergeConfig({ enabled: true, includeTimings: true }, true);
+      expect(config?.includeTimings).toBe(true);
+    });
+
+    test('should allow request to override includeTimings', () => {
+      const config = BaselineManager.mergeConfig(
+        { enabled: true, includeTimings: false },
+        { enabled: true, includeTimings: true },
+      );
+      expect(config?.includeTimings).toBe(true);
+    });
+  });
+});

package/src/diff/baseline-manager.ts

@@ -0,0 +1,266 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import type {
+  Baseline,
+  BaselineFile,
+  DiffConfig,
+  ExecutionResult,
+  GlobalDiffConfig,
+} from '../types/config';
+
+const BASELINE_VERSION = 1;
+const DEFAULT_BASELINE_DIR = '__baselines__';
+
+/**
+ * Manages baseline files: reading, writing, and listing.
+ */
+export class BaselineManager {
+  private baselineDir: string;
+  private writeLocks: Map<string, Promise<void>> = new Map();
+
+  constructor(globalConfig: GlobalDiffConfig = {}) {
+    this.baselineDir = globalConfig.dir || DEFAULT_BASELINE_DIR;
+  }
+
+  /**
+   * Gets the baseline file path for a label.
+   */
+  getBaselinePath(yamlPath: string, label: string): string {
+    const dir = path.dirname(yamlPath);
+    const basename = path.basename(yamlPath, path.extname(yamlPath));
+    return path.join(dir, this.baselineDir, `${basename}.${label}.baseline.json`);
+  }
+
+  /**
+   * Gets the baseline directory for a YAML file.
+   */
+  getBaselineDir(yamlPath: string): string {
+    return path.join(path.dirname(yamlPath), this.baselineDir);
+  }
+
+  /**
+   * Loads baseline file for a specific label.
+   */
+  async load(yamlPath: string, label: string): Promise<BaselineFile | null> {
+    const baselinePath = this.getBaselinePath(yamlPath, label);
+    try {
+      const file = Bun.file(baselinePath);
+      if (!(await file.exists())) {
+        return null;
+      }
+      const content = await file.text();
+      return JSON.parse(content) as BaselineFile;
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Saves baseline file with write queue for parallel safety.
+   */
+  async save(yamlPath: string, label: string, data: BaselineFile): Promise<void> {
+    const baselinePath = this.getBaselinePath(yamlPath, label);
+
+    const existingLock = this.writeLocks.get(baselinePath);
+    const writePromise = (async () => {
+      if (existingLock) {
+        await existingLock;
+      }
+
+      const dir = path.dirname(baselinePath);
+      await fs.mkdir(dir, { recursive: true });
+
+      const content = JSON.stringify(data, null, 2);
+      await Bun.write(baselinePath, content);
+    })();
+
+    this.writeLocks.set(baselinePath, writePromise);
+    await writePromise;
+    this.writeLocks.delete(baselinePath);
+  }
+
+  /**
+   * Gets a single baseline by request name.
+   */
+  async get(yamlPath: string, label: string, requestName: string): Promise<Baseline | null> {
+    const file = await this.load(yamlPath, label);
+    return file?.baselines[requestName] || null;
+  }
+
+  /**
+   * Lists all available baseline labels for a YAML file.
+   */
+  async listLabels(yamlPath: string): Promise<string[]> {
+    const dir = this.getBaselineDir(yamlPath);
+    const basename = path.basename(yamlPath, path.extname(yamlPath));
+
+    try {
+      const files = await fs.readdir(dir);
+      const labels: string[] = [];
+
+      for (const file of files) {
+        const match = file.match(new RegExp(`^${basename}\\.(.+)\\.baseline\\.json$`));
+        if (match) {
+          labels.push(match[1]);
+        }
+      }
+
+      return labels.sort();
+    } catch {
+      return [];
+    }
+  }
+
+  /**
+   * Creates a baseline from execution result.
+   */
+  createBaseline(result: ExecutionResult, config: DiffConfig): Baseline {
+    const baseline: Baseline = {
+      hash: '',
+      capturedAt: new Date().toISOString(),
+    };
+
+    if (result.status !== undefined) {
+      baseline.status = result.status;
+    }
+
+    if (result.headers) {
+      baseline.headers = this.normalizeHeaders(result.headers);
+    }
+
+    if (result.body !== undefined) {
+      baseline.body = result.body;
+    }
+
+    if (config.includeTimings && result.metrics?.duration !== undefined) {
+      baseline.timing = result.metrics.duration;
+    }
+
+    baseline.hash = this.hash(baseline);
+
+    return baseline;
+  }
+
+  /**
+   * Normalizes headers for consistent comparison.
+   */
+  private normalizeHeaders(headers: Record<string, string>): Record<string, string> {
+    const normalized: Record<string, string> = {};
+    const sortedKeys = Object.keys(headers).sort();
+    for (const key of sortedKeys) {
+      normalized[key.toLowerCase()] = headers[key];
+    }
+    return normalized;
+  }
+
+  /**
+   * Generates a hash for baseline content.
+   */
+  hash(content: unknown): string {
+    const str = JSON.stringify(content);
+    const hasher = new Bun.CryptoHasher('md5');
+    hasher.update(str);
+    return hasher.digest('hex').slice(0, 8);
+  }
+
+  /**
+   * Saves execution results as a baseline.
+   */
+  async saveBaseline(
+    yamlPath: string,
+    label: string,
+    results: ExecutionResult[],
+    config: DiffConfig,
+  ): Promise<void> {
+    const baselines: Record<string, Baseline> = {};
+
+    for (const result of results) {
+      if (result.skipped || !result.success) {
+        continue;
+      }
+      const name = result.request.name || result.request.url;
+      baselines[name] = this.createBaseline(result, config);
+    }
+
+    const file: BaselineFile = {
+      version: BASELINE_VERSION,
+      label,
+      capturedAt: new Date().toISOString(),
+      baselines,
+    };
+
+    await this.save(yamlPath, label, file);
+  }
+
+  /**
+   * Deletes baselines older than specified days.
+   */
+  async cleanOldBaselines(yamlPath: string, olderThanDays: number): Promise<number> {
+    const dir = this.getBaselineDir(yamlPath);
+    const cutoff = Date.now() - olderThanDays * 24 * 60 * 60 * 1000;
+    let deleted = 0;
+
+    try {
+      const files = await fs.readdir(dir);
+
+      for (const file of files) {
+        if (!file.endsWith('.baseline.json')) {
+          continue;
+        }
+
+        const filePath = path.join(dir, file);
+        const stat = await fs.stat(filePath);
+
+        if (stat.mtimeMs < cutoff) {
+          await fs.unlink(filePath);
+          deleted++;
+        }
+      }
+    } catch {
+      // Directory doesn't exist or other error
+    }
+
+    return deleted;
+  }
+
+  /**
+   * Merges request-level config with global config.
+   */
+  static mergeConfig(
+    globalConfig: GlobalDiffConfig | undefined,
+    requestConfig: DiffConfig | boolean | undefined,
+  ): DiffConfig | null {
+    if (!requestConfig && !globalConfig?.enabled) {
+      return null;
+    }
+
+    if (requestConfig === true) {
+      return {
+        enabled: true,
+        exclude: globalConfig?.exclude || [],
+        match: globalConfig?.match || {},
+        includeTimings: globalConfig?.includeTimings || false,
+      };
+    }
+
+    if (typeof requestConfig === 'object' && requestConfig.enabled !== false) {
+      return {
+        enabled: true,
+        exclude: [...(globalConfig?.exclude || []), ...(requestConfig.exclude || [])],
+        match: { ...(globalConfig?.match || {}), ...(requestConfig.match || {}) },
+        includeTimings: requestConfig.includeTimings ?? globalConfig?.includeTimings ?? false,
+      };
+    }
+
+    if (globalConfig?.enabled && requestConfig === undefined) {
+      return {
+        enabled: true,
+        exclude: globalConfig.exclude || [],
+        match: globalConfig.match || {},
+        includeTimings: globalConfig.includeTimings || false,
+      };
+    }
+
+    return null;
+  }
+}