@williamp29/project-mcp-server 2.0.0 → 3.0.0

package/README.md

@@ -42,26 +42,92 @@ npm install @williamp29/project-mcp-server
 Create a file (e.g., `mcp-server.ts`) to configure and start your server:
 
 ```typescript
-import { MCPServer } from "@williamp29/project-mcp-server";
+import { MCPServer, MySQLDriver } from "@williamp29/project-mcp-server";
 import { AuthStrategy, GlobalAuthContext } from "@williamp29/project-mcp-server/api-explorer";
 
-// (Optional) Define a custom authentication strategy
+// 1. (Optional) Define a custom authentication strategy for APIs
 class MyCustomAuth implements AuthStrategy {
   name = "MyCustomAuth";
   async getHeaders() {
-    // Fetch token from vault, env, or database
     return { "Authorization": `Bearer ${process.env.MY_API_TOKEN}` };
   }
 }
 
+// 2. (Optional) Initialize a database driver
+// You can use the built-in MySQLDriver
+const mysqlDriver = new MySQLDriver({
+  host: process.env.DB_HOST || "localhost",
+  port: 3306,
+  user: "root",
+  password: "password",
+  database: "my_database"
+});
+
+// 3. Create and start the server
 const server = new MCPServer({
-  specPath: "./openapi-spec.json", // Path to your OpenAPI spec
-  authContext: new GlobalAuthContext(new MyCustomAuth())
+  specPath: "./openapi-spec.json",
+  api: {
+    baseUrl: "https://api.example.com",
+    authContext: new GlobalAuthContext(new MyCustomAuth()),
+  },
+  database: {
+    driver: mysqlDriver,
+    permissions: {
+      enableRunQuery: true,         // Default: true
+      enableRunUpdateStatement: true, // Default: true
+      enableRunDeleteStatement: false, // Default: false
+      enableRunStatement: false      // Default: false
+    }
+  }
 });
 
 server.start().catch(console.error);
 ```
 
