@snokam/mcp-api 0.130.0 → 0.131.1

package/dist/auth.d.ts

@@ -1,15 +1 @@
-/**
- * Token acquisition for Snokam backend APIs.
- *
- * Modes (auto-detected, in order):
- *
- * 1. **SNOKAM_ACCESS_TOKEN_FILE:** path to a bearer the host refreshes (every
- *    ~30 min via the VM managed identity). Read fresh per call so a rotated
- *    token is picked up without restarting. Preferred for egress-isolated
- *    containers that can't reach IMDS.
- * 2. **SNOKAM_ACCESS_TOKEN:** a pre-minted bearer injected directly.
- * 3. **DefaultAzureCredential:** Azure CLI (local dev) or managed identity (Azure).
- *
- * Endpoints without a scope get no Authorization header.
- */
 export declare function getAccessToken(scope: string | null): Promise<string | null>;

package/dist/auth.js

@@ -1,17 +1,3 @@
-/**
- * Token acquisition for Snokam backend APIs.
- *
- * Modes (auto-detected, in order):
- *
- * 1. **SNOKAM_ACCESS_TOKEN_FILE:** path to a bearer the host refreshes (every
- *    ~30 min via the VM managed identity). Read fresh per call so a rotated
- *    token is picked up without restarting. Preferred for egress-isolated
- *    containers that can't reach IMDS.
- * 2. **SNOKAM_ACCESS_TOKEN:** a pre-minted bearer injected directly.
- * 3. **DefaultAzureCredential:** Azure CLI (local dev) or managed identity (Azure).
- *
- * Endpoints without a scope get no Authorization header.
- */
 import { readFileSync } from "fs";
 import { DefaultAzureCredential } from "@azure/identity";
 let defaultCredential = null;
@@ -25,9 +11,7 @@ export async function getAccessToken(scope) {
             if (fromFile)
                 return fromFile;
         }
-        catch {
-            // fall through to the other modes
-        }
+        catch { }
     }
     const preMinted = process.env.SNOKAM_ACCESS_TOKEN;
     if (preMinted)

package/dist/builtin-tools.d.ts

@@ -0,0 +1,109 @@
+import type { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+export declare const SWITCH_TOOL_NAME = "SwitchEnvironment";
+export declare const VALID_ENVIRONMENTS: string[];
+export declare const switchToolDef: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            environment: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare const SET_URL_TOOL_NAME = "SetServiceUrl";
+export declare const RESET_URL_TOOL_NAME = "ResetServiceUrl";
+export declare const setUrlToolDef: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            service: {
+                type: string;
+                description: string;
+            };
+            url: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare const resetUrlToolDef: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            service: {
+                type: string;
+                description: string;
+            };
+        };
+    };
+};
+export declare const SWITCH_DOMAIN_TOOL_NAME = "SwitchDomain";
+export declare const switchDomainToolDef: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            domain: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare const BUILTIN_TOOL_DEFS: ({
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            environment: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            service: {
+                type: string;
+                description: string;
+            };
+        };
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            domain: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+})[];
+export declare const BUILTIN_TOOL_NAMES: Set<string>;
+export declare function handleBuiltinTool(server: Server, name: string, args: Record<string, unknown>): Promise<CallToolResult>;

package/dist/builtin-tools.js

