@ecubelabs/mysql-mcp 0.0.0-stage → 0.0.1

package/dist/src/db/utils.js

@@ -0,0 +1,264 @@
+import SqlParser from 'node-sql-parser';
+import { MYSQL_DB } from './../config/index.js';
+import { log } from './../utils/index.js';
+const { Parser } = SqlParser;
+const parser = new Parser();
+const READ_STATEMENT_TYPES = new Set(['select', 'show', 'desc', 'explain']);
+const WRITE_STATEMENT_TYPES = new Set(['insert', 'update', 'delete', 'create', 'alter', 'drop', 'truncate']);
+function findUnsupportedStatementType(queryTypes) {
+    return queryTypes.find((type) => !READ_STATEMENT_TYPES.has(type) && !WRITE_STATEMENT_TYPES.has(type)) ?? null;
+}
+function findFileExport(sql) {
+    let astOrArray;
+    try {
+        astOrArray = parser.astify(stripExplainModifiers(sql), { database: 'mysql' });
+    }
+    catch {
+        return null;
+    }
+    const visit = (node) => {
+        if (!isRecord(node)) {
+            return null;
+        }
+        const into = node.into;
+        const keyword = typeof into?.keyword === 'string' ? into.keyword.toUpperCase() : null;
+        if (keyword === 'OUTFILE' || keyword === 'DUMPFILE') {
+            return `INTO ${keyword}`;
+        }
+        for (const value of Object.values(node)) {
+            const items = Array.isArray(value) ? value : [value];
+            for (const item of items) {
+                const found = visit(item);
+                if (found) {
+                    return found;
+                }
+            }
+        }
+        return null;
+    };
+    return visit(astOrArray);
+}
+function databaseStatementName(node) {
+    if (typeof node.name === 'string') {
+        return node.name;
+    }
+    const schema = node.database?.schema?.[0]?.value;
+    return typeof schema === 'string' ? schema : null;
+}
+function extractReferencedSchemas(sql) {
+    let astOrArray;
+    try {
+        astOrArray = parser.astify(sql, { database: 'mysql' });
+    }
+    catch (err) {
+        log('error', 'Failed to parse SQL for schema extraction:', err.message);
+        return null;
+    }
+    const defaultSchema = MYSQL_DB ?? null;
+    const schemas = new Set();
+    const qualified = new Map();
+    const unqualified = [];
+    const visit = (node) => {
+        if (!isRecord(node)) {
+            return;
+        }
+        if ((node.keyword === 'database' || node.keyword === 'schema') && typeof node.type === 'string') {
+            schemas.add(databaseStatementName(node));
+        }
+        const name = typeof node.table === 'string' ? node.table : typeof node.view === 'string' ? node.view : null;
+        if (node.type !== 'column_ref' && name && (typeof node.db === 'string' || node.db === null)) {
+            if (typeof node.db === 'string' && node.db) {
+                schemas.add(node.db);
+                qualified.set(name.toLowerCase(), node.db);
+                if (typeof node.as === 'string' && node.as) {
+                    qualified.set(node.as.toLowerCase(), node.db);
+                }
+            }
+            else {
+                unqualified.push(name.toLowerCase());
+            }
+        }
+        for (const value of Object.values(node)) {
+            if (Array.isArray(value)) {
+                for (const item of value) {
+                    visit(item);
+                }
+            }
+            else {
+                visit(value);
+            }
+        }
+    };
+    visit(astOrArray);
+    for (const name of unqualified) {
+        schemas.add(qualified.get(name) ?? defaultSchema);
+    }
+    if (schemas.size === 0) {
+        schemas.add(null);
+    }
+    return [...schemas];
+}
+const EXPLAIN_MODIFIER_RE = /^(\s*EXPLAIN\s+)((?:ANALYZE\s+|EXTENDED\s+|PARTITIONS\s+|FORMAT\s*=\s*\w+\s+)+)/i;
+function stripExplainModifiers(sql) {
+    return sql.replace(EXPLAIN_MODIFIER_RE, '$1');
+}
+async function getQueryTypes(query) {
+    try {
+        log('info', `Parsing SQL query (${query.length} chars)`);
+        const normalised = stripExplainModifiers(query);
+        const astOrArray = parser.astify(normalised, { database: 'mysql' });
+        const statements = Array.isArray(astOrArray) ? astOrArray : [astOrArray];
+        return statements.map((stmt) => stmt.type?.toLowerCase() ?? 'unknown');
+    }
+    catch (err) {
+        log('error', 'Error parsing SQL query:', err.message);
+        throw new Error(`Parsing failed: ${err.message}`);
+    }
+}
+const SHOW_INTROSPECTION_RE = /^\s*SHOW\s+(?:FULL\s+)?(COLUMNS|FIELDS|CREATE\s+TABLE|CREATE\s+VIEW|INDEX(?:ES)?|KEYS|TABLE\s+STATUS|TABLES|DATABASES|SCHEMAS|CHARACTER\s+SET|CHARSET|COLLATION)\b/i;
+const DESCRIBE_RE = /^\s*(?:DESCRIBE|DESC)\s+/i;
+const EXPLAIN_TABLE_RE = /^\s*EXPLAIN\s+(?!SELECT\b|INSERT\b|UPDATE\b|DELETE\b|REPLACE\b|ANALYZE\b|FORMAT\b|FOR\s|EXTENDED\b|PARTITIONS\b|\()[A-Za-z_`]/i;
+function isIntrospectionQuery(sql) {
+    const showMatch = sql.match(SHOW_INTROSPECTION_RE);
+    if (showMatch) {
+        const keyword = showMatch[1].toUpperCase().replace(/\s+/g, ' ');
+        if (keyword.startsWith('COLUMNS') || keyword.startsWith('FIELDS')) {
+            return { kind: 'show_columns' };
+        }
+        if (keyword.startsWith('CREATE')) {
+            return { kind: 'show_create' };
+        }
+        if (keyword.startsWith('INDEX') || keyword.startsWith('KEYS')) {
+            return { kind: 'show_index' };
+        }
+        if (keyword === 'TABLES' ||
+            keyword.startsWith('TABLE STATUS') ||
+            keyword === 'DATABASES' ||
+            keyword === 'SCHEMAS' ||
+            keyword.startsWith('CHARACTER') ||
+            keyword === 'CHARSET' ||
+            keyword === 'COLLATION') {
+            return { kind: 'show_passthrough' };
+        }
+        return { kind: 'show_other' };
+    }
+    if (DESCRIBE_RE.test(sql) || EXPLAIN_TABLE_RE.test(sql)) {
+        return { kind: 'describe' };
+    }
+    let astOrArray;
+    try {
+        astOrArray = parser.astify(sql, { database: 'mysql' });
+    }
+    catch {
+        return { kind: null };
+    }
+    const statements = Array.isArray(astOrArray) ? astOrArray : [astOrArray];
+    for (const stmt of statements) {
+        const kind = findIntrospectionKind(stmt);
+        if (kind) {
+            return { kind };
+        }
+    }
+    return { kind: null };
+}
+function findIntrospectionKind(node) {
+    if (node == null || typeof node !== 'object') {
+        return null;
+    }
+    if (node instanceof Date) {
+        return null;
+    }
+    const obj = node;
+    if (obj.type === 'show') {
+        const keyword = typeof obj.keyword === 'string' ? obj.keyword.toLowerCase() : '';
+        if (keyword === 'columns' || keyword === 'fields') {
+            return 'show_columns';
+        }
+        if (keyword === 'create') {
+            return 'show_create';
+        }
+        if (keyword === 'index' || keyword === 'keys') {
+            return 'show_index';
+        }
+        if (keyword === 'tables' || keyword === 'databases' || keyword === 'character' || keyword === 'collation') {
+            return 'show_passthrough';
+        }
+        return 'show_other';
+    }
+    if (obj.type === 'desc' || obj.type === 'describe') {
+        return 'describe';
+    }
+    if (typeof obj.db === 'string') {
+        const db = obj.db.toLowerCase();
+        if (db === 'information_schema') {
+            return 'information_schema';
+        }
+        if (db === 'mysql') {
+            return 'mysql_schema';
+        }
+    }
+    for (const value of Object.values(obj)) {
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                const kind = findIntrospectionKind(item);
+                if (kind) {
+                    return kind;
+                }
+            }
+        }
+        else if (value && typeof value === 'object') {
+            const kind = findIntrospectionKind(value);
+            if (kind) {
+                return kind;
+            }
+        }
+    }
+    return null;
+}
+function isRecord(node) {
+    return node != null && typeof node === 'object' && !(node instanceof Date);
+}
+function extractQualifiers(sql) {
+    const map = new Map();
+    let astOrArray;
+    try {
+        astOrArray = parser.astify(stripExplainModifiers(sql), { database: 'mysql' });
+    }
+    catch {
+        return map;
+    }
+    const visit = (node) => {
+        if (!isRecord(node)) {
+            return;
+        }
+        if (node.type !== 'column_ref' &&
+            typeof node.table === 'string' &&
+            (typeof node.db === 'string' || node.db === null)) {
+            const reference = {
+                schema: typeof node.db === 'string' && node.db ? node.db : null,
+                table: node.table,
+            };
+            map.set(node.table.toLowerCase(), reference);
+            if (typeof node.as === 'string' && node.as) {
+                map.set(node.as.toLowerCase(), reference);
+            }
+        }
+        for (const value of Object.values(node)) {
+            if (Array.isArray(value)) {
+                for (const item of value) {
+                    visit(item);
+                }
+            }
+            else {
+                visit(value);
+            }
+        }
+    };
+    visit(astOrArray);
+    return map;
+}
+function isUnparseableIntrospection(sql) {
+    const kind = isIntrospectionQuery(sql).kind;
+    return kind !== null && kind !== 'information_schema' && kind !== 'mysql_schema';
+}
+export { findUnsupportedStatementType, findFileExport, extractReferencedSchemas, getQueryTypes, isIntrospectionQuery, isUnparseableIntrospection, extractQualifiers, stripExplainModifiers, };

package/dist/src/ssh/config.js

@@ -0,0 +1,137 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+export function expandHome(p) {
+    if (p === '~') {
+        return os.homedir();
+    }
+    if (p.startsWith('~/')) {
+        return path.join(os.homedir(), p.slice(2));
+    }
+    return p;
+}
+function splitDirective(line) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) {
+        return null;
+    }
+    const eq = trimmed.indexOf('=');
+    const ws = trimmed.search(/\s/);
+    let sepIndex;
+    if (eq !== -1 && (ws === -1 || eq < ws)) {
+        sepIndex = eq;
+    }
+    else if (ws !== -1) {
+        sepIndex = ws;
+    }
+    else {
+        return null;
+    }
+    const keyword = trimmed.slice(0, sepIndex).trim().toLowerCase();
+    const value = trimmed
+        .slice(sepIndex + 1)
+        .trim()
+        .replace(/^=/, '')
+        .trim();
+    if (!keyword || !value) {
+        return null;
+    }
+    return [keyword, value];
+}
+function parseLocalForward(value) {
+    const parts = value.split(/\s+/).filter(Boolean);
+    if (parts.length < 2) {
+        return null;
+    }
+    const localRaw = parts[0];
+    const localPortStr = localRaw.includes(':') ? localRaw.slice(localRaw.lastIndexOf(':') + 1) : localRaw;
+    const localPort = Number(localPortStr);
+    if (!Number.isInteger(localPort) || localPort < 0 || localPort > 65535) {
+        return null;
+    }
+    let remoteHost;
+    let remotePortStr;
+    const remoteRaw = parts[1];
+    const lastColon = remoteRaw.lastIndexOf(':');
+    if (lastColon > 0) {
+        remoteHost = remoteRaw.slice(0, lastColon);
+        remotePortStr = remoteRaw.slice(lastColon + 1);
+    }
+    else if (parts.length >= 3) {
+        remoteHost = remoteRaw;
+        remotePortStr = parts[2];
+    }
+    else {
+        return null;
+    }
+    const remotePort = Number(remotePortStr);
+    if (!remoteHost || !Number.isInteger(remotePort) || remotePort <= 0) {
+        return null;
+    }
+    return { localPort, remoteHost, remotePort };
+}
+export function readSSHConfigHost(alias, configPath = path.join(os.homedir(), '.ssh', 'config')) {
+    if (!fs.existsSync(configPath)) {
+        return null;
+    }
+    const wanted = alias.trim().toLowerCase();
+    let raw;
+    try {
+        raw = fs.readFileSync(configPath, 'utf8');
+    }
+    catch (err) {
+        throw new Error(`Failed to read SSH config at ${configPath}: ${err.message}`);
+    }
+    let inBlock = false;
+    const entry = {};
+    let found = false;
+    for (const line of raw.split(/\r?\n/)) {
+        const directive = splitDirective(line);
+        if (!directive) {
+            continue;
+        }
+        const [keyword, value] = directive;
+        if (keyword === 'host') {
+            inBlock = value.split(/\s+/).some((token) => token.toLowerCase() === wanted);
+            if (inBlock) {
+                found = true;
+            }
+            continue;
+        }
+        if (keyword === 'match') {
+            inBlock = false;
+            continue;
+        }
+        if (!inBlock) {
+            continue;
+        }
+        switch (keyword) {
+            case 'hostname':
+                entry.hostName ??= value;
+                break;
+            case 'user':
+                entry.user ??= value;
+                break;
+            case 'port': {
+                const port = Number(value);
+                if (Number.isInteger(port) && port > 0 && port <= 65535) {
+                    entry.port ??= port;
+                }
+                break;
+            }
+            case 'identityfile':
+                entry.identityFile ??= expandHome(value.replace(/^"|"$/g, ''));
+                break;
+            case 'localforward': {
+                const forward = parseLocalForward(value);
+                if (forward && !entry.localForward) {
+                    entry.localForward = forward;
+                }
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    return found ? entry : null;
+}