+### 3. Custom Database Drivers
+You can implement your own database driver by satisfying the `DbDriver` interface. This allows you to use any database (PostgreSQL, SQLite, etc.) with the MCP server.
+
+```typescript
+import { MCPServer, DbDriver, DbDriverPermissions, DbDriverToolDefinitions } from "@williamp29/project-mcp-server";
+
+class MyPostgresDriver implements DbDriver {
+  name = "postgres";
+  
+  async connect() { /* ... */ }
+  async disconnect() { /* ... */ }
+  
+  // Implement introspection methods
+  async listTables() { /* ... */ }
+  async listTableNames() { return ["table1", "table2"]; }
+  async describeTable(table: string) { /* ... */ }
+  // ... other DbDriver methods
+
+  // Define which tools this driver supports
+  getToolDefinitions(permissions: DbDriverPermissions): DbDriverToolDefinitions {
+    return {
+      db_list_tables: { description: "List all tables" },
+      // ...
+    };
+  }
+
+  // Handle tool execution
+  async handleToolCall(name: string, args: any) {
+    if (name === "db_list_tables") return this.listTables();
+    // ...
+  }
+}
+
+const server = new MCPServer({
+  specPath: "./openapi-spec.json",
+  api: {
+    baseUrl: "https://api.example.com",
+  },
+  database: {
+    driver: new MyPostgresDriver()
+  }
+});
+```
+
 ### 3. Add Script to package.json
 ```json
 {
@@ -113,8 +179,9 @@ These variables control the server behavior. They are automatically loaded if yo
   - `api_set_identity`: Switch the active user context for API calls dynamically during a session.
 
 - **Database Explorer**:
-  - Inspect schemas with `db_list_tables`, `db_describe_tables`, and `db_get_schemas`.
+  - Inspect schemas with `db_list_tables`, `db_list_table_names`, `db_describe_tables`, and `db_get_schemas`.
   - Discover database structure with `db_get_relationships` (supports table filtering).
   - Analyze data with `db_get_table_stats` and `db_sample_rows`.
   - Run validated SQL with `db_run_query`, `db_run_update_statement`, and `db_run_delete_statement`.
-  - Supports MySQL (driver included).
+  - Extensible architecture: Supports **Custom Drivers**!
+  - Includes `MySQLDriver` for direct MySQL/MariaDB usage.

package/dist/api-explorer/api-executor.js

@@ -1,7 +1,5 @@
 import axios from "axios";
-import dotenv from "dotenv";
 import { createAuthContextFromEnv, runRequestHooks } from "./auth/index.js";
-dotenv.config();
 /**
  * Handles the actual HTTP communication with the API.
  * Uses axios interceptors to dynamically inject authentication headers and run request hooks.

package/dist/api-explorer/auth/auth-context.js

@@ -2,8 +2,6 @@ import { isIdentifiable } from "./types.js";
 import { BearerStrategy } from "./strategies/bearer-strategy.js";
 import { IdentityStrategy } from "./strategies/identity-strategy.js";
 import { NoAuthStrategy } from "./strategies/no-auth-strategy.js";
-import dotenv from "dotenv";
-dotenv.config();
 /**
  * Standard implementation of AuthContext that wraps an AuthStrategy.
  * Handles runtime identifier updates for identity-based strategies.

package/dist/api-explorer/index.d.ts

@@ -2,3 +2,19 @@ export { OpenAPIParser } from "./openapi-parser.js";
 export { ToolGenerator } from "./tool-generator.js";
 export { ApiExecutor } from "./api-executor.js";
 export * from "./auth/index.js";
+import { AuthContext } from "./auth/index.js";
+/**
+ * Configuration for the API Explorer.
+ */
+export interface ApiConfig {
+    /**
+     * Optional custom authentication context.
+     * If not provided, it will be created from environment variables.
+     */
+    authContext?: AuthContext;
+    /**
+     * The target API base URL.
+     * If not provided, it will default to env.PROJECT_MCP_API_BASE_URL or "http://localhost:5000".
+     */
+    baseUrl?: string;
+}

package/dist/cli.js

@@ -1,27 +1,10 @@
 #!/usr/bin/env node
 import "dotenv/config";
-import { MCPServer } from "./index.js";
+import { MCPServer } from "./mcp-server.js";
 import path from "path";
 const specPath = process.env.PROJECT_MCP_OPENAPI_SPEC || path.resolve(process.cwd(), "openapi-spec.json");
-let dbConfig = undefined;
-if (process.env.PROJECT_MCP_DB_HOST) {
-    dbConfig = {
-        driver: process.env.PROJECT_MCP_DB_DRIVER || "mysql",
-        host: process.env.PROJECT_MCP_DB_HOST || "localhost",
-        port: parseInt(process.env.PROJECT_MCP_DB_PORT || "3306", 10),
-        user: process.env.PROJECT_MCP_DB_USER || "",
-        password: process.env.PROJECT_MCP_DB_PASSWORD || "",
-        database: process.env.PROJECT_MCP_DB_DATABASE || "",
-        poolSize: parseInt(process.env.PROJECT_MCP_DB_POOL_SIZE || "10", 10),
-        enableRunQuery: process.env.PROJECT_MCP_DB_ENABLE_QUERY !== "false",
-        enableRunUpdateStatement: process.env.PROJECT_MCP_DB_ENABLE_UPDATE !== "false",
-        enableRunDeleteStatement: process.env.PROJECT_MCP_DB_ENABLE_DELETE === "true",
-        enableRunStatement: process.env.PROJECT_MCP_DB_ENABLE_STATEMENT === "true",
-    };
-}
 const server = new MCPServer({
-    specPath,
-    dbConfig
+    specPath
 });
 server.start().catch((error) => {
     console.error("Failed to start MCP server:", error);

package/dist/db-explorer/db-executor.d.ts

@@ -1,12 +1,12 @@
-import { DbDriver, DbConfig } from "./types.js";
+import { DbDriver, DbDriverPermissions } from "./types.js";
 export declare class DbExecutor {
     private driver;
-    private config;
-    constructor(driver: DbDriver, config: DbConfig);
+    private permissions;
+    constructor(driver: DbDriver, permissions?: DbDriverPermissions);
     getDriver(): DbDriver;
     connect(): Promise<void>;
     disconnect(): Promise<void>;
-    listTables(): Promise<import("./types.js").TableInfo[]>;
+    listTables(tables?: string[]): Promise<import("./types.js").TableInfo[]>;
     describeTable(table: string): Promise<import("./types.js").ColumnInfo[]>;
     describeTables(tables: string[]): Promise<Record<string, any>>;
     getTableSchema(table: string): Promise<string>;
@@ -18,4 +18,5 @@ export declare class DbExecutor {
     runUpdateStatement(query: string): Promise<import("./types.js").UpdateResult>;
     runDeleteStatement(query: string): Promise<import("./types.js").DeleteResult>;
     runStatement(query: string): Promise<import("./types.js").StatementResult>;
+    handleToolCall(name: string, args: any): Promise<any>;
 }

package/dist/db-explorer/db-executor.js

@@ -1,10 +1,10 @@
 import { SqlValidator } from "./sql-validator.js";
 export class DbExecutor {
     driver;
-    config;
-    constructor(driver, config) {
+    permissions;
+    constructor(driver, permissions = {}) {
         this.driver = driver;
-        this.config = config;
+        this.permissions = permissions;
     }
     getDriver() {
         return this.driver;
@@ -15,8 +15,8 @@ export class DbExecutor {
     async disconnect() {
         await this.driver.disconnect();
     }
-    async listTables() {
-        return await this.driver.listTables();
+    async listTables(tables) {
+        return await this.driver.listTables(tables);
     }
     async describeTable(table) {
         return await this.driver.describeTable(table);
@@ -48,30 +48,44 @@ export class DbExecutor {
         return await this.driver.sampleRows(table, limit);
     }
     async runQuery(query) {
-        if (this.config.enableRunQuery === false) {
+        if (this.permissions.enableRunQuery === false) {
             throw new Error("Tool 'run_query' is disabled.");
         }
         SqlValidator.isSelectOnly(query);
         return await this.driver.executeQuery(query);
     }
     async runUpdateStatement(query) {
-        if (this.config.enableRunUpdateStatement === false) {
+        if (this.permissions.enableRunUpdateStatement === false) {
             throw new Error("Tool 'run_update_statement' is disabled.");
         }
         SqlValidator.isUpdateOnly(query);
         return await this.driver.executeUpdate(query);
     }
     async runDeleteStatement(query) {
-        if (this.config.enableRunDeleteStatement !== true) {
+        if (this.permissions.enableRunDeleteStatement !== true) {
             throw new Error("Tool 'run_delete_statement' is disabled.");
         }
         SqlValidator.isDeleteOnly(query);
         return await this.driver.executeDelete(query);
     }
     async runStatement(query) {
-        if (this.config.enableRunStatement !== true) {
+        if (this.permissions.enableRunStatement !== true) {
             throw new Error("Tool 'run_statement' is disabled.");
         }
         return await this.driver.executeStatement(query);
     }
+    async handleToolCall(name, args) {
+        switch (name) {
+            case "db_run_query":
+                return await this.runQuery(args.query);
+            case "db_run_update_statement":
+                return await this.runUpdateStatement(args.query);
+            case "db_run_delete_statement":
+                return await this.runDeleteStatement(args.query);
+            case "db_run_statement":
+                return await this.runStatement(args.query);
+            default:
+                return await this.driver.handleToolCall(name, args);
+        }
+    }
 }

package/dist/db-explorer/db-tool-generator.d.ts

@@ -1,67 +1,9 @@
-import { z } from "zod";
-import { DbExecutor } from "./db-executor.js";
+import { DbDriver, DbDriverPermissions } from "./types.js";
 export declare class DbToolGenerator {
+    private driver;
+    private permissions;
     private executor;
-    constructor(executor: DbExecutor);
-    getToolDefinitions(): {
-        db_list_tables: {
-            description: string;
-        };
-        db_describe_tables: {
-            description: string;
-            inputSchema: z.ZodObject<{
-                tables: z.ZodArray<z.ZodString>;
-            }, z.core.$strip>;
-        };
-        db_get_schemas: {
-            description: string;
-            inputSchema: z.ZodObject<{
-                tables: z.ZodArray<z.ZodString>;
-            }, z.core.$strip>;
-        };
-        db_get_relationships: {
-            description: string;
-            inputSchema: z.ZodObject<{
-                tables: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            }, z.core.$strip>;
-        };
-        db_get_table_stats: {
-            description: string;
-            inputSchema: z.ZodObject<{
-                table: z.ZodString;
-            }, z.core.$strip>;
-        };
-        db_sample_rows: {
-            description: string;
-            inputSchema: z.ZodObject<{
-                table: z.ZodString;
-                limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-            }, z.core.$strip>;
-        };
-        db_run_query: {
-            description: string;
-            inputSchema: z.ZodObject<{
-                query: z.ZodString;
-            }, z.core.$strip>;
-        };
-        db_run_update_statement: {
-            description: string;
-            inputSchema: z.ZodObject<{
-                query: z.ZodString;
-            }, z.core.$strip>;
-        };
-        db_run_delete_statement: {
-            description: string;
-            inputSchema: z.ZodObject<{
-                query: z.ZodString;
-            }, z.core.$strip>;
-        };
-        db_run_statement: {
-            description: string;
-            inputSchema: z.ZodObject<{
-                query: z.ZodString;
-            }, z.core.$strip>;
-        };
-    };
-    handleToolCall(name: string, args: any): Promise<any[] | Record<string, any> | import("./types.js").TableStats | import("./types.js").QueryResult | import("./types.js").DeleteResult | import("./types.js").StatementResult>;
+    constructor(driver: DbDriver, permissions?: DbDriverPermissions);
+    getToolDefinitions(): import("./types.js").DbDriverToolDefinitions;
+    handleToolCall(name: string, args: any): Promise<any>;
 }

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

@@ -1,95 +1,17 @@
-import { z } from "zod";
+import { DbExecutor } from "./db-executor.js";
 export class DbToolGenerator {
+    driver;
+    permissions;
     executor;
-    constructor(executor) {
-        this.executor = executor;
+    constructor(driver, permissions = {}) {
+        this.driver = driver;
+        this.permissions = permissions;
+        this.executor = new DbExecutor(driver, permissions);
     }
     getToolDefinitions() {
-        return {
-            db_list_tables: {
-                description: "List all tables in the current database.",
-            },
-            db_describe_tables: {
-                description: "Get detailed information about columns for multiple tables.",
-                inputSchema: z.object({
-                    tables: z.array(z.string()).describe("List of table names to describe."),
-                }),
-            },
-            db_get_schemas: {
-                description: "Get the DDL statements for multiple tables.",
-                inputSchema: z.object({
-                    tables: z.array(z.string()).describe("List of table names."),
-                }),
-            },
-            db_get_relationships: {
-                description: "Get foreign key relationships in the database, optionally filtered by tables.",
-                inputSchema: z.object({
-                    tables: z.array(z.string()).optional().describe("Optional list of table names to filter relationships by."),
-                }),
-            },
-            db_get_table_stats: {
-                description: "Get row count and other statistics for a table.",
-                inputSchema: z.object({
-                    table: z.string().describe("The name of the table."),
-                }),
-            },
-            db_sample_rows: {
-                description: "Fetch sample rows from a table.",
-                inputSchema: z.object({
-                    table: z.string().describe("The name of the table."),
-                    limit: z.number().optional().default(10).describe("Maximum number of rows to fetch."),
-                }),
-            },
-            db_run_query: {
-                description: "Execute a read-only SELECT query. Blocks modification keywords.",
-                inputSchema: z.object({
-                    query: z.string().describe("The SQL SELECT query to execute."),
-                }),
-            },
-            db_run_update_statement: {
-                description: "Execute an INSERT or UPDATE statement. Blocks DELETE and other dangerous keywords.",
-                inputSchema: z.object({
-                    query: z.string().describe("The SQL INSERT/UPDATE statement."),
-                }),
-            },
-            db_run_delete_statement: {
-                description: "Execute a DELETE or TRUNCATE statement. Blocks DROP/ALTER.",
-                inputSchema: z.object({
-                    query: z.string().describe("The SQL DELETE/TRUNCATE statement."),
-                }),
-            },
-            db_run_statement: {
-                description: "Execute any SQL statement. Full access, use with extreme caution. Disabled by default.",
-                inputSchema: z.object({
-                    query: z.string().describe("The SQL statement to execute."),
-                }),
-            },
-        };
+        return this.driver.getToolDefinitions(this.permissions);
     }
     async handleToolCall(name, args) {
-        switch (name) {
-            case "db_list_tables":
-                return await this.executor.listTables();
-            case "db_describe_tables":
-                return await this.executor.describeTables(args.tables);
-            case "db_get_schemas":
-                return await this.executor.getTableSchemas(args.tables);
-            case "db_get_relationships":
-                return await this.executor.getRelationships(args.tables);
-            case "db_get_table_stats":
-                return await this.executor.getTableStats(args.table);
-            case "db_sample_rows":
-                return await this.executor.sampleRows(args.table, args.limit);
-            case "db_run_query":
-                return await this.executor.runQuery(args.query);
-            case "db_run_update_statement":
-                return await this.executor.runUpdateStatement(args.query);
-            case "db_run_delete_statement":
-                return await this.executor.runDeleteStatement(args.query);
-            case "db_run_statement":
-                return await this.executor.runStatement(args.query);
-            default:
-                throw new Error(`Unknown database tool: ${name}`);
-        }
+        return await this.executor.handleToolCall(name, args);
     }
 }

package/dist/db-explorer/drivers/mysql-driver.d.ts

@@ -1,13 +1,22 @@
-import { DbDriver, DbConfig, TableInfo, ColumnInfo, Relationship, TableStats, QueryResult, UpdateResult, DeleteResult, StatementResult } from "../types.js";
+import { DbDriver, TableInfo, ColumnInfo, Relationship, TableStats, QueryResult, UpdateResult, DeleteResult, StatementResult, DbDriverPermissions, DbDriverToolDefinitions } from "../types.js";
+export interface MySQLDriverConfig {
+    host: string;
+    port: number;
+    user: string;
+    password: string;
+    database: string;
+    poolSize?: number;
+}
 export declare class MySQLDriver implements DbDriver {
     name: string;
     private pool;
     private config;
-    constructor(config: DbConfig);
+    constructor(config: MySQLDriverConfig);
     connect(): Promise<void>;
     disconnect(): Promise<void>;
     private getPool;
-    listTables(): Promise<TableInfo[]>;
+    listTables(tables?: string[]): Promise<TableInfo[]>;
+    listTableNames(): Promise<string[]>;
     describeTable(table: string): Promise<ColumnInfo[]>;
     getTableSchema(table: string): Promise<string>;
     getRelationships(tables?: string[]): Promise<Relationship[]>;
@@ -17,4 +26,6 @@ export declare class MySQLDriver implements DbDriver {
     executeUpdate(query: string): Promise<UpdateResult>;
     executeDelete(query: string): Promise<DeleteResult>;
     executeStatement(query: string): Promise<StatementResult>;
+    getToolDefinitions(permissions?: DbDriverPermissions): DbDriverToolDefinitions;
+    handleToolCall(name: string, args: any): Promise<any>;
 }

package/dist/db-explorer/drivers/mysql-driver.js

@@ -1,4 +1,5 @@
 import mysql from "mysql2/promise";
+import { z } from "zod";
 export class MySQLDriver {
     name = "mysql";
     pool = null;
@@ -34,10 +35,17 @@ export class MySQLDriver {
             throw new Error("Driver not connected. Call connect() first.");
         return this.pool;
     }
-    async listTables() {
-        const [rows] = await this.getPool().execute(`SELECT TABLE_NAME as name, TABLE_SCHEMA as \`schema\`, TABLE_TYPE as type, TABLE_COMMENT as comment 
+    async listTables(tables) {
+        let query = `SELECT TABLE_NAME as name, TABLE_SCHEMA as \`schema\`, TABLE_TYPE as type, TABLE_COMMENT as comment 
        FROM INFORMATION_SCHEMA.TABLES 
-       WHERE TABLE_SCHEMA = ?`, [this.config.database]);
+       WHERE TABLE_SCHEMA = ?`;
+        const params = [this.config.database];
+        if (tables && tables.length > 0) {
+            const placeholders = tables.map(() => "?").join(",");
+            query += ` AND TABLE_NAME IN (${placeholders})`;
+            params.push(...tables);
+        }
+        const [rows] = await this.getPool().execute(query, params);
         return rows.map((r) => ({
             name: r.name,
             schema: r.schema,
@@ -45,6 +53,12 @@ export class MySQLDriver {
             comment: r.comment || undefined
         }));
     }
+    async listTableNames() {
+        const [rows] = await this.getPool().execute(`SELECT TABLE_NAME as name 
+       FROM INFORMATION_SCHEMA.TABLES 
+       WHERE TABLE_SCHEMA = ?`, [this.config.database]);
+        return rows.map((r) => r.name);
+    }
     async describeTable(table) {
         const [rows] = await this.getPool().execute(`SELECT 
         COLUMN_NAME as name, 
