@snokam/mcp-api 0.5.1 → 0.7.0

package/dist/index.js

@@ -12,9 +12,86 @@ import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSche
 import { fetchSpecs } from "./openapi-loader.js";
 import { getAccessToken } from "./auth.js";
 // ---------------------------------------------------------------------------
-// Config
+// State
 // ---------------------------------------------------------------------------
-const ENVIRONMENT = process.env.SNOKAM_ENVIRONMENT ?? "production";
+let currentEnvironment = process.env.SNOKAM_ENVIRONMENT ?? "production";
+let endpoints = [];
+let endpointsByTool = new Map();
+const serviceUrlOverrides = new Map();
+async function loadEndpoints(environment) {
+    currentEnvironment = environment;
+    endpoints = await fetchSpecs(environment);
+    endpointsByTool = new Map();
+    for (const ep of endpoints) {
+        endpointsByTool.set(ep.toolName, ep);
+    }
+    // Re-apply any active URL overrides
+    applyUrlOverrides();
+}
+function applyUrlOverrides() {
+    for (const ep of endpoints) {
+        const override = serviceUrlOverrides.get(ep.service);
+        if (override) {
+            ep.baseUrl = override;
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Built-in tool: SwitchEnvironment
+// ---------------------------------------------------------------------------
+const SWITCH_TOOL_NAME = "SwitchEnvironment";
+const VALID_ENVIRONMENTS = ["production", "test"];
+const switchToolDef = {
+    name: SWITCH_TOOL_NAME,
+    description: "Switch the Snokam MCP server between environments (production/test). Reloads all API specs for the new environment.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            environment: {
+                type: "string",
+                enum: VALID_ENVIRONMENTS,
+                description: "The environment to switch to",
+            },
+        },
+        required: ["environment"],
+    },
+};
+// ---------------------------------------------------------------------------
+// Built-in tool: SetServiceUrl
+// ---------------------------------------------------------------------------
+const SET_URL_TOOL_NAME = "SetServiceUrl";
+const RESET_URL_TOOL_NAME = "ResetServiceUrl";
+const setUrlToolDef = {
+    name: SET_URL_TOOL_NAME,
+    description: "Override a service's base URL, e.g. to point to a locally running function. Auth is skipped for localhost URLs. Use ResetServiceUrl to revert.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            service: {
+                type: "string",
+                description: "The service name (e.g. employees, notifications, events)",
+            },
+            url: {
+                type: "string",
+                description: "The base URL to use (e.g. http://localhost:7071)",
+            },
+        },
+        required: ["service", "url"],
+    },
+};
+const resetUrlToolDef = {
+    name: RESET_URL_TOOL_NAME,
+    description: "Reset a service's base URL back to the environment default. Call without arguments to reset all overrides.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            service: {
+                type: "string",
+                description: "The service name to reset. Omit to reset all overrides.",
+            },
+        },
+    },
+};
 // ---------------------------------------------------------------------------
 // JSON Schema builder for tool inputs
 // ---------------------------------------------------------------------------
