@cocaxcode/api-testing-mcp 0.6.0 → 0.8.0

package/dist/index.js

@@ -16,12 +16,14 @@ var Storage = class {
   environmentsDir;
   specsDir;
   activeEnvFile;
+  projectEnvsFile;
   constructor(baseDir) {
     this.baseDir = baseDir ?? process.env.API_TESTING_DIR ?? join(homedir(), ".api-testing");
     this.collectionsDir = join(this.baseDir, "collections");
     this.environmentsDir = join(this.baseDir, "environments");
     this.specsDir = join(this.baseDir, "specs");
     this.activeEnvFile = join(this.baseDir, "active-env");
+    this.projectEnvsFile = join(this.baseDir, "project-envs.json");
   }
   // ── Collections ──
   async saveCollection(saved) {
@@ -36,19 +38,19 @@ var Storage = class {
   async listCollections(tag) {
     await this.ensureDir("collections");
     const files = await this.listJsonFiles(this.collectionsDir);
-    const items = [];
-    for (const file of files) {
-      const saved = await this.readJson(join(this.collectionsDir, file));
-      if (!saved) continue;
-      if (tag && !(saved.tags ?? []).includes(tag)) continue;
-      items.push({
-        name: saved.name,
-        method: saved.request.method,
-        url: saved.request.url,
-        tags: saved.tags ?? []
-      });
-    }
-    return items;
+    const allSaved = await Promise.all(
+      files.map((file) => this.readJson(join(this.collectionsDir, file)))
+    );
+    return allSaved.filter((saved) => {
+      if (!saved) return false;
+      if (tag && !(saved.tags ?? []).includes(tag)) return false;
+      return true;
+    }).map((saved) => ({
+      name: saved.name,
+      method: saved.request.method,
+      url: saved.request.url,
+      tags: saved.tags ?? []
+    }));
   }
   async deleteCollection(name) {
     const filePath = join(this.collectionsDir, `${this.sanitizeName(name)}.json`);
@@ -73,18 +75,15 @@ var Storage = class {
     await this.ensureDir("environments");
     const files = await this.listJsonFiles(this.environmentsDir);
     const activeEnv = await this.getActiveEnvironment();
-    const items = [];
-    for (const file of files) {
-      const env = await this.readJson(join(this.environmentsDir, file));
-      if (!env) continue;
-      items.push({
-        name: env.name,
-        active: env.name === activeEnv,
-        variableCount: Object.keys(env.variables).length,
-        spec: env.spec
-      });
-    }
-    return items;
+    const allEnvs = await Promise.all(
+      files.map((file) => this.readJson(join(this.environmentsDir, file)))
+    );
+    return allEnvs.filter((env) => env !== null).map((env) => ({
+      name: env.name,
+      active: env.name === activeEnv,
+      variableCount: Object.keys(env.variables).length,
+      spec: env.spec
+    }));
   }
   async updateEnvironment(name, variables) {
     const env = await this.getEnvironment(name);
@@ -96,7 +95,14 @@ var Storage = class {
     const filePath = join(this.environmentsDir, `${this.sanitizeName(name)}.json`);
     await this.writeJson(filePath, env);
   }
-  async getActiveEnvironment() {
+  async getActiveEnvironment(project) {
+    const projectPath = project ?? process.cwd();
+    const projectEnvs = await this.getProjectEnvs();
+    const projectEnv = projectEnvs[projectPath];
+    if (projectEnv) {
+      const env = await this.getEnvironment(projectEnv);
+      if (env) return projectEnv;
+    }
     try {
       const content = await readFile(this.activeEnvFile, "utf-8");
       return content.trim() || null;
@@ -104,13 +110,33 @@ var Storage = class {
       return null;
     }
   }
-  async setActiveEnvironment(name) {
+  async setActiveEnvironment(name, project) {
     const env = await this.getEnvironment(name);
     if (!env) {
       throw new Error(`Entorno '${name}' no encontrado`);
     }
-    await this.ensureDir("");
-    await writeFile(this.activeEnvFile, name, "utf-8");
+    if (project) {
+      const projectEnvs = await this.getProjectEnvs();
+      projectEnvs[project] = name;
+      await this.ensureDir("");
+      await this.writeJson(this.projectEnvsFile, projectEnvs);
+    } else {
+      await this.ensureDir("");
+      await writeFile(this.activeEnvFile, name, "utf-8");
+    }
+  }
+  async clearProjectEnvironment(project) {
+    const projectEnvs = await this.getProjectEnvs();
+    if (!(project in projectEnvs)) return false;
+    delete projectEnvs[project];
+    await this.writeJson(this.projectEnvsFile, projectEnvs);
+    return true;
+  }
+  async listProjectEnvironments() {
+    return this.getProjectEnvs();
+  }
+  async getProjectEnvs() {
+    return await this.readJson(this.projectEnvsFile) ?? {};
   }
   async setEnvironmentSpec(envName, specName) {
     const env = await this.getEnvironment(envName);
@@ -141,9 +167,23 @@ var Storage = class {
     env.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
     await this.createEnvironment(env);
     await unlink(join(this.environmentsDir, `${this.sanitizeName(oldName)}.json`));
-    const activeEnv = await this.getActiveEnvironment();
-    if (activeEnv === oldName) {
-      await writeFile(this.activeEnvFile, newName, "utf-8");
+    try {
+      const globalActive = await readFile(this.activeEnvFile, "utf-8");
+      if (globalActive.trim() === oldName) {
+        await writeFile(this.activeEnvFile, newName, "utf-8");
+      }
+    } catch {
+    }
+    const projectEnvs = await this.getProjectEnvs();
+    let changed = false;
+    for (const [project, envName] of Object.entries(projectEnvs)) {
+      if (envName === oldName) {
+        projectEnvs[project] = newName;
+        changed = true;
+      }
+    }
+    if (changed) {
+      await this.writeJson(this.projectEnvsFile, projectEnvs);
     }
   }
   async deleteEnvironment(name) {
@@ -152,13 +192,24 @@ var Storage = class {
       throw new Error(`Entorno '${name}' no encontrado`);
     }
     await unlink(join(this.environmentsDir, `${this.sanitizeName(name)}.json`));
-    const activeEnv = await this.getActiveEnvironment();
-    if (activeEnv === name) {
-      try {
+    try {
+      const globalActive = await readFile(this.activeEnvFile, "utf-8");
+      if (globalActive.trim() === name) {
         await unlink(this.activeEnvFile);
-      } catch {
+      }
+    } catch {
+    }
+    const projectEnvs = await this.getProjectEnvs();
+    let changed = false;
+    for (const [project, envName] of Object.entries(projectEnvs)) {
+      if (envName === name) {
+        delete projectEnvs[project];
+        changed = true;
       }
     }
+    if (changed) {
+      await this.writeJson(this.projectEnvsFile, projectEnvs);
+    }
   }
   /**
    * Carga las variables del entorno activo.
@@ -183,18 +234,15 @@ var Storage = class {
   async listSpecs() {
     await this.ensureDir("specs");
     const files = await this.listJsonFiles(this.specsDir);
-    const items = [];
-    for (const file of files) {
-      const spec = await this.readJson(join(this.specsDir, file));
-      if (!spec) continue;
-      items.push({
-        name: spec.name,
-        source: spec.source,
-        endpointCount: spec.endpoints.length,
-        version: spec.version
-      });
-    }
-    return items;
+    const allSpecs = await Promise.all(
+      files.map((file) => this.readJson(join(this.specsDir, file)))
+    );
+    return allSpecs.filter((spec) => spec !== null).map((spec) => ({
+      name: spec.name,
+      source: spec.source,
+      endpointCount: spec.endpoints.length,
+      version: spec.version
+    }));
   }
   async deleteSpec(name) {
     const filePath = join(this.specsDir, `${this.sanitizeName(name)}.json`);
@@ -234,12 +282,16 @@ var Storage = class {
    * Reemplaza caracteres no alfanuméricos por guiones.
    */
   sanitizeName(name) {
-    return name.toLowerCase().replace(/[^a-z0-9_-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+    const sanitized = name.toLowerCase().replace(/[^a-z0-9_-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+    if (!sanitized) {
+      throw new Error(`Nombre inv\xE1lido: '${name}'`);
+    }
+    return sanitized;
   }
 };
 
 // src/tools/request.ts
-import { z } from "zod";
+import { z as z2 } from "zod";
 
 // src/lib/http-client.ts
 var DEFAULT_TIMEOUT = 3e4;
@@ -376,38 +428,56 @@ function interpolateRequest(config, variables) {
   };
 }
 
-// src/tools/request.ts
-var AuthSchema = {
+// src/lib/url.ts
+function resolveUrl(url, variables) {
+  if (url.startsWith("/") && variables.BASE_URL) {
+    const baseUrl = variables.BASE_URL.replace(/\/+$/, "");
+    return `${baseUrl}${url}`;
+  }
+  return url;
+}
+
+// src/lib/schemas.ts
+import { z } from "zod";
+var HttpMethodSchema = z.enum([
+  "GET",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE",
+  "HEAD",
+  "OPTIONS"
+]);
+var AuthSchema = z.object({
   type: z.enum(["bearer", "api-key", "basic"]).describe("Tipo de autenticaci\xF3n"),
   token: z.string().optional().describe("Token para Bearer auth"),
   key: z.string().optional().describe("API key value"),
   header: z.string().optional().describe("Header name para API key (default: X-API-Key)"),
   username: z.string().optional().describe("Username para Basic auth"),
   password: z.string().optional().describe("Password para Basic auth")
-};
+});
+var AuthSchemaShape = AuthSchema.shape;
+
+// src/tools/request.ts
 function registerRequestTool(server, storage) {
   server.tool(
     "request",
     "Ejecuta un HTTP request. URLs relativas (/path) usan BASE_URL del entorno activo. Soporta {{variables}}.",
     {
-      method: z.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]).describe("HTTP method"),
-      url: z.string().describe(
+      method: z2.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]).describe("HTTP method"),
+      url: z2.string().describe(
         "URL del endpoint. Si empieza con / se antepone BASE_URL del entorno activo. Soporta {{variables}}."
       ),
-      headers: z.record(z.string()).optional().describe("Headers HTTP como key-value pairs"),
-      body: z.any().optional().describe("Body del request (JSON). Soporta {{variables}}"),
-      query: z.record(z.string()).optional().describe("Query parameters como key-value pairs"),
-      timeout: z.number().optional().describe("Timeout en milisegundos (default: 30000)"),
-      auth: z.object(AuthSchema).optional().describe("Configuraci\xF3n de autenticaci\xF3n")
+      headers: z2.record(z2.string()).optional().describe("Headers HTTP como key-value pairs"),
+      body: z2.any().optional().describe("Body del request (JSON). Soporta {{variables}}"),
+      query: z2.record(z2.string()).optional().describe("Query parameters como key-value pairs"),
+      timeout: z2.number().optional().describe("Timeout en milisegundos (default: 30000)"),
+      auth: z2.object(AuthSchemaShape).optional().describe("Configuraci\xF3n de autenticaci\xF3n")
     },
     async (params) => {
       try {
         const variables = await storage.getActiveVariables();
-        let resolvedUrl = params.url;
-        if (resolvedUrl.startsWith("/") && variables.BASE_URL) {
-          const baseUrl = variables.BASE_URL.replace(/\/+$/, "");
-          resolvedUrl = `${baseUrl}${resolvedUrl}`;
-        }
+        const resolvedUrl = resolveUrl(params.url, variables);
         const config = {
           method: params.method,
           url: resolvedUrl,
@@ -439,30 +509,22 @@ function registerRequestTool(server, storage) {
 }
 
 // src/tools/collection.ts
-import { z as z2 } from "zod";
-var AuthSchema2 = {
-  type: z2.enum(["bearer", "api-key", "basic"]).describe("Tipo de autenticaci\xF3n"),
-  token: z2.string().optional().describe("Token para Bearer auth"),
-  key: z2.string().optional().describe("API key value"),
-  header: z2.string().optional().describe("Header name para API key (default: X-API-Key)"),
-  username: z2.string().optional().describe("Username para Basic auth"),
-  password: z2.string().optional().describe("Password para Basic auth")
-};
+import { z as z3 } from "zod";
 function registerCollectionTools(server, storage) {
   server.tool(
     "collection_save",
     "Guarda un request en la colecci\xF3n local. Si ya existe un request con el mismo nombre, lo sobreescribe.",
     {
-      name: z2.string().describe("Nombre \xFAnico del request guardado"),
-      request: z2.object({
-        method: z2.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]),
-        url: z2.string(),
-        headers: z2.record(z2.string()).optional(),
-        body: z2.any().optional(),
-        query: z2.record(z2.string()).optional(),
-        auth: z2.object(AuthSchema2).optional()
+      name: z3.string().describe("Nombre \xFAnico del request guardado"),
+      request: z3.object({
+        method: z3.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]),
+        url: z3.string(),
+        headers: z3.record(z3.string()).optional(),
+        body: z3.any().optional(),
+        query: z3.record(z3.string()).optional(),
+        auth: z3.object(AuthSchemaShape).optional()
       }).describe("Configuraci\xF3n del request a guardar"),
-      tags: z2.array(z2.string()).optional().describe('Tags para organizar (ej: ["auth", "users"])')
+      tags: z3.array(z3.string()).optional().describe('Tags para organizar (ej: ["auth", "users"])')
     },
     async (params) => {
       try {
@@ -497,7 +559,7 @@ function registerCollectionTools(server, storage) {
     "collection_list",
     "Lista todos los requests guardados en la colecci\xF3n. Opcionalmente filtra por tag.",
     {
-      tag: z2.string().optional().describe("Filtrar por tag")
+      tag: z3.string().optional().describe("Filtrar por tag")
     },
     async (params) => {
       try {
@@ -527,7 +589,7 @@ function registerCollectionTools(server, storage) {
     "collection_get",
     "Obtiene los detalles completos de un request guardado por su nombre.",
     {
-      name: z2.string().describe("Nombre del request guardado")
+      name: z3.string().describe("Nombre del request guardado")
     },
     async (params) => {
       try {
@@ -564,7 +626,7 @@ function registerCollectionTools(server, storage) {
     "collection_delete",
     "Elimina un request guardado de la colecci\xF3n.",
     {
-      name: z2.string().describe("Nombre del request a eliminar")
+      name: z3.string().describe("Nombre del request a eliminar")
     },
     async (params) => {
       try {
@@ -600,15 +662,15 @@ function registerCollectionTools(server, storage) {
 }
 
 // src/tools/environment.ts
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 function registerEnvironmentTools(server, storage) {
   server.tool(
     "env_create",
     "Crea un nuevo entorno (ej: dev, staging, prod) con variables opcionales.",
     {
-      name: z3.string().describe("Nombre del entorno (ej: dev, staging, prod)"),
-      variables: z3.record(z3.string()).optional().describe("Variables iniciales como key-value"),
-      spec: z3.string().optional().describe('Nombre del spec API asociado (ej: "cocaxcode-api")')
+      name: z4.string().describe("Nombre del entorno (ej: dev, staging, prod)"),
+      variables: z4.record(z4.string()).optional().describe("Variables iniciales como key-value"),
+      spec: z4.string().optional().describe('Nombre del spec API asociado (ej: "cocaxcode-api")')
     },
     async (params) => {
       try {
@@ -673,9 +735,9 @@ function registerEnvironmentTools(server, storage) {
     "env_set",
     "Establece una variable en un entorno. Si no se especifica entorno, usa el activo.",
     {
-      key: z3.string().describe("Nombre de la variable"),
-      value: z3.string().describe("Valor de la variable"),
-      environment: z3.string().optional().describe("Entorno destino (default: entorno activo)")
+      key: z4.string().describe("Nombre de la variable"),
+      value: z4.string().describe("Valor de la variable"),
+      environment: z4.string().optional().describe("Entorno destino (default: entorno activo)")
     },
     async (params) => {
       try {
@@ -713,8 +775,8 @@ function registerEnvironmentTools(server, storage) {
     "env_get",
     "Obtiene una variable espec\xEDfica o todas las variables de un entorno.",
     {
-      key: z3.string().optional().describe("Variable espec\xEDfica. Si se omite, retorna todas"),
-      environment: z3.string().optional().describe("Entorno a consultar (default: entorno activo)")
+      key: z4.string().optional().describe("Variable espec\xEDfica. Si se omite, retorna todas"),
+      environment: z4.string().optional().describe("Entorno a consultar (default: entorno activo)")
     },
     async (params) => {
       try {
@@ -786,8 +848,8 @@ function registerEnvironmentTools(server, storage) {
     "env_spec",
     "Asocia o desasocia un spec API a un entorno. Si no se especifica entorno, usa el activo.",
     {
-      spec: z3.string().optional().describe("Nombre del spec a asociar. Si se omite, desasocia el spec actual"),
-      environment: z3.string().optional().describe("Entorno destino (default: entorno activo)")
+      spec: z4.string().optional().describe("Nombre del spec a asociar. Si se omite, desasocia el spec actual"),
+      environment: z4.string().optional().describe("Entorno destino (default: entorno activo)")
     },
     async (params) => {
       try {
@@ -821,8 +883,8 @@ function registerEnvironmentTools(server, storage) {
     "env_rename",
     "Renombra un entorno existente. Si es el entorno activo, actualiza la referencia.",
     {
-      name: z3.string().describe("Nombre actual del entorno"),
-      new_name: z3.string().describe("Nuevo nombre para el entorno")
+      name: z4.string().describe("Nombre actual del entorno"),
+      new_name: z4.string().describe("Nuevo nombre para el entorno")
     },
     async (params) => {
       try {
@@ -848,7 +910,7 @@ function registerEnvironmentTools(server, storage) {
     "env_delete",
     "Elimina un entorno y todas sus variables. Si es el entorno activo, lo desactiva.",
     {
-      name: z3.string().describe("Nombre del entorno a eliminar")
+      name: z4.string().describe("Nombre del entorno a eliminar")
     },
     async (params) => {
       try {
@@ -872,18 +934,95 @@ function registerEnvironmentTools(server, storage) {
   );
   server.tool(
     "env_switch",
-    "Cambia el entorno activo. Las variables del entorno activo se usan en {{interpolaci\xF3n}}.",
+    "Cambia el entorno activo. Si se especifica project, solo aplica a ese directorio de proyecto.",
+    {
+      name: z4.string().describe("Nombre del entorno a activar"),
+      project: z4.string().optional().describe("Ruta del proyecto (ej: C:/cocaxcode). Si se omite, cambia el entorno global")
+    },
+    async (params) => {
+      try {
+        await storage.setActiveEnvironment(params.name, params.project);
+        const scope = params.project ? ` para proyecto '${params.project}'` : " (global)";
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Entorno activo cambiado a '${params.name}'${scope}`
+            }
+          ]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "env_project_clear",
+    "Elimina la asociaci\xF3n de entorno espec\xEDfico de un proyecto. El proyecto usar\xE1 el entorno global.",
     {
-      name: z3.string().describe("Nombre del entorno a activar")
+      project: z4.string().describe("Ruta del proyecto del que eliminar la asociaci\xF3n")
     },
     async (params) => {
       try {
-        await storage.setActiveEnvironment(params.name);
+        const removed = await storage.clearProjectEnvironment(params.project);
+        if (!removed) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `No hay entorno espec\xEDfico para el proyecto '${params.project}'`
+              }
+            ]
+          };
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Entorno espec\xEDfico eliminado para proyecto '${params.project}'. Usar\xE1 el entorno global.`
+            }
+          ]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "env_project_list",
+    "Lista todos los proyectos con entornos espec\xEDficos asignados.",
+    {},
+    async () => {
+      try {
+        const projectEnvs = await storage.listProjectEnvironments();
+        const entries = Object.entries(projectEnvs);
+        if (entries.length === 0) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "No hay entornos espec\xEDficos por proyecto. Todos usan el entorno global."
+              }
+            ]
+          };
+        }
         return {
           content: [
             {
               type: "text",
-              text: `Entorno activo cambiado a '${params.name}'`
+              text: JSON.stringify(
+                entries.map(([project, env]) => ({ project, environment: env })),
+                null,
+                2
+              )
             }
           ]
         };
@@ -899,7 +1038,7 @@ function registerEnvironmentTools(server, storage) {
 }
 
 // src/tools/api-spec.ts
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 
 // src/lib/openapi-parser.ts
 var VALID_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"];
@@ -925,6 +1064,35 @@ function resolveSchema(schema, root, depth = 0) {
     return { type: "object", description: `Unresolved: ${schema.$ref}` };
   }
   const result = { ...schema };
+  const rawAllOf = schema.allOf;
+  if (rawAllOf && Array.isArray(rawAllOf)) {
+    const merged = { type: "object" };
+    const mergedProps = {};
+    const mergedRequired = [];
+    for (const sub of rawAllOf) {
+      const resolved = resolveSchema(sub, root, depth + 1);
+      if (resolved?.properties) {
+        Object.assign(mergedProps, resolved.properties);
+      }
+      if (resolved?.required) {
+        mergedRequired.push(...resolved.required);
+      }
+      if (resolved?.description && !merged.description) {
+        merged.description = resolved.description;
+      }
+    }
+    merged.properties = { ...result.properties ?? {}, ...mergedProps };
+    if (mergedRequired.length > 0) {
+      merged.required = [.../* @__PURE__ */ new Set([...result.required ?? [], ...mergedRequired])];
+    }
+    return merged;
+  }
+  const rawOneOf = schema.oneOf;
+  const rawAnyOf = schema.anyOf;
+  const unionSchemas = rawOneOf ?? rawAnyOf;
+  if (unionSchemas && Array.isArray(unionSchemas) && unionSchemas.length > 0) {
+    return resolveSchema(unionSchemas[0], root, depth + 1);
+  }
   if (result.properties) {
     const resolvedProps = {};
     for (const [key, prop] of Object.entries(result.properties)) {
@@ -1043,8 +1211,8 @@ function registerApiSpecTools(server, storage) {
     "api_import",
     "Importa un spec OpenAPI/Swagger desde una URL o archivo local. Guarda los endpoints y schemas para consulta.",
     {
-      name: z4.string().describe('Nombre para identificar este API (ej: "mi-backend", "cocaxcode-api")'),
-      source: z4.string().describe(
+      name: z5.string().describe('Nombre para identificar este API (ej: "mi-backend", "cocaxcode-api")'),
+      source: z5.string().describe(
         "URL del spec OpenAPI JSON (ej: http://localhost:3001/api-docs-json) o ruta a archivo local"
       )
     },
@@ -1180,27 +1348,28 @@ function registerApiSpecTools(server, storage) {
     "api_endpoints",
     "Lista los endpoints de un API importada. Filtra por tag, m\xE9todo o path. Si no se especifica nombre y solo hay un spec importado, lo usa autom\xE1ticamente.",
     {
-      name: z4.string().optional().describe("Nombre del API importada. Si se omite y solo hay un spec, lo usa autom\xE1ticamente"),
-      tag: z4.string().optional().describe('Filtrar por tag (ej: "blog", "auth", "users")'),
-      method: z4.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]).optional().describe("Filtrar por m\xE9todo HTTP"),
-      path: z4.string().optional().describe('Filtrar por path (b\xFAsqueda parcial, ej: "/blog" muestra todos los que contienen /blog)')
+      name: z5.string().optional().describe("Nombre del API importada. Si se omite y solo hay un spec, lo usa autom\xE1ticamente"),
+      tag: z5.string().optional().describe('Filtrar por tag (ej: "blog", "auth", "users")'),
+      method: z5.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]).optional().describe("Filtrar por m\xE9todo HTTP"),
+      path: z5.string().optional().describe('Filtrar por path (b\xFAsqueda parcial, ej: "/blog" muestra todos los que contienen /blog)')
     },
     async (params) => {
       try {
-        const specName = await resolveSpecName(params.name, storage);
-        if (specName.error) {
+        const resolved = await resolveSpecName(params.name, storage);
+        if (resolved.error) {
           return {
-            content: [{ type: "text", text: specName.error }],
+            content: [{ type: "text", text: resolved.error }],
             isError: true
           };
         }
-        const spec = await storage.getSpec(specName.name);
+        const resolvedName = resolved.name;
+        const spec = await storage.getSpec(resolvedName);
         if (!spec) {
           return {
             content: [
               {
                 type: "text",
-                text: `Error: API '${specName.name}' no encontrada. Usa api_import para importarla primero.`
+                text: `Error: API '${resolvedName}' no encontrada. Usa api_import para importarla primero.`
               }
             ],
             isError: true
@@ -1261,26 +1430,27 @@ function registerApiSpecTools(server, storage) {
     "api_endpoint_detail",
     "Muestra el detalle completo de un endpoint: par\xE1metros, body schema, y respuestas. \xDAtil para saber qu\xE9 datos enviar.",
     {
-      name: z4.string().optional().describe("Nombre del API importada. Si se omite y solo hay un spec, lo usa autom\xE1ticamente"),
-      method: z4.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]).describe("M\xE9todo HTTP del endpoint"),
-      path: z4.string().describe('Path exacto del endpoint (ej: "/blog", "/auth/login")')
+      name: z5.string().optional().describe("Nombre del API importada. Si se omite y solo hay un spec, lo usa autom\xE1ticamente"),
+      method: z5.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]).describe("M\xE9todo HTTP del endpoint"),
+      path: z5.string().describe('Path exacto del endpoint (ej: "/blog", "/auth/login")')
     },
     async (params) => {
       try {
-        const specName = await resolveSpecName(params.name, storage);
-        if (specName.error) {
+        const resolved = await resolveSpecName(params.name, storage);
+        if (resolved.error) {
           return {
-            content: [{ type: "text", text: specName.error }],
+            content: [{ type: "text", text: resolved.error }],
             isError: true
           };
         }
-        const spec = await storage.getSpec(specName.name);
+        const resolvedName = resolved.name;
+        const spec = await storage.getSpec(resolvedName);
         if (!spec) {
           return {
             content: [
               {
                 type: "text",
-                text: `Error: API '${specName.name}' no encontrada. Usa api_import para importarla primero.`
+                text: `Error: API '${resolvedName}' no encontrada. Usa api_import para importarla primero.`
               }
             ],
             isError: true
@@ -1423,29 +1593,37 @@ function formatSchema(schema, depth = 0) {
 }
 
 // src/tools/assert.ts
-import { z as z5 } from "zod";
-var AssertionSchema = z5.object({
-  path: z5.string().describe(
-    'JSONPath al valor a validar: "status", "body.data.id", "headers.content-type", "timing.total_ms"'
-  ),
-  operator: z5.enum(["eq", "neq", "gt", "gte", "lt", "lte", "contains", "not_contains", "exists", "type"]).describe(
-    "Operador: eq (igual), neq (no igual), gt/gte/lt/lte (num\xE9ricos), contains/not_contains (strings/arrays), exists (campo existe), type (typeof)"
-  ),
-  expected: z5.any().optional().describe('Valor esperado (no necesario para "exists")')
-});
+import { z as z6 } from "zod";
+
+// src/lib/path.ts
 function getByPath(obj, path) {
   const parts = path.split(".");
   let current = obj;
   for (const part of parts) {
     if (current === null || current === void 0) return void 0;
     if (typeof current === "object") {
-      current = current[part];
+      if (Array.isArray(current) && /^\d+$/.test(part)) {
+        current = current[parseInt(part)];
+      } else {
+        current = current[part];
+      }
     } else {
       return void 0;
     }
   }
   return current;
 }
+
+// src/tools/assert.ts
+var AssertionSchema = z6.object({
+  path: z6.string().describe(
+    'JSONPath al valor a validar: "status", "body.data.id", "headers.content-type", "timing.total_ms"'
+  ),
+  operator: z6.enum(["eq", "neq", "gt", "gte", "lt", "lte", "contains", "not_contains", "exists", "type"]).describe(
+    "Operador: eq (igual), neq (no igual), gt/gte/lt/lte (num\xE9ricos), contains/not_contains (strings/arrays), exists (campo existe), type (typeof)"
+  ),
+  expected: z6.any().optional().describe('Valor esperado (no necesario para "exists")')
+});
 function evaluateAssertion(response, assertion) {
   const actual = getByPath(response, assertion.path);
   switch (assertion.operator) {
@@ -1522,29 +1700,18 @@ function registerAssertTool(server, storage) {
     "assert",
     "Ejecuta un request y valida la respuesta con assertions. Retorna resultado pass/fail por cada assertion.",
     {
-      method: z5.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]).describe("HTTP method"),
-      url: z5.string().describe("URL del endpoint (soporta /relativa y {{variables}})"),
-      headers: z5.record(z5.string()).optional().describe("Headers HTTP"),
-      body: z5.any().optional().describe("Body del request (JSON)"),
-      query: z5.record(z5.string()).optional().describe("Query parameters"),
-      auth: z5.object({
-        type: z5.enum(["bearer", "api-key", "basic"]),
-        token: z5.string().optional(),
-        key: z5.string().optional(),
-        header: z5.string().optional(),
-        username: z5.string().optional(),
-        password: z5.string().optional()
-      }).optional().describe("Autenticaci\xF3n"),
-      assertions: z5.array(AssertionSchema).describe("Lista de assertions a validar contra la respuesta")
+      method: z6.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]).describe("HTTP method"),
+      url: z6.string().describe("URL del endpoint (soporta /relativa y {{variables}})"),
+      headers: z6.record(z6.string()).optional().describe("Headers HTTP"),
+      body: z6.any().optional().describe("Body del request (JSON)"),
+      query: z6.record(z6.string()).optional().describe("Query parameters"),
+      auth: AuthSchema.optional().describe("Autenticaci\xF3n"),
+      assertions: z6.array(AssertionSchema).describe("Lista de assertions a validar contra la respuesta")
     },
     async (params) => {
       try {
         const variables = await storage.getActiveVariables();
-        let resolvedUrl = params.url;
-        if (resolvedUrl.startsWith("/") && variables.BASE_URL) {
-          const baseUrl = variables.BASE_URL.replace(/\/+$/, "");
-          resolvedUrl = `${baseUrl}${resolvedUrl}`;
-        }
+        const resolvedUrl = resolveUrl(params.url, variables);
         const config = {
           method: params.method,
           url: resolvedUrl,
@@ -1587,50 +1754,26 @@ function registerAssertTool(server, storage) {
 }
 
 // src/tools/flow.ts
-import { z as z6 } from "zod";
-var FlowStepSchema = z6.object({
-  name: z6.string().describe('Nombre del paso (ej: "login", "crear-post")'),
-  method: z6.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]).describe("HTTP method"),
-  url: z6.string().describe("URL del endpoint"),
-  headers: z6.record(z6.string()).optional().describe("Headers HTTP"),
-  body: z6.any().optional().describe("Body del request"),
-  query: z6.record(z6.string()).optional().describe("Query parameters"),
-  auth: z6.object({
-    type: z6.enum(["bearer", "api-key", "basic"]),
-    token: z6.string().optional(),
-    key: z6.string().optional(),
-    header: z6.string().optional(),
-    username: z6.string().optional(),
-    password: z6.string().optional()
-  }).optional().describe("Autenticaci\xF3n"),
-  extract: z6.record(z6.string()).optional().describe(
+import { z as z7 } from "zod";
+var FlowStepSchema = z7.object({
+  name: z7.string().describe('Nombre del paso (ej: "login", "crear-post")'),
+  method: z7.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]).describe("HTTP method"),
+  url: z7.string().describe("URL del endpoint"),
+  headers: z7.record(z7.string()).optional().describe("Headers HTTP"),
+  body: z7.any().optional().describe("Body del request"),
+  query: z7.record(z7.string()).optional().describe("Query parameters"),
+  auth: AuthSchema.optional().describe("Autenticaci\xF3n"),
+  extract: z7.record(z7.string()).optional().describe(
     'Variables a extraer de la respuesta para pasos siguientes. Key = nombre variable, value = path (ej: { "TOKEN": "body.token", "USER_ID": "body.data.id" })'
   )
 });
-function getByPath2(obj, path) {
-  const parts = path.split(".");
-  let current = obj;
-  for (const part of parts) {
-    if (current === null || current === void 0) return void 0;
-    if (typeof current === "object") {
-      if (Array.isArray(current) && /^\d+$/.test(part)) {
-        current = current[parseInt(part)];
-      } else {
-        current = current[part];
-      }
-    } else {
-      return void 0;
-    }
-  }
-  return current;
-}
 function registerFlowTool(server, storage) {
   server.tool(
     "flow_run",
     "Ejecuta una secuencia de requests en orden. Extrae variables de cada respuesta para usar en pasos siguientes con {{variable}}.",
     {
-      steps: z6.array(FlowStepSchema).describe("Pasos a ejecutar en orden"),
-      stop_on_error: z6.boolean().optional().describe("Detener al primer error (default: true)")
+      steps: z7.array(FlowStepSchema).describe("Pasos a ejecutar en orden"),
+      stop_on_error: z7.boolean().optional().describe("Detener al primer error (default: true)")
     },
     async (params) => {
       try {
@@ -1640,11 +1783,7 @@ function registerFlowTool(server, storage) {
         const results = [];
         for (const step of params.steps) {
           try {
-            let resolvedUrl = step.url;
-            if (resolvedUrl.startsWith("/") && flowVariables.BASE_URL) {
-              const baseUrl = flowVariables.BASE_URL.replace(/\/+$/, "");
-              resolvedUrl = `${baseUrl}${resolvedUrl}`;
-            }
+            const resolvedUrl = resolveUrl(step.url, flowVariables);
             const config = {
               method: step.method,
               url: resolvedUrl,
@@ -1658,7 +1797,7 @@ function registerFlowTool(server, storage) {
             const extracted = {};
             if (step.extract) {
               for (const [varName, path] of Object.entries(step.extract)) {
-                const value = getByPath2(response, path);
+                const value = getByPath(response, path);
                 if (value !== void 0 && value !== null) {
                   extracted[varName] = String(value);
                   flowVariables[varName] = String(value);
@@ -1719,14 +1858,14 @@ function registerFlowTool(server, storage) {
 }
 
 // src/tools/utilities.ts
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 function registerUtilityTools(server, storage) {
   server.tool(
     "export_curl",
     "Genera un comando cURL a partir de un request guardado en la colecci\xF3n. Listo para copiar y pegar.",
     {
-      name: z7.string().describe("Nombre del request guardado en la colecci\xF3n"),
-      resolve_variables: z7.boolean().optional().describe("Resolver {{variables}} del entorno activo (default: true)")
+      name: z8.string().describe("Nombre del request guardado en la colecci\xF3n"),
+      resolve_variables: z8.boolean().optional().describe("Resolver {{variables}} del entorno activo (default: true)")
     },
     async (params) => {
       try {
@@ -1746,11 +1885,7 @@ function registerUtilityTools(server, storage) {
         const resolveVars = params.resolve_variables ?? true;
         if (resolveVars) {
           const variables = await storage.getActiveVariables();
-          let resolvedUrl = config.url;
-          if (resolvedUrl.startsWith("/") && variables.BASE_URL) {
-            const baseUrl = variables.BASE_URL.replace(/\/+$/, "");
-            resolvedUrl = `${baseUrl}${resolvedUrl}`;
-          }
+          const resolvedUrl = resolveUrl(config.url, variables);
           config = { ...config, url: resolvedUrl };
           config = interpolateRequest(config, variables);
         }
@@ -1814,52 +1949,27 @@ ${curlCommand}`
       }
     }
   );
+  const DiffRequestSchema = z8.object({
+    label: z8.string().optional().describe('Etiqueta (ej: "antes", "dev", "v1")'),
+    method: z8.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]),
+    url: z8.string(),
+    headers: z8.record(z8.string()).optional(),
+    body: z8.any().optional(),
+    query: z8.record(z8.string()).optional(),
+    auth: AuthSchema.optional()
+  });
   server.tool(
     "diff_responses",
     "Ejecuta dos requests y compara sus respuestas. \xDAtil para detectar regresiones o comparar entornos.",
     {
-      request_a: z7.object({
-        label: z7.string().optional().describe('Etiqueta (ej: "antes", "dev", "v1")'),
-        method: z7.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]),
-        url: z7.string(),
-        headers: z7.record(z7.string()).optional(),
-        body: z7.any().optional(),
-        query: z7.record(z7.string()).optional(),
-        auth: z7.object({
-          type: z7.enum(["bearer", "api-key", "basic"]),
-          token: z7.string().optional(),
-          key: z7.string().optional(),
-          header: z7.string().optional(),
-          username: z7.string().optional(),
-          password: z7.string().optional()
-        }).optional()
-      }).describe("Primer request"),
-      request_b: z7.object({
-        label: z7.string().optional().describe('Etiqueta (ej: "despu\xE9s", "prod", "v2")'),
-        method: z7.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]),
-        url: z7.string(),
-        headers: z7.record(z7.string()).optional(),
-        body: z7.any().optional(),
-        query: z7.record(z7.string()).optional(),
-        auth: z7.object({
-          type: z7.enum(["bearer", "api-key", "basic"]),
-          token: z7.string().optional(),
-          key: z7.string().optional(),
-          header: z7.string().optional(),
-          username: z7.string().optional(),
-          password: z7.string().optional()
-        }).optional()
-      }).describe("Segundo request")
+      request_a: DiffRequestSchema.describe("Primer request"),
+      request_b: DiffRequestSchema.describe("Segundo request")
     },
     async (params) => {
       try {
         const variables = await storage.getActiveVariables();
         const executeOne = async (req) => {
-          let resolvedUrl = req.url;
-          if (resolvedUrl.startsWith("/") && variables.BASE_URL) {
-            const baseUrl = variables.BASE_URL.replace(/\/+$/, "");
-            resolvedUrl = `${baseUrl}${resolvedUrl}`;
-          }
+          const resolvedUrl = resolveUrl(req.url, variables);
           const config = {
             method: req.method,
             url: resolvedUrl,
@@ -1951,8 +2061,8 @@ ${curlCommand}`
     "bulk_test",
     "Ejecuta todos los requests guardados en la colecci\xF3n y reporta resultados. Filtrable por tag.",
     {
-      tag: z7.string().optional().describe("Filtrar por tag"),
-      expected_status: z7.number().optional().describe("Status HTTP esperado para todos (default: cualquier 2xx)")
+      tag: z8.string().optional().describe("Filtrar por tag"),
+      expected_status: z8.number().optional().describe("Status HTTP esperado para todos (default: cualquier 2xx)")
     },
     async (params) => {
       try {
@@ -1974,11 +2084,7 @@ ${curlCommand}`
           if (!saved) continue;
           try {
             let config = saved.request;
-            let resolvedUrl = config.url;
-            if (resolvedUrl.startsWith("/") && variables.BASE_URL) {
-              const baseUrl = variables.BASE_URL.replace(/\/+$/, "");
-              resolvedUrl = `${baseUrl}${resolvedUrl}`;
-            }
+            const resolvedUrl = resolveUrl(config.url, variables);
             config = { ...config, url: resolvedUrl };
             const interpolated = interpolateRequest(config, variables);
             const response = await executeRequest(interpolated);
@@ -2035,7 +2141,7 @@ ${curlCommand}`
 }
 
 // src/tools/mock.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 function generateMockData(schema, depth = 0) {
   if (depth > 8) return null;
   if (schema.example !== void 0) return schema.example;
@@ -2106,12 +2212,12 @@ function registerMockTool(server, storage) {
     "mock",
     "Genera datos mock/fake para un endpoint bas\xE1ndose en su spec OpenAPI importada. \xDAtil para frontend sin backend.",
     {
-      name: z8.string().describe("Nombre del API importada"),
-      method: z8.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]).describe("M\xE9todo HTTP del endpoint"),
-      path: z8.string().describe('Path del endpoint (ej: "/users", "/blog")'),
-      target: z8.enum(["request", "response"]).optional().describe("Generar mock del body de request o de la response (default: response)"),
-      status: z8.string().optional().describe('Status code de la respuesta a mockear (default: "200" o "201")'),
-      count: z8.number().optional().describe("N\xFAmero de items mock a generar si el schema es un array (default: 3)")
+      name: z9.string().describe("Nombre del API importada"),
+      method: z9.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]).describe("M\xE9todo HTTP del endpoint"),
+      path: z9.string().describe('Path del endpoint (ej: "/users", "/blog")'),
+      target: z9.enum(["request", "response"]).optional().describe("Generar mock del body de request o de la response (default: response)"),
+      status: z9.string().optional().describe('Status code de la respuesta a mockear (default: "200" o "201")'),
+      count: z9.number().optional().describe("N\xFAmero de items mock a generar si el schema es un array (default: 3)")
     },
     async (params) => {
       try {
@@ -2231,37 +2337,26 @@ function registerMockTool(server, storage) {
 }
 
 // src/tools/load-test.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 function registerLoadTestTool(server, storage) {
   server.tool(
     "load_test",
     "Lanza N requests concurrentes al mismo endpoint y mide tiempos promedio, percentiles y tasa de errores.",
     {
-      method: z9.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]).describe("HTTP method"),
-      url: z9.string().describe("URL del endpoint"),
-      headers: z9.record(z9.string()).optional().describe("Headers HTTP"),
-      body: z9.any().optional().describe("Body del request"),
-      query: z9.record(z9.string()).optional().describe("Query parameters"),
-      auth: z9.object({
-        type: z9.enum(["bearer", "api-key", "basic"]),
-        token: z9.string().optional(),
-        key: z9.string().optional(),
-        header: z9.string().optional(),
-        username: z9.string().optional(),
-        password: z9.string().optional()
-      }).optional().describe("Autenticaci\xF3n"),
-      concurrent: z9.number().describe("N\xFAmero de requests concurrentes a lanzar (max: 100)"),
-      timeout: z9.number().optional().describe("Timeout por request en ms (default: 30000)")
+      method: z10.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]).describe("HTTP method"),
+      url: z10.string().describe("URL del endpoint"),
+      headers: z10.record(z10.string()).optional().describe("Headers HTTP"),
+      body: z10.any().optional().describe("Body del request"),
+      query: z10.record(z10.string()).optional().describe("Query parameters"),
+      auth: AuthSchema.optional().describe("Autenticaci\xF3n"),
+      concurrent: z10.number().describe("N\xFAmero de requests concurrentes a lanzar (max: 100)"),
+      timeout: z10.number().optional().describe("Timeout por request en ms (default: 30000)")
     },
     async (params) => {
       try {
         const concurrentCount = Math.min(Math.max(params.concurrent, 1), 100);
         const variables = await storage.getActiveVariables();
-        let resolvedUrl = params.url;
-        if (resolvedUrl.startsWith("/") && variables.BASE_URL) {
-          const baseUrl = variables.BASE_URL.replace(/\/+$/, "");
-          resolvedUrl = `${baseUrl}${resolvedUrl}`;
-        }
+        const resolvedUrl = resolveUrl(params.url, variables);
         const baseConfig = {
           method: params.method,
           url: resolvedUrl,
@@ -2341,7 +2436,6 @@ function registerLoadTestTool(server, storage) {
         return {
           content: [{ type: "text", text: lines.join("\n") }],
           isError: failed.length > successful.length
-          // More than 50% failed
         };
       } catch (error) {
         const message = error instanceof Error ? error.message : String(error);
@@ -2355,7 +2449,7 @@ function registerLoadTestTool(server, storage) {
 }
 
 // src/server.ts
-var VERSION = "0.5.5";
+var VERSION = "0.8.0";
 function createServer(storageDir) {
   const server = new McpServer({
     name: "api-testing-mcp",