@cocaxcode/api-testing-mcp 0.8.3 → 0.10.0

package/dist/index.js

@@ -1860,6 +1860,8 @@ function registerFlowTool(server, storage) {
 
 // src/tools/utilities.ts
 import { z as z8 } from "zod";
+import { mkdir as mkdir2, readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
+import { join as join2 } from "path";
 function registerUtilityTools(server, storage) {
   server.tool(
     "export_curl",
@@ -2139,6 +2141,511 @@ ${curlCommand}`
       }
     }
   );
+  server.tool(
+    "export_postman_collection",
+    "Exporta los requests guardados como una Postman Collection v2.1 (JSON). Escribe el archivo en disco, importable directamente en Postman.",
+    {
+      name: z8.string().optional().describe('Nombre de la colecci\xF3n (default: "API Testing Collection")'),
+      tag: z8.string().optional().describe("Filtrar requests por tag"),
+      output_dir: z8.string().optional().describe("Directorio donde guardar el archivo (default: ./postman/)"),
+      resolve_variables: z8.boolean().optional().describe("Resolver {{variables}} del entorno activo (default: false)")
+    },
+    async (params) => {
+      try {
+        const collections = await storage.listCollections(params.tag);
+        if (collections.length === 0) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: params.tag ? `No hay requests guardados con tag '${params.tag}'.` : "No hay requests guardados en la colecci\xF3n."
+              }
+            ]
+          };
+        }
+        const resolveVars = params.resolve_variables ?? false;
+        const variables = resolveVars ? await storage.getActiveVariables() : {};
+        const savedRequests = [];
+        for (const item of collections) {
+          const saved = await storage.getCollection(item.name);
+          if (saved) savedRequests.push(saved);
+        }
+        const tagged = /* @__PURE__ */ new Map();
+        const untagged = [];
+        for (const saved of savedRequests) {
+          if (saved.tags && saved.tags.length > 0) {
+            const tag = saved.tags[0];
+            if (!tagged.has(tag)) tagged.set(tag, []);
+            tagged.get(tag).push(saved);
+          } else {
+            untagged.push(saved);
+          }
+        }
+        const items = [];
+        for (const [tag, requests] of tagged) {
+          items.push({
+            name: tag,
+            item: requests.map((r) => buildPostmanItem(r, variables, resolveVars))
+          });
+        }
+        for (const saved of untagged) {
+          items.push(buildPostmanItem(saved, variables, resolveVars));
+        }
+        const activeVars = await storage.getActiveVariables();
+        const collectionVars = Object.entries(activeVars).map(([key, value]) => ({
+          key,
+          value,
+          type: "string"
+        }));
+        const collectionName = params.name ?? "API Testing Collection";
+        const postmanCollection = {
+          info: {
+            name: collectionName,
+            schema: "https://schema.getpostman.com/json/collection/v2.1.0/collection.json"
+          },
+          item: items,
+          variable: collectionVars
+        };
+        const json = JSON.stringify(postmanCollection, null, 2);
+        const outputDir = params.output_dir ?? join2(process.cwd(), "postman");
+        await mkdir2(outputDir, { recursive: true });
+        const fileName = collectionName.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") + ".postman_collection.json";
+        const filePath = join2(outputDir, fileName);
+        await writeFile2(filePath, json, "utf-8");
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Postman Collection v2.1 exportada (${savedRequests.length} requests).
+
+Archivo: ${filePath}
+
+Importa este archivo en Postman: File \u2192 Import \u2192 selecciona el archivo.`
+            }
+          ]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "import_postman_collection",
+    "Importa una Postman Collection v2.1 (JSON) como requests guardados en la colecci\xF3n. Soporta folders, auth, headers, body y query params.",
+    {
+      file: z8.string().describe("Ruta al archivo .postman_collection.json exportado de Postman"),
+      tag: z8.string().optional().describe("Tag adicional para aplicar a todos los requests importados"),
+      overwrite: z8.boolean().optional().describe("Sobreescribir requests existentes con el mismo nombre (default: false)")
+    },
+    async (params) => {
+      try {
+        const raw = await readFile3(params.file, "utf-8");
+        const collection = JSON.parse(raw);
+        if (!collection.item || !Array.isArray(collection.item)) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: 'Error: El archivo no parece ser una Postman Collection v\xE1lida. Falta la propiedad "item".'
+              }
+            ],
+            isError: true
+          };
+        }
+        const overwrite = params.overwrite ?? false;
+        const extraTag = params.tag;
+        const flatItems = flattenPostmanItems(collection.item, collection.auth);
+        let imported = 0;
+        let skipped = 0;
+        const errors = [];
+        for (const item of flatItems) {
+          try {
+            const saved = parsePostmanItem(item, extraTag);
+            if (!saved) continue;
+            if (!overwrite) {
+              const existing = await storage.getCollection(saved.name);
+              if (existing) {
+                skipped++;
+                continue;
+              }
+            }
+            await storage.saveCollection(saved);
+            imported++;
+          } catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            errors.push(`${item.name ?? "unknown"}: ${msg}`);
+          }
+        }
+        const lines = [
+          `Postman Collection importada: ${imported} requests guardados.`
+        ];
+        if (skipped > 0) lines.push(`${skipped} requests omitidos (ya exist\xEDan, usa overwrite: true para sobreescribir).`);
+        if (errors.length > 0) {
+          lines.push(`${errors.length} errores:`);
+          for (const e of errors) lines.push(`  - ${e}`);
+        }
+        if (collection.info?.name) lines.push(`
+Colecci\xF3n: ${collection.info.name}`);
+        return {
+          content: [{ type: "text", text: lines.join("\n") }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "import_postman_environment",
+    "Importa un Postman Environment (JSON) como entorno local. Soporta variables con valores initial/current.",
+    {
+      file: z8.string().describe("Ruta al archivo .postman_environment.json exportado de Postman"),
+      name: z8.string().optional().describe("Nombre para el entorno (default: usa el nombre del archivo Postman)"),
+      overwrite: z8.boolean().optional().describe("Sobreescribir si ya existe un entorno con el mismo nombre (default: false)"),
+      activate: z8.boolean().optional().describe("Activar el entorno importado como entorno activo (default: false)")
+    },
+    async (params) => {
+      try {
+        const raw = await readFile3(params.file, "utf-8");
+        const postmanEnv = JSON.parse(raw);
+        if (!postmanEnv.values || !Array.isArray(postmanEnv.values)) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: 'Error: El archivo no parece ser un Postman Environment v\xE1lido. Falta la propiedad "values".'
+              }
+            ],
+            isError: true
+          };
+        }
+        const envName = params.name ?? postmanEnv.name ?? "postman-import";
+        const overwrite = params.overwrite ?? false;
+        const existing = await storage.getEnvironment(envName);
+        if (existing && !overwrite) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Error: Ya existe un entorno '${envName}'. Usa overwrite: true para sobreescribir.`
+              }
+            ],
+            isError: true
+          };
+        }
+        const variables = {};
+        for (const v of postmanEnv.values) {
+          if (!v.key) continue;
+          if (v.enabled === false) continue;
+          variables[v.key] = String(v.currentValue ?? v.value ?? "");
+        }
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        await storage.createEnvironment({
+          name: envName,
+          variables,
+          createdAt: now,
+          updatedAt: now
+        });
+        if (params.activate) {
+          await storage.setActiveEnvironment(envName);
+        }
+        const lines = [
+          `Postman Environment "${envName}" importado (${Object.keys(variables).length} variables).`
+        ];
+        if (params.activate) lines.push("Entorno activado como activo.");
+        return {
+          content: [{ type: "text", text: lines.join("\n") }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "export_postman_environment",
+    "Exporta un entorno como Postman Environment (JSON). Escribe el archivo en disco, importable directamente en Postman.",
+    {
+      name: z8.string().optional().describe("Nombre del entorno a exportar (default: entorno activo)"),
+      output_dir: z8.string().optional().describe("Directorio donde guardar el archivo (default: ./postman/)")
+    },
+    async (params) => {
+      try {
+        let envName = params.name;
+        if (!envName) {
+          envName = await storage.getActiveEnvironment() ?? void 0;
+          if (!envName) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: 'No hay entorno activo. Especifica un nombre con el par\xE1metro "name".'
+                }
+              ],
+              isError: true
+            };
+          }
+        }
+        const env = await storage.getEnvironment(envName);
+        if (!env) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Entorno '${envName}' no encontrado.`
+              }
+            ],
+            isError: true
+          };
+        }
+        const postmanEnv = {
+          name: env.name,
+          values: Object.entries(env.variables).map(([key, value]) => ({
+            key,
+            value,
+            type: "default",
+            enabled: true
+          })),
+          _postman_variable_scope: "environment"
+        };
+        const json = JSON.stringify(postmanEnv, null, 2);
+        const outputDir = params.output_dir ?? join2(process.cwd(), "postman");
+        await mkdir2(outputDir, { recursive: true });
+        const fileName = env.name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") + ".postman_environment.json";
+        const filePath = join2(outputDir, fileName);
+        await writeFile2(filePath, json, "utf-8");
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Postman Environment "${env.name}" exportado (${Object.keys(env.variables).length} variables).
+
+Archivo: ${filePath}
+
+Importa este archivo en Postman: File \u2192 Import \u2192 selecciona el archivo.`
+            }
+          ]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+function buildPostmanItem(saved, variables, resolveVars) {
+  let config = saved.request;
+  if (resolveVars) {
+    const resolvedUrl = resolveUrl(config.url, variables);
+    config = { ...config, url: resolvedUrl };
+    config = interpolateRequest(config, variables);
+  }
+  const item = {
+    name: saved.name,
+    request: buildPostmanRequest(config)
+  };
+  return item;
+}
+function buildPostmanRequest(config) {
+  const request = {
+    method: config.method,
+    header: buildPostmanHeaders(config.headers),
+    url: buildPostmanUrl(config.url, config.query)
+  };
+  if (config.body !== void 0 && config.body !== null) {
+    request.body = {
+      mode: "raw",
+      raw: typeof config.body === "string" ? config.body : JSON.stringify(config.body, null, 2),
+      options: { raw: { language: "json" } }
+    };
+    const headers = request.header;
+    if (!headers.some((h) => h.key.toLowerCase() === "content-type")) {
+      headers.push({ key: "Content-Type", value: "application/json" });
+    }
+  }
+  if (config.auth) {
+    request.auth = buildPostmanAuth(config.auth);
+  }
+  return request;
+}
+function buildPostmanHeaders(headers) {
+  if (!headers) return [];
+  return Object.entries(headers).map(([key, value]) => ({ key, value }));
+}
+function buildPostmanUrl(rawUrl, query) {
+  const url = { raw: rawUrl };
+  const match = rawUrl.match(/^(https?):\/\/([^/]+)(\/.*)?$/);
+  if (match) {
+    url.protocol = match[1];
+    url.host = match[2].split(".");
+    url.path = match[3] ? match[3].slice(1).split("/") : [];
+  }
+  if (query && Object.keys(query).length > 0) {
+    url.query = Object.entries(query).map(([key, value]) => ({ key, value }));
+    const queryStr = Object.entries(query).map(([k, v]) => `${k}=${v}`).join("&");
+    url.raw = rawUrl + (rawUrl.includes("?") ? "&" : "?") + queryStr;
+  }
+  return url;
+}
+function buildPostmanAuth(auth) {
+  switch (auth.type) {
+    case "bearer":
+      return {
+        type: "bearer",
+        bearer: [{ key: "token", value: auth.token ?? "", type: "string" }]
+      };
+    case "api-key":
+      return {
+        type: "apikey",
+        apikey: [
+          { key: "key", value: auth.key ?? "", type: "string" },
+          { key: "value", value: auth.header ?? "X-API-Key", type: "string" },
+          { key: "in", value: "header", type: "string" }
+        ]
+      };
+    case "basic":
+      return {
+        type: "basic",
+        basic: [
+          { key: "username", value: auth.username ?? "", type: "string" },
+          { key: "password", value: auth.password ?? "", type: "string" }
+        ]
+      };
+  }
+}
+function flattenPostmanItems(items, parentAuth, parentTags = []) {
+  const result = [];
+  for (const item of items) {
+    if (item.item && Array.isArray(item.item)) {
+      const folderTags = item.name ? [...parentTags, item.name] : parentTags;
+      const folderAuth = item.auth ?? parentAuth;
+      result.push(...flattenPostmanItems(item.item, folderAuth, folderTags));
+    } else if (item.request) {
+      result.push({
+        ...item,
+        _folderTags: parentTags,
+        _inheritedAuth: item.request?.auth ? void 0 : parentAuth
+      });
+    }
+  }
+  return result;
+}
+var VALID_METHODS2 = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]);
+function parsePostmanItem(item, extraTag) {
+  const req = item.request;
+  if (!req) return null;
+  const method = typeof req.method === "string" ? req.method.toUpperCase() : "GET";
+  if (!VALID_METHODS2.has(method)) return null;
+  const url = parsePostmanUrl(req.url);
+  if (!url) return null;
+  const headers = {};
+  if (Array.isArray(req.header)) {
+    for (const h of req.header) {
+      if (h.disabled) continue;
+      if (h.key && h.value !== void 0) {
+        headers[h.key] = String(h.value);
+      }
+    }
+  }
+  const query = {};
+  if (req.url && typeof req.url === "object" && Array.isArray(req.url.query)) {
+    for (const q of req.url.query) {
+      if (q.disabled) continue;
+      if (q.key) {
+        query[q.key] = String(q.value ?? "");
+      }
+    }
+  }
+  let body = void 0;
+  if (req.body) {
+    if (req.body.mode === "raw" && typeof req.body.raw === "string") {
+      try {
+        body = JSON.parse(req.body.raw);
+      } catch {
+        body = req.body.raw;
+      }
+    } else if (req.body.mode === "urlencoded" && Array.isArray(req.body.urlencoded)) {
+      const formData = {};
+      for (const p of req.body.urlencoded) {
+        if (p.key) formData[p.key] = String(p.value ?? "");
+      }
+      body = formData;
+    } else if (req.body.mode === "formdata" && Array.isArray(req.body.formdata)) {
+      const formData = {};
+      for (const p of req.body.formdata) {
+        if (p.key && p.type !== "file") formData[p.key] = String(p.value ?? "");
+      }
+      body = formData;
+    }
+  }
+  const authSource = req.auth ?? item._inheritedAuth;
+  const auth = parsePostmanAuth(authSource);
+  const tags = [...item._folderTags ?? []];
+  if (extraTag && !tags.includes(extraTag)) tags.push(extraTag);
+  const name = item.name || `${method} ${url}`;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const config = { method, url };
+  if (Object.keys(headers).length > 0) config.headers = headers;
+  if (Object.keys(query).length > 0) config.query = query;
+  if (body !== void 0) config.body = body;
+  if (auth) config.auth = auth;
+  return {
+    name,
+    request: config,
+    tags: tags.length > 0 ? tags : void 0,
+    createdAt: now,
+    updatedAt: now
+  };
+}
+function parsePostmanUrl(url) {
+  if (typeof url === "string") return url || null;
+  if (url && typeof url === "object") {
+    if (typeof url.raw === "string") return url.raw || null;
+    const protocol = url.protocol ?? "https";
+    const host = Array.isArray(url.host) ? url.host.join(".") : url.host;
+    const path = Array.isArray(url.path) ? url.path.join("/") : url.path ?? "";
+    if (host) return `${protocol}://${host}${path ? "/" + path : ""}`;
+  }
+  return null;
+}
+function parsePostmanAuth(auth) {
+  if (!auth || !auth.type) return void 0;
+  const getVal = (arr, key) => {
+    if (!Array.isArray(arr)) return void 0;
+    const item = arr.find((a) => a.key === key);
+    return item?.value ? String(item.value) : void 0;
+  };
+  switch (auth.type) {
+    case "bearer": {
+      const token = getVal(auth.bearer, "token");
+      return token ? { type: "bearer", token } : void 0;
+    }
+    case "apikey": {
+      const key = getVal(auth.apikey, "key");
+      const headerName = getVal(auth.apikey, "value");
+      return key ? { type: "api-key", key, header: headerName } : void 0;
+    }
+    case "basic": {
+      const username = getVal(auth.basic, "username");
+      const password = getVal(auth.basic, "password");
+      return username ? { type: "basic", username, password } : void 0;
+    }
+    default:
+      return void 0;
+  }
 }
 
 // src/tools/mock.ts
@@ -2450,7 +2957,7 @@ function registerLoadTestTool(server, storage) {
 }
 
 // src/server.ts
-var VERSION = "0.8.0";
+var VERSION = "0.10.0";
 function createServer(storageDir) {
   const server = new McpServer({
     name: "api-testing-mcp",