@@ -84,9 +161,12 @@ async function executeCall(endpoint, args) {
     const headers = {
         Accept: "application/json",
     };
-    const token = await getAccessToken(endpoint.scope);
-    if (token) {
-        headers.Authorization = `Bearer ${token}`;
+    const isLocal = url.startsWith("http://localhost") || url.startsWith("http://127.0.0.1");
+    if (!isLocal) {
+        const token = await getAccessToken(endpoint.scope);
+        if (token) {
+            headers.Authorization = `Bearer ${token}`;
+        }
     }
     let fetchBody;
     if (args.body !== undefined && endpoint.method !== "GET") {
@@ -112,17 +192,13 @@ async function executeCall(endpoint, args) {
 // Server setup
 // ---------------------------------------------------------------------------
 async function main() {
-    const endpoints = await fetchSpecs(ENVIRONMENT);
+    await loadEndpoints(currentEnvironment);
     if (endpoints.length === 0) {
         console.error("[snokam-mcp] No endpoints loaded. Ensure specs/*.json files exist.");
     }
-    const endpointsByTool = new Map();
-    for (const ep of endpoints) {
-        endpointsByTool.set(ep.toolName, ep);
-    }
     const server = new Server({
         name: "snokam",
-        version: "0.2.0",
+        version: "0.3.0",
     }, {
         capabilities: {
             tools: {},
@@ -170,7 +246,7 @@ async function main() {
 
 ## Environment
 
-Currently connected to: **${ENVIRONMENT}**
+Currently connected to: **${currentEnvironment}**
 
 ## Available Services
 
@@ -218,15 +294,106 @@ Controls: Sonos speakers, lights, YouTube queue
     });
     // List tools
     server.setRequestHandler(ListToolsRequestSchema, async () => ({
-        tools: endpoints.map((ep) => ({
-            name: ep.toolName,
-            description: ep.description || ep.summary || `${ep.method} ${ep.path}`,
-            inputSchema: buildInputSchema(ep),
-        })),
+        tools: [
+            switchToolDef,
+            setUrlToolDef,
+            resetUrlToolDef,
+            ...endpoints.map((ep) => ({
+                name: ep.toolName,
+                description: ep.description || ep.summary || `${ep.method} ${ep.path}`,
+                inputSchema: buildInputSchema(ep),
+            })),
+        ],
     }));
     // Call tool
     server.setRequestHandler(CallToolRequestSchema, async (request) => {
         const { name, arguments: args = {} } = request.params;
+        // Handle SwitchEnvironment
+        if (name === SWITCH_TOOL_NAME) {
+            const env = String(args.environment ?? "");
+            if (!VALID_ENVIRONMENTS.includes(env)) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Invalid environment: ${env}. Must be one of: ${VALID_ENVIRONMENTS.join(", ")}`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            if (env === currentEnvironment) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Already connected to ${env} (${endpoints.length} endpoints)`,
+                        },
+                    ],
+                };
+            }
+            await loadEndpoints(env);
+            // Notify client that the tool list has changed
+            await server.sendToolListChanged();
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Switched to ${env} environment. Loaded ${endpoints.length} endpoints.`,
+                    },
+                ],
+            };
+        }
+        // Handle SetServiceUrl
+        if (name === SET_URL_TOOL_NAME) {
+            const service = String(args.service ?? "");
+            const url = String(args.url ?? "");
+            const serviceEndpoints = endpoints.filter((ep) => ep.service === service);
+            if (serviceEndpoints.length === 0) {
+                const available = [
+                    ...new Set(endpoints.map((ep) => ep.service)),
+                ].sort();
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Unknown service: ${service}. Available: ${available.join(", ")}`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            serviceUrlOverrides.set(service, url);
+            for (const ep of serviceEndpoints) {
+                ep.baseUrl = url;
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Overrode ${service} → ${url} (${serviceEndpoints.length} endpoints). Auth ${url.startsWith("http://localhost") || url.startsWith("http://127.0.0.1") ? "skipped" : "active"}.`,
+                    },
+                ],
+            };
+        }
+        // Handle ResetServiceUrl
+        if (name === RESET_URL_TOOL_NAME) {
+            const service = args.service ? String(args.service) : undefined;
+            if (service) {
+                serviceUrlOverrides.delete(service);
+            }
+            else {
+                serviceUrlOverrides.clear();
+            }
+            // Reload to restore original URLs
+            await loadEndpoints(currentEnvironment);
+            const msg = service
+                ? `Reset ${service} to environment default`
+                : `Reset all service URL overrides`;
+            return {
+                content: [{ type: "text", text: msg }],
+            };
+        }
         const endpoint = endpointsByTool.get(name);
         if (!endpoint) {
             return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snokam/mcp-api",
-  "version": "0.5.1",
+  "version": "0.7.0",
   "description": "MCP server exposing Snokam backend APIs as tools for Claude Code and other MCP clients",
   "type": "module",
   "bin": {