apigrip 0.1.0

package/cli/commands/send.js

@@ -0,0 +1,189 @@
+// cli/commands/send.js — Send an API request via curl
+
+import fs from 'node:fs';
+import jq from '@michaelhomer/jqjs';
+import { parseSpec, extractEndpoints, getEndpointDetails } from '../../core/spec-parser.js';
+import { buildCurlArgs, buildUrl, resolveVariables, shellQuote } from '../../core/curl-builder.js';
+import { loadEnvironments, resolveEnvironment, resolveAllParams } from '../../core/env-resolver.js';
+import { executeCurl } from '../../core/curl-executor.js';
+import { saveLastResponse } from '../../core/response-store.js';
+import { formatResponse } from '../output.js';
+import { resolveProjectContext } from '../resolve-project.js';
+
+/**
+ * Resolve body data from -d argument.
+ * Supports: inline JSON, @filename (read from file), @- (read from stdin).
+ */
+function resolveBodyData(data) {
+  if (!data) return data;
+  if (typeof data !== 'string') return data;
+  if (!data.startsWith('@')) return data;
+
+  const source = data.slice(1);
+  if (source === '-') {
+    return fs.readFileSync(0, 'utf8').trim();
+  }
+  if (!fs.existsSync(source)) {
+    console.error(`Body file not found: ${source}`);
+    process.exitCode = 1;
+    return null;
+  }
+  return fs.readFileSync(source, 'utf8').trim();
+}
+
+/**
+ * Send command handler.
+ * @param {object} argv - Parsed CLI arguments
+ */
+export async function sendCommand(argv) {
+  const { projectDir, specPath } = await resolveProjectContext(argv);
+  if (!specPath) {
+    console.error('No spec file found');
+    process.exit(2);
+  }
+
+  let spec;
+  try {
+    spec = await parseSpec(specPath);
+  } catch (err) {
+    console.error(`Spec parse error: ${err.message}`);
+    process.exit(2);
+  }
+
+  const method = argv.method.toUpperCase();
+  const pathArg = argv.path;
+  const apiPath = typeof pathArg === 'string' ? (pathArg.startsWith('/') ? pathArg : '/' + pathArg) : '/' + String(pathArg);
+  const details = getEndpointDetails(spec, method, apiPath);
+  if (!details) {
+    console.error(`Endpoint not found: ${method} ${apiPath}`);
+    process.exit(3);
+  }
+
+  // Parse path params from --pathParam key=value pairs
+  const pathParams = {};
+  if (argv.pathParam) {
+    for (const p of argv.pathParam) {
+      const [k, ...v] = p.split('=');
+      pathParams[k] = v.join('=');
+    }
+  }
+
+  const queryParams = {};
+  if (argv.query) {
+    for (const q of argv.query) {
+      const [k, ...v] = q.split('=');
+      queryParams[k] = v.join('=');
+    }
+  }
+  const headers = {};
+  if (argv.header) {
+    for (const h of argv.header) {
+      const [k, ...v] = h.split(':');
+      headers[k.trim()] = v.join(':').trim();
+    }
+  }
+
+  // Resolve environment
+  let env = {};
+  try {
+    const envData = loadEnvironments(projectDir);
+    if (argv.env) {
+      envData.active = argv.env;
+    }
+    // Manually merge base + active environment
+    env = { ...envData.base };
+    if (envData.active && envData.environments[envData.active]) {
+      Object.assign(env, envData.environments[envData.active]);
+    }
+  } catch (e) {
+    // No env file, continue without
+  }
+
+  // Resolve {{ variable }} references
+  for (const [k, v] of Object.entries(pathParams)) {
+    pathParams[k] = resolveVariables(v, env);
+  }
+  for (const [k, v] of Object.entries(queryParams)) {
+    queryParams[k] = resolveVariables(v, env);
+  }
+  for (const [k, v] of Object.entries(headers)) {
+    headers[k] = resolveVariables(v, env);
+  }
+  const bodyData = resolveBodyData(argv.data);
+  if (bodyData === null && argv.data) {
+    return; // resolveBodyData already printed error
+  }
+  const resolvedBody = bodyData ? resolveVariables(bodyData, env) : bodyData;
+
+  const servers = details.servers || spec.servers || [];
+  const url = buildUrl(servers, 0, {}, apiPath, pathParams, queryParams, env.base_url);
+
+  const contentType = resolvedBody ? 'application/json' : null;
+  const curlArgs = buildCurlArgs({
+    method,
+    url,
+    headers,
+    body: resolvedBody,
+    contentType,
+    insecure: env.insecure === true,
+    timeout: env.timeout || 30,
+    outputFile: 'TMPFILE',
+  });
+
+  if (argv.curl) {
+    console.log(`curl ${curlArgs.map(a => shellQuote(a)).join(' ')}`);
+    process.exit(0);
+  }
+
+  if (argv.dryRun) {
+    console.log(`Would send: ${method} ${url}`);
+    console.log(`curl ${curlArgs.map(a => shellQuote(a)).join(' ')}`);
+    process.exit(0);
+  }
+
+  try {
+    const response = await executeCurl(curlArgs);
+
+    // Cache response for later retrieval
+    try {
+      saveLastResponse(projectDir, method, apiPath, {
+        status: response.status,
+        status_text: response.status_text,
+        headers: response.headers,
+        body: response.body,
+        size_bytes: response.size_bytes,
+        timing: response.timing,
+        curl_command: response.curl_command,
+      });
+    } catch {
+      // Non-critical — don't fail the command if caching fails
+    }
+
+    if (argv.filter) {
+      // Apply jq filter to response body
+      let parsed;
+      try {
+        parsed = JSON.parse(response.body);
+      } catch {
+        console.error('Cannot apply --filter: response body is not valid JSON');
+        console.log(response.body);
+        process.exit(1);
+      }
+      try {
+        const fn = jq.compile(argv.filter);
+        const results = [...fn(parsed)];
+        for (const r of results) {
+          console.log(typeof r === 'string' ? r : JSON.stringify(r, null, 2));
+        }
+      } catch (err) {
+        console.error(`jq filter error: ${err.message}`);
+        process.exit(1);
+      }
+    } else {
+      console.log(formatResponse(response, { verbose: argv.verbose, headers: argv.headers }));
+    }
+  } catch (err) {
+    console.error(`Request failed: ${err.message}`);
+    process.exit(1);
+  }
+}