@@ -0,0 +1,200 @@
+import { fetchSpecFromUrl } from "./openapi-loader.js";
+import { activeApiHost, apiHostOverride, currentEnvironment, endpoints, loadEndpoints, normalizeDomain, replaceServiceEndpoints, serviceUrlOverrides, setApiHostOverride, } from "./state.js";
+export const SWITCH_TOOL_NAME = "SwitchEnvironment";
+export const VALID_ENVIRONMENTS = ["production", "test"];
+export 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"],
+    },
+};
+export const SET_URL_TOOL_NAME = "SetServiceUrl";
+export const RESET_URL_TOOL_NAME = "ResetServiceUrl";
+export 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"],
+    },
+};
+export 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.",
+            },
+        },
+    },
+};
+export const SWITCH_DOMAIN_TOOL_NAME = "SwitchDomain";
+export const switchDomainToolDef = {
+    name: SWITCH_DOMAIN_TOOL_NAME,
+    description: "Point all Snokam API calls at a specific business's API host, so the same MCP can serve any tenant. Pass the business's API host (custom, e.g. acme.no, or its snosky fallback, e.g. acme.snosky.no); calls then go to {host}/api/{service}. Pass an empty string to reset to the environment default.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            domain: {
+                type: "string",
+                description: "The business's API host (e.g. acme.snosky.no). Empty string resets to the environment default.",
+            },
+        },
+        required: ["domain"],
+    },
+};
+export const BUILTIN_TOOL_DEFS = [
+    switchToolDef,
+    switchDomainToolDef,
+    setUrlToolDef,
+    resetUrlToolDef,
+];
+export const BUILTIN_TOOL_NAMES = new Set(BUILTIN_TOOL_DEFS.map((def) => def.name));
+export async function handleBuiltinTool(server, name, args) {
+    if (name === SWITCH_TOOL_NAME) {
+        return handleSwitchEnvironment(server, args);
+    }
+    if (name === SWITCH_DOMAIN_TOOL_NAME) {
+        return handleSwitchDomain(server, args);
+    }
+    if (name === SET_URL_TOOL_NAME) {
+        return handleSetServiceUrl(server, args);
+    }
+    return handleResetServiceUrl(args);
+}
+async function handleSwitchEnvironment(server, args) {
+    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);
+    await server.sendToolListChanged();
+    return {
+        content: [
+            {
+                type: "text",
+                text: `Switched to ${env} environment. Loaded ${endpoints.length} endpoints.`,
+            },
+        ],
+    };
+}
+async function handleSwitchDomain(server, args) {
+    setApiHostOverride(normalizeDomain(String(args.domain ?? "")) || null);
+    await loadEndpoints(currentEnvironment);
+    await server.sendToolListChanged();
+    return {
+        content: [
+            {
+                type: "text",
+                text: apiHostOverride
+                    ? `API calls now target ${apiHostOverride}/api/{service}.`
+                    : `API host reset to the environment default (${activeApiHost()}).`,
+            },
+        ],
+    };
+}
+async function handleSetServiceUrl(server, args) {
+    const service = String(args.service ?? "");
+    const url = String(args.url ?? "");
+    const isLocal = url.startsWith("http://localhost") || url.startsWith("http://127.0.0.1");
+    if (isLocal) {
+        try {
+            const liveEndpoints = await fetchSpecFromUrl(service, url);
+            replaceServiceEndpoints(service, liveEndpoints);
+            serviceUrlOverrides.set(service, url);
+            await server.sendToolListChanged();
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Overrode ${service} → ${url}. Loaded ${liveEndpoints.length} endpoints from local swagger.`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            console.error(`[snokam-mcp] Failed to fetch swagger from ${url}, falling back to static spec:`, error instanceof Error ? error.message : error);
+        }
+    }
+    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).`,
+            },
+        ],
+    };
+}
+async function handleResetServiceUrl(args) {
+    const service = args.service ? String(args.service) : undefined;
+    if (service) {
+        serviceUrlOverrides.delete(service);
+    }
+    else {
+        serviceUrlOverrides.clear();
+    }
+    await loadEndpoints(currentEnvironment);
+    const msg = service
+        ? `Reset ${service} to environment default`
+        : `Reset all service URL overrides`;
+    return {
+        content: [{ type: "text", text: msg }],
+    };
+}

package/dist/execute-call.d.ts

@@ -0,0 +1,5 @@
+import { type ApiEndpoint } from "./openapi-loader.js";
+export declare function executeCall(endpoint: ApiEndpoint, args: Record<string, unknown>): Promise<{
+    status: number;
+    body: unknown;
+}>;

package/dist/execute-call.js