@@ -167,4 +181,117 @@ export class MySQLDriver {
             data: result
         };
     }
+    getToolDefinitions(permissions = {}) {
+        const tools = {
+            db_list_tables: {
+                description: "List all tables in the current database.",
+                inputSchema: z.object({
+                    tables: z.array(z.string()).optional().describe("Optional list of table names to filter by. If not provided, all tables are returned."),
+                }),
+            },
+            db_list_table_names: {
+                description: "List all table names in the current database.",
+            },
+            db_describe_tables: {
+                description: "Get detailed information about columns for multiple tables.",
+                inputSchema: z.object({
+                    tables: z.array(z.string()).describe("List of table names to describe."),
+                }),
+            },
+            db_get_schemas: {
+                description: "Get the DDL statements for multiple tables.",
+                inputSchema: z.object({
+                    tables: z.array(z.string()).describe("List of table names."),
+                }),
+            },
+            db_get_relationships: {
+                description: "Get foreign key relationships in the database, optionally filtered by tables.",
+                inputSchema: z.object({
+                    tables: z.array(z.string()).optional().describe("Optional list of table names to filter relationships by."),
+                }),
+            },
+            db_get_table_stats: {
+                description: "Get row count and other statistics for a table.",
+                inputSchema: z.object({
+                    table: z.string().describe("The name of the table."),
+                }),
+            },
+            db_sample_rows: {
+                description: "Fetch sample rows from a table.",
+                inputSchema: z.object({
+                    table: z.string().describe("The name of the table."),
+                    limit: z.number().optional().default(10).describe("Maximum number of rows to fetch."),
+                }),
+            },
+        };
+        if (permissions.enableRunQuery !== false) {
+            tools.db_run_query = {
+                description: "Execute a read-only SELECT query. Blocks modification keywords.",
+                inputSchema: z.object({
+                    query: z.string().describe("The SQL SELECT query to execute."),
+                }),
+            };
+        }
+        if (permissions.enableRunUpdateStatement !== false) {
+            tools.db_run_update_statement = {
+                description: "Execute an INSERT or UPDATE statement. Blocks DELETE and other dangerous keywords.",
+                inputSchema: z.object({
+                    query: z.string().describe("The SQL INSERT/UPDATE statement."),
+                }),
+            };
+        }
+        if (permissions.enableRunDeleteStatement === true) {
+            tools.db_run_delete_statement = {
+                description: "Execute a DELETE or TRUNCATE statement. Blocks DROP/ALTER.",
+                inputSchema: z.object({
+                    query: z.string().describe("The SQL DELETE/TRUNCATE statement."),
+                }),
+            };
+        }
+        if (permissions.enableRunStatement === true) {
+            tools.db_run_statement = {
+                description: "Execute any SQL statement. Full access, use with extreme caution. Disabled by default.",
+                inputSchema: z.object({
+                    query: z.string().describe("The SQL statement to execute."),
+                }),
+            };
+        }
+        return tools;
+    }
+    async handleToolCall(name, args) {
+        switch (name) {
+            case "db_list_tables":
+                return await this.listTables(args.tables);
+            case "db_list_table_names":
+                return await this.listTableNames();
+            case "db_describe_tables":
+                const describeResults = {};
+                for (const table of args.tables) {
+                    describeResults[table] = await this.describeTable(table);
+                }
+                return describeResults;
+            case "db_get_schemas":
+                const schemaResults = {};
+                for (const table of args.tables) {
+                    schemaResults[table] = await this.getTableSchema(table);
+                }
+                return schemaResults;
+            case "db_get_relationships":
+                return await this.getRelationships(args.tables);
+            case "db_get_table_stats":
+                return await this.getTableStats(args.table);
+            case "db_sample_rows":
+                return await this.sampleRows(args.table, args.limit);
+            case "db_run_query":
+                return await this.executeQuery(args.query);
+            case "db_run_update_statement":
+                return await this.executeUpdate(args.query);
+            case "db_run_delete_statement":
+                return await this.executeDelete(args.query);
+            case "db_run_statement":
+                return await this.executeStatement(args.query);
+            default:
+                throw new Error(`Unknown database tool: ${name}`);
+        }
+    }
 }

