@ecubelabs/mysql-mcp 0.0.1 → 1.0.0-next.1

package/README.md

@@ -51,13 +51,18 @@ Host ecubelabs2-prod-db
     LocalForward 3308 <prod RDS reader 엔드포인트>:3306
 ```
 
-`HostName`, `User`, `Port`, `IdentityFile`, 그리고 첫 번째 `LocalForward`를
-읽어갑니다. 다음 단계로 넘어가기 전에 alias 자체가 동작하는지 확인하세요:
+`HostName`, `User`, `Port`, `IdentityFile`, `UserKnownHostsFile`, `HostKeyAlias`,
+그리고 첫 번째 `LocalForward`를 읽어갑니다. 다음 단계로 넘어가기 전에 alias로 한 번
+접속하세요:
 
 ```bash
 ssh ecubelabs2-stage-db "echo ok"
 ```
 
+- alias가 동작하는지 확인합니다.
+- bastion 호스트 키를 `~/.ssh/known_hosts`에 기록합니다. 서버는 기록된 키만 받고
+  처음 보는 키는 거부합니다.
+
 ### 2. MCP 클라이언트에 등록하기
 
 - `MYSQL_PROFILE`은 빼지 마세요. prod 쓰기 금지를 이 값이 정합니다.
@@ -399,16 +404,16 @@ Catalog는 선언된 schema만 훑으므로, 선언이 없으면 스스로 꺼
 
 ### SSH tunnel
 
-| 변수                         | 기본값                                       | 의미                                                                                                 |
-| ---------------------------- | -------------------------------------------- | ---------------------------------------------------------------------------------------------------- |
-| `MYSQL_SSH_CONFIG_HOST`      | _(미설정)_                                   | `HostName`, `User`, `Port`, `IdentityFile`, 첫 `LocalForward`를 읽어올 `~/.ssh/config`의 Host alias. |
-| `MYSQL_SSH_HOST`             | alias에서                                    | bastion 호스트명.                                                                                    |
-| `MYSQL_SSH_PORT`             | alias `Port`, 없으면 `22`                    | bastion SSH 포트.                                                                                    |
-| `MYSQL_SSH_USER`             | alias에서                                    | bastion 사용자.                                                                                      |
-| `MYSQL_SSH_PRIVATE_KEY_PATH` | alias `IdentityFile`, 없으면 `~/.ssh/id_rsa` | bastion 인증에 쓰는 키.                                                                              |
-| `MYSQL_SSH_PASSPHRASE`       | _(미설정)_                                   | 암호화된 키일 때만 필요합니다.                                                                       |
-| `MYSQL_SSH_LOCAL_PORT`       | alias `LocalForward`, 없으면 `0`             | 선호하는 loopback 포트. `0`은 자동 할당. 포트가 이미 쓰이고 있으면 자동 할당된 포트를 대신 씁니다.   |
-| `MYSQL_SSH_REUSE_EXISTING`   | `false`                                      | 직접 열지 않고 해당 포트에 이미 떠 있는 forward에 붙습니다. 아래 경고를 참고하세요.                  |
+| 변수                         | 기본값                                       | 의미                                                                                                                                       |
+| ---------------------------- | -------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ |
+| `MYSQL_SSH_CONFIG_HOST`      | _(미설정)_                                   | `HostName`, `User`, `Port`, `IdentityFile`, `UserKnownHostsFile`, `HostKeyAlias`, 첫 `LocalForward`를 읽어올 `~/.ssh/config`의 Host alias. |
+| `MYSQL_SSH_HOST`             | alias에서                                    | bastion 호스트명.                                                                                                                          |
+| `MYSQL_SSH_PORT`             | alias `Port`, 없으면 `22`                    | bastion SSH 포트.                                                                                                                          |
+| `MYSQL_SSH_USER`             | alias에서                                    | bastion 사용자.                                                                                                                            |
+| `MYSQL_SSH_PRIVATE_KEY_PATH` | alias `IdentityFile`, 없으면 `~/.ssh/id_rsa` | bastion 인증에 쓰는 키.                                                                                                                    |
+| `MYSQL_SSH_PASSPHRASE`       | _(미설정)_                                   | 암호화된 키일 때만 필요합니다.                                                                                                             |
+| `MYSQL_SSH_LOCAL_PORT`       | alias `LocalForward`, 없으면 `0`             | 선호하는 loopback 포트. `0`은 자동 할당. 포트가 이미 쓰이고 있으면 자동 할당된 포트를 대신 씁니다.                                         |
+| `MYSQL_SSH_REUSE_EXISTING`   | `false`                                      | 직접 열지 않고 해당 포트에 이미 떠 있는 forward에 붙습니다. 아래 경고를 참고하세요.                                                        |
 
 - `MYSQL_SSH_CONFIG_HOST`나 `MYSQL_SSH_HOST`가 있으면 접속 전에 tunnel을 엽니다. 둘
   다 없으면 tunnel 없이 `MYSQL_HOST`로 직접 접속합니다.
@@ -450,9 +455,16 @@ Catalog는 선언된 schema만 훑으므로, 선언이 없으면 스스로 꺼
 | `ALLOW_INSERT_OPERATION` | INSERT 허용.                                                                                  |
 | `ALLOW_UPDATE_OPERATION` | UPDATE 허용.                                                                                  |
 | `ALLOW_DELETE_OPERATION` | DELETE 허용.                                                                                  |
-| `ALLOW_DDL_OPERATION`    | CREATE/ALTER/DROP/TRUNCATE 허용.                                                              |
+| `ALLOW_DDL_OPERATION`    | CREATE/ALTER/DROP/TRUNCATE/RENAME 허용.                                                       |
 | `SCHEMA_*_PERMISSIONS`   | schema별 override, `"db1:true,db2:false"`. 문장이 참조하는 schema가 모두 허용돼야 실행합니다. |
 
+- schema별 값이 `ALLOW_*`보다 우선합니다. 적은 schema는 그 값으로, 적지 않은 schema는
+  `ALLOW_*`로 판정합니다.
+- 그래서 `ALLOW_UPDATE_OPERATION`을 끈 채 `SCHEMA_UPDATE_PERMISSIONS=haulla:true`만 적으면
+  `haulla`에서만 UPDATE가 열립니다.
+- 쓰기가 하나라도 열리면 도구 설명에 `with support for: UPDATE (haulla only) …`처럼 적고
+  `readOnlyHint`를 `false`로 알립니다.
+
 ### 진단
 
 | 변수                                   | 기본값  | 의미                                                                                                                                                                                                                                                             |
@@ -482,17 +494,31 @@ flag는 평범한 설정이기 때문입니다.
 
 어느 profile이든 실행하는 문장 종류는 허용 목록으로 정합니다. 읽기는 `SELECT`,
 `SHOW`, `DESCRIBE`, `EXPLAIN`뿐이고, 쓰기는 `INSERT`, `UPDATE`, `DELETE`와
-DDL(`CREATE`/`ALTER`/`DROP`/`TRUNCATE`)이 위 flag를 통과할 때만 실행합니다. 그 밖의
-문장은 모두 거부합니다. `RENAME TABLE`, `GRANT`처럼 implicit commit을 일으키는 문장은
+DDL(`CREATE`/`ALTER`/`DROP`/`TRUNCATE`/`RENAME`)이 위 flag를 통과할 때만 실행합니다. 그
+밖의 문장은 모두 거부합니다. `GRANT`처럼 implicit commit을 일으키는 문장은
 `START TRANSACTION READ ONLY`로도 막히지 않고, `SET`, `LOCK TABLES`, `USE`는 pool에
 반납된 connection에 상태를 남기기 때문입니다. 다른 schema의 table은 `USE` 대신
 `schema.table`로 적습니다. `SELECT … INTO OUTFILE`·`INTO DUMPFILE`도 DB 서버에 파일을
 쓰므로 거부합니다.
 
+SQL parser가 주석으로 버리지만 MySQL이 따르는 주석도 거부합니다.
+
+- `/*! … */` 실행 주석. MySQL은 그 안을 문장으로 실행합니다. 검사는 parser가 본 문장으로
+  하므로, `/*! RENAME TABLE … */`는 빈 문장으로 보여 허용 목록을 통과합니다.
+- `/*+ MAX_EXECUTION_TIME(…) */`와 `/*+ SET_VAR(…) */` hint. 아래 시간 상한을
+  덮어씁니다.
+- 텍스트로 찾으므로 문자열 리터럴 안의 같은 글자도 거부합니다.
+
 schema별 쓰기 권한은 문장이 참조하는 schema 전부에 대해 판정합니다. 하나라도
 막혀 있으면 거부합니다. 읽기만 하는 table의 schema도 포함하므로,
 `INSERT INTO a.t SELECT … FROM b.u`는 `a`와 `b` 둘 다 INSERT가 허용돼야 합니다.
 
+- schema를 적지 않은 table은 기본 schema(`MYSQL_DB`)로 봅니다. 같은 문장에 같은
+  이름의 다른 schema table이 있어도 그렇습니다. MySQL이 그렇게 실행하기 때문입니다.
+- 예외는 다중 table DELETE의 대상 목록입니다. `DELETE o FROM a.t AS o …`의 `o`는
+  FROM이 붙인 이름이므로 `a`로 판정합니다.
+- `RENAME TABLE a.t TO b.t`는 `a`와 `b` 둘 다 DDL이 허용돼야 합니다.
+
 ## 결과는 있는 그대로 반환합니다
 
 Row 값도, column 이름도, index 이름도 가리지 않습니다. 원본 프로젝트의 PII
@@ -524,6 +550,15 @@ Forwarding은 `ssh -N -L`을 spawn 하는 대신 `ssh2`를 통해 프로세스
 
 - Listener는 `127.0.0.1`에만 bind 합니다. forwarding된 데이터베이스에 인증 없이
   접근할 수 있게 해주므로, 네트워크에서 절대 닿을 수 있어서는 안 됩니다.
+- **bastion 호스트 키는 OpenSSH `known_hosts`로 검증합니다.** `ssh2`는 스스로
+  `known_hosts`를 읽지 않고, 검증하지 않으면 어떤 키든 받습니다. 그러면 경로 위의
+  공격자가 bastion을 사칭해 DB 비밀번호를 받아 갈 수 있습니다.
+    - alias의 `UserKnownHostsFile`(없으면 `~/.ssh/known_hosts`, `~/.ssh/known_hosts2`)와
+      `/etc/ssh/ssh_known_hosts`를 읽습니다. alias에 `HostKeyAlias`가 있으면 그 이름으로
+      찾습니다.
+    - 기록된 키 종류로만 협상합니다. 처음 보는 호스트는 기록하지 않고 거부합니다. 지문을
+      확인할 수 있는 `ssh`로 한 번 접속해 기록하세요.
+    - `@cert-authority` 인증서 기반 호스트 키는 지원하지 않습니다.
 - **각 서버는 자기 tunnel을 소유합니다.** `MYSQL_SSH_LOCAL_PORT`는 요구 사항이
   아니라 선호일 뿐입니다. 포트가 이미 쓰이고 있으면 이 서버는 OS가 할당한
   포트에 자기 tunnel을 엽니다. pool은 어디로 접속할지 전달받으므로 뒷단에서는
@@ -566,6 +601,8 @@ forward가 있으면 거기에 붙었습니다. 결과적으로 잘못된 선택
   때문입니다.
 - 상한 30초는 MCP 클라이언트의 기본 tool timeout보다 낮게 유지하세요. 클라이언트가
   먼저 포기하면 모델에게는 보고서가 아니라 아무것도 남지 않습니다.
+- SQL 안의 `/*+ MAX_EXECUTION_TIME(…) */`·`/*+ SET_VAR(…) */` hint는 거부합니다.
+  MySQL은 이 hint를 세션 상한보다 우선하므로, 허용하면 상한이 풀립니다.
 
 ### 행 수 상한
 
@@ -714,6 +751,24 @@ MYSQL_USER=<user> MYSQL_PASS=<password> npx -y @ecubelabs/mysql-mcp < /dev/null
 - 키는 `chmod 600`이어야 합니다.
 - 암호화된 키라면 `MYSQL_SSH_PASSPHRASE`가 필요합니다.
 
+### `No host key for <host> in known_hosts`
+
+bastion 호스트 키가 `known_hosts`에 기록돼 있지 않습니다. 오류 메시지가 실행할 명령을
+알려 줍니다.
+
+- alias로 한 번 접속해 지문을 확인하고 기록하세요: `ssh ecubelabs2-stage-db "echo ok"`.
+- 기록돼 있는지 확인하려면: `ssh-keygen -F <bastion 호스트명>`. 22번이 아닌 포트는
+  `ssh-keygen -F "[<bastion 호스트명>]:<port>"`입니다.
+
+### `the host key for <host> does not match known_hosts`
+
+bastion이 기록과 다른 키를 내밀었습니다. bastion을 다시 만들었거나, 누군가 접속을
+가로채고 있습니다.
+
+- 같은 alias로 `ssh`를 실행해 OpenSSH의 경고를 확인하세요.
+- 키가 바뀐 것이 확실할 때만 `ssh-keygen -R <bastion 호스트명>`으로 옛 키를 지우고 다시
+  접속해 기록하세요.
+
 ### `local port N is taken` 로그
 
 ```text