@@ -0,0 +1,45 @@
+import { getAccessToken } from "./auth.js";
+export async function executeCall(endpoint, args) {
+    let url = `${endpoint.baseUrl}${endpoint.path}`;
+    const queryParams = [];
+    for (const param of endpoint.parameters) {
+        const value = args[param.name];
+        if (value === undefined)
+            continue;
+        if (param.in === "path") {
+            url = url.replace(`{${param.name}}`, encodeURIComponent(String(value)));
+        }
+        else if (param.in === "query") {
+            queryParams.push(`${encodeURIComponent(param.name)}=${encodeURIComponent(String(value))}`);
+        }
+    }
+    if (queryParams.length > 0) {
+        url += `?${queryParams.join("&")}`;
+    }
+    const headers = {
+        Accept: "application/json",
+    };
+    const token = await getAccessToken(endpoint.scope);
+    if (token) {
+        headers.Authorization = `Bearer ${token}`;
+    }
+    let fetchBody;
+    if (args.body !== undefined && endpoint.method !== "GET") {
+        headers["Content-Type"] = "application/json";
+        fetchBody = JSON.stringify(args.body);
+    }
+    const response = await fetch(url, {
+        method: endpoint.method,
+        headers,
+        body: fetchBody,
+    });
+    let body;
+    const contentType = response.headers.get("content-type") ?? "";
+    if (contentType.includes("application/json")) {
+        body = await response.json();
+    }
+    else {
+        body = await response.text();
+    }
+    return { status: response.status, body };
+}

package/dist/index.d.ts

@@ -1,9 +1,2 @@
 #!/usr/bin/env node
-/**
- * Snokam MCP Server
- *
- * Exposes Snokam backend APIs as MCP tools by reading bundled OpenAPI specs.
- * Auth: a pre-minted SNOKAM_ACCESS_TOKEN when present, else @azure/identity
- * (Azure CLI locally, managed identity in Azure).
- */
 export {};

package/dist/index.js

@@ -1,229 +1,11 @@
 #!/usr/bin/env node