package/cli/commands/serve.js

@@ -0,0 +1,46 @@
+import fs from 'node:fs';
+import { parseSpec } from '../../core/spec-parser.js';
+import { createServer } from '../../server/index.js';
+import { resolveProjectContext } from '../resolve-project.js';
+
+export async function serveCommand(argv) {
+  const { projectDir, specPath } = await resolveProjectContext(argv);
+
+  if (!fs.existsSync(projectDir)) {
+    console.error(`Project directory does not exist: ${projectDir}`);
+    process.exitCode = 2;
+    return;
+  }
+
+  let spec = null;
+  if (specPath) {
+    try {
+      spec = await parseSpec(specPath);
+    } catch (err) {
+      console.error(`Warning: Spec parse error: ${err.message}`);
+    }
+  }
+
+  const noBrowse = argv.noBrowse || argv['no-browse'] || false;
+  const port = argv.port || 3000;
+  const host = argv.host || '127.0.0.1';
+
+  // Warn when exposing to network without --no-browse
+  if (host !== '127.0.0.1' && host !== 'localhost' && !noBrowse) {
+    console.warn('WARNING: Binding to a public interface without --no-browse.');
+    console.warn('         The /api/browse endpoint exposes your filesystem.');
+    console.warn('         Use --no-browse to disable directory listing and project switching.');
+  }
+
+  const { app } = createServer({ projectDir, specPath, spec, noBrowse });
+
+  app.listen(port, host, () => {
+    console.log(`Server listening on http://${host}:${port}`);
+    if (argv.open) {
+      import('child_process').then(({ exec }) => {
+        const cmd = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
+        exec(`${cmd} http://${host}:${port}`);
+      });
+    }
+  });
+}