@@ -816,6 +871,7 @@ src/config/           환경 변수 해석, profile 정책, mysql2 옵션
 src/catalog/          로컬 schema catalog: DB metadata 수집, 문서 연결, 사용 기록, 검색
 src/db/               쿼리 routing, 권한 검사, pool, 타임아웃 진단
 src/ssh/config.ts     ~/.ssh/config Host alias parser
+src/ssh/known-hosts.ts  known_hosts 조회와 bastion 호스트 키 검증
 src/ssh/tunnel.ts     tunnel lifecycle: 열기, 재사용, 재연결, 닫기
 src/types/            공유 타입
 src/utils/            stderr 전용 로거, table resource URI

package/dist/index.js

@@ -4,10 +4,11 @@ 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 { log, sharedOnce, tableResourceUri } from './src/utils/index.js';
+import { writeCapabilities } from './src/db/permissions.js';
+import { 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 { describeConnection, getPool, executeQuery, executeReadOnlyQuery, setQueryDiagnosticsSource, clampTimeoutSeconds, describeQueryError, 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}]`;
@@ -21,21 +22,10 @@ if (MYSQL_PROFILE) {
 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';
+const writes = writeCapabilities();
+if (writes.length > 0) {
+    const supported = writes.map(({ label, schemas }) => (schemas ? `${label} (${schemas.join(', ')} only)` : label));
+    baseToolDescription += ` with support for: ${supported.join(', ')} 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 ||
@@ -50,7 +40,8 @@ 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.`;
+        `USE and SET are rejected; write schema.table instead of USE. ` +
+        `Executable comments (/*! ... */) and MAX_EXECUTION_TIME or SET_VAR hints are rejected; use timeout_seconds instead.`;
 if (CODE_BRANCH) {
     baseToolDescription +=
         `\n\nCODE REVISION: this database matches the \`${CODE_BRANCH}\` branch. ` +
