@hyqf98/easy_db_mcp_server 1.0.0

package/src/database/sqlite.ts

@@ -0,0 +1,93 @@
+import Database from 'better-sqlite3';
+import type {
+  DatabaseAdapter,
+  TableInfo,
+  TableColumn,
+  QueryResult,
+} from './base.js';
+import type { DatabaseConfig } from '../config.js';
+
+export class SQLiteAdapter implements DatabaseAdapter {
+  private db?: Database.Database;
+  private config: DatabaseConfig;
+
+  constructor(config: DatabaseConfig) {
+    this.config = config;
+  }
+
+  async connect(): Promise<void> {
+    if (!this.config.database) {
+      throw new Error('Database file path required for SQLite');
+    }
+
+    this.db = new Database(this.config.database);
+  }
+
+  async listTables(): Promise<TableInfo[]> {
+    if (!this.db) throw new Error('Not connected');
+
+    const rows = this.db
+      .prepare(
+        `SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' ORDER BY name`
+      )
+      .all() as any[];
+
+    return rows.map((row: any) => ({
+      name: row.name,
+    }));
+  }
+
+  async describeTable(table: string): Promise<TableColumn[]> {
+    if (!this.db) throw new Error('Not connected');
+
+    const rows = this.db.prepare(`PRAGMA table_info(${table})`).all() as any[];
+
+    return rows.map((row: any) => ({
+      name: row.name,
+      type: row.type,
+      nullable: row.notnull === 0,
+      defaultValue: row.dflt_value,
+      primaryKey: row.pk > 0,
+    }));
+  }
+
+  async executeQuery(sql: string): Promise<QueryResult> {
+    if (!this.db) throw new Error('Not connected');
+
+    const trimmed = sql.trim().toUpperCase();
+    if (!trimmed.startsWith('SELECT')) {
+      throw new Error('Only SELECT queries allowed in executeQuery');
+    }
+
+    const rows = this.db.prepare(sql).all() as Record<string, unknown>[];
+
+    return {
+      rows,
+      rowCount: rows.length,
+    };
+  }
+
+  async executeSQL(sql: string): Promise<QueryResult | { affectedRows: number }> {
+    if (!this.db) throw new Error('Not connected');
+
+    const trimmed = sql.trim().toUpperCase();
+
+    if (trimmed.startsWith('SELECT')) {
+      const rows = this.db.prepare(sql).all() as Record<string, unknown>[];
+      return {
+        rows,
+        rowCount: rows.length,
+      };
+    }
+
+    const result = this.db.prepare(sql).run();
+    return { affectedRows: result.changes };
+  }
+
+  async close(): Promise<void> {
+    if (this.db) {
+      this.db.close();
+      this.db = undefined;
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,256 @@
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+import { loadConfig } from './config.js';
+import { createAdapter } from './database/factory.js';
+import type { DatabaseAdapter } from './database/base.js';
+
+// Create server instance
+const server = new Server(
+  {
+    name: 'hyqf98@easy_db_mcp_server',
+    version: '1.0.0',
+  },
+  {
+    capabilities: {
+      tools: {},
+    },
+  }
+);
+
+// Load configuration and create adapter
+let adapter: DatabaseAdapter;
+
+try {
+  const config = loadConfig();
+  adapter = createAdapter(config);
+  await adapter.connect();
+  console.error(`Connected to ${config.type} database`);
+} catch (error) {
+  console.error('Failed to connect to database:', error);
+  process.exit(1);
+}
+
+// List available tools
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  return {
+    tools: [
+      {
+        name: 'list_tables',
+        description: 'List all tables in the database. If EASYDB_DATABASE is not set, the database parameter must be provided.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            database: {
+              type: 'string',
+              description: 'Database name (optional if EASYDB_DATABASE is set, otherwise required)',
+            },
+          },
+        },
+      },
+      {
+        name: 'describe_table',
+        description: 'Get the structure of a table including columns, types, and constraints. If EASYDB_DATABASE is not set, the database parameter must be provided.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            table: {
+              type: 'string',
+              description: 'Table name',
+            },
+            database: {
+              type: 'string',
+              description: 'Database name (optional if EASYDB_DATABASE is set, otherwise required)',
+            },
+          },
+          required: ['table'],
+        },
+      },
+      {
+        name: 'execute_query',
+        description: 'Execute a SELECT query (read-only). If EASYDB_DATABASE is not set, the database parameter must be provided.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            sql: {
+              type: 'string',
+              description: 'SQL SELECT query to execute',
+            },
+            database: {
+              type: 'string',
+              description: 'Database name (optional if EASYDB_DATABASE is set, otherwise required)',
+            },
+          },
+          required: ['sql'],
+        },
+      },
+      {
+        name: 'execute_sql',
+        description: 'Execute any SQL statement (requires EASYDB_ALLOW_WRITE=true). If EASYDB_DATABASE is not set, the database parameter must be provided.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            sql: {
+              type: 'string',
+              description: 'SQL statement to execute (INSERT, UPDATE, DELETE, DDL, etc.)',
+            },
+            database: {
+              type: 'string',
+              description: 'Database name (optional if EASYDB_DATABASE is set, otherwise required)',
+            },
+          },
+          required: ['sql'],
+        },
+      },
+    ],
+  };
+});
+
+// Handle tool calls
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+  const config = loadConfig();
+
+  // Helper function to validate database parameter
+  const getDatabase = (paramDb?: string): string => {
+    if (paramDb) {
+      return paramDb;
+    }
+    if (config.database) {
+      return config.database;
+    }
+    throw new Error(
+      'Database name is required. Either set EASYDB_DATABASE environment variable or pass the database parameter in the tool call.'
+    );
+  };
+
+  try {
+    switch (name) {
+      case 'list_tables': {
+        const database = getDatabase(args?.database as string | undefined);
+        const tables = await adapter.listTables(database);
+        return {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify(tables, null, 2),
+            },
+          ],
+        };
+      }
+
+      case 'describe_table': {
+        const database = getDatabase(args?.database as string | undefined);
+        const columns = await adapter.describeTable(
+          args?.table as string,
+          database
+        );
+        return {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify(columns, null, 2),
+            },
+          ],
+        };
+      }
+
+      case 'execute_query': {
+        const database = getDatabase(args?.database as string | undefined);
+        const result = await adapter.executeQuery(
+          args?.sql as string,
+          database
+        );
+        return {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify(result, null, 2),
+            },
+          ],
+        };
+      }
+
+      case 'execute_sql': {
+        if (!config.allowWrite) {
+          throw new Error(
+            'SQL execution requires EASYDB_ALLOW_WRITE=true for safety. Please enable this environment variable if you want to allow write operations.'
+          );
+        }
+
+        const sql = args?.sql as string;
+        const trimmed = sql.trim().toUpperCase();
+
+        // Check for DDL statements
+        const isDDL =
+          trimmed.startsWith('CREATE ') ||
+          trimmed.startsWith('DROP ') ||
+          trimmed.startsWith('ALTER ') ||
+          trimmed.startsWith('TRUNCATE ');
+
+        if (isDDL && !config.allowDDL) {
+          throw new Error(
+            'DDL statements require EASYDB_ALLOW_DDL=true for safety. Please enable this environment variable if you want to allow DDL operations.'
+          );
+        }
+
+        const database = getDatabase(args?.database as string | undefined);
+        const result = await adapter.executeSQL(
+          sql,
+          database
+        );
+        return {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify(result, null, 2),
+            },
+          ],
+        };
+      }
+
+      default:
+        throw new Error(`Unknown tool: ${name}`);
+    }
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify(
+            {
+              success: false,
+              error: error instanceof Error ? error.message : String(error),
+            },
+            null,
+            2
+          ),
+        },
+      ],
+      isError: true,
+    };
+  }
+});
+
+// Start server
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error('EasyDB MCP Server running');
+}
+
+main().catch((error) => {
+  console.error('Server error:', error);
+  process.exit(1);
+});
+
+// Cleanup on exit
+process.on('SIGINT', async () => {
+  console.error('\\nShutting down...');
+  await adapter.close();
+  process.exit(0);
+});

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "node",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}