package/dist/db-explorer/index.d.ts

@@ -1,5 +1,10 @@
+import { DbDriver, DbDriverPermissions } from "./types.js";
 export { DbExecutor } from "./db-executor.js";
 export { DbToolGenerator } from "./db-tool-generator.js";
-export type { DbConfig } from "./types.js";
 export * from "./types.js";
 export * from "./drivers/index.js";
+export interface DatabaseConfig {
+    driver: DbDriver;
+    permissions?: DbDriverPermissions;
+}
+export declare function createDbConfigFromEnv(): DatabaseConfig | undefined;

package/dist/db-explorer/index.js

@@ -1,4 +1,25 @@
+import { MySQLDriver } from "./drivers/mysql-driver.js";
 export { DbExecutor } from "./db-executor.js";
 export { DbToolGenerator } from "./db-tool-generator.js";
 export * from "./types.js";
 export * from "./drivers/index.js";
+export function createDbConfigFromEnv() {
+    if (!process.env.PROJECT_MCP_DB_DATABASE && !process.env.PROJECT_MCP_DB_HOST) {
+        return undefined;
+    }
+    const driver = new MySQLDriver({
+        host: process.env.PROJECT_MCP_DB_HOST || "localhost",
+        port: parseInt(process.env.PROJECT_MCP_DB_PORT || "3306", 10),
+        user: process.env.PROJECT_MCP_DB_USER || "",
+        password: process.env.PROJECT_MCP_DB_PASSWORD || "",
+        database: process.env.PROJECT_MCP_DB_DATABASE || "",
+        poolSize: parseInt(process.env.PROJECT_MCP_DB_POOL_SIZE || "10", 10),
+    });
+    const permissions = {
+        enableRunQuery: process.env.PROJECT_MCP_DB_ENABLE_QUERY !== "false",
+        enableRunUpdateStatement: process.env.PROJECT_MCP_DB_ENABLE_UPDATE !== "false",
+        enableRunDeleteStatement: process.env.PROJECT_MCP_DB_ENABLE_DELETE === "true",
+        enableRunStatement: process.env.PROJECT_MCP_DB_ENABLE_STATEMENT === "true",
+    };
+    return { driver, permissions };
+}