-/**
- * Snokam MCP Server
- *
- * Exposes Snokam backend APIs as MCP tools by reading bundled OpenAPI specs.
- * Auth: a pre-minted SNOKAM_ACCESS_TOKEN when present, else @azure/identity
- * (Azure CLI locally, managed identity in Azure).
- */
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
-import { fetchSpecs, fetchSpecFromUrl, } from "./openapi-loader.js";
-import { getAccessToken } from "./auth.js";
-// ---------------------------------------------------------------------------
-// State
-// ---------------------------------------------------------------------------
-let currentEnvironment = process.env.SNOKAM_ENVIRONMENT ?? "production";
-let apiHostOverride = null;
-let endpoints = [];
-let endpointsByTool = new Map();
-const serviceUrlOverrides = new Map();
-// Backends are reached at {host}/api/{service} on the business's snosky host.
-// SNOKAM_API_HOST sets it explicitly (injected per-business), else it's derived
-// from SNOKAM_BUSINESS + env, and SwitchDomain overrides it at runtime.
-function resolveApiHost(environment) {
-    const explicit = process.env.SNOKAM_API_HOST;
-    if (explicit)
-        return normalizeDomain(explicit);
-    const suffix = environment === "test" ? "test.snosky.no" : "snosky.no";
-    const business = process.env.SNOKAM_BUSINESS;
-    return business ? `${business}.${suffix}` : suffix;
-}
-function activeApiHost() {
-    return apiHostOverride ?? resolveApiHost(currentEnvironment);
-}
-async function loadEndpoints(environment) {
-    currentEnvironment = environment;
-    endpoints = await fetchSpecs(environment, activeApiHost());
-    endpointsByTool = new Map();
-    for (const ep of endpoints) {
-        endpointsByTool.set(ep.toolName, ep);
-    }
-    // Layer per-service overrides (e.g. localhost) on top; most specific wins.
-    applyUrlOverrides();
-}
-function applyUrlOverrides() {
-    for (const ep of endpoints) {
-        const override = serviceUrlOverrides.get(ep.service);
-        if (override) {
-            ep.baseUrl = override;
-        }
-    }
-}
-function normalizeDomain(raw) {
-    return raw
-        .trim()
-        .replace(/^https?:\/\//, "")
-        .replace(/\/$/, "");
-}
-// ---------------------------------------------------------------------------
-// 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.",
-            },
-        },
-    },
-};
-const SWITCH_DOMAIN_TOOL_NAME = "SwitchDomain";
-const switchDomainToolDef = {
-    name: SWITCH_DOMAIN_TOOL_NAME,
-    description: "Point all Snokam API calls at a specific business's API host, so the same MCP can serve any tenant. Pass the business's API host (custom, e.g. acme.no, or its snosky fallback, e.g. acme.snosky.no); calls then go to {host}/api/{service}. Pass an empty string to reset to the environment default.",
-    inputSchema: {
-        type: "object",
-        properties: {
-            domain: {
-                type: "string",
-                description: "The business's API host (e.g. acme.snosky.no). Empty string resets to the environment default.",
-            },
-        },
-        required: ["domain"],
-    },
-};
-// ---------------------------------------------------------------------------
-// JSON Schema builder for tool inputs
-// ---------------------------------------------------------------------------
-function buildInputSchema(endpoint) {
-    const properties = {};
-    const required = [];
-    for (const param of endpoint.parameters) {
-        const prop = {};
-        if (param.schema?.type)
-            prop.type = param.schema.type;
-        if (param.schema?.enum)
-            prop.enum = param.schema.enum;
-        if (param.schema?.format)
-            prop.format = param.schema.format;
-        if (param.schema?.items)
-            prop.items = param.schema.items;
-        if (param.description)
-            prop.description = param.description;
-        if (!prop.type)
-            prop.type = "string";
-        properties[param.name] = prop;
-        if (param.required)
-            required.push(param.name);
-    }
-    if (endpoint.requestBody) {
-        properties.body = {
-            type: "object",
-            description: endpoint.requestBody.description ?? "Request body",
-        };
-        // Extract schema from content type if available
-        const jsonContent = endpoint.requestBody.content?.["application/json"];
-        if (jsonContent?.schema) {
-            properties.body = {
-                ...properties.body,
-                ...jsonContent.schema,
-            };
-        }
-        if (endpoint.requestBody.required)
-            required.push("body");
-    }
-    return {
-        type: "object",
-        properties,
-        required: required.length > 0 ? required : undefined,
-    };
-}
-// ---------------------------------------------------------------------------
-// HTTP call execution
-// ---------------------------------------------------------------------------
-async function executeCall(endpoint, args) {
-    let url = `${endpoint.baseUrl}${endpoint.path}`;
-    const queryParams = [];
-    for (const param of endpoint.parameters) {
-        const value = args[param.name];
-        if (value === undefined)
-            continue;
-        if (param.in === "path") {
-            url = url.replace(`{${param.name}}`, encodeURIComponent(String(value)));
-        }
-        else if (param.in === "query") {
-            queryParams.push(`${encodeURIComponent(param.name)}=${encodeURIComponent(String(value))}`);
-        }
-    }
-    if (queryParams.length > 0) {
-        url += `?${queryParams.join("&")}`;
-    }
-    const headers = {
-        Accept: "application/json",
-    };
-    const token = await getAccessToken(endpoint.scope);
-    if (token) {
-        headers.Authorization = `Bearer ${token}`;
-    }
-    let fetchBody;
-    if (args.body !== undefined && endpoint.method !== "GET") {
-        headers["Content-Type"] = "application/json";
-        fetchBody = JSON.stringify(args.body);
-    }
-    const response = await fetch(url, {
-        method: endpoint.method,
-        headers,
-        body: fetchBody,
-    });
-    let body;
-    const contentType = response.headers.get("content-type") ?? "";
-    if (contentType.includes("application/json")) {
-        body = await response.json();
-    }
-    else {
-        body = await response.text();
-    }
-    return { status: response.status, body };
-}
-// ---------------------------------------------------------------------------
-// Server setup
-// ---------------------------------------------------------------------------
+import { BUILTIN_TOOL_DEFS, BUILTIN_TOOL_NAMES, handleBuiltinTool, } from "./builtin-tools.js";
+import { executeCall } from "./execute-call.js";
+import { currentEnvironment, endpoints, endpointsByTool, loadEndpoints, } from "./state.js";
+import { buildInputSchema } from "./tool-schema.js";
 async function main() {
     await loadEndpoints(currentEnvironment);
     if (endpoints.length === 0) {
@@ -238,7 +20,6 @@ async function main() {
             resources: {},
         },
     });
-    // List resources
     server.setRequestHandler(ListResourcesRequestSchema, async () => ({
         resources: [
             {
@@ -249,11 +30,9 @@ async function main() {
             },
         ],
     }));
-    // Read resource
     server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
         const { uri } = request.params;
         if (uri === "snokam://about") {
-            // Group endpoints by service with their descriptions
             const serviceMap = new Map();
             for (const ep of endpoints) {
                 const existing = serviceMap.get(ep.service);
@@ -325,13 +104,9 @@ Controls: Sonos speakers, lights, YouTube queue
             isError: true,
         };
     });