package/cli/index.js

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+
+// Register commands
+const cli = yargs(hideBin(process.argv))
+  .scriptName('apigrip')
+  .usage('$0 <command> [options]')
+  .command('serve', 'Start the web UI server', (yargs) => {
+    return yargs
+      .option('port', { type: 'number', default: 3000, describe: 'Port to listen on' })
+      .option('host', { type: 'string', default: '127.0.0.1', describe: 'Host to bind to' })
+      .option('open', { type: 'boolean', default: false, describe: 'Open browser on start' })
+      .option('no-browse', { type: 'boolean', default: false, describe: 'Disable directory browsing and project switching' });
+  }, async (argv) => {
+    const { serveCommand } = await import('./commands/serve.js');
+    await serveCommand(argv);
+  })
+  .command('send <method> <path>', 'Send an API request', (yargs) => {
+    return yargs
+      .positional('method', { type: 'string', describe: 'HTTP method' })
+      .positional('path', { type: 'string', describe: 'API path' })
+      .option('d', { alias: 'data', type: 'string', describe: 'Request body' })
+      .option('e', { alias: 'env', type: 'string', describe: 'Environment name' })
+      .option('query', { type: 'array', describe: 'Query params (key=value)' })
+      .option('header', { type: 'array', describe: 'Headers (Name: value)' })
+      .option('pathParam', { type: 'array', describe: 'Path params (key=value)' })
+      .option('v', { alias: 'verbose', type: 'boolean', describe: 'Verbose output' })
+      .option('i', { alias: 'headers', type: 'boolean', describe: 'Include headers' })
+      .option('dry-run', { type: 'boolean', describe: 'Print request without sending' })
+      .option('curl', { type: 'boolean', describe: 'Print curl command only' })
+      .option('filter', { type: 'string', describe: 'jq filter for response body (e.g. .data[0].name)' })
+      .option('spec', { type: 'string', describe: 'Path to spec file' })
+      .option('project', { type: 'string', describe: 'Project directory' });
+  }, async (argv) => {
+    const { sendCommand } = await import('./commands/send.js');
+    await sendCommand(argv);
+  })
+  .command('curl <method> <path>', 'Generate curl command', (yargs) => {
+    return yargs
+      .positional('method', { type: 'string' })
+      .positional('path', { type: 'string' })
+      .option('d', { alias: 'data', type: 'string' })
+      .option('e', { alias: 'env', type: 'string' })
+      .option('query', { type: 'array' })
+      .option('header', { type: 'array' })
+      .option('pathParam', { type: 'array', describe: 'Path params (key=value)' })
+      .option('spec', { type: 'string' })
+      .option('project', { type: 'string' });
+  }, async (argv) => {
+    const { curlCommand } = await import('./commands/curl.js');
+    await curlCommand(argv);
+  })
+  .command('list', 'List endpoints from spec', (yargs) => {
+    return yargs
+      .option('tag', { type: 'string', describe: 'Filter by tag' })
+      .option('search', { type: 'string', describe: 'Search endpoints' })
+      .option('json', { type: 'boolean', describe: 'JSON output' })
+      .option('spec', { type: 'string' })
+      .option('project', { type: 'string' });
+  }, async (argv) => {
+    const { listCommand } = await import('./commands/list.js');
+    await listCommand(argv);
+  })
+  .command('projects [action] [dir]', 'Manage project bookmarks', (yargs) => {
+    return yargs
+      .positional('action', { choices: ['add', 'remove'], describe: 'Action' })
+      .positional('dir', { type: 'string', describe: 'Directory path' });
+  }, async (argv) => {
+    const { projectsCommand } = await import('./commands/projects.js');
+    await projectsCommand(argv);
+  })
+  .command('last [method] [path]', 'Show last cached response for an endpoint', (yargs) => {
+    return yargs
+      .positional('method', { type: 'string', describe: 'HTTP method' })
+      .positional('path', { type: 'string', describe: 'API path' })
+      .option('json', { type: 'boolean', describe: 'Full JSON output' })
+      .option('v', { alias: 'verbose', type: 'boolean', describe: 'Verbose output' })
+      .option('i', { alias: 'headers', type: 'boolean', describe: 'Include headers' })
+      .option('project', { type: 'string', describe: 'Project directory' })
+      .option('spec', { type: 'string', describe: 'Path to spec file' });
+  }, async (argv) => {
+    const { lastCommand } = await import('./commands/last.js');
+    await lastCommand(argv);
+  })
+  .command('env [action] [name] [key] [value]', 'Manage environments', (yargs) => {
+    return yargs
+      .positional('action', { choices: ['show', 'set', 'delete', 'import'], describe: 'Action' })
+      .positional('name', { type: 'string', describe: 'Environment name or file path (for import)' })
+      .positional('key', { type: 'string', describe: 'Variable key' })
+      .positional('value', { type: 'string', describe: 'Variable value' })
+      .option('project', { type: 'string', describe: 'Project directory' })
+      .option('import-name', { type: 'string', describe: 'Target environment name for import (default: auto-detect)' })
+      .option('merge', { type: 'boolean', default: false, describe: 'Merge with existing values instead of replacing' });
+  }, async (argv) => {
+    const { envCommand } = await import('./commands/env.js');
+    await envCommand(argv);
+  })
+  .command('mcp', 'Start MCP server', (yargs) => {
+    return yargs
+      .option('project', { type: 'string' })
+      .option('spec', { type: 'string' });
+  }, async (argv) => {
+    const { mcpCommand } = await import('./commands/mcp.js');
+    await mcpCommand(argv);
+  })
+  .demandCommand(1, 'You need at least one command')
+  .help()
+  .argv;

