@epilot/cli 0.1.0

package/dist/chunk-57PPARIW.js

@@ -0,0 +1,715 @@
+#!/usr/bin/env node
+import {
+  resolveToken
+} from "./chunk-5WUPDZ5D.js";
+import {
+  getResolvedProfile
+} from "./chunk-IST42ZNL.js";
+import {
+  isInteractive,
+  pickOperation,
+  printOperationsTable,
+  promptParam
+} from "./chunk-RC3GCXCI.js";
+import {
+  BOLD,
+  DIM,
+  GREEN,
+  RED,
+  RESET,
+  YELLOW,
+  isValidJson,
+  methodColor,
+  parseKeyValue,
+  parseParamValue
+} from "./chunk-TKZLQD2B.js";
+
+// src/lib/call.ts
+import OpenAPIClientAxiosModule from "openapi-client-axios";
+
+// src/lib/definition-loader.ts
+import { existsSync, readFileSync } from "fs";
+import { resolve, join, dirname } from "path";
+import { fileURLToPath } from "url";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+var loadDefinition = async (apiName, definitionOverride) => {
+  if (definitionOverride) {
+    if (definitionOverride.startsWith("http://") || definitionOverride.startsWith("https://")) {
+      const res = await fetch(definitionOverride);
+      if (!res.ok) {
+        throw new Error(`Failed to fetch definition from ${definitionOverride}: ${res.status} ${res.statusText}`);
+      }
+      return await res.json();
+    }
+    const absPath = resolve(definitionOverride);
+    if (!existsSync(absPath)) {
+      throw new Error(`Definition file not found: ${absPath}`);
+    }
+    return JSON.parse(readFileSync(absPath, "utf-8"));
+  }
+  const overridePath = join(process.cwd(), ".epilot", "overrides", `${apiName}.json`);
+  if (existsSync(overridePath)) {
+    return JSON.parse(readFileSync(overridePath, "utf-8"));
+  }
+  const searchPaths = [
+    // Built dist: dist/bin/epilot.js -> dist/definitions/
+    resolve(__dirname, "..", "definitions", `${apiName}.json`),
+    // Built dist (deeper): dist/lib/ -> dist/definitions/
+    resolve(__dirname, "..", "..", "definitions", `${apiName}.json`),
+    // Dev mode with tsx: src/lib/ -> definitions/
+    resolve(__dirname, "..", "..", "..", "definitions", `${apiName}.json`),
+    // Dev mode: packages/cli/definitions/
+    resolve(__dirname, "..", "..", "definitions", `${apiName}.json`)
+  ];
+  for (const path of searchPaths) {
+    if (existsSync(path)) {
+      return JSON.parse(readFileSync(path, "utf-8"));
+    }
+  }
+  throw new Error(
+    `No OpenAPI definition found for "${apiName}". Use --definition <file|url> to provide one, or place it at .epilot/overrides/${apiName}.json`
+  );
+};
+
+// src/lib/param-collector.ts
+var getOperationParams = (spec, operationId) => {
+  for (const [_path, methods] of Object.entries(spec.paths ?? {})) {
+    if (!methods) continue;
+    const pathParams = methods.parameters || [];
+    for (const method of ["get", "post", "put", "patch", "delete", "head", "options"]) {
+      const op = methods[method];
+      if (!op || op.operationId !== operationId) continue;
+      const opParams = op.parameters || [];
+      const merged = [...pathParams.filter((p) => p.name)];
+      for (const p of opParams) {
+        if (!p.name) continue;
+        const idx = merged.findIndex((pp) => pp.name === p.name && pp.in === p.in);
+        if (idx >= 0) merged[idx] = p;
+        else merged.push(p);
+      }
+      return merged;
+    }
+  }
+  return [];
+};
+var collectParams = (params, paramFlags, positionalArgs) => {
+  const result = {};
+  const pathParams = params.filter((p) => p.in === "path");
+  for (let i = 0; i < positionalArgs.length && i < pathParams.length; i++) {
+    result[pathParams[i].name] = parseParamValue(positionalArgs[i]);
+  }
+  if (paramFlags) {
+    const flags = Array.isArray(paramFlags) ? paramFlags : [paramFlags];
+    for (const flag of flags) {
+      const [key, value] = parseKeyValue(flag);
+      result[key] = parseParamValue(value);
+    }
+  }
+  return result;
+};
+var getMissingRequired = (params, collected) => {
+  return params.filter((p) => p.required && !(p.name in collected)).map((p) => `${p.name} (${p.in})`);
+};
+
+// src/lib/body-handler.ts
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync, unlinkSync } from "fs";
+import { homedir } from "os";
+import { join as join2 } from "path";
+var resolveBody = async (opts) => {
+  const { dataFlag, hasRequestBody, isRequired, interactive, defaultTemplate, cacheKey } = opts;
+  if (dataFlag) {
+    if (!isValidJson(dataFlag)) {
+      throw new Error("Invalid JSON in -d flag. Provide valid JSON data.");
+    }
+    return JSON.parse(dataFlag);
+  }
+  if (!process.stdin.isTTY) {
+    const input = await readStdin();
+    if (input.trim()) {
+      if (!isValidJson(input)) {
+        throw new Error("Invalid JSON from stdin. Provide valid JSON data.");
+      }
+      return JSON.parse(input);
+    }
+  }
+  if (hasRequestBody && interactive && process.stdin.isTTY) {
+    const cached = cacheKey ? loadPayloadCache(cacheKey) : void 0;
+    let editorDefault = cached ?? (defaultTemplate ? JSON.stringify(defaultTemplate, null, 2) : "{\n  \n}");
+    const { editor } = await import("@inquirer/prompts");
+    const MAX_RETRIES = 3;
+    for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+      const result = await editor({
+        message: attempt === 0 ? "Edit request body (JSON):" : "Fix JSON and save (or empty to cancel):",
+        default: editorDefault,
+        waitForUserInput: false
+      });
+      const trimmed = result.trim();
+      if (!trimmed) {
+        if (cacheKey) clearPayloadCache(cacheKey);
+        if (isRequired) {
+          throw new Error("Request body is required but editor returned empty content.");
+        }
+        return null;
+      }
+      if (isValidJson(trimmed)) {
+        if (cacheKey) savePayloadCache(cacheKey, trimmed);
+        return JSON.parse(trimmed);
+      }
+      const parseError = getJsonParseError(trimmed);
+      process.stderr.write(`\x1B[31mInvalid JSON: ${parseError}\x1B[0m
+`);
+      editorDefault = trimmed;
+    }
+    throw new Error("Invalid JSON from editor after multiple attempts.");
+  }
+  if (hasRequestBody && isRequired) {
+    throw new Error(
+      `This operation requires a request body. Provide data with -d '{"key":"value"}' or pipe via stdin.`
+    );
+  }
+  return null;
+};
+var getRequestBodyInfo = (spec, operationId) => {
+  const paths = spec.paths ?? {};
+  for (const methods of Object.values(paths)) {
+    for (const method of ["get", "post", "put", "patch", "delete", "head", "options"]) {
+      const op = methods[method];
+      if (!op || op.operationId !== operationId) continue;
+      const reqBody = op.requestBody;
+      if (!reqBody) return { hasBody: false, isRequired: false };
+      return {
+        hasBody: true,
+        isRequired: !!reqBody.required
+      };
+    }
+  }
+  return { hasBody: false, isRequired: false };
+};
+var getPayloadCacheDir = () => {
+  const xdgConfig = process.env.XDG_CONFIG_HOME;
+  const base = xdgConfig || join2(homedir(), ".config");
+  return join2(base, "epilot", "cache");
+};
+var getPayloadCachePath = (cacheKey) => {
+  return join2(getPayloadCacheDir(), `${cacheKey.replace(/\//g, "_")}.json`);
+};
+var loadPayloadCache = (cacheKey) => {
+  const path = getPayloadCachePath(cacheKey);
+  if (!existsSync2(path)) return void 0;
+  try {
+    return readFileSync2(path, "utf-8");
+  } catch {
+    return void 0;
+  }
+};
+var savePayloadCache = (cacheKey, payload) => {
+  const dir = getPayloadCacheDir();
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(getPayloadCachePath(cacheKey), payload, "utf-8");
+};
+var clearPayloadCache = (cacheKey) => {
+  const path = getPayloadCachePath(cacheKey);
+  if (existsSync2(path)) {
+    try {
+      unlinkSync(path);
+    } catch {
+    }
+  }
+};
+var getJsonParseError = (str) => {
+  try {
+    JSON.parse(str);
+    return "unknown error";
+  } catch (e) {
+    return e instanceof Error ? e.message : String(e);
+  }
+};
+var readStdin = () => {
+  return new Promise((resolve2) => {
+    let data = "";
+    process.stdin.setEncoding("utf-8");
+    const timeout = setTimeout(() => {
+      process.stdin.removeAllListeners("data");
+      process.stdin.removeAllListeners("end");
+      resolve2(data);
+    }, 100);
+    process.stdin.on("data", (chunk) => {
+      data += chunk;
+    });
+    process.stdin.on("end", () => {
+      clearTimeout(timeout);
+      resolve2(data);
+    });
+    if (process.stdin.readableEnded) {
+      clearTimeout(timeout);
+      resolve2(data);
+    }
+  });
+};
+
+// src/lib/response-formatter.ts
+var formatResponse = async (response, options) => {
+  const { json, include, verbose, jsonata } = options;
+  if (verbose) {
+    const req = response.config;
+    process.stderr.write(`${DIM}${req.method?.toUpperCase()} ${req.url}${RESET}
+`);
+    if (req.headers) {
+      for (const [key, value] of Object.entries(req.headers)) {
+        if (typeof value === "string" && key.toLowerCase() !== "authorization") {
+          process.stderr.write(`${DIM}> ${key}: ${value}${RESET}
+`);
+        } else if (key.toLowerCase() === "authorization") {
+          process.stderr.write(`${DIM}> ${key}: Bearer ***${RESET}
+`);
+        }
+      }
+    }
+    process.stderr.write("\n");
+  }
+  if (!json && process.stdout.isTTY && process.stderr.isTTY) {
+    const statusColor = response.status >= 200 && response.status < 300 ? GREEN : response.status >= 400 ? RED : YELLOW;
+    process.stderr.write(
+      `${statusColor}${BOLD}${response.status}${RESET} ${statusColor}${response.statusText}${RESET}
+`
+    );
+  }
+  if (include) {
+    process.stderr.write(`${DIM}HTTP/${response.status} ${response.statusText}${RESET}
+`);
+    for (const [key, value] of Object.entries(response.headers)) {
+      process.stderr.write(`${DIM}${key}: ${value}${RESET}
+`);
+    }
+    process.stderr.write("\n");
+  }
+  let data = response.data;
+  if (jsonata && data) {
+    try {
+      const jsonataModule = await import("jsonata");
+      const expression = jsonataModule.default(jsonata);
+      data = await expression.evaluate(data);
+    } catch (err) {
+      process.stderr.write(`${RED}JSONata error: ${err instanceof Error ? err.message : String(err)}${RESET}
+`);
+      process.exit(1);
+    }
+  }
+  if (data !== void 0 && data !== null) {
+    if (typeof data === "string") {
+      process.stdout.write(data + "\n");
+    } else {
+      const indent = json ? 0 : 2;
+      process.stdout.write(JSON.stringify(data, null, indent) + "\n");
+    }
+  }
+};
+
+// src/lib/call.ts
+import { mock } from "mock-json-schema";
+import dereferenceJsonSchema from "dereference-json-schema";
+var OpenAPIClientAxios = OpenAPIClientAxiosModule.default ?? OpenAPIClientAxiosModule;
+var extractOperations = (spec) => {
+  const operations = [];
+  for (const [path, methods] of Object.entries(spec.paths ?? {})) {
+    if (!methods) continue;
+    for (const method of ["get", "post", "put", "patch", "delete", "head", "options"]) {
+      const op = methods[method];
+      if (!op?.operationId) continue;
+      operations.push({
+        operationId: op.operationId,
+        method: method.toUpperCase(),
+        path,
+        summary: ((op.description || "").split("\n")[0] || "").substring(0, 120)
+      });
+    }
+  }
+  return operations;
+};
+var sampleParamValue = (p) => {
+  const schema = p.schema;
+  if (p.example !== void 0) return String(p.example);
+  if (schema?.example !== void 0) return String(schema.example);
+  if (schema?.type === "boolean") return "true";
+  if (schema?.type === "integer" || schema?.type === "number") return "1";
+  if (p.name === "id" || p.name.endsWith("_id") || p.name.endsWith("Id"))
+    return "123e4567-e89b-12d3-a456-426614174000";
+  if (p.name === "slug") return "contact";
+  if (p.name === "email") return "user@example.com";
+  return "example";
+};
+var MAX_BODY_LINES = 30;
+var truncateJson = (obj, depth = 0, maxDepth = 3) => {
+  if (obj === null || obj === void 0) return obj;
+  if (typeof obj !== "object") return obj;
+  if (depth >= maxDepth) return Array.isArray(obj) ? [] : {};
+  if (Array.isArray(obj)) {
+    return obj.slice(0, 2).map((item) => truncateJson(item, depth + 1, maxDepth));
+  }
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    result[key] = truncateJson(value, depth + 1, maxDepth);
+  }
+  return result;
+};
+var mockFromSchema = (schema) => {
+  return mock(schema);
+};
+var { dereferenceSync } = dereferenceJsonSchema;
+var w = (text) => process.stdout.write(text);
+var getBodySchema = (spec, operationId) => {
+  const paths = spec.paths ?? {};
+  for (const methods of Object.values(paths)) {
+    if (!methods) continue;
+    for (const method of ["get", "post", "put", "patch", "delete", "head", "options"]) {
+      const op = methods[method];
+      if (!op || op.operationId !== operationId) continue;
+      const reqBody = op.requestBody;
+      if (!reqBody) return void 0;
+      const content = reqBody.content?.["application/json"];
+      return content?.schema;
+    }
+  }
+  return void 0;
+};
+var printOperationHelp = (apiName, operationId, spec) => {
+  for (const [path, methods] of Object.entries(spec.paths ?? {})) {
+    if (!methods) continue;
+    for (const method of ["get", "post", "put", "patch", "delete", "head", "options"]) {
+      const op = methods[method];
+      if (!op || op.operationId !== operationId) continue;
+      const color = methodColor(method);
+      const descFirstLine = (op.description || "").split("\n")[0].trim();
+      w(`
+${BOLD}epilot ${apiName} ${operationId}${RESET}`);
+      if (descFirstLine) w(` \u2014 ${descFirstLine}`);
+      w(`
+
+`);
+      w(`  ${color}${method.toUpperCase()}${RESET} ${path}
+`);
+      w(`
+`);
+      if (op.description) {
+        const restOfDesc = op.description.split("\n").slice(1).join("\n").trim();
+        if (restOfDesc) w(`  ${DIM}${restOfDesc}${RESET}
+
+`);
+      }
+      const params = getOperationParams(spec, operationId);
+      if (params.length > 0) {
+        w(`${BOLD}PARAMETERS${RESET}
+
+`);
+        const nameWidth = Math.max(...params.map((p) => p.name.length), 4) + 2;
+        for (const p of params) {
+          const schema = p.schema;
+          const type = schema?.type || "";
+          const format = schema?.format ? ` (${schema.format})` : "";
+          const req = p.required ? `${YELLOW}required${RESET}` : `${DIM}optional${RESET}`;
+          const desc = p.description ? `  ${DIM}${p.description}${RESET}` : "";
+          w(`  ${BOLD}${p.name.padEnd(nameWidth)}${RESET} ${p.in.padEnd(6)}  ${type}${format}  ${req}${desc}
+`);
+        }
+        w(`
+`);
+      }
+      const reqBody = op.requestBody;
+      if (reqBody) {
+        w(`${BOLD}REQUEST BODY${RESET}${reqBody.required ? ` ${YELLOW}(required)${RESET}` : ""}
+`);
+        if (reqBody.description) w(`  ${DIM}${reqBody.description}${RESET}
+`);
+        const content = reqBody.content?.["application/json"];
+        const bodySchema = content?.schema;
+        if (bodySchema) {
+          try {
+            const mockBody = truncateJson(mockFromSchema(bodySchema));
+            const bodyStr = JSON.stringify(mockBody, null, 2);
+            const lines = bodyStr.split("\n");
+            w(`
+`);
+            if (lines.length <= MAX_BODY_LINES) {
+              for (const line of lines) w(`  ${DIM}${line}${RESET}
+`);
+            } else {
+              for (const line of lines.slice(0, MAX_BODY_LINES)) w(`  ${DIM}${line}${RESET}
+`);
+              w(`  ${DIM}  ...${RESET}
+`);
+            }
+          } catch {
+          }
+        }
+        w(`
+`);
+      }
+      w(`${BOLD}EXAMPLES${RESET}
+
+`);
+      const reqParams = params.filter((p) => p.required || p.in === "path");
+      const pathParams = params.filter((p) => p.in === "path");
+      const pFlags = reqParams.map((p) => `-p ${p.name}=${sampleParamValue(p)}`);
+      {
+        const parts = [`  ${GREEN}$${RESET} epilot ${apiName} ${operationId}`];
+        for (const pf of pFlags) parts.push(pf);
+        w(parts.join(" \\\n      ") + "\n");
+      }
+      w(`
+`);
+      if (pathParams.length > 0) {
+        const positionalVals = pathParams.map((p) => sampleParamValue(p));
+        w(`  ${DIM}# positional args for path parameters${RESET}
+`);
+        w(`  ${GREEN}$${RESET} epilot ${apiName} ${operationId} ${positionalVals.join(" ")}
+`);
+        w(`
+`);
+      }
+      if (reqBody) {
+        const content = reqBody.content?.["application/json"];
+        const bodySchema = content?.schema;
+        if (bodySchema) {
+          try {
+            const mockBody = truncateJson(mockFromSchema(bodySchema));
+            const compact = JSON.stringify(mockBody);
+            if (compact.length <= 80) {
+              w(`  ${DIM}# with request body${RESET}
+`);
+              w(`  ${GREEN}$${RESET} epilot ${apiName} ${operationId}`);
+              if (pFlags.length > 0) w(` ${pFlags.join(" ")}`);
+              w(` -d '${compact}'
+`);
+            } else {
+              const pretty = JSON.stringify(mockBody, null, 2);
+              w(`  ${DIM}# with request body${RESET}
+`);
+              const parts = [`  ${GREEN}$${RESET} epilot ${apiName} ${operationId}`];
+              if (pFlags.length > 0) for (const pf of pFlags) parts.push(pf);
+              parts.push(`-d '${pretty}'`);
+              w(parts.join(" \\\n      ") + "\n");
+            }
+            w(`
+`);
+          } catch {
+          }
+        }
+        const pFlagsStr = pFlags.length > 0 ? " " + pFlags.join(" ") : "";
+        w(`  ${DIM}# pipe from file${RESET}
+`);
+        w(`  ${GREEN}$${RESET} cat body.json | epilot ${apiName} ${operationId}${pFlagsStr}
+`);
+        w(`
+`);
+      }
+      {
+        const pFlagsStr = pFlags.length > 0 ? " " + pFlags.join(" ") : "";
+        const jsonataExpr = guessJsonataExpr(op);
+        w(`  ${DIM}# filter response with JSONata${RESET}
+`);
+        w(`  ${GREEN}$${RESET} epilot ${apiName} ${operationId}${pFlagsStr} --jsonata '${jsonataExpr}'
+`);
+        w(`
+`);
+      }
+      {
+        const pFlagsStr = pFlags.length > 0 ? " " + pFlags.join(" ") : "";
+        w(`  ${DIM}# raw JSON for scripting${RESET}
+`);
+        w(`  ${GREEN}$${RESET} epilot ${apiName} ${operationId}${pFlagsStr} --json
+`);
+        w(`
+`);
+      }
+      const successResp = op.responses?.["200"] || op.responses?.["201"];
+      if (successResp) {
+        const respContent = successResp.content?.["application/json"];
+        const respSchema = respContent?.schema;
+        if (respSchema) {
+          try {
+            const mockResp = truncateJson(mockFromSchema(respSchema));
+            const respStr = JSON.stringify(mockResp, null, 2);
+            const lines = respStr.split("\n");
+            w(`${BOLD}SAMPLE RESPONSE${RESET}
+
+`);
+            const limit = 40;
+            const shown = lines.length <= limit ? lines : lines.slice(0, limit);
+            for (const line of shown) w(`  ${DIM}${line}${RESET}
+`);
+            if (lines.length > limit) w(`  ${DIM}  ... (${lines.length - limit} more lines)${RESET}
+`);
+            w(`
+`);
+          } catch {
+          }
+        }
+      }
+      return;
+    }
+  }
+  process.stderr.write(`${RED}Operation "${operationId}" not found.${RESET}
+`);
+  process.exit(1);
+};
+var guessJsonataExpr = (op) => {
+  const successResp = op.responses?.["200"] || op.responses?.["201"];
+  if (!successResp) return "$";
+  const respContent = successResp.content?.["application/json"];
+  const schema = respContent?.schema;
+  if (!schema?.properties) return "$";
+  const props = schema.properties;
+  if (props.results) return "results[0]";
+  if (props.data) return "data";
+  if (props.items) return "items[0]";
+  if (props.hits) return "hits";
+  if (props.entity) return "entity._title";
+  if (props.id) return "id";
+  if (props.email) return "email";
+  const keys = Object.keys(props);
+  return keys.length > 0 ? keys[0] : "$";
+};
+var callApi = async (apiName, args) => {
+  const rawSpec = await loadDefinition(apiName, args.definition);
+  const spec = dereferenceSync(rawSpec);
+  const operations = extractOperations(spec);
+  if (!args.operation) {
+    process.stdout.write(`
+${BOLD}epilot ${apiName}${RESET} - ${spec.info?.title || apiName}
+
+`);
+    process.stdout.write(`${BOLD}Available operations:${RESET}
+
+`);
+    if (isInteractive({ interactive: args.interactive })) {
+      const operationId2 = await pickOperation(operations);
+      return callApi(apiName, { ...args, operation: operationId2 });
+    }
+    printOperationsTable(apiName, operations);
+    return;
+  }
+  const operationId = args.operation;
+  if (args.help) {
+    printOperationHelp(apiName, operationId, spec);
+    return;
+  }
+  const opExists = operations.some((op) => op.operationId === operationId);
+  if (!opExists) {
+    process.stderr.write(`${RED}Unknown operation "${operationId}" for ${apiName}.${RESET}
+`);
+    process.stderr.write(`
+Available operations:
+`);
+    for (const op of operations) {
+      process.stderr.write(`  ${op.operationId}
+`);
+    }
+    process.exit(1);
+  }
+  let token = resolveToken(args.token, args.profile);
+  if (!token) {
+    if (isInteractive({ interactive: args.interactive })) {
+      const { promptToken } = await import("./interactive-46ICLQKL.js");
+      token = await promptToken();
+    }
+    if (!token) {
+      process.stderr.write(`${RED}No authentication token found.${RESET}
+`);
+      process.stderr.write(`Run 'epilot auth login' or pass --token <token>
+`);
+      process.exit(1);
+    }
+  }
+  const opParams = getOperationParams(spec, operationId);
+  const positionalArgs = args._args ?? [];
+  let collected = collectParams(opParams, args.param, positionalArgs);
+  const missing = getMissingRequired(opParams, collected);
+  if (missing.length > 0 && isInteractive({ interactive: args.interactive })) {
+    for (const param of opParams) {
+      if (param.required && !(param.name in collected)) {
+        const value = await promptParam(param.name, param);
+        if (value) collected[param.name] = value;
+      }
+    }
+  }
+  const stillMissing = getMissingRequired(opParams, collected);
+  if (stillMissing.length > 0) {
+    process.stderr.write(`${RED}Missing required parameters: ${stillMissing.join(", ")}${RESET}
+`);
+    process.exit(1);
+  }
+  const { hasBody, isRequired } = getRequestBodyInfo(spec, operationId);
+  let bodyTemplate;
+  if (hasBody && isInteractive({ interactive: args.interactive })) {
+    const bodySchema = getBodySchema(spec, operationId);
+    if (bodySchema) {
+      try {
+        bodyTemplate = mockFromSchema(bodySchema);
+      } catch {
+      }
+    }
+  }
+  const body = await resolveBody({
+    dataFlag: args.data,
+    hasRequestBody: hasBody,
+    isRequired,
+    interactive: isInteractive({ interactive: args.interactive }),
+    defaultTemplate: bodyTemplate,
+    cacheKey: `${apiName}/${operationId}`
+  });
+  const customHeaders = {};
+  if (args.header) {
+    const headers = Array.isArray(args.header) ? args.header : [args.header];
+    for (const h of headers) {
+      const idx = h.indexOf(":");
+      if (idx > 0) {
+        customHeaders[h.substring(0, idx).trim()] = h.substring(idx + 1).trim();
+      }
+    }
+  }
+  const serverOverride = args.server || getResolvedProfile(args.profile)?.server;
+  if (serverOverride) {
+    const specDoc = spec;
+    specDoc.servers = [{ url: serverOverride }];
+  }
+  const api = new OpenAPIClientAxios({
+    definition: spec,
+    quick: true
+  });
+  const client = await api.init();
+  client.defaults.headers.common.authorization = `Bearer ${token}`;
+  for (const [key, value] of Object.entries(customHeaders)) {
+    client.defaults.headers.common[key] = value;
+  }
+  const operationFn = client[operationId];
+  if (typeof operationFn !== "function") {
+    process.stderr.write(`${RED}Operation "${operationId}" not found on client.${RESET}
+`);
+    process.exit(1);
+  }
+  try {
+    const response = await operationFn(
+      Object.keys(collected).length > 0 ? collected : null,
+      body,
+      { validateStatus: () => true }
+    );
+    await formatResponse(response, {
+      json: args.json,
+      include: args.include,
+      verbose: args.verbose,
+      jsonata: args.jsonata
+    });
+    if (response.status >= 400) {
+      process.exit(1);
+    }
+  } catch (err) {
+    process.stderr.write(`${RED}Request failed: ${err instanceof Error ? err.message : String(err)}${RESET}
+`);
+    process.exit(1);
+  }
+};
+
+export {
+  callApi
+};