@ecubelabs/mysql-mcp 0.0.0-stage → 0.0.1

package/dist/index.js

@@ -0,0 +1,684 @@
+#!/usr/bin/env node
+import { fileURLToPath } from 'url';
+import { realpathSync } from 'fs';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { log, tableResourceUri } from './src/utils/index.js';
+import { ALLOW_DELETE_OPERATION, ALLOW_DDL_OPERATION, ALLOW_INSERT_OPERATION, ALLOW_UPDATE_OPERATION, SCHEMA_DELETE_PERMISSIONS, SCHEMA_DDL_PERMISSIONS, SCHEMA_INSERT_PERMISSIONS, SCHEMA_UPDATE_PERMISSIONS, isMultiDbMode, mcpConfig as config, MYSQL_PROFILE, PROFILE_LABEL, IS_WRITE_FORBIDDEN_PROFILE, APP_SCHEMAS, CODE_BRANCH, MYSQL_CATALOG_ENABLED, MYSQL_CATALOG_PATH, MYSQL_CATALOG_TTL_HOURS, MYSQL_DOCS_REPO, MYSQL_DEFAULT_TIMEOUT_SECONDS, MYSQL_MAX_TIMEOUT_SECONDS, MAX_RESPONSE_ROWS, MYSQL_SSL_ENABLED, MYSQL_SSL_CA_PATH, MYSQL_SSL_CERT_PATH, MYSQL_SSL_KEY_PATH, PACKAGE_VERSION, SSH_ENABLED, } from './src/config/index.js';
+import { catalogIdentity, SchemaCatalog } from './src/catalog/index.js';
+import { describeConnection, getPool, executeQuery, executeReadOnlyQuery, setQueryDiagnosticsSource, clampTimeoutSeconds, poolPromise, profileBanner, } from './src/db/index.js';
+import { describeTunnel, ensureTunnel, resolveTunnelConfig, stopTunnel } from './src/ssh/tunnel.js';
+log('info', `Starting MySQL MCP server v${PACKAGE_VERSION}...`);
+const toolVersion = `MySQL MCP Server [v${PACKAGE_VERSION}]`;
+const TOOL_DESCRIPTION_LIMIT = 2048;
+let baseToolDescription = `[${toolVersion}] Run SQL queries against the ${PROFILE_LABEL} MySQL database`;
+if (MYSQL_PROFILE) {
+    baseToolDescription += IS_WRITE_FORBIDDEN_PROFILE
+        ? ` — ENVIRONMENT: ${PROFILE_LABEL}, STRICTLY READ-ONLY (writes are refused by policy)`
+        : ` — ENVIRONMENT: ${PROFILE_LABEL}`;
+}
+if (isMultiDbMode) {
+    baseToolDescription += ' (Multi-DB mode enabled)';
+}
+if (ALLOW_INSERT_OPERATION || ALLOW_UPDATE_OPERATION || ALLOW_DELETE_OPERATION || ALLOW_DDL_OPERATION) {
+    baseToolDescription += ' with support for:';
+    if (ALLOW_INSERT_OPERATION) {
+        baseToolDescription += ' INSERT,';
+    }
+    if (ALLOW_UPDATE_OPERATION) {
+        baseToolDescription += ' UPDATE,';
+    }
+    if (ALLOW_DELETE_OPERATION) {
+        baseToolDescription += ' DELETE,';
+    }
+    if (ALLOW_DDL_OPERATION) {
+        baseToolDescription += ' DDL,';
+    }
+    baseToolDescription = baseToolDescription.replace(/,$/, '') + ' and READ operations';
+    if (Object.keys(SCHEMA_INSERT_PERMISSIONS).length > 0 ||
+        Object.keys(SCHEMA_UPDATE_PERMISSIONS).length > 0 ||
+        Object.keys(SCHEMA_DELETE_PERMISSIONS).length > 0 ||
+        Object.keys(SCHEMA_DDL_PERMISSIONS).length > 0) {
+        baseToolDescription += ' (Schema-specific permissions enabled)';
+    }
+}
+else {
+    baseToolDescription += ' (READ-ONLY)';
+}
+baseToolDescription +=
+    `\n\nLIMITS: every read is cancelled after ${MYSQL_DEFAULT_TIMEOUT_SECONDS}s ` +
+        `(raise per call with timeout_seconds, up to ${MYSQL_MAX_TIMEOUT_SECONDS}) and returns at most ` +
+        `${MAX_RESPONSE_ROWS.toLocaleString('en-US')} rows. Aggregate in SQL rather than pulling rows to count them. ` +
+        `USE and SET are rejected; write schema.table instead of USE.`;
+if (CODE_BRANCH) {
+    baseToolDescription +=
+        `\n\nCODE REVISION: this database matches the \`${CODE_BRANCH}\` branch. ` +
+            `Read entities, migrations, and queries from that branch when correlating code with data.`;
+}
+if (APP_SCHEMAS.length > 0) {
+    baseToolDescription +=
+        '\n\nAPP -> SCHEMA (authoritative — use these directly; do not run SHOW DATABASES ' +
+            'or search information_schema to find a schema):';
+    for (const entry of APP_SCHEMAS) {
+        baseToolDescription +=
+            `\n  - ${entry.app} -> ${entry.schema}` + (entry.description ? ` — ${entry.description}` : '');
+    }
+    baseToolDescription +=
+        '\nQualify every table with its schema (schema.table). Any schema not listed here is ' +
+            'either absent from this environment or not owned by an application.';
+    const needsQuoting = APP_SCHEMAS.find((entry) => !/^[A-Za-z0-9_$]+$/.test(entry.schema));
+    if (needsQuoting) {
+        baseToolDescription +=
+            `\nA schema name that is not a bare identifier must be backtick-quoted, ` +
+                `e.g. SELECT ... FROM \`${needsQuoting.schema}\`.some_table.`;
+    }
+}
+const isReadOnly = !(ALLOW_INSERT_OPERATION || ALLOW_UPDATE_OPERATION || ALLOW_DELETE_OPERATION || ALLOW_DDL_OPERATION);
+const mysqlCatalogTool = {
+    name: 'mysql_catalog',
+    description: 'Read the local schema catalog without rediscovering database metadata. ' +
+        'Use map for the app/schema overview, search to find tables or known columns, ' +
+        'describe before writing SQL, and docs_list/docs_read to inspect domain documents. ' +
+        "Use link or unlink to record the model's document decision. " +
+        'Use note to save a table memo or alias, and forget to clear one catalog scope. ' +
+        'Use refresh when cached metadata contradicts what a query actually returned, ' +
+        'or right after a migration: added columns and indexes raise no error, so ' +
+        'nothing else invalidates them.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            action: {
+                type: 'string',
+                enum: [
+                    'map',
+                    'search',
+                    'describe',
+                    'docs_list',
+                    'docs_read',
+                    'link',
+                    'unlink',
+                    'note',
+                    'forget',
+                    'refresh',
+                ],
+                description: 'Catalog operation to perform',
+            },
+            q: {
+                type: 'string',
+                description: 'Keyword for search',
+            },
+            limit: {
+                type: 'integer',
+                minimum: 1,
+                maximum: 100,
+                description: 'Maximum search results (default 20)',
+            },
+            table: {
+                type: 'string',
+                description: 'Qualified schema.table name for describe, or for unlink. note and ' +
+                    'forget take the same name as target instead.',
+            },
+            schema: {
+                type: 'string',
+                description: 'Declared schema name for docs_list. Results are narrowed to the ' +
+                    'documents under the app directory declared for that schema; the ' +
+                    'response says so and reports how many were left out.',
+            },
+            path: {
+                type: 'string',
+                description: 'Cataloged model.md path for docs_read',
+            },
+            target: {
+                type: 'string',
+                description: 'Qualified schema.table for note or forget. For refresh: "schema.table" for one table\'s ' +
+                    'columns, indexes and foreign keys; a declared schema name for the ' +
+                    'table inventory; "docs" to re-read the document ref after a git ' +
+                    'fetch. Omit it to refresh the inventory and the documents together.',
+            },
+            text: {
+                type: 'string',
+                maxLength: 1000,
+                description: 'Table memo to add with note; use either text or alias',
+            },
+            alias: {
+                type: 'string',
+                maxLength: 200,
+                description: 'Alternative table name to add with note; use either alias or text',
+            },
+            scope: {
+                type: 'string',
+                enum: ['notes', 'aliases', 'usage', 'joins', 'metadata'],
+                description: 'What forget clears for one table. metadata is lazily recollected; ' +
+                    'document decisions use unlink instead.',
+            },
+            links: {
+                type: 'array',
+                description: 'Table/document decisions to record in one call',
+                items: {
+                    type: 'object',
+                    properties: {
+                        table: {
+                            type: 'string',
+                            description: 'Qualified schema.table name',
+                        },
+                        doc: {
+                            type: 'string',
+                            description: 'Cataloged model.md path',
+                        },
+                    },
+                    required: ['table', 'doc'],
+                },
+            },
+        },
+        required: ['action'],
+    },
+    annotations: {
+        readOnlyHint: false,
+        idempotentHint: false,
+        destructiveHint: false,
+        openWorldHint: false,
+        title: 'MySQL Schema Catalog',
+    },
+};
+const mysqlQueryInputSchema = {
+    type: 'object',
+    properties: {
+        sql: {
+            type: 'string',
+            description: 'The SQL query to execute',
+        },
+        timeout_seconds: {
+            type: 'integer',
+            minimum: 1,
+            maximum: MYSQL_MAX_TIMEOUT_SECONDS,
+            description: `Server-side execution limit in seconds (default ${MYSQL_DEFAULT_TIMEOUT_SECONDS}, ` +
+                `maximum ${MYSQL_MAX_TIMEOUT_SECONDS}; out-of-range values are clamped). ` +
+                `Raise it only when a cancelled query's plan looked sound and the query was merely slow. ` +
+                `A query the plan shows scanning a whole table does not finish sooner with more time.`,
+        },
+    },
+    required: ['sql'],
+};
+log('info', 'MySQL Configuration:', JSON.stringify({
+    connection: describeConnection(),
+    user: config.mysql.user,
+    password: config.mysql.password ? '******' : 'not set',
+    database: config.mysql.database || 'MULTI_DB_MODE',
+    ssl: MYSQL_SSL_ENABLED ? 'enabled' : 'disabled',
+    sslCA: MYSQL_SSL_CA_PATH ?? 'not set',
+    sslCert: MYSQL_SSL_CERT_PATH ?? 'not set',
+    sslKey: MYSQL_SSL_KEY_PATH ?? 'not set',
+    multiDbMode: isMultiDbMode ? 'enabled' : 'disabled',
+    profile: PROFILE_LABEL,
+    writePolicy: IS_WRITE_FORBIDDEN_PROFILE
+        ? 'read-only (enforced by profile)'
+        : isReadOnly
+            ? 'read-only'
+            : 'writes enabled',
+    sshTunnel: SSH_ENABLED ? describeTunnel() : 'disabled',
+}, null, 2));
+export default function createMcpServer() {
+    const mysqlSettings = config.mysql;
+    const catalogTarget = SSH_ENABLED
+        ? (() => {
+            const tunnel = resolveTunnelConfig();
+            return JSON.stringify(['tcp', tunnel.remoteHost, tunnel.remotePort]);
+        })()
+        : typeof mysqlSettings.socketPath === 'string'
+            ? JSON.stringify(['unix', mysqlSettings.socketPath])
+            : JSON.stringify(['tcp', String(mysqlSettings.host ?? '127.0.0.1'), Number(mysqlSettings.port ?? 3306)]);
+    const identity = catalogIdentity({
+        profile: MYSQL_PROFILE,
+        target: catalogTarget,
+        user: String(mysqlSettings.user ?? ''),
+        customPath: MYSQL_CATALOG_PATH,
+    });
+    const noDeclaredSchemas = APP_SCHEMAS.length === 0;
+    if (noDeclaredSchemas && MYSQL_CATALOG_ENABLED) {
+        console.error('[catalog] disabled: MYSQL_APP_SCHEMAS declares no schema, so there is ' +
+            'nothing to catalog. Declare the app -> schema map to enable it.');
+    }
+    const catalog = new SchemaCatalog({
+        enabled: MYSQL_CATALOG_ENABLED && !noDeclaredSchemas,
+        profile: MYSQL_PROFILE || 'default',
+        fingerprint: identity.fingerprint,
+        filePath: identity.filePath,
+        ttlHours: MYSQL_CATALOG_TTL_HOURS,
+        appSchemas: APP_SCHEMAS,
+        docsRepo: MYSQL_DOCS_REPO ?? null,
+        docsRef: CODE_BRANCH ? `origin/${CODE_BRANCH}` : null,
+        defaultSchema: typeof mysqlSettings.database === 'string' ? mysqlSettings.database : null,
+    });
+    setQueryDiagnosticsSource({
+        indexFacts: (reference) => catalog.indexFacts(reference),
+    });
+    if (baseToolDescription.length > TOOL_DESCRIPTION_LIMIT) {
+        console.error(`[warn] tool description is ${baseToolDescription.length} characters before the ` +
+            `catalog tail; clients keep ${TOOL_DESCRIPTION_LIMIT} and silently drop the rest. ` +
+            `Shorten MYSQL_APP_SCHEMAS descriptions, or the text in index.ts.`);
+    }
+    const mysqlQueryDescription = () => baseToolDescription + catalog.toolDescriptionSuffix(TOOL_DESCRIPTION_LIMIT - baseToolDescription.length);
+    const loadResourceTables = async () => {
+        if (catalog.isEnabled()) {
+            try {
+                const cached = await catalog.listTables();
+                if (cached.length > 0) {
+                    return cached;
+                }
+            }
+            catch (error) {
+                console.error(`[catalog] table resource fallback: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        return executeQuery(`
+      SELECT
+        table_name as name,
+        table_schema as \`database\`,
+        table_comment as description,
+        table_rows as rowCount,
+        data_length as dataSize,
+        index_length as indexSize,
+        create_time as createTime,
+        update_time as updateTime
+      FROM
+        information_schema.tables
+      WHERE
+        table_schema NOT IN ('information_schema', 'mysql', 'performance_schema', 'sys')
+      ORDER BY
+        table_schema, table_name
+    `);
+    };
+    const server = new Server({
+        name: 'MySQL MCP Server',
+        version: PACKAGE_VERSION,
+    }, {
+        capabilities: {
+            resources: {},
+            tools: catalog.isEnabled() ? { listChanged: true } : {},
+        },
+    });
+    server.setRequestHandler(ListResourcesRequestSchema, async () => {
+        try {
+            log('info', 'Handling ListResourcesRequest');
+            log('info', `Connection info: ${describeConnection()}`);
+            const tables = await loadResourceTables();
+            log('info', `Found ${tables.length} tables`);
+            const resources = tables.map((table) => ({
+                uri: tableResourceUri(table.database, table.name),
+                name: table.name,
+                title: `${table.database}.${table.name}`,
+                description: table.description || `Table ${table.name} in database ${table.database}`,
+                mimeType: 'application/json',
+            }));
+            resources.push({
+                uri: 'mysql://tables',
+                name: 'Tables',
+                title: 'MySQL Tables',
+                description: 'List of all MySQL tables',
+                mimeType: 'application/json',
+            });
+            if (APP_SCHEMAS.length > 0) {
+                resources.push({
+                    uri: 'mysql://schemas',
+                    name: 'App schemas',
+                    title: 'Application to schema map',
+                    description: `Which schema each application owns in ${PROFILE_LABEL}`,
+                    mimeType: 'application/json',
+                });
+            }
+            return { resources };
+        }
+        catch (error) {
+            log('error', 'Error in ListResourcesRequest handler:', error);
+            throw error;
+        }
+    });
+    server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+        try {
+            log('info', 'Handling ReadResourceRequest:', request.params.uri);
+            if (request.params.uri === 'mysql://schemas') {
+                return {
+                    contents: [
+                        {
+                            uri: request.params.uri,
+                            mimeType: 'application/json',
+                            text: JSON.stringify({
+                                profile: PROFILE_LABEL,
+                                ...(CODE_BRANCH ? { codeBranch: CODE_BRANCH } : {}),
+                                apps: APP_SCHEMAS,
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            if (request.params.uri === 'mysql://tables') {
+                return {
+                    contents: [
+                        {
+                            uri: request.params.uri,
+                            mimeType: 'application/json',
+                            text: JSON.stringify(await loadResourceTables(), null, 2),
+                        },
+                    ],
+                };
+            }
+            let dbName = null;
+            let tableName;
+            if (request.params.uri.startsWith('mysql://tables/')) {
+                const parts = request.params.uri.slice('mysql://tables/'.length).split('/').map(decodeURIComponent);
+                dbName = parts.length >= 2 ? parts[0] : null;
+                tableName = parts.length >= 2 ? parts[1] : parts[0];
+                if (catalog.isEnabled()) {
+                    try {
+                        return {
+                            contents: [
+                                {
+                                    uri: request.params.uri,
+                                    mimeType: 'application/json',
+                                    text: await catalog.describe(dbName ? `${dbName}.${tableName}` : tableName),
+                                },
+                            ],
+                        };
+                    }
+                    catch (error) {
+                        log('info', `[catalog] describe fallback for ${request.params.uri}: ${error instanceof Error ? error.message : String(error)}`);
+                    }
+                }
+            }
+            else {
+                const uriParts = request.params.uri.split('/');
+                tableName = uriParts.pop();
+                dbName = uriParts.length > 0 ? (uriParts.pop() ?? null) : null;
+            }
+            if (!tableName) {
+                throw new Error(`Invalid resource URI: ${request.params.uri}`);
+            }
+            let columnsQuery = 'SELECT column_name, data_type FROM information_schema.columns WHERE table_name = ?';
+            let queryParams = [tableName];
+            if (dbName) {
+                columnsQuery += ' AND table_schema = ?';
+                queryParams.push(dbName);
+            }
+            const results = (await executeQuery(columnsQuery, queryParams));
+            return {
+                contents: [
+                    {
+                        uri: request.params.uri,
+                        mimeType: 'application/json',
+                        text: JSON.stringify(results, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            log('error', 'Error in ReadResourceRequest handler:', error);
+            throw error;
+        }
+    });
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        try {
+            log('info', 'Handling CallToolRequest:', request.params.name);
+            if (request.params.name === 'mysql_catalog') {
+                if (!catalog.isEnabled()) {
+                    throw new Error('The schema catalog is disabled.');
+                }
+                const args = request.params.arguments ?? {};
+                const action = args.action;
+                let text;
+                if (action === 'map') {
+                    text = await catalog.map();
+                }
+                else if (action === 'search') {
+                    if (typeof args.q !== 'string' || !args.q.trim()) {
+                        throw new Error('mysql_catalog search requires a non-empty "q".');
+                    }
+                    text = await catalog.search(args.q, typeof args.limit === 'number' ? args.limit : undefined);
+                }
+                else if (action === 'describe') {
+                    if (typeof args.table !== 'string' || !args.table.trim()) {
+                        throw new Error('mysql_catalog describe requires "table" as schema.table.');
+                    }
+                    text = await catalog.describe(args.table);
+                }
+                else if (action === 'docs_list') {
+                    if (typeof args.schema !== 'string' || !args.schema.trim()) {
+                        throw new Error('mysql_catalog docs_list requires "schema".');
+                    }
+                    text = await catalog.docsList(args.schema);
+                }
+                else if (action === 'docs_read') {
+                    if (typeof args.path !== 'string' || !args.path.trim()) {
+                        throw new Error('mysql_catalog docs_read requires "path".');
+                    }
+                    text = await catalog.docsRead(args.path);
+                }
+                else if (action === 'link') {
+                    if (!Array.isArray(args.links) ||
+                        !args.links.every((link) => link &&
+                            typeof link === 'object' &&
+                            typeof link.table === 'string' &&
+                            typeof link.doc === 'string')) {
+                        throw new Error('mysql_catalog link requires "links" as [{table, doc}, ...].');
+                    }
+                    text = await catalog.link(args.links);
+                }
+                else if (action === 'unlink') {
+                    if (typeof args.table !== 'string' || !args.table.trim()) {
+                        throw new Error('mysql_catalog unlink requires "table" as schema.table.');
+                    }
+                    text = await catalog.unlink(args.table);
+                }
+                else if (action === 'note') {
+                    if (typeof args.target !== 'string' || !args.target.trim()) {
+                        throw new Error('mysql_catalog note requires "target" as schema.table.');
+                    }
+                    const hasText = typeof args.text === 'string' && args.text.trim().length > 0;
+                    const hasAlias = typeof args.alias === 'string' && args.alias.trim().length > 0;
+                    if (hasText === hasAlias) {
+                        throw new Error('mysql_catalog note requires exactly one non-empty "text" or "alias".');
+                    }
+                    text = await catalog.note(args.target, {
+                        ...(hasText ? { text: args.text } : {}),
+                        ...(hasAlias ? { alias: args.alias } : {}),
+                    });
+                }
+                else if (action === 'forget') {
+                    if (typeof args.target !== 'string' || !args.target.trim()) {
+                        throw new Error('mysql_catalog forget requires "target" as schema.table.');
+                    }
+                    const scopes = new Set(['notes', 'aliases', 'usage', 'joins', 'metadata']);
+                    if (typeof args.scope !== 'string' || !scopes.has(args.scope)) {
+                        throw new Error('mysql_catalog forget requires "scope" as notes, aliases, usage, joins, or metadata.');
+                    }
+                    text = await catalog.forget(args.target, args.scope);
+                }
+                else if (action === 'refresh') {
+                    if (args.target !== undefined && typeof args.target !== 'string') {
+                        throw new Error('mysql_catalog refresh takes "target" as a string.');
+                    }
+                    text = await catalog.refresh(args.target);
+                }
+                else {
+                    throw new Error(`Unknown mysql_catalog action: ${String(action)}`);
+                }
+                return {
+                    content: [
+                        { type: 'text', text: profileBanner() },
+                        { type: 'text', text },
+                    ],
+                    isError: false,
+                };
+            }
+            if (request.params.name !== 'mysql_query') {
+                throw new Error(`Unknown tool: ${request.params.name}`);
+            }
+            const sql = request.params.arguments?.sql;
+            const timeoutSeconds = clampTimeoutSeconds(request.params.arguments?.timeout_seconds);
+            const references = catalog.prepareQuery(sql);
+            let result;
+            try {
+                result = await executeReadOnlyQuery(sql, { timeoutSeconds });
+            }
+            catch (error) {
+                catalog.afterQuery(references, { content: [], isError: true }, error);
+                throw error;
+            }
+            const documentGuidance = result.isError ? null : catalog.queryDocumentGuidance(references);
+            catalog.afterQuery(references, result);
+            return {
+                ...result,
+                content: [
+                    { type: 'text', text: profileBanner() },
+                    ...(result.content ?? []),
+                    ...(documentGuidance ? [{ type: 'text', text: documentGuidance }] : []),
+                ],
+            };
+        }
+        catch (err) {
+            const error = err;
+            log('error', 'Error in CallToolRequest handler:', error);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `${profileBanner()} Error: ${error.message}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        log('info', 'Handling ListToolsRequest');
+        const toolsResponse = {
+            tools: [
+                {
+                    name: 'mysql_query',
+                    description: mysqlQueryDescription(),
+                    inputSchema: mysqlQueryInputSchema,
+                    annotations: {
+                        readOnlyHint: isReadOnly,
+                        idempotentHint: isReadOnly,
+                        destructiveHint: !isReadOnly,
+                        openWorldHint: false,
+                        title: 'MySQL Query',
+                    },
+                },
+                ...(catalog.isEnabled() ? [mysqlCatalogTool] : []),
+            ],
+        };
+        log('info', 'ListToolsRequest response:', JSON.stringify(toolsResponse, null, 2));
+        return toolsResponse;
+    });
+    catalog.onToolDescriptionFilled(async () => {
+        await server.sendToolListChanged().catch(() => undefined);
+    });
+    (async () => {
+        try {
+            if (SSH_ENABLED) {
+                log('info', 'Opening SSH tunnel before connecting to MySQL...');
+                const endpoint = await ensureTunnel();
+                log('info', `SSH tunnel ready on ${endpoint?.host}:${endpoint?.port}` +
+                    (endpoint?.reused ? ' (reused an existing forward)' : ''));
+            }
+            log('info', 'Attempting to test database connection...');
+            const pool = await getPool();
+            const connection = await pool.getConnection();
+            log('info', 'Database connection test successful');
+            connection.release();
+            catalog.startInventory();
+        }
+        catch (error) {
+            console.error(`[startup] fatal error for profile ${PROFILE_LABEL}: ` +
+                (error instanceof Error ? error.message : String(error)));
+            log('error', 'Fatal error during server startup:', error);
+            await stopTunnel();
+            process.exit(1);
+        }
+    })();
+    const shutdown = async (signal) => {
+        log('error', `Received ${signal}. Shutting down...`);
+        try {
+            await catalog.close();
+            if (poolPromise) {
+                const pool = await poolPromise;
+                await pool.end();
+            }
+        }
+        catch (err) {
+            log('error', 'Error closing pool:', err);
+        }
+        finally {
+            await stopTunnel();
+        }
+    };
+    const shutdownAndExit = async (reason) => {
+        try {
+            await shutdown(reason);
+        }
+        catch (err) {
+            log('error', `Error during ${reason} shutdown:`, err);
+        }
+        process.exit(0);
+    };
+    process.stdin.once('end', () => void shutdownAndExit('stdin end'));
+    process.stdin.once('close', () => void shutdownAndExit('stdin close'));
+    process.on('SIGINT', async () => {
+        try {
+            await shutdown('SIGINT');
+            process.exit(0);
+        }
+        catch (err) {
+            log('error', 'Error during SIGINT shutdown:', err);
+            process.exit(1);
+        }
+    });
+    process.on('SIGTERM', async () => {
+        try {
+            await shutdown('SIGTERM');
+            process.exit(0);
+        }
+        catch (err) {
+            log('error', 'Error during SIGTERM shutdown:', err);
+            process.exit(1);
+        }
+    });
+    process.on('uncaughtException', (error) => {
+        log('error', 'Uncaught exception:', error);
+        process.exit(1);
+    });
+    process.on('unhandledRejection', (reason, promise) => {
+        log('error', 'Unhandled rejection at:', promise, 'reason:', reason);
+        process.exit(1);
+    });
+    return server;
+}
+const isMainModule = () => {
+    if (typeof require !== 'undefined' && require.main === module) {
+        return true;
+    }
+    if (typeof import.meta !== 'undefined' && import.meta.url && process.argv[1]) {
+        const currentModulePath = fileURLToPath(import.meta.url);
+        const mainScriptPath = realpathSync(process.argv[1]);
+        return currentModulePath === mainScriptPath;
+    }
+    return false;
+};
+if (isMainModule()) {
+    log('info', 'Running in standalone mode');
+    (async () => {
+        try {
+            const mcpServer = createMcpServer();
+            const transport = new StdioServerTransport();
+            await mcpServer.connect(transport);
+            log('info', 'Server started and listening on stdio');
+        }
+        catch (error) {
+            console.error(`[startup] fatal error for profile ${PROFILE_LABEL}: ` +
+                (error instanceof Error ? error.message : String(error)));
+            log('error', 'Server error:', error);
+            process.exit(1);
+        }
+    })();
+}