mpx-api 1.0.0

package/src/lib/collection-runner.js

@@ -0,0 +1,66 @@
+import { HttpClient } from './http-client.js';
+import { interpolateObject } from './template.js';
+import { runAssertions } from './assertion.js';
+
+export async function runCollection(collection, options = {}) {
+  const { env = {}, baseUrl = '' } = options;
+  const client = new HttpClient();
+  const results = [];
+  const context = { env };
+
+  for (const request of collection.requests || []) {
+    const result = {
+      name: request.name,
+      passed: false,
+      assertions: [],
+      error: null,
+      response: null,
+    };
+
+    try {
+      // Interpolate request with current context
+      const interpolated = interpolateObject(request, context);
+      
+      // Build URL
+      let url = interpolated.url;
+      if (baseUrl && !url.startsWith('http')) {
+        url = baseUrl + url;
+      }
+      url = interpolateObject(url, context);
+
+      // Build request options
+      const requestOptions = {
+        headers: interpolated.headers || {},
+      };
+
+      if (interpolated.json) {
+        requestOptions.json = interpolated.json;
+      } else if (interpolated.body) {
+        requestOptions.body = interpolated.body;
+      }
+
+      // Make request
+      const response = await client.request(interpolated.method || 'GET', url, requestOptions);
+      result.response = response;
+
+      // Store response in context for chaining
+      context[request.name] = { response };
+
+      // Run assertions if present
+      if (interpolated.assert) {
+        result.assertions = runAssertions(response, interpolated.assert);
+        result.passed = result.assertions.every(a => a.passed);
+      } else {
+        // No assertions, just check if request succeeded
+        result.passed = response.status >= 200 && response.status < 400;
+      }
+    } catch (err) {
+      result.error = err.message;
+      result.passed = false;
+    }
+
+    results.push(result);
+  }
+
+  return results;
+}

package/src/lib/config.js

@@ -0,0 +1,71 @@
+import { homedir } from 'os';
+import { join } from 'path';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+
+const GLOBAL_DIR = join(homedir(), '.mpx-api');
+const LOCAL_DIR = '.mpx-api';
+
+export function ensureGlobalDir() {
+  if (!existsSync(GLOBAL_DIR)) {
+    mkdirSync(GLOBAL_DIR, { recursive: true });
+  }
+  return GLOBAL_DIR;
+}
+
+export function ensureLocalDir() {
+  if (!existsSync(LOCAL_DIR)) {
+    mkdirSync(LOCAL_DIR, { recursive: true });
+  }
+  return LOCAL_DIR;
+}
+
+export function getGlobalConfigPath() {
+  return join(ensureGlobalDir(), 'config.json');
+}
+
+export function getLocalConfigPath() {
+  return join(LOCAL_DIR, 'config.json');
+}
+
+export function getHistoryPath() {
+  return join(ensureGlobalDir(), 'history.jsonl');
+}
+
+export function getCookieJarPath() {
+  return join(ensureGlobalDir(), 'cookies.json');
+}
+
+export function loadGlobalConfig() {
+  const path = getGlobalConfigPath();
+  if (!existsSync(path)) {
+    return {};
+  }
+  try {
+    return JSON.parse(readFileSync(path, 'utf8'));
+  } catch (err) {
+    return {};
+  }
+}
+
+export function saveGlobalConfig(config) {
+  const path = getGlobalConfigPath();
+  writeFileSync(path, JSON.stringify(config, null, 2));
+}
+
+export function loadLocalConfig() {
+  const path = getLocalConfigPath();
+  if (!existsSync(path)) {
+    return {};
+  }
+  try {
+    return JSON.parse(readFileSync(path, 'utf8'));
+  } catch (err) {
+    return {};
+  }
+}
+
+export function saveLocalConfig(config) {
+  ensureLocalDir();
+  const path = getLocalConfigPath();
+  writeFileSync(path, JSON.stringify(config, null, 2));
+}

package/src/lib/history.js

@@ -0,0 +1,51 @@
+import { appendFileSync, readFileSync, existsSync } from 'fs';
+import { getHistoryPath } from './config.js';
+
+export function saveToHistory(request, response) {
+  const historyPath = getHistoryPath();
+  
+  const entry = {
+    timestamp: new Date().toISOString(),
+    method: request.method,
+    url: request.url,
+    headers: request.headers,
+    body: request.body,
+    status: response.status,
+    responseTime: response.responseTime,
+    size: response.size,
+  };
+
+  try {
+    appendFileSync(historyPath, JSON.stringify(entry) + '\n');
+  } catch (err) {
+    // Ignore errors, history is optional
+  }
+}
+
+export function loadHistory(limit = 50) {
+  const historyPath = getHistoryPath();
+  
+  if (!existsSync(historyPath)) {
+    return [];
+  }
+
+  try {
+    const content = readFileSync(historyPath, 'utf8');
+    const lines = content.trim().split('\n').filter(Boolean);
+    
+    // Parse and return last N entries
+    const entries = lines
+      .map(line => {
+        try {
+          return JSON.parse(line);
+        } catch (e) {
+          return null;
+        }
+      })
+      .filter(Boolean);
+    
+    return entries.slice(-limit).reverse();
+  } catch (err) {
+    return [];
+  }
+}

