@snokam/mcp-server 0.1.0 → 0.3.0

package/dist/index.js

@@ -8,7 +8,7 @@
  */
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 import { fetchSpecs } from "./openapi-loader.js";
 import { getAccessToken } from "./auth.js";
 // ---------------------------------------------------------------------------
@@ -120,7 +120,102 @@ async function main() {
     for (const ep of endpoints) {
         endpointsByTool.set(ep.toolName, ep);
     }
-    const server = new Server({ name: "snokam", version: "0.1.0" }, { capabilities: { tools: {} } });
+    const server = new Server({
+        name: "snokam",
+        version: "0.2.0",
+    }, {
+        capabilities: {
+            tools: {},
+            resources: {},
+        },
+    });
+    // List resources
+    server.setRequestHandler(ListResourcesRequestSchema, async () => ({
+        resources: [
+            {
+                uri: "snokam://about",
+                name: "About Snøkam",
+                description: "Information about Snøkam and available API services",
+                mimeType: "text/markdown",
+            },
+        ],
+    }));
+    // 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);
+                if (existing) {
+                    existing.count++;
+                }
+                else {
+                    serviceMap.set(ep.service, {
+                        count: 1,
+                        description: ep.serviceDescription,
+                    });
+                }
+            }
+            const serviceList = Array.from(serviceMap.entries())
+                .sort(([a], [b]) => a.localeCompare(b))
+                .map(([service, { count, description }]) => {
+                return `- **${service}** (${count} endpoints): ${description}`;
+            })
+                .join("\n");
+            const about = `# Snøkam MCP Server
+
+**Snøkam** is a Norwegian software consulting company. This MCP server provides programmatic access to Snøkam's internal backend APIs.
+
+## Environment
+
+Currently connected to: **${ENVIRONMENT}**
+
+## Available Services
+
+${serviceList}
+
+## Authentication
+
+- **Public endpoints**: No authentication required (e.g., \`employees__GetEmployeesPublic\`)
+- **Protected endpoints**: Require Azure AD authentication (e.g., \`employees__GetEmployeesProtected\`)
+
+## Common Use Cases
+
+**Find out who works at Snøkam:**
+\`\`\`
+Use: employees__GetEmployeesPublic
+Returns: List of all employees with names, roles, and technologies
+\`\`\`
+
+**Get upcoming events:**
+\`\`\`
+Use: events__GetPublicEvents (if available)
+Returns: Company events and gatherings
+\`\`\`
+
+**Check office status or control music:**
+\`\`\`
+Use: office__* tools
+Controls: Sonos speakers, lights, YouTube queue
+\`\`\`
+`;
+            return {
+                contents: [
+                    {
+                        uri,
+                        mimeType: "text/markdown",
+                        text: about,
+                    },
+                ],
+            };
+        }
+        return {
+            contents: [],
+            isError: true,
+        };
+    });
     // List tools
     server.setRequestHandler(ListToolsRequestSchema, async () => ({
         tools: endpoints.map((ep) => ({

package/dist/openapi-loader.d.ts

@@ -8,6 +8,7 @@
  */
 export interface ApiEndpoint {
     service: string;
+    serviceDescription: string;
     toolName: string;
     operationId: string;
     method: string;

package/dist/openapi-loader.js

@@ -7,22 +7,26 @@
  * MCP-compatible tool metadata.
  */
 // ---------------------------------------------------------------------------
-// Known services (functions that expose OpenAPI specs)
+// Service discovery - reads from bundled specs directory at runtime
 // ---------------------------------------------------------------------------
-const SERVICES = [
-    "accounting",
-    "broker",
-    "calculators",
-    "chatgpt",
-    "crypto",
-    "employees",
-    "events",
-    "office",
-    "platform",
-    "power-office",
-    "sync",
-    "webshop",
-];
+async function discoverServices(environment) {
+    try {
+        const { readdir } = 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);
+        const files = await readdir(specsDir);
+        return files
+            .filter((f) => f.endsWith(".json"))
+            .map((f) => f.replace(".json", ""))
+            .sort();
+    }
+    catch {
+        // No bundled specs found - return empty array
+        return [];
+    }
+}
 // ---------------------------------------------------------------------------
 // Environment-aware URL resolution
 // ---------------------------------------------------------------------------
@@ -66,6 +70,7 @@ function parseSpec(spec, service, baseUrl) {
     const paths = spec.paths;
     if (!paths || Object.keys(paths).length === 0)
         return endpoints;
+    const serviceDescription = spec.info.description || spec.info.title || "";
     for (const [path, pathItem] of Object.entries(paths)) {
         for (const method of ["get", "post", "put", "patch", "delete"]) {
             const operation = pathItem[method];
@@ -77,6 +82,7 @@ function parseSpec(spec, service, baseUrl) {
             const scope = extractScope(operation);
             endpoints.push({
                 service,
+                serviceDescription,
                 toolName: makeToolName(service, operationId),
                 operationId,
                 method: method.toUpperCase(),
@@ -96,8 +102,26 @@ function parseSpec(spec, service, baseUrl) {
 // Public API
 // ---------------------------------------------------------------------------
 export async function fetchSpecs(environment) {
+    // Try to load bundled specs first (for speed)
+    try {
+        const bundledSpecs = await loadBundledSpecs(environment);
+        if (bundledSpecs.length > 0) {
+            console.error(`[snokam-mcp] Loaded ${bundledSpecs.length} endpoints from bundled specs (env=${environment})`);
+            return bundledSpecs;
+        }
+    }
+    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.");
+        return [];
+    }
     const endpoints = [];
-    const results = await Promise.allSettled(SERVICES.map(async (service) => {
+    const results = await Promise.allSettled(services.map(async (service) => {
         const baseUrl = getBaseUrl(service, environment);
         const swaggerUrl = `${baseUrl}/swagger.json`;
         const response = await fetch(swaggerUrl, {
@@ -118,9 +142,33 @@ export async function fetchSpecs(environment) {
         }
         else {
             const idx = results.indexOf(result);
-            console.error(`[snokam-mcp] Failed to fetch ${SERVICES[idx]}: ${result.reason}`);
+            console.error(`[snokam-mcp] Failed to fetch ${services[idx]}: ${result.reason}`);
+        }
+    }
+    console.error(`[snokam-mcp] Loaded ${endpoints.length} endpoints from ${successCount}/${services.length} services (env=${environment})`);
+    return endpoints;
+}
+async function loadBundledSpecs(environment) {
+    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) {
+        try {
+            const specPath = join(specsDir, `${service}.json`);
+            const specData = await readFile(specPath, "utf-8");
+            const spec = JSON.parse(specData);
+            const baseUrl = getBaseUrl(service, environment);
+            endpoints.push(...parseSpec(spec, service, baseUrl));
+        }
+        catch (error) {
+            // Spec file doesn't exist or is invalid, skip
+            continue;
         }
     }
-    console.error(`[snokam-mcp] Loaded ${endpoints.length} endpoints from ${successCount}/${SERVICES.length} services (env=${environment})`);
     return endpoints;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snokam/mcp-server",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "MCP server exposing Snokam backend APIs as tools",
   "type": "module",
   "bin": {
@@ -8,6 +8,10 @@
   },
   "main": "./dist/index.js",
   "scripts": {
+    "bundle-specs": "node scripts/bundle-specs.js",
+    "bundle-specs:prod": "node scripts/bundle-specs.js production",
+    "bundle-specs:test": "node scripts/bundle-specs.js test",
+    "prebuild": "npm run bundle-specs:prod && npm run bundle-specs:test",
     "build": "tsc",
     "dev": "tsc --watch",
     "start": "node dist/index.js"