@snokam/mcp-api 1.21.1 → 2.0.1

package/dist/index.js

@@ -1,194 +1,15 @@
 #!/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).
- */
 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 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
-// ---------------------------------------------------------------------------
-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 { settled } from "./state.js";
+import { currentEnvironment, endpoints, endpointsByTool, loadEndpoints, } from "./state.js";
+import { buildInputSchema } from "./tool-schema.js";
+import { blockedReason, reportRequirements } from "./requirements.js";
 async function main() {
+    reportRequirements();
     await loadEndpoints(currentEnvironment);
     if (endpoints.length === 0) {
         console.error("[snokam-mcp] No endpoints loaded. Ensure specs/*.json files exist.");
@@ -202,7 +23,6 @@ async function main() {
             resources: {},
         },
     });
-    // List resources
     server.setRequestHandler(ListResourcesRequestSchema, async () => ({
         resources: [
             {
@@ -213,11 +33,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);
@@ -289,12 +107,9 @@ Controls: Sonos speakers, lights, YouTube queue
             isError: true,
         };
     });
-    // List tools
     server.setRequestHandler(ListToolsRequestSchema, async () => ({
         tools: [
-            switchToolDef,
-            setUrlToolDef,
-            resetUrlToolDef,
+            ...BUILTIN_TOOL_DEFS,
             ...endpoints.map((ep) => ({
                 name: ep.toolName,
                 description: ep.description || ep.summary || `${ep.method} ${ep.path}`,
@@ -302,127 +117,17 @@ 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.`,
-                    },
-                ],
-            };
+        if (BUILTIN_TOOL_NAMES.has(name)) {
+            const result = await handleBuiltinTool(server, name, args);
+            reportRequirements();
+            return result;
         }
-        // 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 }],
-            };
+        await settled();
+        const blocked = blockedReason();
+        if (blocked) {
+            return { content: [{ type: "text", text: blocked }], isError: true };
         }
         const endpoint = endpointsByTool.get(name);
         if (!endpoint) {

package/dist/openapi-loader.d.ts

@@ -1,11 +1,3 @@
-/**
- * Fetch OpenAPI specs from live Snokam APIs and produce tool definitions.
- *
- * Each backend function is available at `{service}.api.snokam.no` (prod)
- * or `{service}.api.test.snokam.no` (test). The loader fetches `/swagger.json`
- * from each, extracts endpoints, parameters, and OAuth scopes to generate
- * MCP-compatible tool metadata.
- */
 export interface ApiEndpoint {
     service: string;
     serviceDescription: string;
@@ -18,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 {
@@ -42,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): Promise<ApiEndpoint[]>;
+export declare function fetchSpecs(environment: string, apiHost: string): Promise<ApiEndpoint[]>;
 export {};

package/dist/openapi-loader.js

@@ -1,14 +1,3 @@
-/**
- * Fetch OpenAPI specs from live Snokam APIs and produce tool definitions.
- *
- * Each backend function is available at `{service}.api.snokam.no` (prod)
- * or `{service}.api.test.snokam.no` (test). The loader fetches `/swagger.json`
- * from each, extracts endpoints, parameters, and OAuth scopes to generate
- * MCP-compatible tool metadata.
- */
-// ---------------------------------------------------------------------------
-// Service discovery - reads from bundled specs directory at runtime
-// ---------------------------------------------------------------------------
 async function discoverServices(environment) {
     try {
         const { readdir } = await import("fs/promises");
@@ -23,24 +12,12 @@ async function discoverServices(environment) {
             .sort();
     }
     catch {
-        // No bundled specs found - return empty array
         return [];
     }
 }
-// ---------------------------------------------------------------------------
-// Environment-aware URL resolution
-// ---------------------------------------------------------------------------
-const PROD_DOMAIN = "api.snokam.no";
-const TEST_DOMAIN = "api.test.snokam.no";
-function getBaseDomain(environment) {
-    return environment === "test" ? TEST_DOMAIN : PROD_DOMAIN;
+function getBaseUrl(service, apiHost) {
+    return `https://${apiHost}/api/${service}`;
 }
-function getBaseUrl(service, environment) {
-    return `https://${service}.${getBaseDomain(environment)}`;
-}
-// ---------------------------------------------------------------------------
-// Scope extraction
-// ---------------------------------------------------------------------------
 function extractScope(operation) {
     for (const secReq of operation.security ?? []) {
         for (const scopes of Object.values(secReq)) {
@@ -56,15 +33,27 @@ function extractScope(operation) {
     }
     return null;
 }
-// ---------------------------------------------------------------------------
-// Tool naming
-// ---------------------------------------------------------------------------
 function makeToolName(service, operationId) {
     return `${service}__${operationId}`;
 }
-// ---------------------------------------------------------------------------
-// Spec parsing
-// ---------------------------------------------------------------------------
+function resourceOf(path) {
+    const segment = path
+        .split("/")
+        .find((part) => part && !part.startsWith("{") && !/^v[0-9]/.test(part));
+    return segment ? segment.replace(/[^a-zA-Z0-9]/g, "") : "";
+}
+function disambiguate(endpoints) {
+    const counts = new Map();
+    for (const ep of endpoints) {
+        counts.set(ep.toolName, (counts.get(ep.toolName) ?? 0) + 1);
+    }
+    return endpoints.map((ep) => {
+        if ((counts.get(ep.toolName) ?? 0) < 2)
+            return ep;
+        const resource = resourceOf(ep.path);
+        return resource ? { ...ep, toolName: `${ep.toolName}_${resource}` } : ep;
+    });
+}
 function parseSpec(spec, service, baseUrl) {
     const endpoints = [];
     const paths = spec.paths;
@@ -96,15 +85,8 @@ function parseSpec(spec, service, baseUrl) {
             });
         }
     }
-    return endpoints;
+    return disambiguate(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, {
@@ -116,10 +98,9 @@ export async function fetchSpecFromUrl(service, baseUrl) {
     const spec = (await response.json());
     return parseSpec(spec, service, baseUrl);
 }
-export async function fetchSpecs(environment) {
-    // Try to load bundled specs first (for speed)
+export async function fetchSpecs(environment, apiHost) {
     try {
-        const bundledSpecs = await loadBundledSpecs(environment);
+        const bundledSpecs = await loadBundledSpecs(environment, apiHost);
         if (bundledSpecs.length > 0) {
             console.error(`[snokam-mcp] Loaded ${bundledSpecs.length} endpoints from bundled specs (env=${environment})`);
             return bundledSpecs;
@@ -128,8 +109,6 @@ export async function fetchSpecs(environment) {
     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.");
@@ -137,7 +116,7 @@ export async function fetchSpecs(environment) {
     }
     const endpoints = [];
     const results = await Promise.allSettled(services.map(async (service) => {
-        const baseUrl = getBaseUrl(service, environment);
+        const baseUrl = getBaseUrl(service, apiHost);
         const swaggerUrl = `${baseUrl}/swagger.json`;
         const response = await fetch(swaggerUrl, {
             signal: AbortSignal.timeout(10_000),
@@ -163,13 +142,12 @@ export async function fetchSpecs(environment) {
     console.error(`[snokam-mcp] Loaded ${endpoints.length} endpoints from ${successCount}/${services.length} services (env=${environment})`);
     return endpoints;
 }
-async function loadBundledSpecs(environment) {
+async function loadBundledSpecs(environment, apiHost) {
     const { readFile } = await import("fs/promises");
     const { fileURLToPath } = await import("url");
     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,11 +155,10 @@ async function loadBundledSpecs(environment) {
             const specPath = join(specsDir, `${service}.json`);
             const specData = await readFile(specPath, "utf-8");
             const spec = JSON.parse(specData);
-            const baseUrl = getBaseUrl(service, environment);
+            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/requirements.d.ts

@@ -0,0 +1,10 @@
+export interface Requirement {
+    name: string;
+    ok: boolean;
+    detail: string;
+    fix?: string;
+}
+export declare function checkRequirements(): Requirement[];
+export declare function unmetRequirements(): Requirement[];
+export declare function reportRequirements(): Requirement[];
+export declare function blockedReason(): string | null;

package/dist/requirements.js

@@ -0,0 +1,92 @@
+import { activeApiHost, apiHostOverride, currentEnvironment } from "./state.js";
+import { SWITCH_DOMAIN_TOOL_NAME, SWITCH_TOOL_NAME, VALID_ENVIRONMENTS, } from "./builtin-tools.js";
+const BUSINESS_HOST = /^[a-z0-9-]+\.(test\.)?snosky\.no$/;
+function hostRequirement() {
+    const host = activeApiHost();
+    const explicit = process.env.SNOKAM_API_HOST?.trim();
+    const business = process.env.SNOKAM_BUSINESS?.trim();
+    if (apiHostOverride) {
+        return {
+            name: "api host",
+            ok: true,
+            detail: `${apiHostOverride} (set with ${SWITCH_DOMAIN_TOOL_NAME})`,
+        };
+    }
+    if (explicit) {
+        return { name: "api host", ok: true, detail: `${host} (SNOKAM_API_HOST)` };
+    }
+    if (business) {
+        return {
+            name: "api host",
+            ok: BUSINESS_HOST.test(host),
+            detail: `${host} (SNOKAM_BUSINESS=${business})`,
+            fix: BUSINESS_HOST.test(host)
+                ? undefined
+                : `"${business}" does not produce a business host. Call ${SWITCH_DOMAIN_TOOL_NAME} with the host itself, e.g. acme.snosky.no.`,
+        };
+    }
+    return {
+        name: "api host",
+        ok: false,
+        detail: `${host} — no business chosen`,
+        fix: `${host} is the marketing site, not a business API host: requests reach the frontend and come back as its 404 page, which is indistinguishable from a missing document. Call ${SWITCH_DOMAIN_TOOL_NAME} with the business host (e.g. snokam.snosky.no), or start with SNOKAM_BUSINESS=snokam.`,
+    };
+}
+function environmentRequirement() {
+    const ok = VALID_ENVIRONMENTS.includes(currentEnvironment);
+    return {
+        name: "environment",
+        ok,
+        detail: currentEnvironment,
+        fix: ok
+            ? undefined
+            : `Expected one of ${VALID_ENVIRONMENTS.join(", ")}. Call ${SWITCH_TOOL_NAME}, or set SNOKAM_ENVIRONMENT.`,
+    };
+}
+function credentialsRequirement() {
+    if (process.env.SNOKAM_ACCESS_TOKEN) {
+        return { name: "credentials", ok: true, detail: "SNOKAM_ACCESS_TOKEN" };
+    }
+    if (process.env.SNOKAM_ACCESS_TOKEN_FILE) {
+        return {
+            name: "credentials",
+            ok: true,
+            detail: "SNOKAM_ACCESS_TOKEN_FILE",
+        };
+    }
+    return {
+        name: "credentials",
+        ok: true,
+        detail: "Azure credentials (az login). Calls needing a token fail with 401 if none can be minted.",
+    };
+}
+export function checkRequirements() {
+    return [
+        hostRequirement(),
+        environmentRequirement(),
+        credentialsRequirement(),
+    ];
+}
+export function unmetRequirements() {
+    return checkRequirements().filter((requirement) => !requirement.ok);
+}
+export function reportRequirements() {
+    const requirements = checkRequirements();
+    for (const requirement of requirements) {
+        console.error(`[snokam-mcp] ${requirement.ok ? "✔" : "✖"} ${requirement.name}: ${requirement.detail}`);
+        if (requirement.fix)
+            console.error(`[snokam-mcp]   ${requirement.fix}`);
+    }
+    return requirements;
+}
+export function blockedReason() {
+    const unmet = unmetRequirements();
+    if (unmet.length === 0)
+        return null;
+    return [
+        "This call was not sent, because the server is not in a state where it could succeed:",
+        ...unmet.map((r) => `  ✖ ${r.name}: ${r.detail}\n    ${r.fix ?? ""}`.trimEnd()),
+        "",
+        "Fix the above, then call this tool again. Nothing else has changed.",
+    ].join("\n");
+}

package/dist/state.d.ts

@@ -0,0 +1,14 @@
+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 settled(): Promise<void>;
+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;