-    // List tools
     server.setRequestHandler(ListToolsRequestSchema, async () => ({
         tools: [
-            switchToolDef,
-            switchDomainToolDef,
-            setUrlToolDef,
-            resetUrlToolDef,
+            ...BUILTIN_TOOL_DEFS,
             ...endpoints.map((ep) => ({
                 name: ep.toolName,
                 description: ep.description || ep.summary || `${ep.method} ${ep.path}`,
@@ -339,143 +114,10 @@ Controls: Sonos speakers, lights, YouTube queue
             })),
         ],
     }));
-    // 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 SwitchDomain
-        if (name === SWITCH_DOMAIN_TOOL_NAME) {
-            apiHostOverride = normalizeDomain(String(args.domain ?? "")) || null;
-            await loadEndpoints(currentEnvironment);
-            await server.sendToolListChanged();
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: apiHostOverride
-                            ? `API calls now target ${apiHostOverride}/api/{service}.`
-                            : `API host reset to the environment default (${activeApiHost()}).`,
-                    },
-                ],
-            };
-        }
-        // Handle SetServiceUrl
-        if (name === SET_URL_TOOL_NAME) {
-            const service = String(args.service ?? "");
-            const url = String(args.url ?? "");
-            const isLocal = url.startsWith("http://localhost") ||
-                url.startsWith("http://127.0.0.1");
-            // For localhost URLs, fetch the live swagger spec from the local function
-            // to pick up any new/changed endpoints during development
-            if (isLocal) {
-                try {
-                    const liveEndpoints = await fetchSpecFromUrl(service, url);
-                    // Remove old endpoints for this service
-                    endpoints = endpoints.filter((ep) => ep.service !== service);
-                    // Add the fresh ones
-                    endpoints.push(...liveEndpoints);
-                    // Rebuild lookup map
-                    endpointsByTool = new Map();
-                    for (const ep of endpoints) {
-                        endpointsByTool.set(ep.toolName, ep);
-                    }
-                    serviceUrlOverrides.set(service, url);
-                    await server.sendToolListChanged();
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: `Overrode ${service} → ${url}. Loaded ${liveEndpoints.length} endpoints from local swagger.`,
-                            },
-                        ],
-                    };
-                }
-                catch (error) {
-                    // Fall through to static override if swagger fetch fails
-                    console.error(`[snokam-mcp] Failed to fetch swagger from ${url}, falling back to static spec:`, error instanceof Error ? error.message : error);
-                }
-            }
-            // Static override: just change the base URL on existing endpoints
-            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).`,
-                    },
-                ],
-            };
-        }
-        // 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 }],
-            };
+        if (BUILTIN_TOOL_NAMES.has(name)) {
+            return handleBuiltinTool(server, name, args);
         }
         const endpoint = endpointsByTool.get(name);
         if (!endpoint) {

package/dist/openapi-loader.d.ts

@@ -1,13 +1,3 @@
-/**
- * Fetch OpenAPI specs from live Snokam APIs and produce tool definitions.
- *
- * Backends are reached per-business at `{business}.snosky.no/api/{service}`
- * (prod) or `{business}.test.snosky.no/api/{service}` (test) — the uniform
- * snosky routing that works for every tenant, no per-customer hostname. The
- * business API host is injected (SNOKAM_API_HOST) and can be retargeted at
- * runtime via the SwitchDomain tool. The loader extracts endpoints,
- * parameters, and OAuth scopes for MCP tool metadata.
- */
 export interface ApiEndpoint {
     service: string;
     serviceDescription: string;
@@ -20,7 +10,6 @@ export interface ApiEndpoint {
     description: string;
     parameters: OpenApiParameter[];
     requestBody: OpenApiRequestBody | null;
-    /** OAuth2 scope in `.default` format for OBO exchange, or null for public endpoints. */
     scope: string | null;
 }
 interface OpenApiParameter {
@@ -44,10 +33,6 @@ interface OpenApiRequestBody {
         schema?: Record<string, unknown>;
     }>;
 }
-/**
- * Fetch a swagger spec from a specific URL (e.g. a locally running function)
- * and return parsed endpoints for that service.
- */
 export declare function fetchSpecFromUrl(service: string, baseUrl: string): Promise<ApiEndpoint[]>;
 export declare function fetchSpecs(environment: string, apiHost: string): Promise<ApiEndpoint[]>;
 export {};

package/dist/openapi-loader.js

@@ -1,16 +1,3 @@
-/**
- * Fetch OpenAPI specs from live Snokam APIs and produce tool definitions.
- *
- * Backends are reached per-business at `{business}.snosky.no/api/{service}`
- * (prod) or `{business}.test.snosky.no/api/{service}` (test) — the uniform
- * snosky routing that works for every tenant, no per-customer hostname. The
- * business API host is injected (SNOKAM_API_HOST) and can be retargeted at
- * runtime via the SwitchDomain tool. The loader extracts endpoints,
- * parameters, and OAuth scopes for MCP tool metadata.
- */
-// ---------------------------------------------------------------------------
-// Service discovery - reads from bundled specs directory at runtime
-// ---------------------------------------------------------------------------
 async function discoverServices(environment) {
     try {
         const { readdir } = await import("fs/promises");
@@ -25,19 +12,12 @@ async function discoverServices(environment) {
             .sort();
     }
     catch {
-        // No bundled specs found - return empty array
         return [];
     }
 }
-// ---------------------------------------------------------------------------
-// Environment-aware URL resolution
-// ---------------------------------------------------------------------------
 function getBaseUrl(service, apiHost) {
     return `https://${apiHost}/api/${service}`;
 }