package/dist/db-explorer/types.d.ts

@@ -1,8 +1,21 @@
+import { z } from "zod";
+export interface DbDriverToolDefinition {
+    description: string;
+    inputSchema?: z.ZodType;
+}
+export type DbDriverToolDefinitions = Record<string, DbDriverToolDefinition>;
+export interface DbDriverPermissions {
+    enableRunQuery?: boolean;
+    enableRunUpdateStatement?: boolean;
+    enableRunDeleteStatement?: boolean;
+    enableRunStatement?: boolean;
+}
 export interface DbDriver {
     name: string;
     connect(): Promise<void>;
     disconnect(): Promise<void>;
-    listTables(): Promise<TableInfo[]>;
+    listTables(tables?: string[]): Promise<TableInfo[]>;
+    listTableNames(): Promise<string[]>;
     describeTable(table: string): Promise<ColumnInfo[]>;
     getTableSchema(table: string): Promise<string>;
     getRelationships(tables?: string[]): Promise<Relationship[]>;
@@ -12,7 +25,12 @@ export interface DbDriver {
     executeUpdate(query: string): Promise<UpdateResult>;
     executeDelete(query: string): Promise<DeleteResult>;
     executeStatement(query: string): Promise<StatementResult>;
+    getToolDefinitions(permissions?: DbDriverPermissions): DbDriverToolDefinitions;
+    handleToolCall(name: string, args: any): Promise<any>;
 }
+/**
+ * @deprecated Use driver-specific configuration and DbDriverPermissions instead.
+ */
 export interface DbConfig {
     driver: 'mysql';
     host: string;

package/dist/index.d.ts

@@ -1,2 +1,3 @@
 export { MCPServer } from "./mcp-server.js";
+export type { ApiConfig, MCPServerOptions } from "./mcp-server.js";
 export * from "./db-explorer/index.js";

package/dist/mcp-server.d.ts

@@ -1,5 +1,6 @@
-import { AuthContext } from "./api-explorer/auth/index.js";
-import type { DbConfig } from "./db-explorer/index.js";
+import { ApiConfig } from "./api-explorer/index.js";
+import type { DatabaseConfig } from "./db-explorer/index.js";
+export type { ApiConfig };
 /**
  * The main MCP Server implementation that coordinates the OpenAPI parser,
  * tool generation, and API execution.
@@ -11,8 +12,8 @@ import type { DbConfig } from "./db-explorer/index.js";
  */
 export interface MCPServerOptions {
     specPath: string;
-    authContext?: AuthContext;
-    dbConfig?: DbConfig;
+    api?: ApiConfig;
+    database?: DatabaseConfig;
 }
 /**
  * The main MCP Server implementation that coordinates the OpenAPI parser,

package/dist/mcp-server.js

@@ -5,8 +5,7 @@ import { OpenAPIParser } from "./api-explorer/openapi-parser.js";
 import { ToolGenerator } from "./api-explorer/tool-generator.js";
 import { ApiExecutor } from "./api-explorer/api-executor.js";
 import { createAuthContextFromEnv } from "./api-explorer/auth/index.js";
-import { DbExecutor, DbToolGenerator } from "./db-explorer/index.js";
-import { MySQLDriver } from "./db-explorer/drivers/mysql-driver.js";
+import { createDbConfigFromEnv, DbExecutor, DbToolGenerator } from "./db-explorer/index.js";
 /**
  * The main MCP Server implementation that coordinates the OpenAPI parser,
  * tool generation, and API execution.
@@ -32,12 +31,13 @@ export class MCPServer {
         this.specPath = options.specPath;
         this.parser = new OpenAPIParser();
         this.toolGenerator = new ToolGenerator(this.parser);
-        this.authContext = options.authContext || createAuthContextFromEnv();
-        this.apiExecutor = new ApiExecutor(undefined, this.authContext);
-        if (options.dbConfig) {
-            const driver = new MySQLDriver(options.dbConfig);
-            this.dbExecutor = new DbExecutor(driver, options.dbConfig);
-            this.dbToolGenerator = new DbToolGenerator(this.dbExecutor);
+        this.authContext = options.api?.authContext || createAuthContextFromEnv();
+        const apiBaseUrl = options.api?.baseUrl;
+        const dbConfig = options.database || createDbConfigFromEnv();
+        this.apiExecutor = new ApiExecutor(apiBaseUrl, this.authContext);
+        if (dbConfig) {
+            this.dbExecutor = new DbExecutor(dbConfig.driver, dbConfig.permissions);
+            this.dbToolGenerator = new DbToolGenerator(dbConfig.driver, dbConfig.permissions);
         }
         this.server = new McpServer({
             name: "project-mcp-server",
@@ -108,7 +108,7 @@ export class MCPServer {
                 });
             });
         }
-        this.server.registerTool("set_identity", {
+        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)."),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@williamp29/project-mcp-server",
-  "version": "2.0.0",
+  "version": "3.0.0",
   "description": "A ModelContextProtocol server to let agents discover your project, such as APIs (using OpenAPI) or other resources.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",