@cocaxcode/api-testing-mcp 0.5.7 → 0.7.0

package/README.md

@@ -351,11 +351,24 @@ curl -X POST \
 
 Save requests for reuse (with tags), manage variables across environments (dev/staging/prod), and switch contexts instantly.
 
+### Project-Scoped Environments
+
+Different projects can have different active environments. When you switch to an environment for a specific project, it only affects that project — other projects keep their own active environment.
+
+```
+"Switch to dev for this project"          → dev is active only in the current project
+"Switch to prod globally"                 → prod is the default for projects without a specific assignment
+"Show me which projects have environments" → lists all project-environment assignments
+"Clear the project environment for this project" → falls back to the global active environment
+```
+
+Resolution order: project-specific environment → global active environment.
+
 ---
 
 ## Tool Reference
 
-22 tools organized in 8 categories:
+27 tools organized in 8 categories:
 
 | Category | Tools | Count |
 |----------|-------|-------|
@@ -363,8 +376,8 @@ Save requests for reuse (with tags), manage variables across environments (dev/s
 | **Testing** | `assert` | 1 |
 | **Flows** | `flow_run` | 1 |
 | **Collections** | `collection_save` `collection_list` `collection_get` `collection_delete` | 4 |
-| **Environments** | `env_create` `env_list` `env_set` `env_get` `env_switch` `env_rename` `env_delete` | 7 |
-| **API Specs** | `api_import` `api_endpoints` `api_endpoint_detail` | 3 |
+| **Environments** | `env_create` `env_list` `env_set` `env_get` `env_switch` `env_rename` `env_delete` `env_spec` `env_project_clear` `env_project_list` | 10 |
+| **API Specs** | `api_import` `api_spec_list` `api_endpoints` `api_endpoint_detail` | 4 |
 | **Mock** | `mock` | 1 |
 | **Utilities** | `load_test` `export_curl` `diff_responses` `bulk_test` | 4 |
 
@@ -378,7 +391,8 @@ All data lives in `~/.api-testing/` (user home directory) as plain JSON — no d
 
 ```
 ~/.api-testing/
-├── active-env                     # Active environment name
+├── active-env                     # Global active environment name
+├── project-envs.json              # Per-project active environments
 ├── collections/                   # Saved requests
 ├── environments/                  # Environment variables (dev, prod, ...)
 └── specs/                         # Imported OpenAPI specs
@@ -412,7 +426,7 @@ Override the default directory in your MCP config:
 git clone https://github.com/cocaxcode/api-testing-mcp.git
 cd api-testing-mcp
 npm install
-npm test            # 77 tests across 10 suites
+npm test            # 83 tests across 10 suites
 npm run build       # ESM bundle via tsup
 npm run typecheck   # Strict TypeScript
 ```

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) {
@@ -80,7 +82,8 @@ var Storage = class {
       items.push({
         name: env.name,
         active: env.name === activeEnv,
-        variableCount: Object.keys(env.variables).length
+        variableCount: Object.keys(env.variables).length,
+        spec: env.spec
       });
     }
     return items;
@@ -95,7 +98,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;
@@ -103,13 +113,49 @@ 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);
+    if (!env) {
+      throw new Error(`Entorno '${envName}' no encontrado`);
+    }
+    env.spec = specName ?? void 0;
+    env.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const filePath = join(this.environmentsDir, `${this.sanitizeName(envName)}.json`);
+    await this.writeJson(filePath, env);
+  }
+  async getActiveSpec() {
+    const activeName = await this.getActiveEnvironment();
+    if (!activeName) return null;
+    const env = await this.getEnvironment(activeName);
+    return env?.spec ?? null;
   }
   async renameEnvironment(oldName, newName) {
     const env = await this.getEnvironment(oldName);
@@ -124,9 +170,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) {
@@ -135,13 +195,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.
@@ -590,7 +661,8 @@ function registerEnvironmentTools(server, storage) {
     "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")
+      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")')
     },
     async (params) => {
       try {
@@ -598,16 +670,18 @@ function registerEnvironmentTools(server, storage) {
         const env = {
           name: params.name,
           variables: params.variables ?? {},
+          spec: params.spec,
           createdAt: now,
           updatedAt: now
         };
         await storage.createEnvironment(env);
         const varCount = Object.keys(env.variables).length;
+        const specMsg = params.spec ? ` \u2014 spec: '${params.spec}'` : "";
         return {
           content: [
             {
               type: "text",
-              text: `Entorno '${params.name}' creado con ${varCount} variable(s)`
+              text: `Entorno '${params.name}' creado con ${varCount} variable(s)${specMsg}`
             }
           ]
         };
@@ -762,6 +836,41 @@ function registerEnvironmentTools(server, storage) {
       }
     }
   );
+  server.tool(
+    "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)")
+    },
+    async (params) => {
+      try {
+        const envName = params.environment ?? await storage.getActiveEnvironment();
+        if (!envName) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "No hay entorno activo. Usa env_switch para activar uno."
+              }
+            ],
+            isError: true
+          };
+        }
+        await storage.setEnvironmentSpec(envName, params.spec ?? null);
+        const message = params.spec ? `Spec '${params.spec}' asociado al entorno '${envName}'` : `Spec desasociado del entorno '${envName}'`;
+        return {
+          content: [{ type: "text", text: message }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
   server.tool(
     "env_rename",
     "Renombra un entorno existente. Si es el entorno activo, actualiza la referencia.",
@@ -817,18 +926,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: z3.string().describe("Nombre del entorno a activar")
+      name: z3.string().describe("Nombre del entorno a activar"),
+      project: z3.string().optional().describe("Ruta del proyecto (ej: C:/cocaxcode). Si se omite, cambia el entorno global")
     },
     async (params) => {
       try {
-        await storage.setActiveEnvironment(params.name);
+        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.",
+    {
+      project: z3.string().describe("Ruta del proyecto del que eliminar la asociaci\xF3n")
+    },
+    async (params) => {
+      try {
+        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
+              )
             }
           ]
         };
@@ -968,6 +1154,21 @@ function parseOpenApiSpec(doc, name, source) {
 
 // src/tools/api-spec.ts
 import { readFile as readFile2 } from "fs/promises";
+async function resolveSpecName(name, storage) {
+  if (name) return { name };
+  const activeSpec = await storage.getActiveSpec();
+  if (activeSpec) return { name: activeSpec };
+  const specs = await storage.listSpecs();
+  if (specs.length === 0) {
+    return { error: "No hay specs importados. Usa api_import para importar uno." };
+  }
+  if (specs.length === 1) {
+    return { name: specs[0].name };
+  }
+  return {
+    error: `Hay ${specs.length} specs importados. Especifica cu\xE1l usar: ${specs.map((s) => s.name).join(", ")}`
+  };
+}
 function registerApiSpecTools(server, storage) {
   server.tool(
     "api_import",
@@ -1030,6 +1231,10 @@ function registerApiSpecTools(server, storage) {
         }
         const spec = parseOpenApiSpec(rawDoc, params.name, params.source);
         await storage.saveSpec(spec);
+        const activeEnv = await storage.getActiveEnvironment();
+        if (activeEnv) {
+          await storage.setEnvironmentSpec(activeEnv, params.name);
+        }
         const tagCounts = {};
         for (const ep of spec.endpoints) {
           for (const tag of ep.tags ?? ["sin-tag"]) {
@@ -1052,6 +1257,7 @@ function registerApiSpecTools(server, storage) {
                 "Endpoints por tag:",
                 tagSummary,
                 "",
+                activeEnv ? `Asociado al entorno '${activeEnv}'.` : "",
                 "Usa api_endpoints para ver los endpoints disponibles.",
                 "Usa api_endpoint_detail para ver el detalle de un endpoint espec\xEDfico."
               ].join("\n")
@@ -1067,24 +1273,66 @@ function registerApiSpecTools(server, storage) {
       }
     }
   );
+  server.tool(
+    "api_spec_list",
+    "Lista todos los specs de API importados. \xDAsalo para descubrir qu\xE9 APIs est\xE1n disponibles.",
+    {},
+    async () => {
+      try {
+        const items = await storage.listSpecs();
+        if (items.length === 0) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "No hay specs importados. Usa api_import para importar uno."
+              }
+            ]
+          };
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(items, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
   server.tool(
     "api_endpoints",
-    "Lista los endpoints de un API importada. Filtra por tag, m\xE9todo o path.",
+    "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().describe("Nombre del API importada"),
+      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)')
     },
     async (params) => {
       try {
-        const spec = await storage.getSpec(params.name);
+        const resolved = await resolveSpecName(params.name, storage);
+        if (resolved.error) {
+          return {
+            content: [{ type: "text", text: resolved.error }],
+            isError: true
+          };
+        }
+        const resolvedName = resolved.name;
+        const spec = await storage.getSpec(resolvedName);
         if (!spec) {
           return {
             content: [
               {
                 type: "text",
-                text: `Error: API '${params.name}' no encontrada. Usa api_import para importarla primero.`
+                text: `Error: API '${resolvedName}' no encontrada. Usa api_import para importarla primero.`
               }
             ],
             isError: true
@@ -1145,19 +1393,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().describe("Nombre del API importada"),
+      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")')
     },
     async (params) => {
       try {
-        const spec = await storage.getSpec(params.name);
+        const resolved = await resolveSpecName(params.name, storage);
+        if (resolved.error) {
+          return {
+            content: [{ type: "text", text: resolved.error }],
+            isError: true
+          };
+        }
+        const resolvedName = resolved.name;
+        const spec = await storage.getSpec(resolvedName);
         if (!spec) {
           return {
             content: [
               {
                 type: "text",
-                text: `Error: API '${params.name}' no encontrada. Usa api_import para importarla primero.`
+                text: `Error: API '${resolvedName}' no encontrada. Usa api_import para importarla primero.`
               }
             ],
             isError: true
@@ -2232,7 +2488,7 @@ function registerLoadTestTool(server, storage) {
 }
 
 // src/server.ts
-var VERSION = "0.5.5";
+var VERSION = "0.7.0";
 function createServer(storageDir) {
   const server = new McpServer({
     name: "api-testing-mcp",