package/cli/output.js

@@ -0,0 +1,168 @@
+// cli/output.js — CLI output formatting functions
+
+const RESET = '\x1b[0m';
+
+const METHOD_COLORS = {
+  GET: '\x1b[32m',     // green
+  POST: '\x1b[35m',    // magenta
+  PUT: '\x1b[33m',     // yellow
+  DELETE: '\x1b[31m',  // red
+  PATCH: '\x1b[33m',   // yellow
+};
+
+/**
+ * Color an HTTP method string using ANSI codes.
+ * @param {string} method - HTTP method (e.g. "GET", "POST")
+ * @returns {string} ANSI-colored method string
+ */
+export function colorMethod(method) {
+  const upper = method.toUpperCase();
+  const color = METHOD_COLORS[upper] || '';
+  if (!color) return upper;
+  return `${color}${upper}${RESET}`;
+}
+
+/**
+ * Format rows into a simple padded text table.
+ * @param {string[][]} rows - Array of row arrays
+ * @param {string[]} [headers] - Optional header row
+ * @returns {string} Formatted table string
+ */
+export function formatTable(rows, headers) {
+  const allRows = headers ? [headers, ...rows] : rows;
+  if (allRows.length === 0) return '';
+
+  // Determine the number of columns
+  const numCols = Math.max(...allRows.map(r => r.length));
+
+  // Calculate max width for each column
+  const colWidths = [];
+  for (let col = 0; col < numCols; col++) {
+    let maxWidth = 0;
+    for (const row of allRows) {
+      const cell = row[col] || '';
+      // Strip ANSI codes for width calculation
+      const stripped = cell.replace(/\x1b\[[0-9;]*m/g, '');
+      if (stripped.length > maxWidth) {
+        maxWidth = stripped.length;
+      }
+    }
+    colWidths.push(maxWidth);
+  }
+
+  // Format each row
+  const lines = allRows.map(row => {
+    const cells = [];
+    for (let col = 0; col < numCols; col++) {
+      const cell = row[col] || '';
+      const stripped = cell.replace(/\x1b\[[0-9;]*m/g, '');
+      const padding = colWidths[col] - stripped.length;
+      // Right-pad each cell (except last column)
+      if (col < numCols - 1) {
+        cells.push(cell + ' '.repeat(padding));
+      } else {
+        cells.push(cell);
+      }
+    }
+    return cells.join('    ');
+  });
+
+  return lines.join('\n');
+}
+
+/**
+ * Format a list of endpoints grouped by tag.
+ * @param {Array<{method: string, path: string, summary: string, tags: string[]}>} endpoints
+ * @param {object} [options]
+ * @param {boolean} [options.json] - If true, return JSON string instead
+ * @returns {string} Formatted endpoint list
+ */
+export function formatEndpointList(endpoints, options = {}) {
+  if (options.json) {
+    return JSON.stringify(endpoints);
+  }
+
+  if (!endpoints || endpoints.length === 0) {
+    return 'No endpoints found.';
+  }
+
+  // Group endpoints by tag
+  const groups = new Map();
+  for (const ep of endpoints) {
+    const tags = ep.tags && ep.tags.length > 0 ? ep.tags : ['untagged'];
+    for (const tag of tags) {
+      if (!groups.has(tag)) {
+        groups.set(tag, []);
+      }
+      groups.get(tag).push(ep);
+    }
+  }
+
+  // Calculate max path width across all endpoints for consistent alignment
+  let maxPathLen = 0;
+  for (const ep of endpoints) {
+    if (ep.path.length > maxPathLen) maxPathLen = ep.path.length;
+  }
+  const pathPad = Math.max(maxPathLen + 2, 20);
+
+  const lines = [];
+  let first = true;
+  for (const [tag, eps] of groups) {
+    if (!first) lines.push('');
+    first = false;
+    lines.push(`[${tag}]`);
+    for (const ep of eps) {
+      // Pad the raw method to 8 chars for alignment, accounting for ANSI codes
+      const methodStr = colorMethod(ep.method);
+      const rawLen = ep.method.length;
+      const padded = methodStr + ' '.repeat(Math.max(0, 8 - rawLen));
+      const summary = ep.summary || '';
+      lines.push(`  ${padded}${ep.path.padEnd(pathPad)}${summary}`);
+    }
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Format a curl/HTTP response for terminal output.
+ * @param {object} response - Response object with status, statusText, headers, body, verbose
+ * @param {object} [options]
+ * @param {boolean} [options.verbose] - Show verbose output (like curl -v)
+ * @param {boolean} [options.headers] - Show status line + headers + body
+ * @returns {string} Formatted response output
+ */
+export function formatResponse(response, options = {}) {
+  if (options.verbose) {
+    // Full verbose output
+    const parts = [];
+    if (response.verbose) {
+      parts.push(response.verbose);
+    }
+    if (response.body) {
+      parts.push(response.body);
+    }
+    return parts.join('\n');
+  }
+
+  if (options.headers) {
+    // Status line + headers + body
+    const parts = [];
+    const httpVersion = response.http_version || response.httpVersion || '1.1';
+    const statusText = response.status_text || response.statusText || '';
+    parts.push(`HTTP/${httpVersion} ${response.status} ${statusText}`);
+    if (response.headers) {
+      for (const [name, value] of Object.entries(response.headers)) {
+        parts.push(`${name}: ${value}`);
+      }
+    }
+    parts.push('');
+    if (response.body) {
+      parts.push(response.body);
+    }
+    return parts.join('\n');
+  }
+
+  // Default: body only
+  return response.body || '';
+}

package/cli/resolve-project.js

@@ -0,0 +1,43 @@
+// cli/resolve-project.js — Shared project context resolution for all CLI commands
+//
+// Resolution order (per spec):
+//   1. If --project or --spec is passed, use that
+//   2. If cwd is inside a bookmarked project, use it
+//   3. If cwd contains an OpenAPI spec file, use it directly
+//   4. Otherwise, return null specPath
+
+import { discoverSpec } from '../core/spec-discovery.js';
+import { findProjectForDir } from '../core/projects-store.js';
+
+/**
+ * Resolve the project directory and spec path from CLI args.
+ * @param {object} argv - Parsed CLI arguments (may have .project, .spec)
+ * @returns {Promise<{ projectDir: string, specPath: string|null }>}
+ */
+export async function resolveProjectContext(argv) {
+  // 1. Explicit flags take priority
+  if (argv.spec) {
+    return { projectDir: argv.project || process.cwd(), specPath: argv.spec };
+  }
+  if (argv.project) {
+    const discovered = await discoverSpec(argv.project);
+    return { projectDir: argv.project, specPath: discovered?.specPath || null };
+  }
+
+  // 2. Check if cwd is inside a bookmarked project
+  const cwd = process.cwd();
+  const bookmark = findProjectForDir(cwd);
+  if (bookmark) {
+    const specPath = bookmark.spec || (await discoverSpec(bookmark.path))?.specPath || null;
+    return { projectDir: bookmark.path, specPath };
+  }
+
+  // 3. Try spec discovery in cwd
+  const discovered = await discoverSpec(cwd);
+  if (discovered?.specPath) {
+    return { projectDir: cwd, specPath: discovered.specPath };
+  }
+
+  // 4. Nothing found
+  return { projectDir: cwd, specPath: null };
+}