modality-mcp-kit 1.5.1 → 1.6.1

package/dist/types/index.d.ts

@@ -3,4 +3,4 @@ export { setupAITools, ModalityFastMCP } from "./util_mcp_tools_converter";
 export type { AITools, AITool, FastMCPTool, } from "./schemas/schemas_tool_config";
 export type { FastMCPCompatible, BasePrompt, } from "./util_mcp_tools_converter";
 export { FastHonoMcp } from "./FastHonoMcp";
-export { mcpProxyHandler, mcpProxyListHandler, mcpProxyCacheHandler, type McpProxyConfig, } from "./util_mcp_proxy";
+export { mcpProxyHandler, mcpProxyListHandler, mcpProxyCacheHandler, type McpProxyConfig, type OAuthAllowAccessFn, } from "./util_mcp_proxy";

package/dist/types/util_mcp_proxy.d.ts

@@ -12,12 +12,16 @@ interface MCPServerConfig {
     description?: string;
 }
 export type McpProxyConfig = Record<string, MCPServerConfig>;
+export type OAuthAllowAccessFn = (serverUrl: string, mcpName: string) => Promise<{
+    status: string;
+    message?: string;
+}>;
 /**
  * Hono handler for MCP proxy
  * @param c - Hono context with mcpName param
  * @returns Response proxied from MCP server
  */
-export declare const mcpProxyHandler: (MCP_SERVERS: McpProxyConfig) => (c: any) => Promise<any>;
+export declare const mcpProxyHandler: (MCP_SERVERS: McpProxyConfig, oauthAllowAccess?: OAuthAllowAccessFn) => (c: any) => Promise<any>;
 /**
  * Hono handler for listing available MCP servers
  * @param c - Hono context

package/dist/util_mcp_proxy.js

@@ -8,6 +8,10 @@
  * Example: /proxy/figma → http://127.0.0.1:3845/mcp
  */
 import { SimpleCache } from "modality-kit";
+import { createHash } from "node:crypto";
+import { readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
 // ============================================
 // CACHE CONFIGURATION
 // ============================================
@@ -195,14 +199,96 @@ function getAnyCacheForMethod(cache, method) {
     }
 }
 // ============================================
-// HONO HANDLERS
+// OAUTH TOKEN HELPERS
 // ============================================
