@snokam/mcp-api 1.10.0 → 1.11.1

package/dist/auth.d.ts

@@ -1,16 +1 @@
-/**
- * Token acquisition for Snokam backend APIs.
- *
- * Supports three modes (auto-detected):
- *
- * 1. **OBO (On-Behalf-Of):** When SNOKAM_USER_JWT is set, exchanges the user
- *    JWT for a service-specific token via Azure AD OBO flow.
- *    Requires AZURE_AD_CLIENT_ID, AZURE_AD_TENANT_ID, and either
- *    AZURE_AD_SECRET (client secret) or managed identity.
- *
- * 2. **DefaultAzureCredential:** When no user JWT is present, falls back to
- *    Azure CLI (local dev), managed identity (Azure), etc.
- *
- * 3. **No auth:** Endpoints without a scope get no Authorization header.
- */
 export declare function getAccessToken(scope: string | null): Promise<string | null>;

package/dist/auth.js

@@ -1,68 +1,24 @@
-/**
- * Token acquisition for Snokam backend APIs.
- *
- * Supports three modes (auto-detected):
- *
- * 1. **OBO (On-Behalf-Of):** When SNOKAM_USER_JWT is set, exchanges the user
- *    JWT for a service-specific token via Azure AD OBO flow.
- *    Requires AZURE_AD_CLIENT_ID, AZURE_AD_TENANT_ID, and either
- *    AZURE_AD_SECRET (client secret) or managed identity.
- *
- * 2. **DefaultAzureCredential:** When no user JWT is present, falls back to
- *    Azure CLI (local dev), managed identity (Azure), etc.
- *
- * 3. **No auth:** Endpoints without a scope get no Authorization header.
- */
-import { DefaultAzureCredential, OnBehalfOfCredential, } from "@azure/identity";
-// Cache credentials per scope to avoid re-creating them
-const credentialCache = new Map();
-function getOboCredential(userJwt, clientId, tenantId) {
-    const clientSecret = process.env.AZURE_AD_SECRET;
-    if (clientSecret) {
-        return new OnBehalfOfCredential({
-            tenantId,
-            clientId,
-            clientSecret,
-            userAssertionToken: userJwt,
-        });
-    }
-    // Managed identity as client assertion (federated identity)
-    const mi = new DefaultAzureCredential();
-    return new OnBehalfOfCredential({
-        tenantId,
-        clientId,
-        userAssertionToken: userJwt,
-        getAssertion: async () => {
-            const token = await mi.getToken("api://AzureADTokenExchange");
-            return token.token;
-        },
-    });
-}
+import { readFileSync } from "fs";
+import { DefaultAzureCredential } from "@azure/identity";
+let defaultCredential = null;
 export async function getAccessToken(scope) {
     if (!scope)
         return null;
-    const userJwt = process.env.SNOKAM_USER_JWT;
-    const clientId = process.env.AZURE_AD_CLIENT_ID ?? "";
-    const tenantId = process.env.AZURE_AD_TENANT_ID ?? "";
-    let credential;
-    if (userJwt && clientId && tenantId) {
-        // OBO mode
-        const cacheKey = `obo:${scope}`;
-        if (!credentialCache.has(cacheKey)) {
-            credentialCache.set(cacheKey, getOboCredential(userJwt, clientId, tenantId));
-        }
-        credential = credentialCache.get(cacheKey);
-    }
-    else {
-        // Default credential (Azure CLI locally, managed identity in Azure)
-        const cacheKey = "default";
-        if (!credentialCache.has(cacheKey)) {
-            credentialCache.set(cacheKey, new DefaultAzureCredential());
+    const tokenFile = process.env.SNOKAM_ACCESS_TOKEN_FILE;
+    if (tokenFile) {
+        try {
+            const fromFile = readFileSync(tokenFile, "utf8").trim();
+            if (fromFile)
+                return fromFile;
         }
-        credential = credentialCache.get(cacheKey);
+        catch { }
     }
+    const preMinted = process.env.SNOKAM_ACCESS_TOKEN;
+    if (preMinted)
+        return preMinted;
     try {
-        const token = await credential.getToken(scope);
+        defaultCredential ??= new DefaultAzureCredential();
+        const token = await defaultCredential.getToken(scope);
         return token?.token ?? null;
     }
     catch (error) {

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 is handled via @azure/identity — supports Azure CLI (local),
- * managed identity (Azure), and OBO (when SNOKAM_USER_JWT is set).
- */
 export {};