@williamp29/project-mcp-server 3.0.1 → 3.1.0

package/README.md

@@ -65,23 +65,44 @@ const mysqlDriver = new MySQLDriver({
 
 // 3. Create and start the server
 const server = new MCPServer({
-  specPath: "./openapi-spec.json",
+  specPath: "./openapi-spec.json", // Optional: Omit to skip API explorer
   api: {
     baseUrl: "https://api.example.com",
     authContext: new GlobalAuthContext(new MyCustomAuth()),
   },
-  database: {
+  database: { // Optional: Pass undefined to skip database initialization
     driver: mysqlDriver,
     permissions: {
-      enableRunQuery: true,         // Default: true
-      enableRunUpdateStatement: true, // Default: true
-      enableRunDeleteStatement: false, // Default: false
-      enableRunStatement: false      // Default: false
+      enableRunQuery: true,
+      enableRunUpdateStatement: true,
+      enableRunDeleteStatement: false,
+      enableRunStatement: false
     }
   }
 });
 
-server.start().catch(console.error);
+await server.start();
+```
+
+### Lifecycle Management
+
+The `MCPServer` class provides methods to manage the server's lifecycle programmatically:
+
+| Method | Description |
+| :--- | :--- |
+| `start()` | Initializes the API explorer and database connection, then connects to the transport. |
+| `stop()` | Gracefully disconnects from the database and closes the MCP server. |
+| `reload()` | Restarts the server, clearing registered tools and re-initializing all configurations. |
+
+Example:
+```typescript
+await server.start();
+
+// Later, to restart the server with refreshed configuration:
+await server.reload();
+
+// To shut down the server:
+await server.stop();
 ```
 
 ### 3. Custom Database Drivers

package/dist/api-explorer/tool-generator.js

@@ -71,7 +71,11 @@ export class ToolGenerator {
             case "api_get_tags_endpoints":
                 return this.parser.getEndpointsByTags(args.tags);
             case "api_get_all_endpoints":
-                return this.parser.getEndpoints();
+                return this.parser.getEndpoints().map(e => ({
+                    method: e.method,
+                    path: e.path,
+                    summary: e.summary,
+                }));
             case "api_get_endpoint":
                 return this.parser.getEndpoint(args.method, args.path);
             case "api_get_endpoints":

package/dist/mcp-server.d.ts

@@ -11,7 +11,7 @@ export type { ApiConfig };
  * 3. Impersonate users via the set_identity tool.
  */
 export interface MCPServerOptions {
-    specPath: string;
+    specPath?: string;
     api?: ApiConfig;
     database?: DatabaseConfig;
 }
@@ -26,22 +26,30 @@ export interface MCPServerOptions {
  */
 export declare class MCPServer {
     private server;
-    private parser;
-    private toolGenerator;
-    private apiExecutor;
-    private authContext;
+    private parser?;
+    private toolGenerator?;
+    private apiExecutor?;
+    private authContext?;
     private dbExecutor?;
     private dbToolGenerator?;
-    private specPath;
+    private specPath?;
+    private transport?;
+    private options;
     /**
      * @param options - Configuration options for the MCP Server.
      */
     constructor(options: MCPServerOptions);
-    private initParser;
+    private initApiExplorer;
+    private initDatabase;
     private registerTools;
+    start(): Promise<void>;
     /**
-     * Starts the MCP server on Stdio transport.
-     * This method ensures the OpenAPI spec is loaded and tools are registered before connecting.
+     * Stops the MCP server and disconnects any database connections.
      */
-    start(): Promise<void>;
+    stop(): Promise<void>;
+    /**
+     * Reloads the MCP server by stopping it and starting it again.
+     * This will re-initialize the OpenAPI parser and database connection.
+     */
+    reload(): Promise<void>;
 }

package/dist/mcp-server.js

@@ -24,17 +24,22 @@ export class MCPServer {
     dbExecutor;
     dbToolGenerator;
     specPath;
+    transport;
+    options;
     /**
      * @param options - Configuration options for the MCP Server.
      */
     constructor(options) {
+        this.options = options;
         this.specPath = options.specPath;
-        this.parser = new OpenAPIParser();
-        this.toolGenerator = new ToolGenerator(this.parser);
-        this.authContext = options.api?.authContext || createAuthContextFromEnv();
-        const apiBaseUrl = options.api?.baseUrl;
-        const dbConfig = options.database || createDbConfigFromEnv();
-        this.apiExecutor = new ApiExecutor(apiBaseUrl, this.authContext);
+        if (this.specPath) {
+            this.parser = new OpenAPIParser();
+            this.toolGenerator = new ToolGenerator(this.parser);
+            this.authContext = options.api?.authContext || createAuthContextFromEnv();
+            const apiBaseUrl = options.api?.baseUrl;
+            this.apiExecutor = new ApiExecutor(apiBaseUrl, this.authContext);
+        }
+        const dbConfig = 'database' in options ? options.database : createDbConfigFromEnv();
         if (dbConfig) {
             this.dbExecutor = new DbExecutor(dbConfig.driver, dbConfig.permissions);
             this.dbToolGenerator = new DbToolGenerator(dbConfig.driver, dbConfig.permissions);
@@ -44,47 +49,58 @@ export class MCPServer {
             version: "1.0.0",
         });
     }
-    async initParser() {
+    async initApiExplorer() {
+        if (!this.parser || !this.specPath)
+            return;
         try {
             await this.parser.loadSpec(this.specPath);
             console.error(`Loaded OpenAPI spec from ${this.specPath}`);
-            if (this.dbExecutor) {
-                await this.dbExecutor.connect();
-            }
-            this.registerTools();
         }
         catch (error) {
             console.error(`Failed to load OpenAPI spec: ${error}`);
             process.exit(1);
         }
     }
+    async initDatabase() {
+        if (this.dbExecutor) {
+            try {
+                await this.dbExecutor.connect();
+                console.error("Connected to database");
+            }
+            catch (error) {
+                console.error(`Failed to connect to database: ${error}`);
+            }
+        }
+    }
     registerTools() {
-        const definitions = this.toolGenerator.getToolDefinitions();
-        Object.entries(definitions).forEach(([name, def]) => {
-            this.server.registerTool(name, {
-                description: def.description,
-                inputSchema: def.inputSchema,
-            }, async (args) => {
-                try {
-                    let result;
-                    if (name === "api_call_endpoint") {
-                        result = await this.apiExecutor.callEndpoint(args);
+        if (this.toolGenerator && this.apiExecutor) {
+            const definitions = this.toolGenerator.getToolDefinitions();
+            Object.entries(definitions).forEach(([name, def]) => {
+                this.server.registerTool(name, {
+                    description: def.description,
+                    inputSchema: def.inputSchema,
+                }, async (args) => {
+                    try {
+                        let result;
+                        if (name === "api_call_endpoint") {
+                            result = await this.apiExecutor.callEndpoint(args);
+                        }
+                        else {
+                            result = this.toolGenerator.handleToolCall(name, args);
+                        }
+                        return {
+                            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+                        };
                     }
-                    else {
-                        result = this.toolGenerator.handleToolCall(name, args);
+                    catch (error) {
+                        return {
+                            content: [{ type: "text", text: `Error: ${error.message}` }],
+                            isError: true,
+                        };
                     }
-                    return {
-                        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
-                    };
-                }
-                catch (error) {
-                    return {
-                        content: [{ type: "text", text: `Error: ${error.message}` }],
-                        isError: true,
-                    };
-                }
+                });
             });
-        });
+        }
         if (this.dbToolGenerator) {
             const dbDefinitions = this.dbToolGenerator.getToolDefinitions();
             Object.entries(dbDefinitions).forEach(([name, def]) => {
@@ -108,34 +124,60 @@ export class MCPServer {
                 });
             });
         }
-        this.server.registerTool("api_set_identity", {
-            description: "Set the identity (identifier) for future API requests. Requires an 'identity' auth strategy to be active.",
-            inputSchema: z.object({
-                identifier: z.string().describe("The new identity value (e.g., user UID)."),
-            }),
-        }, async ({ identifier }) => {
-            try {
-                this.authContext.setIdentifier(identifier);
-                return {
-                    content: [{ type: "text", text: `Successfully updated identity to: ${identifier}` }],
-                };
-            }
-            catch (error) {
-                return {
-                    content: [{ type: "text", text: `Error: ${error.message}` }],
-                    isError: true,
-                };
-            }
-        });
+        if (this.authContext) {
+            this.server.registerTool("api_set_identity", {
+                description: "Set the identity (identifier) for future API requests. Requires an 'identity' auth strategy to be active.",
+                inputSchema: z.object({
+                    identifier: z.string().describe("The new identity value (e.g., user UID)."),
+                }),
+            }, async ({ identifier }) => {
+                try {
+                    this.authContext.setIdentifier(identifier);
+                    return {
+                        content: [{ type: "text", text: `Successfully updated identity to: ${identifier}` }],
+                    };
+                }
+                catch (error) {
+                    return {
+                        content: [{ type: "text", text: `Error: ${error.message}` }],
+                        isError: true,
+                    };
+                }
+            });
+        }
     }
-    /**
-     * Starts the MCP server on Stdio transport.
-     * This method ensures the OpenAPI spec is loaded and tools are registered before connecting.
-     */
     async start() {
-        await this.initParser();
-        const transport = new StdioServerTransport();
-        await this.server.connect(transport);
+        await this.initApiExplorer();
+        await this.initDatabase();
+        this.registerTools();
+        if (!this.transport) {
+            this.transport = new StdioServerTransport();
+        }
+        await this.server.connect(this.transport);
         console.error("OpenAPI MCP server running on stdio");
     }
+    /**
+     * Stops the MCP server and disconnects any database connections.
+     */
+    async stop() {
+        if (this.dbExecutor) {
+            await this.dbExecutor.disconnect();
+        }
+        await this.server.close();
+        this.transport = undefined;
+        console.error("MCP server stopped");
+    }
+    /**
+     * Reloads the MCP server by stopping it and starting it again.
+     * This will re-initialize the OpenAPI parser and database connection.
+     */
+    async reload() {
+        await this.stop();
+        this.server = new McpServer({
+            name: "project-mcp-server",
+            version: "1.0.0",
+        });
+        await this.start();
+        console.error("MCP server reloaded");
+    }
 }

package/package.json

@@ -1,10 +1,24 @@
 {
   "name": "@williamp29/project-mcp-server",
-  "version": "3.0.1",
+  "version": "3.1.0",
   "description": "A ModelContextProtocol server to let agents discover your project, such as APIs (using OpenAPI) or other resources.",
   "repository": "https://github.com/WilliamPinto-Olmos/project-mcp-server",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "license": "MIT",
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "ai",
+    "agent",
+    "openapi",
+    "database",
+    "api",
+    "sql",
+    "cursor",
+    "claudecode",
+    "copilot"
+  ],
   "bin": {
     "project-mcp-server": "dist/cli.js"
   },