mcpbox 0.2.0 → 0.2.2

package/README.md

@@ -5,14 +5,18 @@
   </picture>
 </p>
 
-**MCPBox** is a lightweight gateway that exposes local stdio-based MCP (Model Context Protocol) servers via Streamable HTTP, enabling Claude and other AI agents to connect from anywhere.
+**MCPBox** is a lightweight gateway that exposes local stdio-based [MCP](https://modelcontextprotocol.io) servers via Streamable HTTP, enabling Claude and other AI agents to connect from anywhere.
 
-- Aggregate multiple local stdio servers behind a single HTTP endpoint
-- Exposes Tools, Resources & Prompts
-- Namespaces with `servername__` prefix to avoid collisions (e.g., `github__create_issue`)
+- Runs multiple servers behind a single HTTP endpoint
+- Supports Tools, Resources & Prompts
+- Namespaces with `servername__` prefix to avoid collisions
+- Per-server tool filtering to limit AI access and reduce context usage
 - OAuth or API key authentication
 
-![mcpbox diagram](assets/diagram.excalidraw.png)
+<picture>
+  <source media="(prefers-color-scheme: dark)" srcset="assets/diagram-dark.excalidraw.png">
+  <img src="assets/diagram.excalidraw.png" alt="mcpbox diagram">
+</picture>
 
 ## Quick Start
 
@@ -70,10 +74,10 @@ See [`mcpbox.example.jsonc`](mcpbox.example.jsonc) for all options. All string v
 
 To expose MCPBox remotely, put it behind a TLS-terminating reverse proxy.
 
-Before deploying:
-- [ ] Use `storage.type: "sqlite"` for persistence across restarts
-- [ ] Set `auth.issuer` to your public URL when using OAuth
-- [ ] Use bcrypt hashes for passwords
+Before deploying with OAuth:
+- [ ] Use sqlite storage for persistence across restarts
+- [ ] Set issuer to your public URL
+- [ ] Use bcrypt hashes for local passwords
 
 > [!NOTE]
 > MCPBox is single-instance only — don't run multiple instances behind a load balancer.
@@ -93,7 +97,9 @@ Then update your config with the generated public URL:
   "auth": {
     "type": "oauth",
     "issuer": "https://<tunnel-id>.trycloudflare.com",
-    "users": [{ "username": "admin", "password": "${MCPBOX_PASSWORD}" }],
+    "identityProviders": [
+      { "type": "local", "users": [{ "username": "admin", "password": "${MCPBOX_PASSWORD}" }] }
+    ],
     "dynamicRegistration": true
   },
   "storage": {
@@ -126,12 +132,28 @@ claude mcp add --transport http mcpbox https://your-mcpbox-url.com
 
 Requires `dynamicRegistration: true` in your config.
 
-### MCP clients with JSON config
+### Other MCP clients
+
+**With dynamic registration (OAuth)** — just provide the URL:
 
 ```json
 {
   "mcpServers": {
     "mcpbox": {
+      "type": "http",
+      "url": "https://your-mcpbox-url.com"
+    }
+  }
+}
+```
+
+**With API key:**
+
+```json
+{
+  "mcpServers": {
+    "mcpbox": {
+      "type": "http",
       "url": "https://your-mcpbox-url.com",
       "headers": {
         "Authorization": "Bearer YOUR_API_KEY"

package/dist/auth/oauth.js

@@ -63,7 +63,7 @@ export class OAuthServer {
         return {
             resource: this.config.issuer,
             authorization_servers: [this.config.issuer],
-            scopes_supported: ["mcp:tools"],
+            scopes_supported: ["mcp"],
             bearer_methods_supported: ["header"],
             // Non-standard: logo for client display
             logo_uri: `${this.config.issuer}/logo.png`,
@@ -87,7 +87,7 @@ export class OAuthServer {
             token_endpoint: `${this.config.issuer}/token`,
             grant_types_supported: grantTypes,
             token_endpoint_auth_methods_supported: ["none", "client_secret_post"],
-            scopes_supported: ["mcp:tools"],
+            scopes_supported: ["mcp"],
         };
         // Only advertise authorization endpoint if identity providers are configured
         if (hasProviders) {
@@ -656,7 +656,7 @@ export class OAuthServer {
         this.store.saveAccessToken({
             token: hashSecret(accessToken),
             clientId,
-            scope: "mcp:tools",
+            scope: "mcp",
             expiresAt: Date.now() + expiresIn * 1000,
             userId: `client:${clientId}`, // Mark as client-authenticated
         });
@@ -666,7 +666,7 @@ export class OAuthServer {
             access_token: accessToken, // Return unhashed token to client
             token_type: "Bearer",
             expires_in: expiresIn,
-            scope: "mcp:tools",
+            scope: "mcp",
         });
     }
     // RFC 6749 Section 4.1: Authorization Code Grant

package/dist/config/schema.js

@@ -129,6 +129,14 @@ export const AuthConfigSchema = z.discriminatedUnion("type", [
         return oauth.identityProviders && oauth.identityProviders.length > 0;
     }, {
         message: "dynamic registration requires identity providers to be configured for user login",
+    })
+        .refine((oauth) => {
+        if (!oauth.clients)
+            return true;
+        const ids = oauth.clients.map((c) => c.clientId);
+        return new Set(ids).size === ids.length;
+    }, {
+        message: "Duplicate client IDs are not allowed",
     }),
 ]);
 /**

package/dist/index.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { existsSync } from "node:fs";
 import { loadConfig, resolveConfigPath, } from "./config/loader.js";
 import { configureLogger, logger } from "./logger.js";
 import { createServer } from "./server.js";
@@ -33,10 +34,6 @@ function parseArgs(args) {
         else if (arg === "-c" || arg === "--config") {
             result.config = args[++i];
         }
-        else if (!arg.startsWith("-")) {
-            // Positional arg = config path (backwards compat)
-            result.config = arg;
-        }
     }
     return result;
 }
@@ -50,6 +47,10 @@ if (args.version) {
     process.exit(0);
 }
 const configPath = resolveConfigPath(args.config);
+if (args.config && !existsSync(configPath)) {
+    console.error(`Config file not found: ${configPath}`);
+    process.exit(1);
+}
 let config;
 let warnings;
 try {
@@ -57,7 +58,6 @@ try {
 }
 catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    // Log to stderr directly since logger config isn't loaded yet
     console.error(`Failed to load config from ${configPath}:\n${message}`);
     process.exit(1);
 }

package/dist/mcp/handler.d.ts

@@ -0,0 +1,22 @@
+import { ErrorCode } from "@modelcontextprotocol/sdk/types.js";
+import type { Context } from "hono";
+import type { McpManager } from "./manager.js";
+export declare function createMcpHandler(mcpManager: McpManager): (c: Context) => Promise<(Response & import("hono").TypedResponse<{
+    jsonrpc: "2.0";
+    id: string | number;
+    error: {
+        code: number;
+        message: string;
+    };
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    jsonrpc: "2.0";
+    id: string | number;
+    result: import("hono/utils/types").JSONValue;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    jsonrpc: string;
+    error: {
+        code: ErrorCode;
+        message: string;
+    };
+    id: null;
+}, 400, "json">) | (Response & import("hono").TypedResponse<null, 202, "body">)>;

package/dist/mcp/handler.js

@@ -0,0 +1,148 @@
+import { CallToolRequestSchema, CompleteRequestSchema, ErrorCode, GetPromptRequestSchema, InitializeRequestSchema, isJSONRPCNotification, JSONRPCRequestSchema, ListPromptsRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, PingRequestSchema, ReadResourceRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { logger } from "../logger.js";
+import { NAME, VERSION } from "../version.js";
+function jsonrpcResult(id, result) {
+    return { jsonrpc: "2.0", id, result };
+}
+function jsonrpcError(id, code, message) {
+    return { jsonrpc: "2.0", id, error: { code, message } };
+}
+export function createMcpHandler(mcpManager) {
+    return async (c) => {
+        let body;
+        try {
+            body = await c.req.json();
+        }
+        catch (e) {
+            logger.warn({ error: e instanceof Error ? e.message : String(e) }, "MCP parse error");
+            return c.json({
+                jsonrpc: "2.0",
+                error: { code: ErrorCode.ParseError, message: "Parse error" },
+                id: null,
+            }, 400);
+        }
+        if (isJSONRPCNotification(body)) {
+            const method = body.method;
+            logger.debug({ method }, "MCP notification");
+            return c.body(null, 202);
+        }
+        const envelope = JSONRPCRequestSchema.safeParse(body);
+        if (!envelope.success) {
+            return c.json({
+                jsonrpc: "2.0",
+                error: {
+                    code: ErrorCode.InvalidRequest,
+                    message: "Invalid request",
+                },
+                id: null,
+            }, 400);
+        }
+        const request = envelope.data;
+        logger.debug({ method: request.method, id: request.id }, "MCP request");
+        return handleRequest(c, request, mcpManager);
+    };
+}
+async function handleRequest(c, request, mcpManager) {
+    const { id, method } = request;
+    if (method === "initialize") {
+        const parsed = InitializeRequestSchema.safeParse(request);
+        if (!parsed.success) {
+            return c.json(jsonrpcError(id, ErrorCode.InvalidParams, "Invalid params"));
+        }
+        const result = {
+            protocolVersion: "2025-11-25",
+            capabilities: {
+                tools: { listChanged: true },
+                resources: { listChanged: true },
+                prompts: { listChanged: true },
+                completions: {},
+            },
+            serverInfo: {
+                name: NAME,
+                version: VERSION,
+            },
+        };
+        return c.json(jsonrpcResult(id, result));
+    }
+    if (method === "ping") {
+        const parsed = PingRequestSchema.safeParse(request);
+        if (!parsed.success) {
+            return c.json(jsonrpcError(id, ErrorCode.InvalidParams, "Invalid params"));
+        }
+        return c.json(jsonrpcResult(id, {}));
+    }
+    if (method === "tools/list") {
+        const parsed = ListToolsRequestSchema.safeParse(request);
+        if (!parsed.success) {
+            return c.json(jsonrpcError(id, ErrorCode.InvalidParams, "Invalid params"));
+        }
+        return c.json(jsonrpcResult(id, { tools: mcpManager.listTools() }));
+    }
+    if (method === "tools/call") {
+        const parsed = CallToolRequestSchema.safeParse(request);
+        if (!parsed.success) {
+            return c.json(jsonrpcError(id, ErrorCode.InvalidParams, "Invalid params"));
+        }
+        try {
+            const result = await mcpManager.callTool(parsed.data.params);
+            return c.json(jsonrpcResult(id, result));
+        }
+        catch (error) {
+            return c.json(jsonrpcError(id, ErrorCode.InternalError, error instanceof Error ? error.message : "Internal error"));
+        }
+    }
+    if (method === "resources/list") {
+        const parsed = ListResourcesRequestSchema.safeParse(request);
+        if (!parsed.success) {
+            return c.json(jsonrpcError(id, ErrorCode.InvalidParams, "Invalid params"));
+        }
+        return c.json(jsonrpcResult(id, { resources: mcpManager.listResources() }));
+    }
+    if (method === "resources/read") {
+        const parsed = ReadResourceRequestSchema.safeParse(request);
+        if (!parsed.success) {
+            return c.json(jsonrpcError(id, ErrorCode.InvalidParams, "Invalid params"));
+        }
+        try {
+            const result = await mcpManager.readResource(parsed.data.params);
+            return c.json(jsonrpcResult(id, result));
+        }
+        catch (error) {
+            return c.json(jsonrpcError(id, ErrorCode.InternalError, error instanceof Error ? error.message : "Internal error"));
+        }
+    }
+    if (method === "prompts/list") {
+        const parsed = ListPromptsRequestSchema.safeParse(request);
+        if (!parsed.success) {
+            return c.json(jsonrpcError(id, ErrorCode.InvalidParams, "Invalid params"));
+        }
+        return c.json(jsonrpcResult(id, { prompts: mcpManager.listPrompts() }));
+    }
+    if (method === "prompts/get") {
+        const parsed = GetPromptRequestSchema.safeParse(request);
+        if (!parsed.success) {
+            return c.json(jsonrpcError(id, ErrorCode.InvalidParams, "Invalid params"));
+        }
+        try {
+            const result = await mcpManager.getPrompt(parsed.data.params);
+            return c.json(jsonrpcResult(id, result));
+        }
+        catch (error) {
+            return c.json(jsonrpcError(id, ErrorCode.InternalError, error instanceof Error ? error.message : "Internal error"));
+        }
+    }
+    if (method === "completion/complete") {
+        const parsed = CompleteRequestSchema.safeParse(request);
+        if (!parsed.success) {
+            return c.json(jsonrpcError(id, ErrorCode.InvalidParams, "Invalid params"));
+        }
+        try {
+            const result = await mcpManager.complete(parsed.data.params);
+            return c.json(jsonrpcResult(id, result));
+        }
+        catch (error) {
+            return c.json(jsonrpcError(id, ErrorCode.InternalError, error instanceof Error ? error.message : "Internal error"));
+        }
+    }
+    return c.json(jsonrpcError(id, ErrorCode.MethodNotFound, `Method not found: ${method}`));
+}

package/dist/mcp/manager.d.ts

@@ -1,6 +1,6 @@
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-import type { CallToolResult, CompleteResult, GetPromptResult, Prompt, ReadResourceResult, Resource, Tool } from "@modelcontextprotocol/sdk/types.js";
+import type { CallToolRequestParams, CallToolResult, CompleteRequestParams, CompleteResult, GetPromptRequestParams, GetPromptResult, Prompt, ReadResourceRequestParams, ReadResourceResult, Resource, Tool } from "@modelcontextprotocol/sdk/types.js";
 import type { LogConfig, McpConfig } from "../config/types.js";
 export interface ManagedMcp {
     name: string;
@@ -33,16 +33,9 @@ export declare class McpManager {
             prompts: number;
         }>;
     }>;
-    callTool(toolName: string, args: Record<string, unknown>): Promise<CallToolResult>;
-    readResource(resourceUri: string): Promise<ReadResourceResult>;
-    getPrompt(promptName: string, args?: Record<string, string>): Promise<GetPromptResult>;
-    complete(ref: {
-        type: string;
-        name?: string;
-        uri?: string;
-    }, argument: {
-        name: string;
-        value: string;
-    }): Promise<CompleteResult>;
+    callTool(params: CallToolRequestParams): Promise<CallToolResult>;
+    readResource(params: ReadResourceRequestParams): Promise<ReadResourceResult>;
+    getPrompt(params: GetPromptRequestParams): Promise<GetPromptResult>;
+    complete(params: CompleteRequestParams): Promise<CompleteResult>;
     private resolveCompletionRef;
 }

package/dist/mcp/manager.js

@@ -217,91 +217,94 @@ export class McpManager {
         }
         return { servers };
     }
-    async callTool(toolName, args) {
-        const mcpName = this.toolToMcp.get(toolName);
+    async callTool(params) {
+        const mcpName = this.toolToMcp.get(params.name);
         if (!mcpName) {
-            logger.warn(`Unknown tool called: ${toolName}`);
-            throw new Error(`Unknown tool: ${toolName}`);
+            logger.warn(`Unknown tool called: ${params.name}`);
+            throw new Error(`Unknown tool: ${params.name}`);
         }
         const mcp = this.mcps.get(mcpName);
         if (!mcp) {
-            logger.error({ mcpName }, `MCP not found for tool: ${toolName}`);
+            logger.error({ mcpName }, `MCP not found for tool: ${params.name}`);
             throw new Error(`MCP not found: ${mcpName}`);
         }
         // Strip namespace prefix to get original tool name
         const originalName = this.useNamespacing
-            ? stripNamespace(mcpName, toolName)
-            : toolName;
-        logger.info({ args }, `Tool call: ${toolName}`);
+            ? stripNamespace(mcpName, params.name)
+            : params.name;
+        logger.info({ arguments: params.arguments }, `Tool call: ${params.name}`);
         const startTime = Date.now();
         const result = await mcp.client.callTool({
             name: originalName,
-            arguments: args,
+            arguments: params.arguments,
         });
         const duration = Date.now() - startTime;
         logger.info({
             duration: `${duration}ms`,
             isError: result.isError ?? false,
-        }, `Tool result: ${toolName}`);
+        }, `Tool result: ${params.name}`);
         return result;
     }
-    async readResource(resourceUri) {
-        const mcpName = this.resourceToMcp.get(resourceUri);
+    async readResource(params) {
+        const mcpName = this.resourceToMcp.get(params.uri);
         if (!mcpName) {
-            logger.warn(`Unknown resource: ${resourceUri}`);
-            throw new Error(`Unknown resource: ${resourceUri}`);
+            logger.warn(`Unknown resource: ${params.uri}`);
+            throw new Error(`Unknown resource: ${params.uri}`);
         }
         const mcp = this.mcps.get(mcpName);
         if (!mcp) {
-            logger.error({ mcpName }, `MCP not found for resource: ${resourceUri}`);
+            logger.error({ mcpName }, `MCP not found for resource: ${params.uri}`);
             throw new Error(`MCP not found: ${mcpName}`);
         }
         // Strip namespace prefix to get original URI
         const originalUri = this.useNamespacing
-            ? stripNamespace(mcpName, resourceUri)
-            : resourceUri;
-        logger.info(`Resource read: ${resourceUri}`);
+            ? stripNamespace(mcpName, params.uri)
+            : params.uri;
+        logger.info(`Resource read: ${params.uri}`);
         const startTime = Date.now();
         const result = await mcp.client.readResource({ uri: originalUri });
         const duration = Date.now() - startTime;
-        logger.info({ duration: `${duration}ms` }, `Resource result: ${resourceUri}`);
+        logger.info({ duration: `${duration}ms` }, `Resource result: ${params.uri}`);
         return result;
     }
-    async getPrompt(promptName, args) {
-        const mcpName = this.promptToMcp.get(promptName);
+    async getPrompt(params) {
+        const mcpName = this.promptToMcp.get(params.name);
         if (!mcpName) {
-            logger.warn(`Unknown prompt: ${promptName}`);
-            throw new Error(`Unknown prompt: ${promptName}`);
+            logger.warn(`Unknown prompt: ${params.name}`);
+            throw new Error(`Unknown prompt: ${params.name}`);
         }
         const mcp = this.mcps.get(mcpName);
         if (!mcp) {
-            logger.error({ mcpName }, `MCP not found for prompt: ${promptName}`);
+            logger.error({ mcpName }, `MCP not found for prompt: ${params.name}`);
             throw new Error(`MCP not found: ${mcpName}`);
         }
         // Strip namespace prefix to get original name
         const originalName = this.useNamespacing
-            ? stripNamespace(mcpName, promptName)
-            : promptName;
-        logger.info({ args }, `Prompt get: ${promptName}`);
+            ? stripNamespace(mcpName, params.name)
+            : params.name;
+        logger.info({ arguments: params.arguments }, `Prompt get: ${params.name}`);
         const startTime = Date.now();
         const result = await mcp.client.getPrompt({
             name: originalName,
-            arguments: args,
+            arguments: params.arguments,
         });
         const duration = Date.now() - startTime;
-        logger.info({ duration: `${duration}ms` }, `Prompt result: ${promptName}`);
+        logger.info({ duration: `${duration}ms` }, `Prompt result: ${params.name}`);
         return result;
     }
-    async complete(ref, argument) {
-        const { mcpName, originalRef } = this.resolveCompletionRef(ref);
+    async complete(params) {
+        const { mcpName, originalRef } = this.resolveCompletionRef(params.ref);
         const mcp = this.mcps.get(mcpName);
         if (!mcp) {
             logger.error({ mcpName }, "MCP not found for completion");
             throw new Error(`MCP not found: ${mcpName}`);
         }
-        logger.info({ ref, argument }, "Completion request");
+        logger.info({ ref: params.ref, argument: params.argument }, "Completion request");
         const startTime = Date.now();
-        const result = await mcp.client.complete({ ref: originalRef, argument });
+        const result = await mcp.client.complete({
+            ref: originalRef,
+            argument: params.argument,
+        });
         const duration = Date.now() - startTime;
         logger.info({ duration: `${duration}ms` }, "Completion result");
         return result;

package/dist/server.js

@@ -7,7 +7,7 @@ import { OAuthServer } from "./auth/oauth.js";
 import { GitHubIdentityProvider } from "./auth/providers/github.js";
 import { LocalIdentityProvider } from "./auth/providers/local.js";
 import { logger } from "./logger.js";
-import { handleCompletionComplete, handleInitialize, handleInitialized, handleMethodNotFound, handlePing, handlePromptsGet, handlePromptsList, handleResourcesList, handleResourcesRead, handleToolsCall, handleToolsList, } from "./mcp/handlers.js";
+import { createMcpHandler } from "./mcp/handler.js";
 import { McpManager } from "./mcp/manager.js";
 import { MemoryStore } from "./storage/memory.js";
 import { SqliteStore } from "./storage/sqlite.js";
@@ -150,67 +150,15 @@ export async function createServer(config) {
         }
         return next();
     });
-    // MCP handler
-    const handleMcp = async (c) => {
-        let message;
-        try {
-            message = await c.req.json();
-        }
-        catch (e) {
-            logger.warn({ error: e instanceof Error ? e.message : String(e) }, "MCP parse error");
-            return c.json({
-                jsonrpc: "2.0",
-                error: { code: -32700, message: "Parse error" },
-                id: null,
-            }, 400);
-        }
-        const method = "method" in message ? message.method : undefined;
-        const id = "id" in message ? message.id : undefined;
-        logger.debug({ method, id }, "MCP request");
-        if (method === "initialize") {
-            return handleInitialize(c, message);
-        }
-        if (method === "notifications/initialized") {
-            return handleInitialized(c);
-        }
-        if (method === "tools/list") {
-            return handleToolsList(c, message, mcpManager);
-        }
-        if (method === "tools/call") {
-            const params = message.params;
-            return handleToolsCall(c, message, mcpManager, params);
-        }
-        if (method === "resources/list") {
-            return handleResourcesList(c, message, mcpManager);
-        }
-        if (method === "resources/read") {
-            const params = message.params;
-            return handleResourcesRead(c, message, mcpManager, params);
-        }
-        if (method === "prompts/list") {
-            return handlePromptsList(c, message, mcpManager);
-        }
-        if (method === "prompts/get") {
-            const params = message.params;
-            return handlePromptsGet(c, message, mcpManager, params);
-        }
-        if (method === "ping") {
-            return handlePing(c, message);
-        }
-        if (method === "completion/complete") {
-            const params = message.params;
-            return handleCompletionComplete(c, message, mcpManager, params);
-        }
-        return handleMethodNotFound(c, message, method ?? "unknown");
-    };
     // Status endpoint (protected)
     protectedRoutes.get("/status", async (c) => {
         const health = await mcpManager.checkHealth();
         return c.json({ servers: health.servers });
     });
     // MCP endpoints (protected)
-    protectedRoutes.post("/", handleMcp);
-    protectedRoutes.post("/mcp", handleMcp);
+    const mcp = createMcpHandler(mcpManager);
+    protectedRoutes.post("/", mcp);
+    protectedRoutes.post("/mcp", mcp);
     // Mount protected routes
     app.route("/", protectedRoutes);
     // 404 for other routes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcpbox",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "A lightweight gateway that exposes local stdio-based MCP servers via Streamable HTTP",
   "main": "dist/index.js",
   "bin": {
@@ -51,7 +51,7 @@
   "dependencies": {
     "@hono/node-server": "^1.19.9",
     "@modelcontextprotocol/sdk": "^1.25.3",
-    "bcryptjs": "^2.4.3",
+    "bcryptjs": "^3.0.0",
     "hono": "^4.11.7",
     "pino": "^10.3.0",
     "pino-pretty": "^13.1.3",
@@ -59,7 +59,6 @@
   },
   "devDependencies": {
     "@biomejs/biome": "^2.3.14",
-    "@types/bcryptjs": "^2.4.6",
     "@types/node": "^25.1.0",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3"

package/dist/mcp/handlers.d.ts

@@ -1,433 +0,0 @@
-import type { JSONRPCMessage } from "@modelcontextprotocol/sdk/types.js";
-import type { Context } from "hono";
-import type { McpManager } from "./manager.js";
-export declare function handleInitialize(c: Context, message: JSONRPCMessage): Response & import("hono").TypedResponse<{
-    jsonrpc: string;
-    id: string | number | undefined;
-    result: {
-        protocolVersion: string;
-        capabilities: {
-            tools: {
-                listChanged: true;
-            };
-            resources: {
-                listChanged: true;
-            };
-            prompts: {
-                listChanged: true;
-            };
-            completions: {};
-        };
-        serverInfo: {
-            name: string;
-            version: string;
-        };
-    };
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">;
-export declare function handleInitialized(c: Context): Response & import("hono").TypedResponse<null, 202, "body">;
-export declare function handleToolsList(c: Context, message: JSONRPCMessage, mcpManager: McpManager): Response & import("hono").TypedResponse<{
-    jsonrpc: string;
-    id: string | number | undefined;
-    result: {
-        tools: {
-            inputSchema: {
-                [x: string]: import("hono/utils/types").JSONValue;
-                type: "object";
-                properties?: {
-                    [x: string]: never;
-                } | undefined;
-                required?: string[] | undefined;
-            };
-            name: string;
-            description?: string | undefined;
-            outputSchema?: {
-                [x: string]: import("hono/utils/types").JSONValue;
-                type: "object";
-                properties?: {
-                    [x: string]: never;
-                } | undefined;
-                required?: string[] | undefined;
-            } | undefined;
-            annotations?: {
-                title?: string | undefined;
-                readOnlyHint?: boolean | undefined;
-                destructiveHint?: boolean | undefined;
-                idempotentHint?: boolean | undefined;
-                openWorldHint?: boolean | undefined;
-            } | undefined;
-            execution?: {
-                taskSupport?: "optional" | "required" | "forbidden" | undefined;
-            } | undefined;
-            _meta?: {
-                [x: string]: import("hono/utils/types").JSONValue;
-            } | undefined;
-            icons?: {
-                src: string;
-                mimeType?: string | undefined;
-                sizes?: string[] | undefined;
-                theme?: "light" | "dark" | undefined;
-            }[] | undefined;
-            title?: string | undefined;
-        }[];
-    };
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">;
-export declare function handleToolsCall(c: Context, message: JSONRPCMessage, mcpManager: McpManager, params: {
-    name: string;
-    arguments?: Record<string, unknown>;
-}): Promise<(Response & import("hono").TypedResponse<{
-    jsonrpc: string;
-    id: string | number | undefined;
-    result: {
-        [x: string]: import("hono/utils/types").JSONValue;
-        content: ({
-            type: "text";
-            text: string;
-            annotations?: {
-                audience?: ("user" | "assistant")[] | undefined;
-                priority?: number | undefined;
-                lastModified?: string | undefined;
-            } | undefined;
-            _meta?: {
-                [x: string]: import("hono/utils/types").JSONValue;
-            } | undefined;
-        } | {
-            type: "image";
-            data: string;
-            mimeType: string;
-            annotations?: {
-                audience?: ("user" | "assistant")[] | undefined;
-                priority?: number | undefined;
-                lastModified?: string | undefined;
-            } | undefined;
-            _meta?: {
-                [x: string]: import("hono/utils/types").JSONValue;
-            } | undefined;
-        } | {
-            type: "audio";
-            data: string;
-            mimeType: string;
-            annotations?: {
-                audience?: ("user" | "assistant")[] | undefined;
-                priority?: number | undefined;
-                lastModified?: string | undefined;
-            } | undefined;
-            _meta?: {
-                [x: string]: import("hono/utils/types").JSONValue;
-            } | undefined;
-        } | {
-            uri: string;
-            name: string;
-            type: "resource_link";
-            description?: string | undefined;
-            mimeType?: string | undefined;
-            annotations?: {
-                audience?: ("user" | "assistant")[] | undefined;
-                priority?: number | undefined;
-                lastModified?: string | undefined;
-            } | undefined;
-            _meta?: {
-                [x: string]: import("hono/utils/types").JSONValue;
-            } | undefined;
-            icons?: {
-                src: string;
-                mimeType?: string | undefined;
-                sizes?: string[] | undefined;
-                theme?: "light" | "dark" | undefined;
-            }[] | undefined;
-            title?: string | undefined;
-        } | {
-            type: "resource";
-            resource: {
-                uri: string;
-                text: string;
-                mimeType?: string | undefined;
-                _meta?: {
-                    [x: string]: import("hono/utils/types").JSONValue;
-                } | undefined;
-            } | {
-                uri: string;
-                blob: string;
-                mimeType?: string | undefined;
-                _meta?: {
-                    [x: string]: import("hono/utils/types").JSONValue;
-                } | undefined;
-            };
-            annotations?: {
-                audience?: ("user" | "assistant")[] | undefined;
-                priority?: number | undefined;
-                lastModified?: string | undefined;
-            } | undefined;
-            _meta?: {
-                [x: string]: import("hono/utils/types").JSONValue;
-            } | undefined;
-        })[];
-        _meta?: {
-            [x: string]: import("hono/utils/types").JSONValue;
-            progressToken?: string | number | undefined;
-            "io.modelcontextprotocol/related-task"?: {
-                taskId: string;
-            } | undefined;
-        } | undefined;
-        structuredContent?: {
-            [x: string]: import("hono/utils/types").JSONValue;
-        } | undefined;
-        isError?: boolean | undefined;
-    };
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
-    jsonrpc: string;
-    id: string | number | undefined;
-    error: {
-        code: number;
-        message: string;
-    };
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">)>;
-export declare function handlePing(c: Context, message: JSONRPCMessage): Response & import("hono").TypedResponse<{
-    jsonrpc: string;
-    id: string | number | undefined;
-    result: {};
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">;
-export declare function handleResourcesList(c: Context, message: JSONRPCMessage, mcpManager: McpManager): Response & import("hono").TypedResponse<{
-    jsonrpc: string;
-    id: string | number | undefined;
-    result: {
-        resources: {
-            uri: string;
-            name: string;
-            description?: string | undefined;
-            mimeType?: string | undefined;
-            annotations?: {
-                audience?: ("user" | "assistant")[] | undefined;
-                priority?: number | undefined;
-                lastModified?: string | undefined;
-            } | undefined;
-            _meta?: {
-                [x: string]: import("hono/utils/types").JSONValue;
-            } | undefined;
-            icons?: {
-                src: string;
-                mimeType?: string | undefined;
-                sizes?: string[] | undefined;
-                theme?: "light" | "dark" | undefined;
-            }[] | undefined;
-            title?: string | undefined;
-        }[];
-    };
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">;
-export declare function handleResourcesRead(c: Context, message: JSONRPCMessage, mcpManager: McpManager, params: {
-    uri: string;
-}): Promise<(Response & import("hono").TypedResponse<{
-    jsonrpc: string;
-    id: string | number | undefined;
-    result: {
-        [x: string]: import("hono/utils/types").JSONValue;
-        contents: ({
-            uri: string;
-            text: string;
-            mimeType?: string | undefined;
-            _meta?: {
-                [x: string]: import("hono/utils/types").JSONValue;
-            } | undefined;
-        } | {
-            uri: string;
-            blob: string;
-            mimeType?: string | undefined;
-            _meta?: {
-                [x: string]: import("hono/utils/types").JSONValue;
-            } | undefined;
-        })[];
-        _meta?: {
-            [x: string]: import("hono/utils/types").JSONValue;
-            progressToken?: string | number | undefined;
-            "io.modelcontextprotocol/related-task"?: {
-                taskId: string;
-            } | undefined;
-        } | undefined;
-    };
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
-    jsonrpc: string;
-    id: string | number | undefined;
-    error: {
-        code: number;
-        message: string;
-    };
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">)>;
-export declare function handlePromptsList(c: Context, message: JSONRPCMessage, mcpManager: McpManager): Response & import("hono").TypedResponse<{
-    jsonrpc: string;
-    id: string | number | undefined;
-    result: {
-        prompts: {
-            name: string;
-            description?: string | undefined;
-            arguments?: {
-                name: string;
-                description?: string | undefined;
-                required?: boolean | undefined;
-            }[] | undefined;
-            _meta?: {
-                [x: string]: import("hono/utils/types").JSONValue;
-            } | undefined;
-            icons?: {
-                src: string;
-                mimeType?: string | undefined;
-                sizes?: string[] | undefined;
-                theme?: "light" | "dark" | undefined;
-            }[] | undefined;
-            title?: string | undefined;
-        }[];
-    };
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">;
-export declare function handlePromptsGet(c: Context, message: JSONRPCMessage, mcpManager: McpManager, params: {
-    name: string;
-    arguments?: Record<string, string>;
-}): Promise<(Response & import("hono").TypedResponse<{
-    jsonrpc: string;
-    id: string | number | undefined;
-    result: {
-        [x: string]: import("hono/utils/types").JSONValue;
-        messages: {
-            role: "user" | "assistant";
-            content: {
-                type: "text";
-                text: string;
-                annotations?: {
-                    audience?: ("user" | "assistant")[] | undefined;
-                    priority?: number | undefined;
-                    lastModified?: string | undefined;
-                } | undefined;
-                _meta?: {
-                    [x: string]: import("hono/utils/types").JSONValue;
-                } | undefined;
-            } | {
-                type: "image";
-                data: string;
-                mimeType: string;
-                annotations?: {
-                    audience?: ("user" | "assistant")[] | undefined;
-                    priority?: number | undefined;
-                    lastModified?: string | undefined;
-                } | undefined;
-                _meta?: {
-                    [x: string]: import("hono/utils/types").JSONValue;
-                } | undefined;
-            } | {
-                type: "audio";
-                data: string;
-                mimeType: string;
-                annotations?: {
-                    audience?: ("user" | "assistant")[] | undefined;
-                    priority?: number | undefined;
-                    lastModified?: string | undefined;
-                } | undefined;
-                _meta?: {
-                    [x: string]: import("hono/utils/types").JSONValue;
-                } | undefined;
-            } | {
-                uri: string;
-                name: string;
-                type: "resource_link";
-                description?: string | undefined;
-                mimeType?: string | undefined;
-                annotations?: {
-                    audience?: ("user" | "assistant")[] | undefined;
-                    priority?: number | undefined;
-                    lastModified?: string | undefined;
-                } | undefined;
-                _meta?: {
-                    [x: string]: import("hono/utils/types").JSONValue;
-                } | undefined;
-                icons?: {
-                    src: string;
-                    mimeType?: string | undefined;
-                    sizes?: string[] | undefined;
-                    theme?: "light" | "dark" | undefined;
-                }[] | undefined;
-                title?: string | undefined;
-            } | {
-                type: "resource";
-                resource: {
-                    uri: string;
-                    text: string;
-                    mimeType?: string | undefined;
-                    _meta?: {
-                        [x: string]: import("hono/utils/types").JSONValue;
-                    } | undefined;
-                } | {
-                    uri: string;
-                    blob: string;
-                    mimeType?: string | undefined;
-                    _meta?: {
-                        [x: string]: import("hono/utils/types").JSONValue;
-                    } | undefined;
-                };
-                annotations?: {
-                    audience?: ("user" | "assistant")[] | undefined;
-                    priority?: number | undefined;
-                    lastModified?: string | undefined;
-                } | undefined;
-                _meta?: {
-                    [x: string]: import("hono/utils/types").JSONValue;
-                } | undefined;
-            };
-        }[];
-        _meta?: {
-            [x: string]: import("hono/utils/types").JSONValue;
-            progressToken?: string | number | undefined;
-            "io.modelcontextprotocol/related-task"?: {
-                taskId: string;
-            } | undefined;
-        } | undefined;
-        description?: string | undefined;
-    };
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
-    jsonrpc: string;
-    id: string | number | undefined;
-    error: {
-        code: number;
-        message: string;
-    };
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">)>;
-export declare function handleCompletionComplete(c: Context, message: JSONRPCMessage, mcpManager: McpManager, params: {
-    ref: {
-        type: string;
-        name?: string;
-        uri?: string;
-    };
-    argument: {
-        name: string;
-        value: string;
-    };
-}): Promise<(Response & import("hono").TypedResponse<{
-    jsonrpc: string;
-    id: string | number | undefined;
-    result: {
-        [x: string]: import("hono/utils/types").JSONValue;
-        completion: {
-            [x: string]: import("hono/utils/types").JSONValue;
-            values: string[];
-            total?: number | undefined;
-            hasMore?: boolean | undefined;
-        };
-        _meta?: {
-            [x: string]: import("hono/utils/types").JSONValue;
-            progressToken?: string | number | undefined;
-            "io.modelcontextprotocol/related-task"?: {
-                taskId: string;
-            } | undefined;
-        } | undefined;
-    };
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
-    jsonrpc: string;
-    id: string | number | undefined;
-    error: {
-        code: number;
-        message: string;
-    };
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">)>;
-export declare function handleMethodNotFound(c: Context, message: JSONRPCMessage, method: string): Response & import("hono").TypedResponse<{
-    jsonrpc: string;
-    id: string | number | null;
-    error: {
-        code: number;
-        message: string;
-    };
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">;

package/dist/mcp/handlers.js

@@ -1,144 +0,0 @@
-import { NAME, VERSION } from "../version.js";
-function getMessageId(message) {
-    return "id" in message ? message.id : undefined;
-}
-export function handleInitialize(c, message) {
-    return c.json({
-        jsonrpc: "2.0",
-        id: getMessageId(message),
-        result: {
-            protocolVersion: "2025-11-25",
-            capabilities: {
-                tools: { listChanged: true },
-                resources: { listChanged: true },
-                prompts: { listChanged: true },
-                completions: {},
-            },
-            serverInfo: {
-                name: NAME,
-                version: VERSION,
-            },
-        },
-    });
-}
-export function handleInitialized(c) {
-    return c.body(null, 202);
-}
-export function handleToolsList(c, message, mcpManager) {
-    const tools = mcpManager.listTools();
-    return c.json({
-        jsonrpc: "2.0",
-        id: getMessageId(message),
-        result: { tools },
-    });
-}
-export async function handleToolsCall(c, message, mcpManager, params) {
-    try {
-        const result = await mcpManager.callTool(params.name, params.arguments ?? {});
-        return c.json({
-            jsonrpc: "2.0",
-            id: getMessageId(message),
-            result,
-        });
-    }
-    catch (error) {
-        return c.json({
-            jsonrpc: "2.0",
-            id: getMessageId(message),
-            error: {
-                code: -32603,
-                message: error instanceof Error ? error.message : "Internal error",
-            },
-        });
-    }
-}
-export function handlePing(c, message) {
-    return c.json({
-        jsonrpc: "2.0",
-        id: getMessageId(message),
-        result: {},
-    });
-}
-export function handleResourcesList(c, message, mcpManager) {
-    const resources = mcpManager.listResources();
-    return c.json({
-        jsonrpc: "2.0",
-        id: getMessageId(message),
-        result: { resources },
-    });
-}
-export async function handleResourcesRead(c, message, mcpManager, params) {
-    try {
-        const result = await mcpManager.readResource(params.uri);
-        return c.json({
-            jsonrpc: "2.0",
-            id: getMessageId(message),
-            result,
-        });
-    }
-    catch (error) {
-        return c.json({
-            jsonrpc: "2.0",
-            id: getMessageId(message),
-            error: {
-                code: -32603,
-                message: error instanceof Error ? error.message : "Internal error",
-            },
-        });
-    }
-}
-export function handlePromptsList(c, message, mcpManager) {
-    const prompts = mcpManager.listPrompts();
-    return c.json({
-        jsonrpc: "2.0",
-        id: getMessageId(message),
-        result: { prompts },
-    });
-}
-export async function handlePromptsGet(c, message, mcpManager, params) {
-    try {
-        const result = await mcpManager.getPrompt(params.name, params.arguments);
-        return c.json({
-            jsonrpc: "2.0",
-            id: getMessageId(message),
-            result,
-        });
-    }
-    catch (error) {
-        return c.json({
-            jsonrpc: "2.0",
-            id: getMessageId(message),
-            error: {
-                code: -32603,
-                message: error instanceof Error ? error.message : "Internal error",
-            },
-        });
-    }
-}
-export async function handleCompletionComplete(c, message, mcpManager, params) {
-    try {
-        const result = await mcpManager.complete(params.ref, params.argument);
-        return c.json({
-            jsonrpc: "2.0",
-            id: getMessageId(message),
-            result,
-        });
-    }
-    catch (error) {
-        return c.json({
-            jsonrpc: "2.0",
-            id: getMessageId(message),
-            error: {
-                code: -32603,
-                message: error instanceof Error ? error.message : "Internal error",
-            },
-        });
-    }
-}
-export function handleMethodNotFound(c, message, method) {
-    return c.json({
-        jsonrpc: "2.0",
-        id: getMessageId(message) ?? null,
-        error: { code: -32601, message: `Method not found: ${method}` },
-    });
-}