package/src/lib/http-client.js

@@ -0,0 +1,179 @@
+import { request } from 'undici';
+import { CookieJar } from 'tough-cookie';
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { getCookieJarPath } from './config.js';
+
+export class HttpClient {
+  constructor(options = {}) {
+    this.followRedirects = options.followRedirects !== false;
+    this.verifySsl = options.verifySsl !== false;
+    this.timeout = options.timeout || 30000;
+    this.cookieJar = new CookieJar();
+    
+    // Load persisted cookies
+    this.loadCookies();
+  }
+
+  loadCookies() {
+    const cookiePath = getCookieJarPath();
+    if (existsSync(cookiePath)) {
+      try {
+        const data = JSON.parse(readFileSync(cookiePath, 'utf8'));
+        this.cookieJar = CookieJar.fromJSON(data);
+      } catch (err) {
+        // Ignore errors, start fresh
+      }
+    }
+  }
+
+  saveCookies() {
+    const cookiePath = getCookieJarPath();
+    try {
+      writeFileSync(cookiePath, JSON.stringify(this.cookieJar.toJSON()));
+    } catch (err) {
+      // Ignore errors
+    }
+  }
+
+  async request(method, url, options = {}) {
+    const startTime = Date.now();
+    
+    const requestOptions = {
+      method: method.toUpperCase(),
+      headers: options.headers || {},
+      body: options.body,
+    };
+    
+    // Note: undici follows redirects by default, maxRedirections removed in newer versions
+
+    // Add cookies to request
+    const cookies = await this.cookieJar.getCookies(url);
+    if (cookies.length > 0) {
+      requestOptions.headers.cookie = cookies.map(c => c.cookieString()).join('; ');
+    }
+
+    // Set content-type for JSON bodies
+    if (options.json) {
+      requestOptions.headers['content-type'] = 'application/json';
+      requestOptions.body = JSON.stringify(options.json);
+    }
+
+    // SSL verification
+    if (!this.verifySsl) {
+      requestOptions.connect = { rejectUnauthorized: false };
+    }
+
+    try {
+      const response = await request(url, requestOptions);
+      
+      // Store cookies from response
+      const setCookieHeaders = response.headers['set-cookie'];
+      if (setCookieHeaders) {
+        const cookieArray = Array.isArray(setCookieHeaders) ? setCookieHeaders : [setCookieHeaders];
+        for (const cookie of cookieArray) {
+          await this.cookieJar.setCookie(cookie, url);
+        }
+        this.saveCookies();
+      }
+
+      // Read response body
+      let body;
+      const contentType = response.headers['content-type'] || '';
+      const buffer = await response.body.arrayBuffer();
+      
+      // Try to parse as text
+      const decoder = new TextDecoder('utf-8');
+      const text = decoder.decode(buffer);
+      
+      // Parse JSON if applicable
+      if (contentType.includes('application/json') || contentType.includes('application/vnd.api+json')) {
+        try {
+          body = JSON.parse(text);
+        } catch (err) {
+          body = text;
+        }
+      } else {
+        body = text;
+      }
+
+      const endTime = Date.now();
+      
+      return {
+        status: response.statusCode,
+        statusText: getStatusText(response.statusCode),
+        headers: response.headers,
+        body,
+        rawBody: text,
+        size: buffer.byteLength,
+        responseTime: endTime - startTime,
+        url,
+        method: method.toUpperCase(),
+      };
+    } catch (err) {
+      // Handle network errors gracefully
+      if (err.code === 'ENOTFOUND') {
+        throw new Error(`DNS lookup failed for ${url}`);
+      } else if (err.code === 'ECONNREFUSED') {
+        throw new Error(`Connection refused to ${url}`);
+      } else if (err.code === 'ETIMEDOUT' || err.name === 'TimeoutError') {
+        throw new Error(`Request timeout after ${this.timeout}ms`);
+      } else if (err.code === 'CERT_HAS_EXPIRED' || err.code === 'UNABLE_TO_VERIFY_LEAF_SIGNATURE') {
+        throw new Error(`SSL certificate error: ${err.message}. Use --no-verify to bypass.`);
+      } else {
+        throw err;
+      }
+    }
+  }
+
+  async get(url, options) {
+    return this.request('GET', url, options);
+  }
+
+  async post(url, options) {
+    return this.request('POST', url, options);
+  }
+
+  async put(url, options) {
+    return this.request('PUT', url, options);
+  }
+
+  async patch(url, options) {
+    return this.request('PATCH', url, options);
+  }
+
+  async delete(url, options) {
+    return this.request('DELETE', url, options);
+  }
+
+  async head(url, options) {
+    return this.request('HEAD', url, options);
+  }
+
+  async options(url, options) {
+    return this.request('OPTIONS', url, options);
+  }
+}
+
+function getStatusText(code) {
+  const statusTexts = {
+    200: 'OK',
+    201: 'Created',
+    204: 'No Content',
+    301: 'Moved Permanently',
+    302: 'Found',
+    304: 'Not Modified',
+    400: 'Bad Request',
+    401: 'Unauthorized',
+    403: 'Forbidden',
+    404: 'Not Found',
+    405: 'Method Not Allowed',
+    409: 'Conflict',
+    422: 'Unprocessable Entity',
+    429: 'Too Many Requests',
+    500: 'Internal Server Error',
+    502: 'Bad Gateway',
+    503: 'Service Unavailable',
+    504: 'Gateway Timeout',
+  };
+  return statusTexts[code] || 'Unknown';
+}