+function getOAuthCachePath(serverUrl) {
+    const key = createHash("sha1").update(serverUrl).digest("hex").slice(0, 12);
+    return join(homedir(), ".cache", "counter", `${key}.json`);
+}
+function getStoredOAuthToken(serverUrl) {
+    try {
+        const data = JSON.parse(readFileSync(getOAuthCachePath(serverUrl), "utf8"));
+        return data.tokens?.access_token ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+function clearStoredOAuthTokens(serverUrl) {
+    const cachePath = getOAuthCachePath(serverUrl);
+    try {
+        const data = JSON.parse(readFileSync(cachePath, "utf8"));
+        delete data.tokens;
+        writeFileSync(cachePath, JSON.stringify(data, null, 2));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// ============================================
+// TOOL PREFETCH HELPERS
+// ============================================
+function parseToolsFromBody(body) {
+    try {
+        const parsed = JSON.parse(body);
+        if (parsed?.result?.tools)
+            return parsed.result.tools;
+    }
+    catch {
+        // Try SSE format
+        const lines = body.split("\n");
+        for (const line of lines) {
+            if (line.startsWith("data: ")) {
+                try {
+                    const parsed = JSON.parse(line.substring(6));
+                    if (parsed?.result?.tools)
+                        return parsed.result.tools;
+                }
+                catch { }
+            }
+        }
+    }
+    return null;
+}
+async function prefetchAndCacheTools(mcpName, serverUrl, cache, storedToken) {
+    const cacheKey = "tools/list";
+    const cached = cache.get(cacheKey);
+    if (cached) {
+        const dataLine = cached.match(/^data: (.+)$/m)?.[1] ?? cached;
+        return { tools: parseToolsFromBody(dataLine), fromCache: true };
+    }
+    try {
+        const headers = {
+            "Content-Type": "application/json",
+            Accept: "application/json, text/event-stream",
+        };
+        if (storedToken) {
+            headers.authorization = `Bearer ${storedToken}`;
+        }
+        const response = await fetch(serverUrl, {
+            method: "POST",
+            headers,
+            body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "tools/list", params: {} }),
+        });
+        const body = await response.text();
+        const ttl = METHOD_TTL_MS["tools/list"];
+        const cacheValue = body.includes("event:") ? body : `event: message\ndata: ${body}\n\n`;
+        cache.set(cacheKey, cacheValue, ttl);
+        console.log(`[MCP-PROXY] Prefetched and cached tools/list for ${mcpName}`);
+        return { tools: parseToolsFromBody(body), fromCache: false };
+    }
+    catch (e) {
+        console.error(`[MCP-PROXY] Failed to prefetch tools for ${mcpName}:`, e);
+        return { tools: null, fromCache: false };
+    }
+}
 /**
  * Hono handler for MCP proxy
  * @param c - Hono context with mcpName param
  * @returns Response proxied from MCP server
  */
-export const mcpProxyHandler = (MCP_SERVERS) => async (c) => {
+export const mcpProxyHandler = (MCP_SERVERS, oauthAllowAccess) => async (c) => {
     const mcpName = c.req.param("mcpName");
     if (!mcpName) {
         return c.json({
@@ -210,6 +296,54 @@ export const mcpProxyHandler = (MCP_SERVERS) => async (c) => {
             availableServers: Object.keys(MCP_SERVERS),
         }, 400);
     }
+    // Handle /_allow sub-route (OAuth access flow)
+    if (c.req.path.endsWith("/_allow")) {
+        const serverConfig = MCP_SERVERS[mcpName];
+        if (!serverConfig) {
+            return c.json({ error: "MCP server not found", availableServers: Object.keys(MCP_SERVERS) }, 404);
+        }
+        if (!oauthAllowAccess) {
+            return c.json({ error: "OAuth not configured for this proxy" }, 501);
+        }
+        try {
+            const result = await oauthAllowAccess(serverConfig.url, mcpName);
+            return c.json(result);
+        }
+        catch (err) {
+            return c.json({ error: "OAuth failed", message: err.message }, 500);
+        }
+    }
+    // Handle /_clear-auth sub-route
+    if (c.req.path.endsWith("/_clear-auth")) {
+        const serverConfig = MCP_SERVERS[mcpName];
+        if (!serverConfig) {
+            return c.json({ error: "MCP server not found", availableServers: Object.keys(MCP_SERVERS) }, 404);
+        }
+        const cleared = clearStoredOAuthTokens(serverConfig.url);
+        return c.json({
+            status: cleared ? "cleared" : "no_cache",
+            mcpName,
+            message: cleared
+                ? "OAuth tokens cleared"
+                : "No cached OAuth state found",
+        });
+    }
+    // Handle /_tools sub-route — prefetch and return cached tool list
+    if (c.req.path.endsWith("/_tools")) {
+        const serverConfig = MCP_SERVERS[mcpName];
+        if (!serverConfig) {
+            return c.json({ error: "MCP server not found", availableServers: Object.keys(MCP_SERVERS) }, 404);
+        }
+        const cache = getServerCache(mcpName);
+        const storedToken = getStoredOAuthToken(serverConfig.url);
+        const { tools, fromCache } = await prefetchAndCacheTools(mcpName, serverConfig.url, cache, storedToken);
+        return c.json({
+            mcpName,
+            fromCache,
+            count: tools?.length ?? 0,
+            tools: tools ?? [],
+        });
+    }
     // Handle /_cache sub-routes (matched via app.use prefix routing)
     const cachePathMatch = c.req.path.match(/\/_cache(?:\/(.+))?$/);
     if (cachePathMatch) {
@@ -272,10 +406,18 @@ export const mcpProxyHandler = (MCP_SERVERS) => async (c) => {
                     upstreamHeaders[header] = value;
                 }
             }
+            // Auto-inject stored OAuth token if no Authorization header present
+            if (!upstreamHeaders.authorization) {
+                const storedToken = getStoredOAuthToken(serverConfig.url);
+                if (storedToken) {
+                    upstreamHeaders.authorization = `Bearer ${storedToken}`;
+                }
+            }
             try {
                 const upstreamResponse = await fetch(serverConfig.url, {
                     method: "GET",
                     headers: upstreamHeaders,
+                    signal: c.req.raw.signal,
                 });
                 // Forward response headers
                 const responseHeaders = new Headers();
@@ -308,11 +450,23 @@ export const mcpProxyHandler = (MCP_SERVERS) => async (c) => {
         }
         // Regular GET - return server info
         const cache = getServerCache(mcpName);
+        const basePath = `/proxy/${mcpName}`;
         return c.json({
             mcpName,
-            ...serverConfig,
-            cacheKeys: cache.keys(),
-            cacheSize: cache.keys().length,
+            upstream: serverConfig.url,
+            description: serverConfig.description,
+            endpoints: {
+                sse: `${basePath} (GET, Accept: text/event-stream)`,
+                rpc: `${basePath} (POST)`,
+                tools: `${basePath}/_tools`,
+                allow: `${basePath}/_allow`,
+                clearAuth: `${basePath}/_clear-auth`,
+                cache: `${basePath}/_cache`,
+            },
+            cache: {
+                keys: cache.keys(),
+                size: cache.keys().length,
+            },
         });
     }
     // POST request - proxy to MCP server with streaming support
@@ -384,6 +538,14 @@ export const mcpProxyHandler = (MCP_SERVERS) => async (c) => {
                     console.log(`[MCP-PROXY] Forwarding header: ${header}=${value.substring(0, 50)}`);
                 }
             }
+            // Auto-inject stored OAuth token if no Authorization header present
+            if (!upstreamHeaders.authorization) {
+                const storedToken = getStoredOAuthToken(serverConfig.url);
+                if (storedToken) {
+                    upstreamHeaders.authorization = `Bearer ${storedToken}`;
+                    console.log(`[MCP-PROXY] Using stored OAuth token for ${mcpName}`);
+                }
+            }
             console.log(`[MCP-PROXY] Upstream headers:`, Object.keys(upstreamHeaders));
             const upstreamResponse = await fetch(serverConfig.url, {
                 method: "POST",

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.5.1",
+  "version": "1.6.1",
   "name": "modality-mcp-kit",
   "repository": {
     "type": "git",