-// ---------------------------------------------------------------------------
-// Scope extraction
-// ---------------------------------------------------------------------------
 function extractScope(operation) {
     for (const secReq of operation.security ?? []) {
         for (const scopes of Object.values(secReq)) {
@@ -53,15 +33,9 @@ function extractScope(operation) {
     }
     return null;
 }
-// ---------------------------------------------------------------------------
-// Tool naming
-// ---------------------------------------------------------------------------
 function makeToolName(service, operationId) {
     return `${service}__${operationId}`;
 }
-// ---------------------------------------------------------------------------
-// Spec parsing
-// ---------------------------------------------------------------------------
 function parseSpec(spec, service, baseUrl) {
     const endpoints = [];
     const paths = spec.paths;
@@ -95,13 +69,6 @@ function parseSpec(spec, service, baseUrl) {
     }
     return endpoints;
 }
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-/**
- * Fetch a swagger spec from a specific URL (e.g. a locally running function)
- * and return parsed endpoints for that service.
- */
 export async function fetchSpecFromUrl(service, baseUrl) {
     const swaggerUrl = `${baseUrl}/swagger.json`;
     const response = await fetch(swaggerUrl, {
@@ -114,7 +81,6 @@ export async function fetchSpecFromUrl(service, baseUrl) {
     return parseSpec(spec, service, baseUrl);
 }
 export async function fetchSpecs(environment, apiHost) {
-    // Try to load bundled specs first (for speed)
     try {
         const bundledSpecs = await loadBundledSpecs(environment, apiHost);
         if (bundledSpecs.length > 0) {
@@ -125,8 +91,6 @@ export async function fetchSpecs(environment, apiHost) {
     catch (error) {
         console.error(`[snokam-mcp] Failed to load bundled specs, falling back to live fetch:`, error);
     }
-    // Fallback to live fetching (slower, for development)
-    // Discover services from environment to know which APIs to fetch
     const services = await discoverServices(environment);
     if (services.length === 0) {
         console.error("[snokam-mcp] No services discovered. Unable to fetch specs.");
@@ -166,7 +130,6 @@ async function loadBundledSpecs(environment, apiHost) {
     const { dirname, join } = await import("path");
     const __dirname = dirname(fileURLToPath(import.meta.url));
     const specsDir = join(__dirname, "..", "specs", environment);
-    // Discover which specs are bundled
     const services = await discoverServices(environment);
     const endpoints = [];
     for (const service of services) {
@@ -177,8 +140,7 @@ async function loadBundledSpecs(environment, apiHost) {
             const baseUrl = getBaseUrl(service, apiHost);
             endpoints.push(...parseSpec(spec, service, baseUrl));
         }
-        catch (error) {
-            // Spec file doesn't exist or is invalid, skip
+        catch {
             continue;
         }
     }

package/dist/state.d.ts

@@ -0,0 +1,13 @@
+import { type ApiEndpoint } from "./openapi-loader.js";
+export declare let currentEnvironment: string;
+export declare let apiHostOverride: string | null;
+export declare let endpoints: ApiEndpoint[];
+export declare let endpointsByTool: Map<string, ApiEndpoint>;
+export declare const serviceUrlOverrides: Map<string, string>;
+export declare function setApiHostOverride(host: string | null): void;
+export declare function resolveApiHost(environment: string): string;
+export declare function activeApiHost(): string;
+export declare function loadEndpoints(environment: string): Promise<void>;
+export declare function normalizeDomain(raw: string): string;
+export declare function rebuildEndpointsByTool(): void;
+export declare function replaceServiceEndpoints(service: string, freshEndpoints: ApiEndpoint[]): void;

package/dist/state.js

@@ -0,0 +1,54 @@
+import { fetchSpecs } from "./openapi-loader.js";
+export let currentEnvironment = process.env.SNOKAM_ENVIRONMENT ?? "production";
+export let apiHostOverride = null;
+export let endpoints = [];
+export let endpointsByTool = new Map();
+export const serviceUrlOverrides = new Map();
+export function setApiHostOverride(host) {
+    apiHostOverride = host;
+}
+export function resolveApiHost(environment) {
+    const explicit = process.env.SNOKAM_API_HOST;
+    if (explicit)
+        return normalizeDomain(explicit);
+    const suffix = environment === "test" ? "test.snosky.no" : "snosky.no";
+    const business = process.env.SNOKAM_BUSINESS;
+    return business ? `${business}.${suffix}` : suffix;
+}
+export function activeApiHost() {
+    return apiHostOverride ?? resolveApiHost(currentEnvironment);
+}
+export async function loadEndpoints(environment) {
+    currentEnvironment = environment;
+    endpoints = await fetchSpecs(environment, activeApiHost());
+    endpointsByTool = new Map();
+    for (const ep of endpoints) {
+        endpointsByTool.set(ep.toolName, ep);
+    }
+    applyUrlOverrides();
+}
+function applyUrlOverrides() {
+    for (const ep of endpoints) {
+        const override = serviceUrlOverrides.get(ep.service);
+        if (override) {
+            ep.baseUrl = override;
+        }
+    }
+}
+export function normalizeDomain(raw) {
+    return raw
+        .trim()
+        .replace(/^https?:\/\//, "")
+        .replace(/\/$/, "");
+}
+export function rebuildEndpointsByTool() {
+    endpointsByTool = new Map();
+    for (const ep of endpoints) {
+        endpointsByTool.set(ep.toolName, ep);
+    }
+}
+export function replaceServiceEndpoints(service, freshEndpoints) {
+    endpoints = endpoints.filter((ep) => ep.service !== service);
+    endpoints.push(...freshEndpoints);
+    rebuildEndpointsByTool();
+}

package/dist/tool-schema.d.ts

@@ -0,0 +1,2 @@
+import { type ApiEndpoint } from "./openapi-loader.js";
+export declare function buildInputSchema(endpoint: ApiEndpoint): Record<string, unknown>;

package/dist/tool-schema.js

@@ -0,0 +1,42 @@
+export function buildInputSchema(endpoint) {
+    const properties = {};
+    const required = [];
+    for (const param of endpoint.parameters) {
+        const prop = {};
+        if (param.schema?.type)
+            prop.type = param.schema.type;
+        if (param.schema?.enum)
+            prop.enum = param.schema.enum;
+        if (param.schema?.format)
+            prop.format = param.schema.format;
+        if (param.schema?.items)
+            prop.items = param.schema.items;
+        if (param.description)
+            prop.description = param.description;
+        if (!prop.type)
+            prop.type = "string";
+        properties[param.name] = prop;
+        if (param.required)
+            required.push(param.name);
+    }
+    if (endpoint.requestBody) {
+        properties.body = {
+            type: "object",
+            description: endpoint.requestBody.description ?? "Request body",
+        };
+        const jsonContent = endpoint.requestBody.content?.["application/json"];
+        if (jsonContent?.schema) {
+            properties.body = {
+                ...properties.body,
+                ...jsonContent.schema,
+            };
+        }
+        if (endpoint.requestBody.required)
+            required.push("body");
+    }
+    return {
+        type: "object",
+        properties,
+        required: required.length > 0 ? required : undefined,
+    };
+}

package/package.json

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