@iaforged/context-code 1.0.72 → 1.0.74

package/dist/src/utils/databaseMcp/server/index.js

@@ -0,0 +1,1442 @@
+import { MACRO } from '../../../recovery/bunBundleShim.js';
+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 { connectToDatabase, getActiveConnection } from './connection.js';
+import { DEFAULT_PORTS } from './types.js';
+import { getQuery } from './queries.js';
+// Tool definitions
+const tools = [
+    // Connection Management
+    {
+        name: 'db_connect',
+        description: 'Conectar a una base de datos. Soporta: oracle, sqlserver, postgresql, mysql. Los puertos por defecto son: Oracle=1521, SQL Server=1433, PostgreSQL=5432, MySQL=3306',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                engine: {
+                    type: 'string',
+                    enum: ['oracle', 'sqlserver', 'postgresql', 'mysql'],
+                    description: 'Motor de base de datos (oracle, sqlserver, postgresql, mysql)'
+                },
+                host: {
+                    type: 'string',
+                    description: 'Servidor/Host de la base de datos'
+                },
+                port: {
+                    type: 'number',
+                    description: 'Puerto (opcional, usa el puerto por defecto del motor si no se especifica)'
+                },
+                user: {
+                    type: 'string',
+                    description: 'Usuario de la base de datos'
+                },
+                password: {
+                    type: 'string',
+                    description: 'Contraseña del usuario'
+                },
+                database: {
+                    type: 'string',
+                    description: 'Nombre de la base de datos (o Service Name para Oracle)'
+                },
+                serviceName: {
+                    type: 'string',
+                    description: 'Service Name para Oracle (alternativo a database)'
+                }
+            },
+            required: ['engine', 'host', 'user', 'password']
+        }
+    },
+    {
+        name: 'db_disconnect',
+        description: 'Desconectar de la base de datos actual',
+        inputSchema: {
+            type: 'object',
+            properties: {}
+        }
+    },
+    {
+        name: 'db_status',
+        description: 'Verificar el estado de la conexión actual',
+        inputSchema: {
+            type: 'object',
+            properties: {}
+        }
+    },
+    // Query Execution
+    {
+        name: 'db_query',
+        description: 'Ejecutar una consulta SQL SELECT y obtener resultados',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                sql: {
+                    type: 'string',
+                    description: 'Consulta SQL a ejecutar'
+                },
+                params: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Parámetros para la consulta (opcional)'
+                }
+            },
+            required: ['sql']
+        }
+    },
+    {
+        name: 'db_execute',
+        description: 'Ejecutar una sentencia SQL (INSERT, UPDATE, DELETE, DDL)',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                sql: {
+                    type: 'string',
+                    description: 'Sentencia SQL a ejecutar'
+                },
+                params: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Parámetros para la sentencia (opcional)'
+                }
+            },
+            required: ['sql']
+        }
+    },
+    // CRUD Operations
+    {
+        name: 'db_select',
+        description: 'Realizar un SELECT simplificado en una tabla',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                table: {
+                    type: 'string',
+                    description: 'Nombre de la tabla (puede incluir schema: schema.tabla)'
+                },
+                columns: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Columnas a seleccionar (opcional, * por defecto)'
+                },
+                where: {
+                    type: 'string',
+                    description: 'Condición WHERE (sin la palabra WHERE)'
+                },
+                orderBy: {
+                    type: 'string',
+                    description: 'Columnas para ordenar'
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Límite de filas a retornar'
+                }
+            },
+            required: ['table']
+        }
+    },
+    {
+        name: 'db_insert',
+        description: 'Insertar registros en una tabla',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                table: {
+                    type: 'string',
+                    description: 'Nombre de la tabla'
+                },
+                data: {
+                    type: 'object',
+                    description: 'Datos a insertar como objeto {columna: valor}'
+                }
+            },
+            required: ['table', 'data']
+        }
+    },
+    {
+        name: 'db_update',
+        description: 'Actualizar registros en una tabla',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                table: {
+                    type: 'string',
+                    description: 'Nombre de la tabla'
+                },
+                data: {
+                    type: 'object',
+                    description: 'Datos a actualizar como objeto {columna: valor}'
+                },
+                where: {
+                    type: 'string',
+                    description: 'Condición WHERE (OBLIGATORIO para evitar actualizaciones masivas)'
+                }
+            },
+            required: ['table', 'data', 'where']
+        }
+    },
+    {
+        name: 'db_delete',
+        description: 'Eliminar registros de una tabla',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                table: {
+                    type: 'string',
+                    description: 'Nombre de la tabla'
+                },
+                where: {
+                    type: 'string',
+                    description: 'Condición WHERE (OBLIGATORIO para evitar eliminaciones masivas)'
+                }
+            },
+            required: ['table', 'where']
+        }
+    },
+    // Schema Information
+    {
+        name: 'db_list_tables',
+        description: 'Listar todas las tablas de la base de datos',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                schema: {
+                    type: 'string',
+                    description: 'Filtrar por schema (opcional)'
+                }
+            }
+        }
+    },
+    {
+        name: 'db_list_views',
+        description: 'Listar todas las vistas de la base de datos',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                schema: {
+                    type: 'string',
+                    description: 'Filtrar por schema (opcional)'
+                }
+            }
+        }
+    },
+    {
+        name: 'db_describe_table',
+        description: 'Describir la estructura de una tabla (columnas, tipos, constraints)',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                table: {
+                    type: 'string',
+                    description: 'Nombre de la tabla'
+                },
+                schema: {
+                    type: 'string',
+                    description: 'Schema de la tabla (opcional)'
+                }
+            },
+            required: ['table']
+        }
+    },
+    {
+        name: 'db_list_columns',
+        description: 'Listar columnas de una tabla con información detallada',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                table: {
+                    type: 'string',
+                    description: 'Nombre de la tabla'
+                },
+                schema: {
+                    type: 'string',
+                    description: 'Schema de la tabla (opcional)'
+                }
+            },
+            required: ['table']
+        }
+    },
+    // Indexes
+    {
+        name: 'db_list_indexes',
+        description: 'Listar todos los índices de la base de datos o de una tabla específica',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                table: {
+                    type: 'string',
+                    description: 'Filtrar por tabla (opcional)'
+                }
+            }
+        }
+    },
+    {
+        name: 'db_create_index',
+        description: 'Crear un índice en una tabla',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: {
+                    type: 'string',
+                    description: 'Nombre del índice'
+                },
+                table: {
+                    type: 'string',
+                    description: 'Nombre de la tabla'
+                },
+                columns: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Columnas del índice'
+                },
+                unique: {
+                    type: 'boolean',
+                    description: 'Si es un índice único (opcional, false por defecto)'
+                }
+            },
+            required: ['name', 'table', 'columns']
+        }
+    },
+    {
+        name: 'db_drop_index',
+        description: 'Eliminar un índice',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: {
+                    type: 'string',
+                    description: 'Nombre del índice'
+                },
+                table: {
+                    type: 'string',
+                    description: 'Nombre de la tabla (requerido para MySQL)'
+                }
+            },
+            required: ['name']
+        }
+    },
+    // Procedures and Functions
+    {
+        name: 'db_list_procedures',
+        description: 'Listar todos los procedimientos almacenados',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                schema: {
+                    type: 'string',
+                    description: 'Filtrar por schema (opcional)'
+                }
+            }
+        }
+    },
+    {
+        name: 'db_list_functions',
+        description: 'Listar todas las funciones',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                schema: {
+                    type: 'string',
+                    description: 'Filtrar por schema (opcional)'
+                }
+            }
+        }
+    },
+    {
+        name: 'db_get_procedure_source',
+        description: 'Obtener el código fuente de un procedimiento o función',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: {
+                    type: 'string',
+                    description: 'Nombre del procedimiento/función'
+                },
+                schema: {
+                    type: 'string',
+                    description: 'Schema (opcional)'
+                },
+                type: {
+                    type: 'string',
+                    enum: ['PROCEDURE', 'FUNCTION'],
+                    description: 'Tipo: PROCEDURE o FUNCTION'
+                }
+            },
+            required: ['name', 'type']
+        }
+    },
+    {
+        name: 'db_execute_procedure',
+        description: 'Ejecutar un procedimiento almacenado',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: {
+                    type: 'string',
+                    description: 'Nombre del procedimiento'
+                },
+                params: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Parámetros del procedimiento'
+                }
+            },
+            required: ['name']
+        }
+    },
+    // Triggers
+    {
+        name: 'db_list_triggers',
+        description: 'Listar todos los triggers',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                table: {
+                    type: 'string',
+                    description: 'Filtrar por tabla (opcional)'
+                }
+            }
+        }
+    },
+    // Constraints
+    {
+        name: 'db_list_constraints',
+        description: 'Listar constraints de una tabla (PK, FK, UNIQUE, CHECK)',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                table: {
+                    type: 'string',
+                    description: 'Nombre de la tabla'
+                },
+                schema: {
+                    type: 'string',
+                    description: 'Schema de la tabla (opcional)'
+                }
+            },
+            required: ['table']
+        }
+    },
+    // Schema Management
+    {
+        name: 'db_list_schemas',
+        description: 'Listar todos los schemas de la base de datos',
+        inputSchema: {
+            type: 'object',
+            properties: {}
+        }
+    },
+    // Sequences
+    {
+        name: 'db_list_sequences',
+        description: 'Listar todas las secuencias',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                schema: {
+                    type: 'string',
+                    description: 'Filtrar por schema (opcional)'
+                }
+            }
+        }
+    },
+    // Users and Permissions
+    {
+        name: 'db_list_users',
+        description: 'Listar usuarios de la base de datos',
+        inputSchema: {
+            type: 'object',
+            properties: {}
+        }
+    },
+    // Sessions and Locks
+    {
+        name: 'db_list_sessions',
+        description: 'Listar sesiones activas en la base de datos',
+        inputSchema: {
+            type: 'object',
+            properties: {}
+        }
+    },
+    {
+        name: 'db_list_locks',
+        description: 'Listar bloqueos activos en la base de datos',
+        inputSchema: {
+            type: 'object',
+            properties: {}
+        }
+    },
+    {
+        name: 'db_kill_session',
+        description: 'Terminar una sesión de base de datos',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                sessionId: {
+                    type: 'string',
+                    description: 'ID de la sesión a terminar'
+                }
+            },
+            required: ['sessionId']
+        }
+    },
+    // Database Statistics
+    {
+        name: 'db_size',
+        description: 'Obtener el tamaño de la base de datos',
+        inputSchema: {
+            type: 'object',
+            properties: {}
+        }
+    },
+    {
+        name: 'db_table_size',
+        description: 'Obtener el tamaño de una tabla',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                table: {
+                    type: 'string',
+                    description: 'Nombre de la tabla'
+                },
+                schema: {
+                    type: 'string',
+                    description: 'Schema de la tabla (opcional)'
+                }
+            },
+            required: ['table']
+        }
+    },
+    {
+        name: 'db_table_count',
+        description: 'Obtener el conteo de registros de una tabla',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                table: {
+                    type: 'string',
+                    description: 'Nombre de la tabla'
+                },
+                where: {
+                    type: 'string',
+                    description: 'Condición WHERE opcional'
+                }
+            },
+            required: ['table']
+        }
+    },
+    // DDL Operations
+    {
+        name: 'db_create_table',
+        description: 'Crear una nueva tabla',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                table: {
+                    type: 'string',
+                    description: 'Nombre de la tabla'
+                },
+                columns: {
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            name: { type: 'string' },
+                            type: { type: 'string' },
+                            nullable: { type: 'boolean' },
+                            primaryKey: { type: 'boolean' },
+                            defaultValue: { type: 'string' }
+                        },
+                        required: ['name', 'type']
+                    },
+                    description: 'Definición de columnas'
+                },
+                schema: {
+                    type: 'string',
+                    description: 'Schema donde crear la tabla (opcional)'
+                }
+            },
+            required: ['table', 'columns']
+        }
+    },
+    {
+        name: 'db_drop_table',
+        description: 'Eliminar una tabla',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                table: {
+                    type: 'string',
+                    description: 'Nombre de la tabla'
+                },
+                cascade: {
+                    type: 'boolean',
+                    description: 'Eliminar en cascada (opcional)'
+                }
+            },
+            required: ['table']
+        }
+    },
+    {
+        name: 'db_alter_table',
+        description: 'Modificar una tabla (agregar/eliminar columna, cambiar tipo)',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                table: {
+                    type: 'string',
+                    description: 'Nombre de la tabla'
+                },
+                operation: {
+                    type: 'string',
+                    enum: ['ADD_COLUMN', 'DROP_COLUMN', 'MODIFY_COLUMN', 'RENAME_COLUMN'],
+                    description: 'Operación a realizar'
+                },
+                columnName: {
+                    type: 'string',
+                    description: 'Nombre de la columna'
+                },
+                newColumnName: {
+                    type: 'string',
+                    description: 'Nuevo nombre de la columna (para RENAME)'
+                },
+                columnType: {
+                    type: 'string',
+                    description: 'Tipo de datos de la columna'
+                },
+                nullable: {
+                    type: 'boolean',
+                    description: 'Si la columna acepta NULL'
+                }
+            },
+            required: ['table', 'operation', 'columnName']
+        }
+    },
+    // Backup and Export
+    {
+        name: 'db_export_table',
+        description: 'Exportar datos de una tabla como INSERT statements',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                table: {
+                    type: 'string',
+                    description: 'Nombre de la tabla'
+                },
+                where: {
+                    type: 'string',
+                    description: 'Condición WHERE para filtrar datos'
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Límite de registros a exportar'
+                }
+            },
+            required: ['table']
+        }
+    },
+    // Tablespaces (Oracle specific)
+    {
+        name: 'db_list_tablespaces',
+        description: 'Listar tablespaces (solo Oracle)',
+        inputSchema: {
+            type: 'object',
+            properties: {}
+        }
+    },
+    // Transaction Management
+    {
+        name: 'db_begin_transaction',
+        description: 'Iniciar una transacción',
+        inputSchema: {
+            type: 'object',
+            properties: {}
+        }
+    },
+    {
+        name: 'db_commit',
+        description: 'Confirmar la transacción actual',
+        inputSchema: {
+            type: 'object',
+            properties: {}
+        }
+    },
+    {
+        name: 'db_rollback',
+        description: 'Revertir la transacción actual',
+        inputSchema: {
+            type: 'object',
+            properties: {}
+        }
+    }
+];
+// Tool handler implementation
+async function handleTool(name, args) {
+    const conn = getActiveConnection();
+    // Tools that don't require connection
+    if (name === 'db_connect') {
+        const config = {
+            engine: args.engine,
+            host: args.host,
+            port: args.port,
+            user: args.user,
+            password: args.password,
+            database: args.database,
+            serviceName: args.serviceName
+        };
+        try {
+            await connectToDatabase(config);
+            const port = config.port || DEFAULT_PORTS[config.engine];
+            return `✅ Conectado exitosamente a ${config.engine.toUpperCase()} en ${config.host}:${port}`;
+        }
+        catch (error) {
+            return `❌ Error al conectar: ${error instanceof Error ? error.message : String(error)}`;
+        }
+    }
+    if (name === 'db_status') {
+        if (conn && conn.isConnected()) {
+            const config = conn.config;
+            const port = config.port || DEFAULT_PORTS[config.engine];
+            return `✅ Conectado a ${config.engine.toUpperCase()}\n` +
+                `   Host: ${config.host}:${port}\n` +
+                `   Usuario: ${config.user}\n` +
+                `   Base de datos: ${config.database || config.serviceName || 'N/A'}`;
+        }
+        return '❌ No hay conexión activa';
+    }
+    // All other tools require an active connection
+    if (!conn || !conn.isConnected()) {
+        return '❌ No hay conexión activa. Use db_connect primero para conectarse a una base de datos.';
+    }
+    const engine = conn.engine;
+    try {
+        switch (name) {
+            case 'db_disconnect': {
+                await conn.disconnect();
+                return '✅ Desconectado exitosamente';
+            }
+            case 'db_query': {
+                const result = await conn.query(args.sql, args.params);
+                return formatQueryResult(result);
+            }
+            case 'db_execute': {
+                const result = await conn.execute(args.sql, args.params);
+                return `✅ Sentencia ejecutada. Filas afectadas: ${result.affectedRows || 0}`;
+            }
+            case 'db_select': {
+                const sql = buildSelectQuery(engine, args);
+                const result = await conn.query(sql);
+                return formatQueryResult(result);
+            }
+            case 'db_insert': {
+                const sql = buildInsertQuery(engine, args.table, args.data);
+                const result = await conn.execute(sql);
+                return `✅ Registro insertado. Filas afectadas: ${result.affectedRows || 1}`;
+            }
+            case 'db_update': {
+                const sql = buildUpdateQuery(engine, args.table, args.data, args.where);
+                const result = await conn.execute(sql);
+                return `✅ Registros actualizados. Filas afectadas: ${result.affectedRows || 0}`;
+            }
+            case 'db_delete': {
+                const sql = `DELETE FROM ${args.table} WHERE ${args.where}`;
+                const result = await conn.execute(sql);
+                return `✅ Registros eliminados. Filas afectadas: ${result.affectedRows || 0}`;
+            }
+            case 'db_list_tables': {
+                const query = getQuery(engine, 'listTables');
+                if (!query)
+                    return '❌ Operación no soportada para este motor';
+                const result = await conn.query(query);
+                return formatTableList(result, 'Tablas');
+            }
+            case 'db_list_views': {
+                const query = getQuery(engine, 'listViews');
+                if (!query)
+                    return '❌ Operación no soportada para este motor';
+                const result = await conn.query(query);
+                return formatTableList(result, 'Vistas');
+            }
+            case 'db_describe_table':
+            case 'db_list_columns': {
+                const query = getQuery(engine, 'listColumns');
+                if (!query)
+                    return '❌ Operación no soportada para este motor';
+                const schema = args.schema || getDefaultSchema(engine);
+                const table = args.table;
+                let result;
+                if (engine === 'sqlserver') {
+                    const fullName = schema ? `${schema}.${table}` : table;
+                    result = await conn.query(query, [fullName]);
+                }
+                else {
+                    result = await conn.query(query, [schema, table]);
+                }
+                return formatColumnsResult(result, table);
+            }
+            case 'db_list_indexes': {
+                const query = getQuery(engine, 'listIndexes');
+                if (!query)
+                    return '❌ Operación no soportada para este motor';
+                const result = await conn.query(query);
+                let rows = result.rows;
+                if (args.table) {
+                    rows = rows.filter((r) => r.tableName?.toLowerCase() === args.table.toLowerCase());
+                }
+                return formatIndexList({ ...result, rows });
+            }
+            case 'db_create_index': {
+                const unique = args.unique ? 'UNIQUE ' : '';
+                const columns = args.columns.join(', ');
+                const sql = `CREATE ${unique}INDEX ${args.name} ON ${args.table} (${columns})`;
+                await conn.execute(sql);
+                return `✅ Índice ${args.name} creado exitosamente`;
+            }
+            case 'db_drop_index': {
+                let sql;
+                if (engine === 'mysql') {
+                    sql = `DROP INDEX ${args.name} ON ${args.table}`;
+                }
+                else {
+                    sql = `DROP INDEX ${args.name}`;
+                }
+                await conn.execute(sql);
+                return `✅ Índice ${args.name} eliminado exitosamente`;
+            }
+            case 'db_list_procedures': {
+                const query = getQuery(engine, 'listProcedures');
+                if (!query)
+                    return '❌ Operación no soportada para este motor';
+                const result = await conn.query(query);
+                return formatRoutineList(result, 'Procedimientos');
+            }
+            case 'db_list_functions': {
+                const query = getQuery(engine, 'listFunctions');
+                if (!query)
+                    return '❌ Operación no soportada para este motor';
+                const result = await conn.query(query);
+                return formatRoutineList(result, 'Funciones');
+            }
+            case 'db_get_procedure_source': {
+                let result;
+                if (engine === 'oracle') {
+                    const query = getQuery(engine, 'getProcedureSource');
+                    if (!query)
+                        return '❌ Operación no soportada';
+                    const schema = args.schema || conn.config.user?.toUpperCase();
+                    result = await conn.query(query, [schema, args.name, args.type]);
+                    const source = result.rows.map((r) => r.line).join('');
+                    return `📝 Código fuente de ${args.type} ${args.name}:\n\n${source}`;
+                }
+                else {
+                    // For other engines, try to get from the routine list
+                    const queryName = args.type === 'PROCEDURE' ? 'listProcedures' : 'listFunctions';
+                    const query = getQuery(engine, queryName);
+                    if (!query)
+                        return '❌ Operación no soportada para este motor';
+                    result = await conn.query(query);
+                    const routine = result.rows.find((r) => r.name?.toLowerCase() === args.name.toLowerCase());
+                    if (routine && routine.definition) {
+                        return `📝 Código fuente de ${args.type} ${args.name}:\n\n${routine.definition}`;
+                    }
+                    return `❌ No se encontró el ${args.type} ${args.name}`;
+                }
+            }
+            case 'db_execute_procedure': {
+                let sql;
+                const params = args.params || [];
+                const paramStr = params.map(p => `'${p}'`).join(', ');
+                switch (engine) {
+                    case 'mysql':
+                        sql = `CALL ${args.name}(${paramStr})`;
+                        break;
+                    case 'sqlserver':
+                        sql = `EXEC ${args.name} ${paramStr}`;
+                        break;
+                    case 'oracle':
+                        sql = `BEGIN ${args.name}(${paramStr}); END;`;
+                        break;
+                    case 'postgresql':
+                        sql = `CALL ${args.name}(${paramStr})`;
+                        break;
+                    default:
+                        return '❌ Motor no soportado';
+                }
+                const result = await conn.execute(sql);
+                return `✅ Procedimiento ${args.name} ejecutado. Filas afectadas: ${result.affectedRows || 0}`;
+            }
+            case 'db_list_triggers': {
+                const query = getQuery(engine, 'listTriggers');
+                if (!query)
+                    return '❌ Operación no soportada para este motor';
+                const result = await conn.query(query);
+                let rows = result.rows;
+                if (args.table) {
+                    rows = rows.filter((r) => r.tableName?.toLowerCase() === args.table.toLowerCase());
+                }
+                return formatTriggerList({ ...result, rows });
+            }
+            case 'db_list_constraints': {
+                const query = getQuery(engine, 'listConstraints');
+                if (!query)
+                    return '❌ Operación no soportada para este motor';
+                const schema = args.schema || getDefaultSchema(engine);
+                const table = args.table;
+                let result;
+                if (engine === 'sqlserver') {
+                    const fullName = schema ? `${schema}.${table}` : table;
+                    result = await conn.query(query, [fullName]);
+                }
+                else {
+                    result = await conn.query(query, [schema, table]);
+                }
+                return formatConstraintList(result, table);
+            }
+            case 'db_list_schemas': {
+                const query = getQuery(engine, 'listSchemas');
+                if (!query)
+                    return '❌ Operación no soportada para este motor';
+                const result = await conn.query(query);
+                return formatSchemaList(result);
+            }
+            case 'db_list_sequences': {
+                const query = getQuery(engine, 'listSequences');
+                if (!query)
+                    return '❌ Operación no soportada para este motor';
+                const result = await conn.query(query);
+                return formatSequenceList(result);
+            }
+            case 'db_list_users': {
+                const query = getQuery(engine, 'listUsers');
+                if (!query)
+                    return '❌ Operación no soportada para este motor';
+                const result = await conn.query(query);
+                return formatUserList(result);
+            }
+            case 'db_list_sessions': {
+                const query = getQuery(engine, 'listSessions');
+                if (!query)
+                    return '❌ Operación no soportada para este motor';
+                const result = await conn.query(query);
+                return formatSessionList(result);
+            }
+            case 'db_list_locks': {
+                const query = getQuery(engine, 'listLocks');
+                if (!query)
+                    return '❌ Operación no soportada para este motor';
+                const result = await conn.query(query);
+                return formatLockList(result);
+            }
+            case 'db_kill_session': {
+                let sql;
+                const sessionId = args.sessionId;
+                switch (engine) {
+                    case 'mysql':
+                        sql = `KILL ${sessionId}`;
+                        break;
+                    case 'sqlserver':
+                        sql = `KILL ${sessionId}`;
+                        break;
+                    case 'oracle':
+                        sql = `ALTER SYSTEM KILL SESSION '${sessionId}' IMMEDIATE`;
+                        break;
+                    case 'postgresql':
+                        sql = `SELECT pg_terminate_backend(${sessionId})`;
+                        break;
+                    default:
+                        return '❌ Motor no soportado';
+                }
+                await conn.execute(sql);
+                return `✅ Sesión ${sessionId} terminada`;
+            }
+            case 'db_size': {
+                const query = getQuery(engine, 'databaseSize');
+                if (!query)
+                    return '❌ Operación no soportada para este motor';
+                const result = await conn.query(query);
+                const size = result.rows[0];
+                return `📊 Tamaño de la base de datos: ${Object.values(size)[0]}`;
+            }
+            case 'db_table_size': {
+                const query = getQuery(engine, 'tableSize');
+                if (!query)
+                    return '❌ Operación no soportada para este motor';
+                let params;
+                if (engine === 'oracle') {
+                    params = [args.schema || conn.config.user?.toUpperCase(), args.table];
+                }
+                else {
+                    params = [args.table];
+                }
+                const result = await conn.query(query, params);
+                return formatTableSize(result, args.table);
+            }
+            case 'db_table_count': {
+                let sql = `SELECT COUNT(*) as count FROM ${args.table}`;
+                if (args.where) {
+                    sql += ` WHERE ${args.where}`;
+                }
+                const result = await conn.query(sql);
+                const count = result.rows[0]?.count || result.rows[0]?.COUNT || 0;
+                return `📊 Tabla ${args.table}: ${count} registros`;
+            }
+            case 'db_create_table': {
+                const sql = buildCreateTableQuery(engine, args);
+                await conn.execute(sql);
+                return `✅ Tabla ${args.table} creada exitosamente`;
+            }
+            case 'db_drop_table': {
+                let sql = `DROP TABLE ${args.table}`;
+                if (args.cascade) {
+                    if (engine === 'postgresql' || engine === 'oracle') {
+                        sql += ' CASCADE';
+                    }
+                }
+                await conn.execute(sql);
+                return `✅ Tabla ${args.table} eliminada exitosamente`;
+            }
+            case 'db_alter_table': {
+                const sql = buildAlterTableQuery(engine, args);
+                await conn.execute(sql);
+                return `✅ Tabla ${args.table} modificada exitosamente`;
+            }
+            case 'db_export_table': {
+                let sql = `SELECT * FROM ${args.table}`;
+                if (args.where) {
+                    sql += ` WHERE ${args.where}`;
+                }
+                if (args.limit) {
+                    sql += getLimitClause(engine, args.limit);
+                }
+                const result = await conn.query(sql);
+                return generateInsertStatements(args.table, result);
+            }
+            case 'db_list_tablespaces': {
+                if (engine !== 'oracle') {
+                    return '❌ Tablespaces solo disponibles en Oracle';
+                }
+                const query = getQuery(engine, 'listTablespaces');
+                if (!query)
+                    return '❌ Operación no soportada';
+                const result = await conn.query(query);
+                return formatTablespaceList(result);
+            }
+            case 'db_begin_transaction': {
+                let sql;
+                switch (engine) {
+                    case 'mysql':
+                        sql = 'START TRANSACTION';
+                        break;
+                    case 'sqlserver':
+                        sql = 'BEGIN TRANSACTION';
+                        break;
+                    case 'postgresql':
+                        sql = 'BEGIN';
+                        break;
+                    case 'oracle':
+                        // Oracle starts transactions implicitly
+                        return '✅ Transacción iniciada (implícita en Oracle)';
+                    default:
+                        return '❌ Motor no soportado';
+                }
+                await conn.execute(sql);
+                return '✅ Transacción iniciada';
+            }
+            case 'db_commit': {
+                await conn.execute('COMMIT');
+                return '✅ Transacción confirmada';
+            }
+            case 'db_rollback': {
+                await conn.execute('ROLLBACK');
+                return '✅ Transacción revertida';
+            }
+            default:
+                return `❌ Herramienta desconocida: ${name}`;
+        }
+    }
+    catch (error) {
+        return `❌ Error: ${error instanceof Error ? error.message : String(error)}`;
+    }
+}
+// Helper functions
+function getDefaultSchema(engine) {
+    switch (engine) {
+        case 'postgresql': return 'public';
+        case 'mysql': return '';
+        case 'sqlserver': return 'dbo';
+        case 'oracle': return '';
+        default: return '';
+    }
+}
+function buildSelectQuery(engine, args) {
+    const columns = args.columns?.join(', ') || '*';
+    let sql = `SELECT ${columns} FROM ${args.table}`;
+    if (args.where) {
+        sql += ` WHERE ${args.where}`;
+    }
+    if (args.orderBy) {
+        sql += ` ORDER BY ${args.orderBy}`;
+    }
+    if (args.limit) {
+        sql += getLimitClause(engine, args.limit);
+    }
+    return sql;
+}
+function getLimitClause(engine, limit) {
+    switch (engine) {
+        case 'oracle':
+            return ` FETCH FIRST ${limit} ROWS ONLY`;
+        case 'sqlserver':
+            return ` TOP ${limit}`;
+        default:
+            return ` LIMIT ${limit}`;
+    }
+}
+function buildInsertQuery(engine, table, data) {
+    const columns = Object.keys(data).join(', ');
+    const values = Object.values(data).map(v => formatValue(v)).join(', ');
+    return `INSERT INTO ${table} (${columns}) VALUES (${values})`;
+}
+function buildUpdateQuery(engine, table, data, where) {
+    const setClause = Object.entries(data)
+        .map(([col, val]) => `${col} = ${formatValue(val)}`)
+        .join(', ');
+    return `UPDATE ${table} SET ${setClause} WHERE ${where}`;
+}
+function formatValue(value) {
+    if (value === null || value === undefined) {
+        return 'NULL';
+    }
+    if (typeof value === 'number') {
+        return String(value);
+    }
+    if (typeof value === 'boolean') {
+        return value ? '1' : '0';
+    }
+    return `'${String(value).replace(/'/g, "''")}'`;
+}
+function buildCreateTableQuery(engine, args) {
+    const columns = args.columns;
+    const columnDefs = columns.map(col => {
+        let def = `${col.name} ${col.type}`;
+        if (col.primaryKey) {
+            def += ' PRIMARY KEY';
+        }
+        if (col.nullable === false) {
+            def += ' NOT NULL';
+        }
+        if (col.defaultValue !== undefined) {
+            def += ` DEFAULT ${col.defaultValue}`;
+        }
+        return def;
+    });
+    const tableName = args.schema ? `${args.schema}.${args.table}` : args.table;
+    return `CREATE TABLE ${tableName} (\n  ${columnDefs.join(',\n  ')}\n)`;
+}
+function buildAlterTableQuery(engine, args) {
+    const table = args.table;
+    const operation = args.operation;
+    const columnName = args.columnName;
+    switch (operation) {
+        case 'ADD_COLUMN': {
+            const type = args.columnType;
+            const nullable = args.nullable !== false ? '' : ' NOT NULL';
+            if (engine === 'oracle') {
+                return `ALTER TABLE ${table} ADD ${columnName} ${type}${nullable}`;
+            }
+            return `ALTER TABLE ${table} ADD COLUMN ${columnName} ${type}${nullable}`;
+        }
+        case 'DROP_COLUMN': {
+            if (engine === 'oracle') {
+                return `ALTER TABLE ${table} DROP COLUMN ${columnName}`;
+            }
+            return `ALTER TABLE ${table} DROP COLUMN ${columnName}`;
+        }
+        case 'MODIFY_COLUMN': {
+            const type = args.columnType;
+            switch (engine) {
+                case 'mysql':
+                    return `ALTER TABLE ${table} MODIFY COLUMN ${columnName} ${type}`;
+                case 'postgresql':
+                    return `ALTER TABLE ${table} ALTER COLUMN ${columnName} TYPE ${type}`;
+                case 'sqlserver':
+                    return `ALTER TABLE ${table} ALTER COLUMN ${columnName} ${type}`;
+                case 'oracle':
+                    return `ALTER TABLE ${table} MODIFY ${columnName} ${type}`;
+                default:
+                    return '';
+            }
+        }
+        case 'RENAME_COLUMN': {
+            const newName = args.newColumnName;
+            switch (engine) {
+                case 'mysql':
+                    const type = args.columnType || 'VARCHAR(255)';
+                    return `ALTER TABLE ${table} CHANGE ${columnName} ${newName} ${type}`;
+                case 'postgresql':
+                    return `ALTER TABLE ${table} RENAME COLUMN ${columnName} TO ${newName}`;
+                case 'sqlserver':
+                    return `EXEC sp_rename '${table}.${columnName}', '${newName}', 'COLUMN'`;
+                case 'oracle':
+                    return `ALTER TABLE ${table} RENAME COLUMN ${columnName} TO ${newName}`;
+                default:
+                    return '';
+            }
+        }
+        default:
+            return '';
+    }
+}
+// Formatting functions
+function formatQueryResult(result) {
+    if (result.rows.length === 0) {
+        return '📭 No se encontraron resultados';
+    }
+    const columns = result.columns.length > 0 ? result.columns : Object.keys(result.rows[0] || {});
+    // Calculate column widths
+    const widths = columns.map(col => {
+        const headerWidth = col.length;
+        const maxDataWidth = Math.max(...result.rows.map(row => String(row[col] ?? '').length));
+        return Math.min(Math.max(headerWidth, maxDataWidth), 50);
+    });
+    // Build header
+    const header = columns.map((col, i) => col.padEnd(widths[i])).join(' | ');
+    const separator = widths.map(w => '-'.repeat(w)).join('-+-');
+    // Build rows
+    const rows = result.rows.map(row => columns.map((col, i) => {
+        const val = String(row[col] ?? '');
+        return val.substring(0, 50).padEnd(widths[i]);
+    }).join(' | ')).join('\n');
+    return `📊 Resultados (${result.rowCount} filas):\n\n${header}\n${separator}\n${rows}`;
+}
+function formatTableList(result, title) {
+    if (result.rows.length === 0) {
+        return `📭 No se encontraron ${title.toLowerCase()}`;
+    }
+    const grouped = {};
+    result.rows.forEach((row) => {
+        const schema = row.schema || 'default';
+        if (!grouped[schema])
+            grouped[schema] = [];
+        grouped[schema].push(row.name);
+    });
+    let output = `📋 ${title} (${result.rows.length}):\n\n`;
+    for (const [schema, tables] of Object.entries(grouped)) {
+        output += `📁 ${schema}:\n`;
+        tables.forEach(t => output += `   • ${t}\n`);
+    }
+    return output;
+}
+function formatColumnsResult(result, table) {
+    if (result.rows.length === 0) {
+        return `📭 No se encontraron columnas para la tabla ${table}`;
+    }
+    let output = `📋 Estructura de ${table}:\n\n`;
+    output += 'Columna'.padEnd(30) + ' | ' + 'Tipo'.padEnd(20) + ' | ' + 'Nullable' + ' | PK\n';
+    output += '-'.repeat(70) + '\n';
+    result.rows.forEach((col) => {
+        const name = String(col.name || '').padEnd(30);
+        const type = String(col.dataType || '').padEnd(20);
+        const nullable = col.nullable ? 'SI' : 'NO';
+        const pk = col.isPrimaryKey ? '✓' : '';
+        output += `${name} | ${type} | ${nullable.padEnd(8)} | ${pk}\n`;
+    });
+    return output;
+}
+function formatIndexList(result) {
+    if (result.rows.length === 0) {
+        return '📭 No se encontraron índices';
+    }
+    let output = `📋 Índices (${result.rows.length}):\n\n`;
+    result.rows.forEach((idx) => {
+        const unique = idx.isUnique ? '🔒 UNIQUE' : '';
+        const pk = idx.isPrimaryKey ? '🔑 PK' : '';
+        output += `• ${idx.name} en ${idx.tableName} ${unique} ${pk}\n`;
+        output += `  Columnas: ${Array.isArray(idx.columns) ? idx.columns.join(', ') : idx.columns}\n`;
+    });
+    return output;
+}
+function formatRoutineList(result, title) {
+    if (result.rows.length === 0) {
+        return `📭 No se encontraron ${title.toLowerCase()}`;
+    }
+    let output = `📋 ${title} (${result.rows.length}):\n\n`;
+    result.rows.forEach((r) => {
+        output += `• ${r.schema ? r.schema + '.' : ''}${r.name}`;
+        if (r.returnType)
+            output += ` → ${r.returnType}`;
+        output += '\n';
+    });
+    return output;
+}
+function formatTriggerList(result) {
+    if (result.rows.length === 0) {
+        return '📭 No se encontraron triggers';
+    }
+    let output = `📋 Triggers (${result.rows.length}):\n\n`;
+    result.rows.forEach((t) => {
+        output += `• ${t.name} en ${t.tableName}\n`;
+        output += `  ${t.timing} ${t.event}\n`;
+    });
+    return output;
+}
+function formatConstraintList(result, table) {
+    if (result.rows.length === 0) {
+        return `📭 No se encontraron constraints para ${table}`;
+    }
+    let output = `📋 Constraints de ${table}:\n\n`;
+    result.rows.forEach((c) => {
+        let icon = '•';
+        if (c.type?.includes('PRIMARY'))
+            icon = '🔑';
+        else if (c.type?.includes('FOREIGN'))
+            icon = '🔗';
+        else if (c.type?.includes('UNIQUE'))
+            icon = '🔒';
+        output += `${icon} ${c.name} (${c.type})\n`;
+        if (c.columns)
+            output += `  Columnas: ${Array.isArray(c.columns) ? c.columns.join(', ') : c.columns}\n`;
+    });
+    return output;
+}
+function formatSchemaList(result) {
+    if (result.rows.length === 0) {
+        return '📭 No se encontraron schemas';
+    }
+    let output = `📋 Schemas (${result.rows.length}):\n\n`;
+    result.rows.forEach((s) => {
+        output += `• ${s.name}\n`;
+    });
+    return output;
+}
+function formatSequenceList(result) {
+    if (result.rows.length === 0) {
+        return '📭 No se encontraron secuencias';
+    }
+    let output = `📋 Secuencias (${result.rows.length}):\n\n`;
+    result.rows.forEach((s) => {
+        output += `• ${s.schema ? s.schema + '.' : ''}${s.name}\n`;
+        if (s.increment)
+            output += `  Incremento: ${s.increment}\n`;
+    });
+    return output;
+}
+function formatUserList(result) {
+    if (result.rows.length === 0) {
+        return '📭 No se encontraron usuarios';
+    }
+    let output = `👥 Usuarios (${result.rows.length}):\n\n`;
+    result.rows.forEach((u) => {
+        output += `• ${u.name}`;
+        if (u.host)
+            output += `@${u.host}`;
+        if (u.roles)
+            output += ` [${Array.isArray(u.roles) ? u.roles.join(', ') : u.roles}]`;
+        output += '\n';
+    });
+    return output;
+}
+function formatSessionList(result) {
+    if (result.rows.length === 0) {
+        return '📭 No hay sesiones activas';
+    }
+    let output = `🔌 Sesiones activas (${result.rows.length}):\n\n`;
+    result.rows.forEach((s) => {
+        output += `• ID: ${s.sessionId} | Usuario: ${s.user || 'N/A'} | Estado: ${s.status || 'N/A'}\n`;
+        if (s.database)
+            output += `  DB: ${s.database}`;
+        if (s.host)
+            output += ` | Host: ${s.host}`;
+        output += '\n';
+    });
+    return output;
+}
+function formatLockList(result) {
+    if (result.rows.length === 0) {
+        return '📭 No hay bloqueos activos';
+    }
+    let output = `🔒 Bloqueos activos (${result.rows.length}):\n\n`;
+    result.rows.forEach((l) => {
+        output += `• Tipo: ${l.lockType} | Tabla: ${l.tableName || 'N/A'}\n`;
+        output += `  Modo: ${l.mode} | Estado: ${l.status} | Sesión: ${l.sessionId}\n`;
+    });
+    return output;
+}
+function formatTableSize(result, table) {
+    if (result.rows.length === 0) {
+        return `📭 No se pudo obtener el tamaño de ${table}`;
+    }
+    const size = result.rows[0];
+    let output = `📊 Tamaño de ${table}:\n\n`;
+    for (const [key, value] of Object.entries(size)) {
+        output += `• ${key}: ${value}\n`;
+    }
+    return output;
+}
+function formatTablespaceList(result) {
+    if (result.rows.length === 0) {
+        return '📭 No se encontraron tablespaces';
+    }
+    let output = `💾 Tablespaces (${result.rows.length}):\n\n`;
+    result.rows.forEach((t) => {
+        output += `• ${t.name}\n`;
+        output += `  Total: ${t.totalMB} MB | Usado: ${t.usedMB} MB\n`;
+    });
+    return output;
+}
+function generateInsertStatements(table, result) {
+    if (result.rows.length === 0) {
+        return '📭 No hay datos para exportar';
+    }
+    const columns = result.columns.length > 0 ? result.columns : Object.keys(result.rows[0]);
+    let output = `-- Exportación de ${table} (${result.rows.length} registros)\n\n`;
+    result.rows.forEach(row => {
+        const values = columns.map(col => formatValue(row[col])).join(', ');
+        output += `INSERT INTO ${table} (${columns.join(', ')}) VALUES (${values});\n`;
+    });
+    return output;
+}
+// Main server setup
+export async function runDatabaseMcpServer() {
+    const server = new Server({
+        name: 'mcp-database-server',
+        version: MACRO.VERSION
+    }, {
+        capabilities: {
+            tools: {}
+        }
+    });
+    // List tools handler
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        return { tools };
+    });
+    // Call tool handler
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        try {
+            const result = await handleTool(name, args || {});
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: result
+                    }
+                ]
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `❌ Error: ${error instanceof Error ? error.message : String(error)}`
+                    }
+                ],
+                isError: true
+            };
+        }
+    });
+    // Start server
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error('MCP Database Server running on stdio');
+}