package/src/lib/license.js

@@ -0,0 +1,35 @@
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { ensureGlobalDir } from './config.js';
+
+export function checkProLicense() {
+  const licenseFile = join(ensureGlobalDir(), 'license.key');
+  
+  if (!existsSync(licenseFile)) {
+    return false;
+  }
+  
+  try {
+    const license = readFileSync(licenseFile, 'utf8').trim();
+    // Simple validation for now (in production, use proper license verification)
+    return license.length > 20 && license.startsWith('MPX-PRO-');
+  } catch (err) {
+    return false;
+  }
+}
+
+export function requireProLicense(featureName) {
+  if (!checkProLicense()) {
+    throw new Error(
+      `${featureName} is a Pro feature.\n\n` +
+      'Upgrade to mpx-api Pro for $12/mo to unlock:\n' +
+      '  • Mock server from OpenAPI specs\n' +
+      '  • Record & replay\n' +
+      '  • Load testing\n' +
+      '  • API documentation generation\n' +
+      '  • Request chaining\n' +
+      '  • Pre/post request scripts\n\n' +
+      'Visit https://mpx-api.dev/pro to upgrade.'
+    );
+  }
+}

package/src/lib/output.js

@@ -0,0 +1,172 @@
+import chalk from 'chalk';
+import { highlight } from 'cli-highlight';
+
+const MAX_BODY_SIZE = 50 * 1024; // 50KB max for terminal display
+
+export function formatResponse(response, options = {}) {
+  const { verbose = false, quiet = false } = options;
+  
+  if (quiet) {
+    // Only output body
+    if (typeof response.body === 'object') {
+      console.log(JSON.stringify(response.body, null, 2));
+    } else {
+      console.log(response.body);
+    }
+    return;
+  }
+
+  const lines = [];
+  
+  // Status line
+  const statusColor = getStatusColor(response.status);
+  lines.push('');
+  lines.push(chalk.bold(`${response.method} ${response.url}`));
+  lines.push(
+    chalk[statusColor].bold(`${response.status} ${response.statusText}`) +
+    chalk.gray(` • ${response.responseTime}ms • ${formatSize(response.size)}`)
+  );
+  lines.push('');
+
+  // Headers (if verbose)
+  if (verbose) {
+    lines.push(chalk.bold.cyan('Response Headers:'));
+    for (const [key, value] of Object.entries(response.headers)) {
+      const valueStr = Array.isArray(value) ? value.join(', ') : value;
+      lines.push(chalk.cyan(`  ${key}: `) + chalk.gray(valueStr));
+    }
+    lines.push('');
+  }
+
+  // Body
+  lines.push(chalk.bold.cyan('Response Body:'));
+  
+  if (response.size > MAX_BODY_SIZE) {
+    lines.push(chalk.yellow(`  [Body too large (${formatSize(response.size)}), showing first ${formatSize(MAX_BODY_SIZE)}]`));
+    const truncated = response.rawBody.slice(0, MAX_BODY_SIZE);
+    lines.push(highlightBody(truncated, response.headers['content-type']));
+  } else if (response.rawBody.length === 0) {
+    lines.push(chalk.gray('  (empty)'));
+  } else {
+    lines.push(highlightBody(response.rawBody, response.headers['content-type']));
+  }
+  
+  lines.push('');
+  
+  console.log(lines.join('\n'));
+}
+
+export function formatError(error) {
+  console.error('');
+  console.error(chalk.red.bold('✗ Error:'), error.message);
+  console.error('');
+}
+
+export function formatSuccess(message) {
+  console.log('');
+  console.log(chalk.green.bold('✓'), message);
+  console.log('');
+}
+
+export function formatInfo(message) {
+  console.log('');
+  console.log(chalk.blue.bold('ℹ'), message);
+  console.log('');
+}
+
+export function formatWarning(message) {
+  console.log('');
+  console.log(chalk.yellow.bold('⚠'), message);
+  console.log('');
+}
+
+function getStatusColor(status) {
+  if (status >= 200 && status < 300) return 'green';
+  if (status >= 300 && status < 400) return 'cyan';
+  if (status >= 400 && status < 500) return 'yellow';
+  if (status >= 500) return 'red';
+  return 'white';
+}
+
+function formatSize(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+}
+
+function highlightBody(text, contentType = '') {
+  try {
+    // Detect language from content-type
+    let language = 'text';
+    if (contentType.includes('json')) {
+      language = 'json';
+      // Pretty-print JSON
+      try {
+        const parsed = JSON.parse(text);
+        text = JSON.stringify(parsed, null, 2);
+      } catch (e) {
+        // Keep original if parse fails
+      }
+    } else if (contentType.includes('xml') || contentType.includes('html')) {
+      language = 'xml';
+    } else if (contentType.includes('javascript')) {
+      language = 'javascript';
+    }
+
+    const highlighted = highlight(text, { language, ignoreIllegals: true });
+    return highlighted.split('\n').map(line => '  ' + line).join('\n');
+  } catch (err) {
+    // Fallback to plain text with indentation
+    return text.split('\n').map(line => '  ' + line).join('\n');
+  }
+}
+
+export function formatTestResults(results) {
+  console.log('');
+  console.log(chalk.bold.cyan('Test Results:'));
+  console.log('');
+
+  let passed = 0;
+  let failed = 0;
+
+  for (const result of results) {
+    if (result.passed) {
+      passed++;
+      console.log(chalk.green('  ✓'), result.name);
+      if (result.assertions) {
+        for (const assertion of result.assertions) {
+          if (assertion.passed) {
+            console.log(chalk.gray(`    ✓ ${assertion.description}`));
+          } else {
+            console.log(chalk.red(`    ✗ ${assertion.description}`));
+            console.log(chalk.red(`      Expected: ${assertion.expected}, Got: ${assertion.actual}`));
+          }
+        }
+      }
+    } else {
+      failed++;
+      console.log(chalk.red('  ✗'), result.name);
+      if (result.error) {
+        console.log(chalk.red(`    ${result.error}`));
+      }
+      if (result.assertions) {
+        for (const assertion of result.assertions) {
+          if (!assertion.passed) {
+            console.log(chalk.red(`    ✗ ${assertion.description}`));
+            console.log(chalk.red(`      Expected: ${assertion.expected}, Got: ${assertion.actual}`));
+          }
+        }
+      }
+    }
+  }
+
+  console.log('');
+  console.log(
+    chalk.bold(`Total: ${results.length} tests, `) +
+    chalk.green.bold(`${passed} passed, `) +
+    (failed > 0 ? chalk.red.bold(`${failed} failed`) : chalk.gray(`${failed} failed`))
+  );
+  console.log('');
+
+  return failed === 0;
+}

