@curl-runner/cli 1.15.0 → 1.16.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@curl-runner/cli",
-  "version": "1.15.0",
+  "version": "1.16.0",
   "description": "A powerful CLI tool for HTTP request management using YAML configuration",
   "type": "module",
   "main": "./dist/cli.js",
@@ -14,6 +14,7 @@
     "format": "biome format --write .",
     "lint": "biome lint .",
     "check": "biome check --write .",
+    "typecheck": "tsc --noEmit",
     "test": "bun test"
   },
   "keywords": [

package/src/ci-exit.test.ts

@@ -52,6 +52,7 @@ function createSummary(total: number, failed: number): ExecutionSummary {
     total,
     successful: total - failed,
     failed,
+    skipped: 0,
     duration: 1000,
     results: [],
   };

package/src/cli.ts

@@ -1,6 +1,7 @@
 #!/usr/bin/env bun
 
 import { Glob } from 'bun';
+import { showUpgradeHelp, UpgradeCommand } from './commands/upgrade';
 import { BaselineManager, DiffFormatter, DiffOrchestrator } from './diff';
 import { ProfileExecutor } from './executor/profile-executor';
 import { RequestExecutor } from './executor/request-executor';
@@ -38,9 +39,9 @@ class CurlRunnerCLI {
         if (await file.exists()) {
           const yamlContent = await YamlParser.parseFile(filename);
           // Extract global config from the YAML file
-          const config = yamlContent.global || yamlContent;
+          const config = yamlContent.global || {};
           this.logger.logInfo(`Loaded configuration from ${filename}`);
-          return config;
+          return config as Partial<GlobalConfig>;
         }
       } catch (error) {
         this.logger.logWarning(`Failed to load configuration from ${filename}: ${error}`);
@@ -318,6 +319,17 @@ class CurlRunnerCLI {
         return;
       }
 
+      // Handle upgrade subcommand: curl-runner upgrade [options]
+      if (args[0] === 'upgrade') {
+        if (args.includes('--help') || args.includes('-h')) {
+          showUpgradeHelp();
+          return;
+        }
+        const upgradeCmd = new UpgradeCommand();
+        await upgradeCmd.run(args.slice(1));
+        return;
+      }
+
       // Handle diff subcommand: curl-runner diff <label1> <label2> [file]
       if (args[0] === 'diff' && args.length >= 3) {
         await this.executeDiffSubcommand(args.slice(1), options);
@@ -373,16 +385,16 @@ class CurlRunnerCLI {
         globalConfig.maxConcurrency = options.maxConcurrent as number;
       }
       if (options.continueOnError !== undefined) {
-        globalConfig.continueOnError = options.continueOnError;
+        globalConfig.continueOnError = options.continueOnError as boolean;
       }
       if (options.verbose !== undefined) {
-        globalConfig.output = { ...globalConfig.output, verbose: options.verbose };
+        globalConfig.output = { ...globalConfig.output, verbose: options.verbose as boolean };
       }
       if (options.quiet !== undefined) {
         globalConfig.output = { ...globalConfig.output, verbose: false };
       }
       if (options.output) {
-        globalConfig.output = { ...globalConfig.output, saveToFile: options.output };
+        globalConfig.output = { ...globalConfig.output, saveToFile: options.output as string };
       }
       if (options.outputFormat) {
         globalConfig.output = {
@@ -397,21 +409,27 @@ class CurlRunnerCLI {
         };
       }
       if (options.showHeaders !== undefined) {
-        globalConfig.output = { ...globalConfig.output, showHeaders: options.showHeaders };
+        globalConfig.output = {
+          ...globalConfig.output,
+          showHeaders: options.showHeaders as boolean,
+        };
       }
       if (options.showBody !== undefined) {
-        globalConfig.output = { ...globalConfig.output, showBody: options.showBody };
+        globalConfig.output = { ...globalConfig.output, showBody: options.showBody as boolean };
       }
       if (options.showMetrics !== undefined) {
-        globalConfig.output = { ...globalConfig.output, showMetrics: options.showMetrics };
+        globalConfig.output = {
+          ...globalConfig.output,
+          showMetrics: options.showMetrics as boolean,
+        };
       }
 
       // Apply timeout and retry settings to defaults
       if (options.timeout) {
-        globalConfig.defaults = { ...globalConfig.defaults, timeout: options.timeout };
+        globalConfig.defaults = { ...globalConfig.defaults, timeout: options.timeout as number };
       }
       if (options.retries || options.noRetry) {
-        const retryCount = options.noRetry ? 0 : options.retries || 0;
+        const retryCount = options.noRetry ? 0 : (options.retries as number) || 0;
         globalConfig.defaults = {
           ...globalConfig.defaults,
           retry: {
@@ -425,7 +443,7 @@ class CurlRunnerCLI {
           ...globalConfig.defaults,
           retry: {
             ...globalConfig.defaults?.retry,
-            delay: options.retryDelay,
+            delay: options.retryDelay as number,
           },
         };
       }
@@ -670,13 +688,15 @@ class CurlRunnerCLI {
       }
 
       // Create combined summary
-      const successful = allResults.filter((r) => r.success).length;
-      const failed = allResults.filter((r) => !r.success).length;
+      const successful = allResults.filter((r) => r.success && !r.skipped).length;
+      const failed = allResults.filter((r) => !r.success && !r.skipped).length;
+      const skipped = allResults.filter((r) => r.skipped).length;
 
       summary = {
         total: allResults.length,
         successful,
         failed,
+        skipped,
         duration: totalDuration,
         results: allResults,
       };
@@ -1081,7 +1101,7 @@ class CurlRunnerCLI {
     variables: Record<string, string>,
     defaults: Partial<RequestConfig>,
   ): RequestConfig {
-    const interpolated = YamlParser.interpolateVariables(request, variables);
+    const interpolated = YamlParser.interpolateVariables(request, variables) as RequestConfig;
     return YamlParser.mergeConfigs(defaults, interpolated);
   }
 
@@ -1214,6 +1234,11 @@ ${this.logger.color('DIFF SUBCOMMAND:', 'yellow')}
   curl-runner diff <label1> <label2> [file.yaml]
                                 Compare two stored baselines without making requests
 
+${this.logger.color('UPGRADE:', 'yellow')}
+  curl-runner upgrade           Upgrade to latest version (auto-detects install method)
+  curl-runner upgrade --dry-run Preview upgrade command without executing
+  curl-runner upgrade --force   Force reinstall even if up to date
+
 ${this.logger.color('EXAMPLES:', 'yellow')}
   # Run all YAML files in current directory
   curl-runner

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/parser/yaml.ts

@@ -1,4 +1,3 @@
-import { YAML } from 'bun';
 import type { RequestConfig, ResponseStoreContext, YamlFile } from '../types/config';
 
 // Using class for organization, but could be refactored to functions
@@ -6,11 +5,11 @@ export class YamlParser {
   static async parseFile(filepath: string): Promise<YamlFile> {
     const file = Bun.file(filepath);
     const content = await file.text();
-    return YAML.parse(content) as YamlFile;
+    return Bun.YAML.parse(content) as YamlFile;
   }
 
   static parse(content: string): YamlFile {
-    return YAML.parse(content) as YamlFile;
+    return Bun.YAML.parse(content) as YamlFile;
   }
 
   /**

package/src/types/bun-yaml.d.ts

@@ -0,0 +1,11 @@
+// Type declarations for Bun.YAML which is not in bun-types
+declare global {
+  namespace Bun {
+    const YAML: {
+      parse(content: string): unknown;
+      stringify(value: unknown): string;
+    };
+  }
+}
+
+export {};

package/src/utils/curl-builder.ts

@@ -133,7 +133,15 @@ export class CurlBuilder {
     status?: number;
     headers?: Record<string, string>;
     body?: string;
-    metrics?: CurlMetrics;
+    metrics?: {
+      duration: number;
+      size?: number;
+      dnsLookup?: number;
+      tcpConnection?: number;
+      tlsHandshake?: number;
+      firstByte?: number;
+      download?: number;
+    };
     error?: string;
   }> {
     try {

package/src/utils/installation-detector.test.ts

@@ -0,0 +1,52 @@
+import { describe, expect, test } from 'bun:test';
+import { getUpgradeCommand, getUpgradeCommandWindows, isWindows } from './installation-detector';
+
+describe('getUpgradeCommand', () => {
+  test('returns bun command for bun source', () => {
+    expect(getUpgradeCommand('bun')).toBe('bun install -g @curl-runner/cli@latest');
+  });
+
+  test('returns npm command for npm source', () => {
+    expect(getUpgradeCommand('npm')).toBe('npm install -g @curl-runner/cli@latest');
+  });
+
+  test('returns curl command for curl source', () => {
+    expect(getUpgradeCommand('curl')).toBe(
+      'curl -fsSL https://www.curl-runner.com/install.sh | bash',
+    );
+  });
+
+  test('returns curl command for standalone source', () => {
+    expect(getUpgradeCommand('standalone')).toBe(
+      'curl -fsSL https://www.curl-runner.com/install.sh | bash',
+    );
+  });
+});
+
+describe('getUpgradeCommandWindows', () => {
+  test('returns bun command for bun source', () => {
+    expect(getUpgradeCommandWindows('bun')).toBe('bun install -g @curl-runner/cli@latest');
+  });
+
+  test('returns npm command for npm source', () => {
+    expect(getUpgradeCommandWindows('npm')).toBe('npm install -g @curl-runner/cli@latest');
+  });
+
+  test('returns PowerShell command for curl source', () => {
+    expect(getUpgradeCommandWindows('curl')).toBe(
+      'irm https://www.curl-runner.com/install.ps1 | iex',
+    );
+  });
+
+  test('returns PowerShell command for standalone source', () => {
+    expect(getUpgradeCommandWindows('standalone')).toBe(
+      'irm https://www.curl-runner.com/install.ps1 | iex',
+    );
+  });
+});
+
+describe('isWindows', () => {
+  test('returns boolean based on platform', () => {
+    expect(typeof isWindows()).toBe('boolean');
+  });
+});

package/src/utils/installation-detector.ts

@@ -0,0 +1,123 @@
+// Installation source detection for curl-runner upgrade command
+
+export type InstallationSource = 'bun' | 'npm' | 'curl' | 'standalone';
+
+export interface DetectionResult {
+  source: InstallationSource;
+  path: string;
+  canAutoUpgrade: boolean;
+}
+
+const CURL_INSTALL_PATHS = [
+  `${process.env.HOME}/.local/bin/curl-runner`,
+  `${process.env.USERPROFILE}\\.local\\bin\\curl-runner.exe`,
+];
+
+export function detectInstallationSource(): DetectionResult {
+  const execPath = process.execPath;
+  const argv0 = process.argv[0];
+
+  // Check for bun installation
+  if (isBunInstall(execPath)) {
+    return {
+      source: 'bun',
+      path: execPath,
+      canAutoUpgrade: true,
+    };
+  }
+
+  // Check for npm installation
+  if (isNpmInstall(execPath, argv0)) {
+    return {
+      source: 'npm',
+      path: execPath,
+      canAutoUpgrade: true,
+    };
+  }
+
+  // Check for curl installation (binary in ~/.local/bin)
+  if (isCurlInstall(execPath)) {
+    return {
+      source: 'curl',
+      path: execPath,
+      canAutoUpgrade: true,
+    };
+  }
+
+  // Standalone binary
+  return {
+    source: 'standalone',
+    path: execPath,
+    canAutoUpgrade: true,
+  };
+}
+
+function isBunInstall(execPath: string): boolean {
+  // Check if running from bun's global install directory
+  if (execPath.includes('.bun')) {
+    return true;
+  }
+  if (process.env.BUN_INSTALL && execPath.includes(process.env.BUN_INSTALL)) {
+    return true;
+  }
+
+  // Check for bun-specific paths
+  const bunPaths = ['/bun/install/', '/.bun/bin/', '/bun/bin/'];
+  return bunPaths.some((p) => execPath.includes(p));
+}
+
+function isNpmInstall(execPath: string, argv0: string): boolean {
+  // Check for npm global install indicators
+  if (execPath.includes('node_modules')) {
+    return true;
+  }
+  if (argv0.includes('node_modules')) {
+    return true;
+  }
+
+  // Check for npm config env vars (set when running via npm)
+  if (process.env.npm_config_prefix) {
+    return true;
+  }
+  if (process.env.npm_execpath) {
+    return true;
+  }
+
+  // Check common npm global paths
+  const npmPaths = ['/lib/node_modules/', '/node_modules/.bin/'];
+  return npmPaths.some((p) => execPath.includes(p) || argv0.includes(p));
+}
+
+function isCurlInstall(execPath: string): boolean {
+  // Check if binary is in curl installer's default location
+  return CURL_INSTALL_PATHS.some((p) => execPath === p || execPath.startsWith(p));
+}
+
+export function getUpgradeCommand(source: InstallationSource): string {
+  switch (source) {
+    case 'bun':
+      return 'bun install -g @curl-runner/cli@latest';
+    case 'npm':
+      return 'npm install -g @curl-runner/cli@latest';
+    case 'curl':
+      return 'curl -fsSL https://www.curl-runner.com/install.sh | bash';
+    case 'standalone':
+      return 'curl -fsSL https://www.curl-runner.com/install.sh | bash';
+  }
+}
+
+export function getUpgradeCommandWindows(source: InstallationSource): string {
+  switch (source) {
+    case 'bun':
+      return 'bun install -g @curl-runner/cli@latest';
+    case 'npm':
+      return 'npm install -g @curl-runner/cli@latest';
+    case 'curl':
+    case 'standalone':
+      return 'irm https://www.curl-runner.com/install.ps1 | iex';
+  }
+}
+
+export function isWindows(): boolean {
+  return process.platform === 'win32';
+}

package/src/utils/logger.ts

@@ -106,7 +106,7 @@ export class Logger {
     };
   }
 
-  private color(text: string, color: keyof typeof this.colors): string {
+  color(text: string, color: keyof typeof this.colors): string {
     return `${this.colors[color]}${text}${this.colors.reset}`;
   }
 

package/src/utils/version-checker.ts

@@ -69,45 +69,38 @@ export class VersionChecker {
   private compareVersions(current: string, latest: string): void {
     if (this.isNewerVersion(current, latest)) {
       console.log();
-      console.log(color('╭────────────────────────────────────────────────────────╮', 'yellow'));
+      console.log(color('╭───────────────────────────────────────────────╮', 'yellow'));
       console.log(
         color('│', 'yellow') +
-          '                                                        ' +
+          '                                               ' +
           color('│', 'yellow'),
       );
       console.log(
         color('│', 'yellow') +
           '  ' +
-          color('📦 New version available!', 'bright') +
+          color('Update available!', 'bright') +
           ` ${color(current, 'red')} → ${color(latest, 'green')}` +
-          '     ' +
+          '        ' +
           color('│', 'yellow'),
       );
       console.log(
         color('│', 'yellow') +
-          '                                                        ' +
+          '                                               ' +
           color('│', 'yellow'),
       );
       console.log(
         color('│', 'yellow') +
-          '  Update with: ' +
-          color('npm install -g @curl-runner/cli', 'cyan') +
-          '   ' +
+          '  Run ' +
+          color('curl-runner upgrade', 'cyan') +
+          ' to update          ' +
           color('│', 'yellow'),
       );
       console.log(
         color('│', 'yellow') +
-          '          or: ' +
-          color('bun install -g @curl-runner/cli', 'cyan') +
-          '   ' +
+          '                                               ' +
           color('│', 'yellow'),
       );
-      console.log(
-        color('│', 'yellow') +
-          '                                                        ' +
-          color('│', 'yellow'),
-      );
-      console.log(color('╰────────────────────────────────────────────────────────╯', 'yellow'));
+      console.log(color('╰───────────────────────────────────────────────╯', 'yellow'));
       console.log();
     }
   }