@@ -74,7 +65,7 @@ if (APP_SCHEMAS.length > 0) {
                 `e.g. SELECT ... FROM \`${needsQuoting.schema}\`.some_table.`;
     }
 }
-const isReadOnly = !(ALLOW_INSERT_OPERATION || ALLOW_UPDATE_OPERATION || ALLOW_DELETE_OPERATION || ALLOW_DDL_OPERATION);
+const isReadOnly = writes.length === 0;
 const mysqlCatalogTool = {
     name: 'mysql_catalog',
     description: 'Read the local schema catalog without rediscovering database metadata. ' +
@@ -514,6 +505,9 @@ export default function createMcpServer() {
                 throw new Error(`Unknown tool: ${request.params.name}`);
             }
             const sql = request.params.arguments?.sql;
+            if (typeof sql !== 'string' || sql.trim() === '') {
+                throw new Error('The "sql" argument is required and must be a non-empty string.');
+            }
             const timeoutSeconds = clampTimeoutSeconds(request.params.arguments?.timeout_seconds);
             const references = catalog.prepareQuery(sql);
             let result;
@@ -537,7 +531,7 @@ export default function createMcpServer() {
         }
         catch (err) {
             const error = err;
-            log('error', 'Error in CallToolRequest handler:', error);
+            log('error', 'Error in CallToolRequest handler:', describeQueryError(error));
             return {
                 content: [
                     {
@@ -597,8 +591,8 @@ export default function createMcpServer() {
             process.exit(1);
         }
     })();
-    const shutdown = async (signal) => {
-        log('error', `Received ${signal}. Shutting down...`);
+    const shutdown = sharedOnce(async (signal) => {
+        log('info', `Received ${signal}. Shutting down...`);
         try {
             await catalog.close();
             if (poolPromise) {
@@ -612,7 +606,7 @@ export default function createMcpServer() {
         finally {
             await stopTunnel();
         }
-    };
+    });
     const shutdownAndExit = async (reason) => {
         try {
             await shutdown(reason);

package/dist/src/db/index.js

@@ -2,7 +2,7 @@ import { performance } from 'perf_hooks';
 import * as mysql2 from 'mysql2/promise';
 import { mcpConfig as config, describeConfiguredTarget, SSH_ENABLED, MYSQL_PROFILE, PROFILE_LABEL, CODE_BRANCH, IS_WRITE_FORBIDDEN_PROFILE, MYSQL_DISABLE_READ_ONLY_TRANSACTIONS, MYSQL_DEFAULT_TIMEOUT_SECONDS, MYSQL_MAX_TIMEOUT_SECONDS, MYSQL_CATALOG_TIMEOUT_SECONDS, MAX_RESPONSE_ROWS, } from './../config/index.js';
 import { isDDLAllowedForSchema, isInsertAllowedForSchema, isUpdateAllowedForSchema, isDeleteAllowedForSchema, } from './permissions.js';
-import { extractReferencedSchemas, findFileExport, findUnsupportedStatementType, getQueryTypes, isUnparseableIntrospection, extractQualifiers, } from './utils.js';
+import { DDL_STATEMENT_TYPES, extractReferencedSchemas, findFileExport, findLimitOverrideHint, findUnsupportedStatementType, getQueryTypes, hasExecutableComment, isUnparseableIntrospection, extractQualifiers, } from './utils.js';
 import { isQueryTimeoutError, parseExplainPayload, renderTimeoutDiagnostic } from './diagnose.js';
 import { log } from './../utils/index.js';
 import { ensureTunnel, getTunnelEndpoint, getTunnelFatalError, describeTunnel } from './../ssh/tunnel.js';
@@ -89,6 +89,14 @@ function describeQueryError(error) {
     }
     return error.message;
 }
+async function rollbackQuietly(connection) {
+    try {
+        await connection.rollback();
+    }
+    catch (error) {
+        log('error', 'Rollback failed; reporting the original error instead:', describeQueryError(error));
+    }
+}
 function assertTunnelHealthy() {
     const fatal = getTunnelFatalError();
     if (fatal) {
@@ -140,7 +148,7 @@ async function executeQuery(sql, params = []) {
                 log('error', 'Error restoring session limits:', restoreError);
             }
             connection.release();
-            log('error', 'Connection released');
+            log('info', 'Connection released');
         }
     }
 }
@@ -163,7 +171,7 @@ async function executeWriteQuery(sql) {
         assertTunnelHealthy();
         const pool = await getPool();
         connection = await pool.getConnection();
-        log('error', 'Write connection acquired');
+        log('info', 'Write connection acquired');
         const schema = (extractReferencedSchemas(sql) ?? [null]).map((name) => name ?? 'default').join(', ');
         await connection.beginTransaction();
         try {
@@ -178,7 +186,7 @@ async function executeWriteQuery(sql) {
             const isUpdateOperation = queryTypes.some((type) => ['update'].includes(type));
             const isInsertOperation = queryTypes.some((type) => ['insert'].includes(type));
             const isDeleteOperation = queryTypes.some((type) => ['delete'].includes(type));
-            const isDDLOperation = queryTypes.some((type) => ['create', 'alter', 'drop', 'truncate'].includes(type));
+            const isDDLOperation = queryTypes.some((type) => DDL_STATEMENT_TYPES.has(type));
             if (isInsertOperation) {
                 const resultHeader = response;
                 responseText = `Insert successful on schema '${schema}'. Affected rows: ${resultHeader.affectedRows}, Last insert ID: ${resultHeader.insertId}`;
@@ -213,7 +221,7 @@ async function executeWriteQuery(sql) {
         }
         catch (error) {
             log('error', 'Error executing write query:', describeQueryError(error));
-            await connection.rollback();
+            await rollbackQuietly(connection);
             return {
                 content: [
                     {
@@ -240,7 +248,7 @@ async function executeWriteQuery(sql) {
     finally {
         if (connection) {
             connection.release();
-            log('error', 'Write connection released');
+            log('info', 'Write connection released');
         }
     }
 }
@@ -297,6 +305,34 @@ async function executeReadOnlyQuery(sql, options = {}) {
     let connection;
     try {
         assertTunnelHealthy();
+        if (hasExecutableComment(sql)) {
+            log('error', 'Refusing a statement with an executable comment.');
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: 'Error: executable comments (/*! ... */) are not allowed because MySQL runs their ' +
+                            'contents. Write the statement without them.',
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const limitHint = findLimitOverrideHint(sql);
+        if (limitHint) {
+            log('error', `Refusing a statement with the ${limitHint} optimizer hint.`);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error: the ${limitHint} optimizer hint is not allowed because it overrides the ` +
+                            `server's execution limit. Remove it and pass timeout_seconds (up to ` +
+                            `${MYSQL_MAX_TIMEOUT_SECONDS}) if the query needs more time.`,
+                    },
+                ],
+                isError: true,
+            };
+        }
         const bypassesQueryTypeChecks = isUnparseableIntrospection(sql);
         let queryTypes = [];
         let isUpdateOperation = false;
@@ -305,6 +341,12 @@ async function executeReadOnlyQuery(sql, options = {}) {
         let isDDLOperation = false;
         if (!bypassesQueryTypeChecks) {
             queryTypes = await getQueryTypes(sql);
+            if (queryTypes.length === 0) {
+                return {
+                    content: [{ type: 'text', text: 'Error: no SQL statement found outside comments.' }],
+                    isError: true,
+                };
+            }
             const unsupported = findUnsupportedStatementType(queryTypes);
             if (unsupported) {
                 const statement = unsupported.toUpperCase();
@@ -338,7 +380,7 @@ async function executeReadOnlyQuery(sql, options = {}) {
             isUpdateOperation = queryTypes.some((type) => ['update'].includes(type));
             isInsertOperation = queryTypes.some((type) => ['insert'].includes(type));
             isDeleteOperation = queryTypes.some((type) => ['delete'].includes(type));
-            isDDLOperation = queryTypes.some((type) => ['create', 'alter', 'drop', 'truncate'].includes(type));
+            isDDLOperation = queryTypes.some((type) => DDL_STATEMENT_TYPES.has(type));
         }
         const writeChecks = [
             { enabled: isInsertOperation, label: 'INSERT', allowed: isInsertAllowedForSchema },
@@ -370,7 +412,7 @@ async function executeReadOnlyQuery(sql, options = {}) {
         }
         const pool = await getPool();
         connection = await pool.getConnection();
-        log('error', 'Read-only connection acquired');
+        log('info', 'Read-only connection acquired');
         const timeoutSeconds = clampTimeoutSeconds(options.timeoutSeconds);
         let roundTrips = await applySessionLimits(connection, {
             maxExecutionTimeMs: timeoutSeconds * 1_000,
@@ -427,7 +469,7 @@ async function executeReadOnlyQuery(sql, options = {}) {
         }
         catch (error) {
             log('error', 'Error executing read-only query:', describeQueryError(error));
-            await connection.rollback();
+            await rollbackQuietly(connection);
             if (isQueryTimeoutError(error)) {
                 const diagnostic = await diagnoseTimeout(connection, sql, timeoutSeconds);
                 log('info', `Read query cancelled at ${timeoutSeconds}s after ${roundTrips + 3} DB round trips (including one EXPLAIN)`);
@@ -441,21 +483,16 @@ async function executeReadOnlyQuery(sql, options = {}) {
     }
     catch (error) {
         log('error', 'Error in read-only query transaction:', describeQueryError(error));
-        try {
-            if (connection) {
-                await connection.rollback();
-            }
-        }
-        catch (cleanupError) {
-            log('error', 'Error during cleanup:', cleanupError);
+        if (connection) {
+            await rollbackQuietly(connection);
         }
         throw error;
     }
     finally {
         if (connection) {
             connection.release();
-            log('error', 'Read-only connection released');
+            log('info', 'Read-only connection released');
         }
     }
 }
-export { profileBanner, describeConnection, executeQuery, getPool, executeWriteQuery, executeReadOnlyQuery, setQueryDiagnosticsSource, clampTimeoutSeconds, describeQueryError, poolPromise, };
+export { profileBanner, describeConnection, executeQuery, getPool, executeWriteQuery, executeReadOnlyQuery, setQueryDiagnosticsSource, clampTimeoutSeconds, describeQueryError, rollbackQuietly, poolPromise, };

package/dist/src/db/permissions.js

@@ -23,4 +23,24 @@ function isDDLAllowedForSchema(schema) {
     }
     return schema in SCHEMA_DDL_PERMISSIONS ? SCHEMA_DDL_PERMISSIONS[schema] : ALLOW_DDL_OPERATION;
 }
-export { isInsertAllowedForSchema, isUpdateAllowedForSchema, isDeleteAllowedForSchema, isDDLAllowedForSchema };
+function writeCapabilities() {
+    const kinds = [
+        { label: 'INSERT', global: ALLOW_INSERT_OPERATION, perSchema: SCHEMA_INSERT_PERMISSIONS },
+        { label: 'UPDATE', global: ALLOW_UPDATE_OPERATION, perSchema: SCHEMA_UPDATE_PERMISSIONS },
+        { label: 'DELETE', global: ALLOW_DELETE_OPERATION, perSchema: SCHEMA_DELETE_PERMISSIONS },
+        { label: 'DDL', global: ALLOW_DDL_OPERATION, perSchema: SCHEMA_DDL_PERMISSIONS },
+    ];
+    const capabilities = [];
+    for (const { label, global, perSchema } of kinds) {
+        if (global) {
+            capabilities.push({ label, schemas: null });
+            continue;
+        }
+        const opened = Object.keys(perSchema).filter((schema) => perSchema[schema]);
+        if (opened.length > 0) {
+            capabilities.push({ label, schemas: opened });
+        }
+    }
+    return capabilities;
+}
+export { isInsertAllowedForSchema, isUpdateAllowedForSchema, isDeleteAllowedForSchema, isDDLAllowedForSchema, writeCapabilities, };

package/dist/src/db/utils.js

@@ -4,10 +4,26 @@ 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']);
+const DDL_STATEMENT_TYPES = new Set(['create', 'alter', 'drop', 'truncate', 'rename']);
+const WRITE_STATEMENT_TYPES = new Set(['insert', 'update', 'delete', ...DDL_STATEMENT_TYPES]);
 function findUnsupportedStatementType(queryTypes) {
     return queryTypes.find((type) => !READ_STATEMENT_TYPES.has(type) && !WRITE_STATEMENT_TYPES.has(type)) ?? null;
 }
+const EXECUTABLE_COMMENT_RE = /\/\*!/;
+function hasExecutableComment(sql) {
+    return EXECUTABLE_COMMENT_RE.test(sql);
+}
+const OPTIMIZER_HINT_RE = /\/\*\+([\s\S]*?)\*\//g;
+const LIMIT_OVERRIDE_HINT_RE = /\b(MAX_EXECUTION_TIME|SET_VAR)\s*\(/i;
+function findLimitOverrideHint(sql) {
+    for (const [, body] of sql.matchAll(OPTIMIZER_HINT_RE)) {
+        const hint = body.match(LIMIT_OVERRIDE_HINT_RE);
+        if (hint) {
+            return hint[1].toUpperCase();
+        }
+    }
+    return null;
+}
 function findFileExport(sql) {
     let astOrArray;
     try {
@@ -56,8 +72,9 @@ function extractReferencedSchemas(sql) {
     }
     const defaultSchema = MYSQL_DB ?? null;
     const schemas = new Set();
-    const qualified = new Map();
-    const unqualified = [];
+    const names = new Map();
+    const deleteTargets = new Set();
+    const targetNames = [];
     const visit = (node) => {
         if (!isRecord(node)) {
             return;
@@ -65,17 +82,23 @@ function extractReferencedSchemas(sql) {
         if ((node.keyword === 'database' || node.keyword === 'schema') && typeof node.type === 'string') {
             schemas.add(databaseStatementName(node));
         }
+        if (node.type === 'delete' && Array.isArray(node.table)) {
+            for (const target of node.table) {
+                deleteTargets.add(target);
+            }
+        }
         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);
-                }
+            if (deleteTargets.has(node) && !node.db) {
+                targetNames.push(name.toLowerCase());
             }
             else {
-                unqualified.push(name.toLowerCase());
+                const schema = typeof node.db === 'string' && node.db ? node.db : defaultSchema;
+                schemas.add(schema);
+                const key = (typeof node.as === 'string' && node.as ? node.as : name).toLowerCase();
+                const known = names.get(key) ?? new Set();
+                known.add(schema);
+                names.set(key, known);
             }
         }
         for (const value of Object.values(node)) {
@@ -90,8 +113,10 @@ function extractReferencedSchemas(sql) {
         }
     };
     visit(astOrArray);
-    for (const name of unqualified) {
-        schemas.add(qualified.get(name) ?? defaultSchema);
+    for (const name of targetNames) {
+        for (const schema of names.get(name) ?? [defaultSchema]) {
+            schemas.add(schema);
+        }
     }
     if (schemas.size === 0) {
         schemas.add(null);
@@ -261,4 +286,4 @@ 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, };
+export { DDL_STATEMENT_TYPES, findUnsupportedStatementType, hasExecutableComment, findLimitOverrideHint, findFileExport, extractReferencedSchemas, getQueryTypes, isIntrospectionQuery, isUnparseableIntrospection, extractQualifiers, stripExplainModifiers, };

package/dist/src/ssh/config.js

@@ -122,6 +122,15 @@ export function readSSHConfigHost(alias, configPath = path.join(os.homedir(), '.
             case 'identityfile':
                 entry.identityFile ??= expandHome(value.replace(/^"|"$/g, ''));
                 break;
+            case 'userknownhostsfile':
+                entry.userKnownHostsFiles ??=
+                    value.toLowerCase() === 'none'
+                        ? []
+                        : value.split(/\s+/).map((file) => expandHome(file.replace(/^"|"$/g, '')));
+                break;
+            case 'hostkeyalias':
+                entry.hostKeyAlias ??= value;
+                break;
             case 'localforward': {
                 const forward = parseLocalForward(value);
                 if (forward && !entry.localForward) {

package/dist/src/ssh/known-hosts.js

@@ -0,0 +1,105 @@
+import { createHmac } from 'crypto';
+import * as fs from 'fs';
+import { expandHome } from './config.js';
+export const DEFAULT_USER_KNOWN_HOSTS_FILES = ['~/.ssh/known_hosts', '~/.ssh/known_hosts2'];
+const GLOBAL_KNOWN_HOSTS_FILES = ['/etc/ssh/ssh_known_hosts', '/etc/ssh/ssh_known_hosts2'];
+export function knownHostsName(host, port) {
+    return port === 22 ? host : `[${host}]:${port}`;
+}
+function matchesWildcard(pattern, name) {
+    const source = pattern
+        .split('')
+        .map((ch) => (ch === '*' ? '.*' : ch === '?' ? '.' : ch.replace(/[\\^$.|+()[\]{}]/g, '\\$&')))
+        .join('');
+    return new RegExp(`^${source}$`, 'i').test(name);
+}
+function matchesHashed(entry, name) {
+    const [, , salt, hash] = entry.split('|');
+    if (!salt || !hash) {
+        return false;
+    }
+    const digest = createHmac('sha1', Buffer.from(salt, 'base64')).update(name).digest('base64');
+    return digest === hash;
+}
+function hostFieldMatches(field, name) {
+    if (field.startsWith('|1|')) {
+        return matchesHashed(field, name);
+    }
+    let matched = false;
+    for (const pattern of field.split(',')) {
+        if (pattern.startsWith('!')) {
+            if (matchesWildcard(pattern.slice(1), name)) {
+                return false;
+            }
+        }
+        else if (matchesWildcard(pattern, name)) {
+            matched = true;
+        }
+    }
+    return matched;
+}
+export function lookupKnownHosts(host, port, files) {
+    const name = knownHostsName(host, port);
+    const result = { name, files: [], keys: [], revoked: [] };
+    for (const file of [...files.map(expandHome), ...GLOBAL_KNOWN_HOSTS_FILES]) {
+        let raw;
+        try {
+            raw = fs.readFileSync(file, 'utf8');
+        }
+        catch {
+            continue;
+        }
+        result.files.push(file);
+        for (const line of raw.split(/\r?\n/)) {
+            const fields = line.trim().split(/\s+/);
+            if (!fields[0] || fields[0].startsWith('#')) {
+                continue;
+            }
+            const marker = fields[0].startsWith('@') ? fields.shift() : undefined;
+            if (marker === '@cert-authority') {
+                continue;
+            }
+            const [hosts, type, key] = fields;
+            if (!hosts || !type || !key || !hostFieldMatches(hosts, name)) {
+                continue;
+            }
+            const blob = Buffer.from(key, 'base64');
+            if (marker === '@revoked') {
+                result.revoked.push(blob);
+            }
+            else {
+                result.keys.push({ type, key: blob });
+            }
+        }
+    }
+    return result;
+}
+export function hostKeyAlgorithms(keys) {
+    const algorithms = [];
+    const add = (algorithm) => {
+        if (!algorithms.includes(algorithm)) {
+            algorithms.push(algorithm);
+        }
+    };
+    for (const { type } of keys) {
+        if (type === 'ssh-rsa') {
+            add('rsa-sha2-512');
+            add('rsa-sha2-256');
+            add('ssh-rsa');
+        }
+        else if (type === 'ssh-ed25519' ||
+            type === 'ecdsa-sha2-nistp256' ||
+            type === 'ecdsa-sha2-nistp384' ||
+            type === 'ecdsa-sha2-nistp521' ||
+            type === 'ssh-dss') {
+            add(type);
+        }
+    }
+    return algorithms;
+}
+export function isKnownHostKey(lookup, presented) {
+    if (lookup.revoked.some((key) => key.equals(presented))) {
+        return false;
+    }
+    return lookup.keys.some(({ key }) => key.equals(presented));
+}

package/dist/src/ssh/tunnel.js

@@ -4,6 +4,7 @@ import { Client as SSHClient } from 'ssh2';
 import { MYSQL_HOST, MYSQL_PORT, SSH_CONFIG_HOST, SSH_ENABLED, SSH_HOST, SSH_LOCAL_PORT, SSH_PASSPHRASE, SSH_PORT, SSH_PRIVATE_KEY_PATH, SSH_REUSE_EXISTING, SSH_USER, } from '../config/index.js';
 import { log } from '../utils/index.js';
 import { expandHome, readSSHConfigHost } from './config.js';
+import { DEFAULT_USER_KNOWN_HOSTS_FILES, hostKeyAlgorithms, isKnownHostKey, lookupKnownHosts } from './known-hosts.js';
 class LocalPortTakenError extends Error {
 }
 const RECONNECT_MAX_ATTEMPTS = 3;
@@ -61,6 +62,9 @@ export function resolveTunnelConfig() {
         sshUser: sshUser,
         privateKeyPath,
         passphrase: SSH_PASSPHRASE,
+        knownHostsFiles: fromConfig?.userKnownHostsFiles ?? DEFAULT_USER_KNOWN_HOSTS_FILES,
+        hostKeyName: fromConfig?.hostKeyAlias ?? sshHost,
+        sshTarget: configHost ?? `${sshPort === 22 ? '' : `-p ${sshPort} `}${sshUser}@${sshHost}`,
         localPort,
         remoteHost: remoteHost,
         remotePort,
@@ -95,8 +99,17 @@ let shuttingDown = false;
 let fatalError = null;
 function connectSSH(cfg) {
     return new Promise((resolve, reject) => {
+        const known = lookupKnownHosts(cfg.hostKeyName, cfg.sshPort, cfg.knownHostsFiles);
+        const algorithms = hostKeyAlgorithms(known.keys);
+        if (algorithms.length === 0) {
+            const searched = known.files.length > 0 ? known.files.join(', ') : cfg.knownHostsFiles.join(', ');
+            reject(new Error(`No host key for ${known.name} in known_hosts (${searched}). ` +
+                `Run \`ssh ${cfg.sshTarget}\` once to verify the bastion's fingerprint and record it, then retry.`));
+            return;
+        }
         const client = new SSHClient();
         let settled = false;
+        let hostKeyRejection = null;
         const timer = setTimeout(() => {
             if (settled) {
                 return;
@@ -120,7 +133,7 @@ function connectSSH(cfg) {
             settled = true;
             clearTimeout(timer);
             client.destroy();
-            reject(new Error(`SSH connection to ${cfg.sshUser}@${cfg.sshHost}:${cfg.sshPort} failed: ${err.message}`));
+            reject(new Error(`SSH connection to ${cfg.sshUser}@${cfg.sshHost}:${cfg.sshPort} failed: ${hostKeyRejection ?? err.message}`));
         });
         let privateKey;
         try {
@@ -141,6 +154,16 @@ function connectSSH(cfg) {
             keepaliveInterval: 15000,
             keepaliveCountMax: 3,
             ...(cfg.passphrase ? { passphrase: cfg.passphrase } : {}),
+            algorithms: { serverHostKey: algorithms },
+            hostVerifier: (key) => {
+                if (isKnownHostKey(known, key)) {
+                    return true;
+                }
+                hostKeyRejection =
+                    `the host key for ${known.name} does not match known_hosts. The bastion's key changed or ` +
+                        `the connection is being intercepted. Check with \`ssh ${cfg.sshTarget}\` before retrying.`;
+                return false;
+            },
         };
         client.connect(connectConfig);
     });
@@ -161,7 +184,7 @@ async function reconnect(cfg) {
             sshClient = client;
             fatalError = null;
             attachDropHandler(client, cfg);
-            log('error', `[ssh] tunnel reconnected on attempt ${attempt}`);
+            log('info', `[ssh] tunnel reconnected on attempt ${attempt}`);
             return;
         }
         catch (err) {
@@ -252,7 +275,7 @@ export function ensureTunnel() {
                 activeEndpoint = { host: '127.0.0.1', port: cfg.localPort, reused: true };
                 return activeEndpoint;
             }
-            log('error', `[ssh] opening tunnel ${cfg.sshUser}@${cfg.sshHost}:${cfg.sshPort} -> ${cfg.remoteHost}:${cfg.remotePort} ` +
+            log('info', `[ssh] opening tunnel ${cfg.sshUser}@${cfg.sshHost}:${cfg.sshPort} -> ${cfg.remoteHost}:${cfg.remotePort} ` +
                 `(local port ${cfg.localPort === 0 ? 'auto' : cfg.localPort})`);
             const client = await connectSSH(cfg);
             sshClient = client;
@@ -277,7 +300,7 @@ export function ensureTunnel() {
                 }
             }
             attachDropHandler(client, cfg);
-            log('error', `[ssh] tunnel listening on 127.0.0.1:${port}`);
+            log('info', `[ssh] tunnel listening on 127.0.0.1:${port}`);
             activeEndpoint = { host: '127.0.0.1', port, reused: false };
             return activeEndpoint;
         })();

package/dist/src/utils/index.js

@@ -2,6 +2,10 @@ import { ENABLE_LOGGING } from '../config/index.js';
 export function tableResourceUri(schema, table) {
     return `mysql://tables/${encodeURIComponent(schema)}/${encodeURIComponent(table)}`;
 }
+export function sharedOnce(fn) {
+    let running;
+    return (...args) => (running ??= fn(...args));
+}
 export function log(type = 'info', ...args) {
     if (!ENABLE_LOGGING) {
         return;

package/package.json

@@ -1,53 +1,53 @@
 {
-  "name": "@ecubelabs/mysql-mcp",
-  "version": "0.0.1",
-  "description": "Read-only MySQL MCP server that reaches its database through an SSH bastion, with per-environment profiles",
-  "license": "MIT",
-  "repository": {
-    "url": "https://github.com/Ecube-Labs/skynet.git",
-    "directory": "packages/mysql-mcp"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "type": "module",
-  "engines": {
-    "node": ">=18"
-  },
-  "main": "dist/index.js",
-  "bin": "dist/index.js",
-  "files": [
-    "dist"
-  ],
-  "scripts": {
-    "lint": "oxfmt --check . && oxlint && eslint index.ts \"src/**/*.ts\"",
-    "lint:ci": "oxfmt --check . && oxlint --quiet && eslint --quiet index.ts \"src/**/*.ts\"",
-    "lint:fix": "oxfmt . && oxlint --fix --quiet && eslint --fix index.ts \"src/**/*.ts\"",
-    "build": "tsc && shx chmod +x dist/index.js",
-    "prepack": "yarn build",
-    "watch": "tsc --watch",
-    "test": "tsc -p tsconfig.test.json && vitest run",
-    "test:watch": "vitest",
-    "start:stage": "./bin/mcp-mysql-stage.sh",
-    "start:prod": "./bin/mcp-mysql-prod.sh"
-  },
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.31.0",
-    "mysql2": "^3.14.1",
-    "node-sql-parser": "^5.3.9",
-    "ssh2": "^1.17.0"
-  },
-  "devDependencies": {
-    "@semantic-release/npm": "^13.1.5",
-    "@types/node": "^22.20.2",
-    "@types/ssh2": "^1.15.5",
-    "eslint": "^9.27.0",
-    "eslint-config-skynet": "^0.0.0",
-    "semantic-release": "^25.0.9",
-    "semantic-release-monorepo": "^8.0.2",
-    "shx": "^0.3.4",
-    "typescript": "^5.8.3",
-    "vite": "^8.3.0",
-    "vitest": "^5.0.0"
-  }
-}
+    "name": "@ecubelabs/mysql-mcp",
+    "version": "1.0.0-next.1",
+    "description": "Read-only MySQL MCP server that reaches its database through an SSH bastion, with per-environment profiles",
+    "license": "MIT",
+    "repository": {
+        "url": "https://github.com/Ecube-Labs/skynet.git",
+        "directory": "packages/mysql-mcp"
+    },
+    "publishConfig": {
+        "access": "public"
+    },
+    "type": "module",
+    "engines": {
+        "node": ">=18"
+    },
+    "main": "dist/index.js",
+    "bin": "dist/index.js",
+    "files": [
+        "dist"
+    ],
+    "scripts": {
+        "lint": "oxfmt --check . && oxlint && eslint index.ts \"src/**/*.ts\"",
+        "lint:ci": "oxfmt --check . && oxlint --quiet && eslint --quiet index.ts \"src/**/*.ts\"",
+        "lint:fix": "oxfmt . && oxlint --fix --quiet && eslint --fix index.ts \"src/**/*.ts\"",
+        "build": "tsc && shx chmod +x dist/index.js",
+        "prepack": "yarn build",
+        "watch": "tsc --watch",
+        "test": "tsc -p tsconfig.test.json && vitest run",
+        "test:watch": "vitest",
+        "start:stage": "./bin/mcp-mysql-stage.sh",
+        "start:prod": "./bin/mcp-mysql-prod.sh"
+    },
+    "dependencies": {
+        "@modelcontextprotocol/sdk": "^1.31.0",
+        "mysql2": "^3.14.1",
+        "node-sql-parser": "^5.3.9",
+        "ssh2": "^1.17.0"
+    },
+    "devDependencies": {
+        "@semantic-release/npm": "^13.1.5",
+        "@types/node": "^22.20.2",
+        "@types/ssh2": "^1.15.5",
+        "eslint": "^9.27.0",
+        "eslint-config-skynet": "workspace:^",
+        "semantic-release": "^25.0.9",
+        "semantic-release-monorepo": "^8.0.2",
+        "shx": "^0.3.4",
+        "typescript": "^5.8.3",
+        "vite": "^8.3.0",
+        "vitest": "^5.0.0"
+    }
+}