package/src/lib/template.js

@@ -0,0 +1,63 @@
+// Template variable interpolation
+// Supports: {{varName}}, {{env.VAR}}, {{request-name.response.body.field}}
+
+export function interpolate(text, context = {}) {
+  if (typeof text !== 'string') return text;
+  
+  return text.replace(/\{\{(.+?)\}\}/g, (match, path) => {
+    path = path.trim();
+    
+    // Handle environment variables
+    if (path.startsWith('env.')) {
+      const envVar = path.slice(4);
+      return process.env[envVar] || match;
+    }
+    
+    // Handle nested object paths (e.g., response.body.users[0].id)
+    const value = getNestedValue(context, path);
+    return value !== undefined ? value : match;
+  });
+}
+
+export function interpolateObject(obj, context = {}) {
+  if (typeof obj === 'string') {
+    return interpolate(obj, context);
+  }
+  
+  if (Array.isArray(obj)) {
+    return obj.map(item => interpolateObject(item, context));
+  }
+  
+  if (obj && typeof obj === 'object') {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      result[key] = interpolateObject(value, context);
+    }
+    return result;
+  }
+  
+  return obj;
+}
+
+function getNestedValue(obj, path) {
+  // Handle array indexing: users[0].name
+  const parts = path.split('.');
+  let current = obj;
+  
+  for (const part of parts) {
+    if (!current) return undefined;
+    
+    // Check for array indexing
+    const arrayMatch = part.match(/^(.+?)\[(\d+)\]$/);
+    if (arrayMatch) {
+      const [, key, index] = arrayMatch;
+      current = current[key];
+      if (!Array.isArray(current)) return undefined;
+      current = current[parseInt(index)];
+    } else {
+      current = current[part];
+    }
+  }
+  
+  return current;
+}