feat: add resources support

QuantGeekDev · QuantGeekDev · commit e8b03d432fd0 · 2024-12-10T00:00:52.000+01:00
diff --git a/src/core/MCPServer.ts b/src/core/MCPServer.ts
@@ -5,11 +5,17 @@ import {
   ListToolsRequestSchema,
   ListPromptsRequestSchema,
   GetPromptRequestSchema,
+  ListResourcesRequestSchema,
+  ReadResourceRequestSchema,
+  SubscribeRequestSchema,
+  UnsubscribeRequestSchema,
 } from "@modelcontextprotocol/sdk/types.js";
 import { ToolLoader } from "./toolLoader.js";
 import { PromptLoader } from "./promptLoader.js";
+import { ResourceLoader } from "./resourceLoader.js";
 import { ToolProtocol } from "../tools/BaseTool.js";
 import { PromptProtocol } from "../prompts/BasePrompt.js";
+import { ResourceProtocol } from "../resources/BaseResource.js";
 import { readFileSync } from "fs";
 import { join, dirname } from "path";
 import { logger } from "./Logger.js";
@@ -30,14 +36,19 @@ export type ServerCapabilities = {
   prompts?: {
     enabled: true;
   };
+  resources?: {
+    enabled: true;
+  };
 };
 
 export class MCPServer {
   private server: Server;
   private toolsMap: Map<string, ToolProtocol> = new Map();
   private promptsMap: Map<string, PromptProtocol> = new Map();
+  private resourcesMap: Map<string, ResourceProtocol> = new Map();
   private toolLoader: ToolLoader;
   private promptLoader: PromptLoader;
+  private resourceLoader: ResourceLoader;
   private serverName: string;
   private serverVersion: string;
   private basePath: string;
@@ -53,6 +64,7 @@ export class MCPServer {
 
     this.toolLoader = new ToolLoader(this.basePath);
     this.promptLoader = new PromptLoader(this.basePath);
+    this.resourceLoader = new ResourceLoader(this.basePath);
 
     this.server = new Server(
       {
@@ -63,6 +75,7 @@ export class MCPServer {
         capabilities: {
           tools: { enabled: true },
           prompts: { enabled: false },
+          resources: { enabled: false },
         },
       }
     );
@@ -162,6 +175,66 @@ export class MCPServer {
         messages: await prompt.getMessages(request.params.arguments),
       };
     });
+
+    this.server.setRequestHandler(ListResourcesRequestSchema, async () => {
+      return {
+        resources: Array.from(this.resourcesMap.values()).map(
+          (resource) => resource.resourceDefinition
+        ),
+      };
+    });
+
+    this.server.setRequestHandler(
+      ReadResourceRequestSchema,
+      async (request) => {
+        const resource = this.resourcesMap.get(request.params.uri);
+        if (!resource) {
+          throw new Error(
+            `Unknown resource: ${
+              request.params.uri
+            }. Available resources: ${Array.from(this.resourcesMap.keys()).join(
+              ", "
+            )}`
+          );
+        }
+
+        return {
+          contents: await resource.read(),
+        };
+      }
+    );
+
+    this.server.setRequestHandler(SubscribeRequestSchema, async (request) => {
+      const resource = this.resourcesMap.get(request.params.uri);
+      if (!resource) {
+        throw new Error(`Unknown resource: ${request.params.uri}`);
+      }
+
+      if (!resource.subscribe) {
+        throw new Error(
+          `Resource ${request.params.uri} does not support subscriptions`
+        );
+      }
+
+      await resource.subscribe();
+      return {};
+    });
+
+    this.server.setRequestHandler(UnsubscribeRequestSchema, async (request) => {
+      const resource = this.resourcesMap.get(request.params.uri);
+      if (!resource) {
+        throw new Error(`Unknown resource: ${request.params.uri}`);
+      }
+
+      if (!resource.unsubscribe) {
+        throw new Error(
+          `Resource ${request.params.uri} does not support subscriptions`
+        );
+      }
+
+      await resource.unsubscribe();
+      return {};
+    });
   }
 
   private async detectCapabilities(): Promise<ServerCapabilities> {
@@ -170,15 +243,16 @@ export class MCPServer {
     if (await this.toolLoader.hasTools()) {
       capabilities.tools = { enabled: true };
       logger.debug("Tools capability enabled");
-    } else {
-      logger.debug("No tools found, tools capability disabled");
     }
 
     if (await this.promptLoader.hasPrompts()) {
       capabilities.prompts = { enabled: true };
       logger.debug("Prompts capability enabled");
-    } else {
-      logger.debug("No prompts found, prompts capability disabled");
+    }
+
+    if (await this.resourceLoader.hasResources()) {
+      capabilities.resources = { enabled: true };
+      logger.debug("Resources capability enabled");
     }
 
     return capabilities;
@@ -196,30 +270,37 @@ export class MCPServer {
         prompts.map((prompt: PromptProtocol) => [prompt.name, prompt])
       );
 
-      this.detectCapabilities();
+      const resources = await this.resourceLoader.loadResources();
+      this.resourcesMap = new Map(
+        resources.map((resource: ResourceProtocol) => [resource.uri, resource])
+      );
+
+      await this.detectCapabilities();
 
       const transport = new StdioServerTransport();
       await this.server.connect(transport);
 
-      if (tools.length > 0 || prompts.length > 0) {
+      logger.info(`Started ${this.serverName}@${this.serverVersion}`);
+
+      if (tools.length > 0) {
         logger.info(
-          `Started ${this.serverName}@${this.serverVersion} with ${tools.length} tools and ${prompts.length} prompts`
+          `Tools (${tools.length}): ${Array.from(this.toolsMap.keys()).join(
+            ", "
+          )}`
         );
-        if (tools.length > 0) {
-          logger.info(
-            `Available tools: ${Array.from(this.toolsMap.keys()).join(", ")}`
-          );
-        }
-        if (prompts.length > 0) {
-          logger.info(
-            `Available prompts: ${Array.from(this.promptsMap.keys()).join(
-              ", "
-            )}`
-          );
-        }
-      } else {
+      }
+      if (prompts.length > 0) {
+        logger.info(
+          `Prompts (${prompts.length}): ${Array.from(
+            this.promptsMap.keys()
+          ).join(", ")}`
+        );
+      }
+      if (resources.length > 0) {
         logger.info(
-          `Started ${this.serverName}@${this.serverVersion} with no tools or prompts`
+          `Resources (${resources.length}): ${Array.from(
+            this.resourcesMap.keys()
+          ).join(", ")}`
         );
       }
     } catch (error) {
diff --git a/src/core/resourceLoader.ts b/src/core/resourceLoader.ts
@@ -0,0 +1,133 @@
+import { ResourceProtocol } from "../resources/BaseResource.js";
+import { join, dirname } from "path";
+import { promises as fs } from "fs";
+import { logger } from "./Logger.js";
+
+export class ResourceLoader {
+  private readonly RESOURCES_DIR: string;
+  private readonly EXCLUDED_FILES = [
+    "BaseResource.js",
+    "*.test.js",
+    "*.spec.js",
+  ];
+
+  constructor(basePath?: string) {
+    const mainModulePath = basePath || process.argv[1];
+    this.RESOURCES_DIR = join(dirname(mainModulePath), "resources");
+    logger.debug(
+      `Initialized ResourceLoader with directory: ${this.RESOURCES_DIR}`
+    );
+  }
+
+  async hasResources(): Promise<boolean> {
+    try {
+      const stats = await fs.stat(this.RESOURCES_DIR);
+      if (!stats.isDirectory()) {
+        logger.debug("Resources path exists but is not a directory");
+        return false;
+      }
+
+      const files = await fs.readdir(this.RESOURCES_DIR);
+      const hasValidFiles = files.some((file) => this.isResourceFile(file));
+      logger.debug(`Resources directory has valid files: ${hasValidFiles}`);
+      return hasValidFiles;
+    } catch (error) {
+      logger.debug("No resources directory found");
+      return false;
+    }
+  }
+
+  private isResourceFile(file: string): boolean {
+    if (!file.endsWith(".js")) return false;
+    const isExcluded = this.EXCLUDED_FILES.some((pattern) => {
+      if (pattern.includes("*")) {
+        const regex = new RegExp(pattern.replace("*", ".*"));
+        return regex.test(file);
+      }
+      return file === pattern;
+    });
+
+    logger.debug(
+      `Checking file ${file}: ${isExcluded ? "excluded" : "included"}`
+    );
+    return !isExcluded;
+  }
+
+  private validateResource(resource: any): resource is ResourceProtocol {
+    const isValid = Boolean(
+      resource &&
+        typeof resource.uri === "string" &&
+        typeof resource.name === "string" &&
+        resource.resourceDefinition &&
+        typeof resource.read === "function"
+    );
+
+    if (isValid) {
+      logger.debug(`Validated resource: ${resource.name}`);
+    } else {
+      logger.warn(`Invalid resource found: missing required properties`);
+    }
+
+    return isValid;
+  }
+
+  async loadResources(): Promise<ResourceProtocol[]> {
+    try {
+      logger.debug(`Attempting to load resources from: ${this.RESOURCES_DIR}`);
+
+      let stats;
+      try {
+        stats = await fs.stat(this.RESOURCES_DIR);
+      } catch (error) {
+        logger.debug("No resources directory found");
+        return [];
+      }
+
+      if (!stats.isDirectory()) {
+        logger.error(`Path is not a directory: ${this.RESOURCES_DIR}`);
+        return [];
+      }
+
+      const files = await fs.readdir(this.RESOURCES_DIR);
+      logger.debug(`Found files in directory: ${files.join(", ")}`);
+
+      const resources: ResourceProtocol[] = [];
+
+      for (const file of files) {
+        if (!this.isResourceFile(file)) {
+          continue;
+        }
+
+        try {
+          const fullPath = join(this.RESOURCES_DIR, file);
+          logger.debug(`Attempting to load resource from: ${fullPath}`);
+
+          const importPath = `file://${fullPath}`;
+          const { default: ResourceClass } = await import(importPath);
+
+          if (!ResourceClass) {
+            logger.warn(`No default export found in ${file}`);
+            continue;
+          }
+
+          const resource = new ResourceClass();
+          if (this.validateResource(resource)) {
+            resources.push(resource);
+          }
+        } catch (error) {
+          logger.error(`Error loading resource ${file}: ${error}`);
+        }
+      }
+
+      logger.debug(
+        `Successfully loaded ${resources.length} resources: ${resources
+          .map((r) => r.name)
+          .join(", ")}`
+      );
+      return resources;
+    } catch (error) {
+      logger.error(`Failed to load resources: ${error}`);
+      return [];
+    }
+  }
+}
diff --git a/src/index.ts b/src/index.ts
@@ -11,5 +11,13 @@ export {
   type PromptArgumentSchema,
   type PromptArguments,
 } from "./prompts/BasePrompt.js";
+export {
+  MCPResource,
+  type ResourceProtocol,
+  type ResourceContent,
+  type ResourceDefinition,
+  type ResourceTemplateDefinition,
+} from "./resources/BaseResource.js";
 export { ToolLoader } from "./core/toolLoader.js";
 export { PromptLoader } from "./core/promptLoader.js";
+export { ResourceLoader } from "./core/resourceLoader.js";
diff --git a/src/resources/BaseResource.ts b/src/resources/BaseResource.ts

-Original file line number
+Diff line change
 +export type ResourceContent = {
 +  uri: string;
 +  mimeType?: string;
 +  text?: string;
 +  blob?: string;
 +};
++
 +export type ResourceDefinition = {
 +  uri: string;
 +  name: string;
 +  description?: string;
 +  mimeType?: string;
 +};
++
 +export type ResourceTemplateDefinition = {
 +  uriTemplate: string;
 +  name: string;
 +  description?: string;
 +  mimeType?: string;
 +};
++
 +export interface ResourceProtocol {
 +  uri: string;
 +  name: string;
 +  description?: string;
 +  mimeType?: string;
 +  resourceDefinition: ResourceDefinition;
 +  read(): Promise<ResourceContent[]>;
 +  subscribe?(): Promise<void>;
 +  unsubscribe?(): Promise<void>;
 +}
++
 +export abstract class MCPResource implements ResourceProtocol {
 +  abstract uri: string;
 +  abstract name: string;
 +  description?: string;
 +  mimeType?: string;
++
 +  get resourceDefinition(): ResourceDefinition {
 +    return {
 +      uri: this.uri,
 +      name: this.name,
 +      description: this.description,
 +      mimeType: this.mimeType,
 +    };
 +  }
++
 +  abstract read(): Promise<ResourceContent[]>;
++
 +  async subscribe?(): Promise<void> {
 +    throw new Error("Subscription not implemented for this resource");
 +  }
++
 +  async unsubscribe?(): Promise<void> {
 +    throw new Error("Unsubscription not implemented for this resource");
 +  }
++
 +  protected async fetch<T>(url: string, init?: RequestInit): Promise<T> {
 +    const response = await fetch(url, init);
 +    if (!response.ok) {
 +      throw new Error(`HTTP error! status: ${response.status}`);
 +    }
 +    return response.json();
 +  }
 +}