@ecubelabs/mysql-mcp 1.0.0-next.7 → 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1,4 +1,4 @@
1
- import { WRITE_KINDS } from '../config/schema.js';
1
+ 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, } from '../config/index.js';
2
2
  function schemaOverride(permissions, schema) {
3
3
  const lowered = schema.toLowerCase();
4
4
  let override;
@@ -15,28 +15,43 @@ function schemaOverride(permissions, schema) {
15
15
  }
16
16
  return override;
17
17
  }
18
- export function isWriteAllowed(policy, kind, schema) {
19
- const global = policy.allow[kind];
18
+ function isInsertAllowedForSchema(schema) {
20
19
  if (!schema) {
21
- return global;
20
+ return ALLOW_INSERT_OPERATION;
22
21
  }
23
- return schemaOverride(policy.schemas[kind], schema) ?? global;
22
+ return schemaOverride(SCHEMA_INSERT_PERMISSIONS, schema) ?? ALLOW_INSERT_OPERATION;
24
23
  }
25
- export const WRITE_LABELS = {
26
- insert: 'INSERT',
27
- update: 'UPDATE',
28
- delete: 'DELETE',
29
- ddl: 'DDL',
30
- };
31
- export function writeCapabilities(policy) {
24
+ function isUpdateAllowedForSchema(schema) {
25
+ if (!schema) {
26
+ return ALLOW_UPDATE_OPERATION;
27
+ }
28
+ return schemaOverride(SCHEMA_UPDATE_PERMISSIONS, schema) ?? ALLOW_UPDATE_OPERATION;
29
+ }
30
+ function isDeleteAllowedForSchema(schema) {
31
+ if (!schema) {
32
+ return ALLOW_DELETE_OPERATION;
33
+ }
34
+ return schemaOverride(SCHEMA_DELETE_PERMISSIONS, schema) ?? ALLOW_DELETE_OPERATION;
35
+ }
36
+ function isDDLAllowedForSchema(schema) {
37
+ if (!schema) {
38
+ return ALLOW_DDL_OPERATION;
39
+ }
40
+ return schemaOverride(SCHEMA_DDL_PERMISSIONS, schema) ?? ALLOW_DDL_OPERATION;
41
+ }
42
+ function writeCapabilities() {
43
+ const kinds = [
44
+ { label: 'INSERT', global: ALLOW_INSERT_OPERATION, perSchema: SCHEMA_INSERT_PERMISSIONS },
45
+ { label: 'UPDATE', global: ALLOW_UPDATE_OPERATION, perSchema: SCHEMA_UPDATE_PERMISSIONS },
46
+ { label: 'DELETE', global: ALLOW_DELETE_OPERATION, perSchema: SCHEMA_DELETE_PERMISSIONS },
47
+ { label: 'DDL', global: ALLOW_DDL_OPERATION, perSchema: SCHEMA_DDL_PERMISSIONS },
48
+ ];
32
49
  const capabilities = [];
33
- for (const kind of WRITE_KINDS) {
34
- const label = WRITE_LABELS[kind];
35
- if (policy.allow[kind]) {
50
+ for (const { label, global, perSchema } of kinds) {
51
+ if (global) {
36
52
  capabilities.push({ label, schemas: null });
37
53
  continue;
38
54
  }
39
- const perSchema = policy.schemas[kind];
40
55
  const opened = Object.keys(perSchema).filter((schema) => schemaOverride(perSchema, schema) === true);
41
56
  if (opened.length > 0) {
42
57
  capabilities.push({ label, schemas: opened });
@@ -44,3 +59,4 @@ export function writeCapabilities(policy) {
44
59
  }
45
60
  return capabilities;
46
61
  }
62
+ export { isInsertAllowedForSchema, isUpdateAllowedForSchema, isDeleteAllowedForSchema, isDDLAllowedForSchema, writeCapabilities, };
@@ -1,4 +1,5 @@
1
1
  import SqlParser from 'node-sql-parser';
2
+ import { MYSQL_DB } from './../config/index.js';
2
3
  import { log } from './../utils/index.js';
3
4
  const { Parser } = SqlParser;
4
5
  const parser = new Parser();
@@ -60,7 +61,7 @@ function databaseStatementName(node) {
60
61
  const schema = node.database?.schema?.[0]?.value;
61
62
  return typeof schema === 'string' ? schema : null;
62
63
  }
63
- function extractReferencedSchemas(sql, defaultSchema = null) {
64
+ function extractReferencedSchemas(sql) {
64
65
  let astOrArray;
65
66
  try {
66
67
  astOrArray = parser.astify(sql, { database: 'mysql' });
@@ -69,6 +70,7 @@ function extractReferencedSchemas(sql, defaultSchema = null) {
69
70
  log('error', 'Failed to parse SQL for schema extraction:', err.message);
70
71
  return null;
71
72
  }
73
+ const defaultSchema = MYSQL_DB ?? null;
72
74
  const schemas = new Set();
73
75
  const names = new Map();
74
76
  const deleteTargets = new Set();
@@ -38,16 +38,37 @@ function splitDirective(line) {
38
38
  }
39
39
  return [keyword, value];
40
40
  }
41
- function parseForwardTarget(value) {
41
+ function parseLocalForward(value) {
42
42
  const parts = value.split(/\s+/).filter(Boolean);
43
- const remote = parts[1];
44
- if (!remote) {
43
+ if (parts.length < 2) {
45
44
  return null;
46
45
  }
47
- const colon = remote.lastIndexOf(':');
48
- const host = colon > 0 ? remote.slice(0, colon) : remote;
49
- const port = Number(colon > 0 ? remote.slice(colon + 1) : parts[2]);
50
- return host && Number.isInteger(port) && port > 0 && port <= 65535 ? { host, port } : null;
46
+ const localRaw = parts[0];
47
+ const localPortStr = localRaw.includes(':') ? localRaw.slice(localRaw.lastIndexOf(':') + 1) : localRaw;
48
+ const localPort = Number(localPortStr);
49
+ if (!Number.isInteger(localPort) || localPort < 0 || localPort > 65535) {
50
+ return null;
51
+ }
52
+ let remoteHost;
53
+ let remotePortStr;
54
+ const remoteRaw = parts[1];
55
+ const lastColon = remoteRaw.lastIndexOf(':');
56
+ if (lastColon > 0) {
57
+ remoteHost = remoteRaw.slice(0, lastColon);
58
+ remotePortStr = remoteRaw.slice(lastColon + 1);
59
+ }
60
+ else if (parts.length >= 3) {
61
+ remoteHost = remoteRaw;
62
+ remotePortStr = parts[2];
63
+ }
64
+ else {
65
+ return null;
66
+ }
67
+ const remotePort = Number(remotePortStr);
68
+ if (!remoteHost || !Number.isInteger(remotePort) || remotePort <= 0) {
69
+ return null;
70
+ }
71
+ return { localPort, remoteHost, remotePort };
51
72
  }
52
73
  export function readSSHConfigHost(alias, configPath = path.join(os.homedir(), '.ssh', 'config')) {
53
74
  if (!fs.existsSync(configPath)) {
@@ -110,30 +131,16 @@ export function readSSHConfigHost(alias, configPath = path.join(os.homedir(), '.
110
131
  case 'hostkeyalias':
111
132
  entry.hostKeyAlias ??= value;
112
133
  break;
113
- case 'localforward':
114
- entry.forwardTarget ??= parseForwardTarget(value) ?? undefined;
134
+ case 'localforward': {
135
+ const forward = parseLocalForward(value);
136
+ if (forward && !entry.localForward) {
137
+ entry.localForward = forward;
138
+ }
115
139
  break;
140
+ }
116
141
  default:
117
142
  break;
118
143
  }
119
144
  }
120
145
  return found ? entry : null;
121
146
  }
122
- export function listHostAliases(configPath = path.join(os.homedir(), '.ssh', 'config')) {
123
- if (!fs.existsSync(configPath)) {
124
- return [];
125
- }
126
- const aliases = new Set();
127
- for (const line of fs.readFileSync(configPath, 'utf8').split(/\r?\n/)) {
128
- const directive = splitDirective(line);
129
- if (!directive || directive[0] !== 'host') {
130
- continue;
131
- }
132
- for (const token of directive[1].split(/\s+/)) {
133
- if (token && !/[*?!]/.test(token)) {
134
- aliases.add(token);
135
- }
136
- }
137
- }
138
- return [...aliases];
139
- }
@@ -1,12 +1,102 @@
1
1
  import * as fs from 'fs';
2
2
  import * as net from 'net';
3
3
  import { Client as SSHClient } from 'ssh2';
4
+ 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';
4
5
  import { log } from '../utils/index.js';
5
6
  import { expandHome, readSSHConfigHost } from './config.js';
6
7
  import { DEFAULT_USER_KNOWN_HOSTS_FILES, hostKeyAlgorithms, isKnownHostKey, knownHostsName, lookupKnownHosts, } from './known-hosts.js';
8
+ class LocalPortTakenError extends Error {
9
+ }
7
10
  const RECONNECT_MAX_ATTEMPTS = 3;
8
11
  const RECONNECT_BASE_DELAY_MS = 1000;
12
+ const PROBE_TIMEOUT_MS = 750;
9
13
  const SSH_READY_TIMEOUT_MS = 20000;
14
+ let resolvedTunnelConfig = null;
15
+ export function resolveTunnelConfig() {
16
+ if (resolvedTunnelConfig) {
17
+ return resolvedTunnelConfig;
18
+ }
19
+ const configHost = SSH_CONFIG_HOST;
20
+ let fromConfig = null;
21
+ if (configHost) {
22
+ fromConfig = readSSHConfigHost(configHost);
23
+ if (!fromConfig) {
24
+ throw new Error(`MYSQL_SSH_CONFIG_HOST="${configHost}" was not found as a Host alias in ~/.ssh/config. ` +
25
+ `Either add the alias or set MYSQL_SSH_HOST / MYSQL_SSH_USER explicitly.`);
26
+ }
27
+ log('info', `[ssh] resolved alias "${configHost}" from ~/.ssh/config: ` +
28
+ JSON.stringify({
29
+ hostName: fromConfig.hostName,
30
+ user: fromConfig.user,
31
+ port: fromConfig.port,
32
+ localForward: fromConfig.localForward,
33
+ }));
34
+ }
35
+ const sshHost = SSH_HOST ?? fromConfig?.hostName;
36
+ const sshUser = SSH_USER ?? fromConfig?.user;
37
+ const sshPort = SSH_PORT ?? fromConfig?.port ?? 22;
38
+ const privateKeyPath = expandHome(SSH_PRIVATE_KEY_PATH ?? fromConfig?.identityFile ?? '~/.ssh/id_rsa');
39
+ const localPort = SSH_LOCAL_PORT ?? fromConfig?.localForward?.localPort ?? 0;
40
+ const remoteHost = fromConfig?.localForward?.remoteHost ?? MYSQL_HOST;
41
+ const remotePort = fromConfig?.localForward?.remotePort ?? MYSQL_PORT;
42
+ const missing = [];
43
+ if (!sshHost) {
44
+ missing.push('MYSQL_SSH_HOST (or a HostName in the alias)');
45
+ }
46
+ if (!sshUser) {
47
+ missing.push('MYSQL_SSH_USER (or a User in the alias)');
48
+ }
49
+ if (!remoteHost) {
50
+ missing.push('MYSQL_HOST (or a LocalForward target in the alias)');
51
+ }
52
+ if (missing.length > 0) {
53
+ throw new Error(`SSH tunnel is enabled but underspecified. Missing: ${missing.join(', ')}.`);
54
+ }
55
+ if (!fs.existsSync(privateKeyPath)) {
56
+ throw new Error(`SSH private key not found at "${privateKeyPath}". ` +
57
+ `Set MYSQL_SSH_PRIVATE_KEY_PATH to the key that authenticates ${sshUser}@${sshHost}.`);
58
+ }
59
+ resolvedTunnelConfig = {
60
+ sshHost: sshHost,
61
+ sshPort,
62
+ sshUser: sshUser,
63
+ privateKeyPath,
64
+ passphrase: SSH_PASSPHRASE,
65
+ knownHostsFiles: fromConfig?.userKnownHostsFiles ?? DEFAULT_USER_KNOWN_HOSTS_FILES,
66
+ hostKeyName: knownHostsName(sshHost, sshPort, fromConfig?.hostKeyAlias),
67
+ sshTarget: configHost ?? `${sshPort === 22 ? '' : `-p ${sshPort} `}${sshUser}@${sshHost}`,
68
+ localPort,
69
+ remoteHost: remoteHost,
70
+ remotePort,
71
+ };
72
+ return resolvedTunnelConfig;
73
+ }
74
+ function probeLocalPort(port) {
75
+ return new Promise((resolve) => {
76
+ const socket = new net.Socket();
77
+ let settled = false;
78
+ const finish = (result) => {
79
+ if (settled) {
80
+ return;
81
+ }
82
+ settled = true;
83
+ socket.destroy();
84
+ resolve(result);
85
+ };
86
+ socket.setTimeout(PROBE_TIMEOUT_MS);
87
+ socket.once('connect', () => finish(true));
88
+ socket.once('timeout', () => finish(false));
89
+ socket.once('error', () => finish(false));
90
+ socket.connect(port, '127.0.0.1');
91
+ });
92
+ }
93
+ let endpointPromise = null;
94
+ let localServer = null;
95
+ let sshClient = null;
96
+ let activeConfig = null;
97
+ let activeEndpoint = null;
98
+ let shuttingDown = false;
99
+ let fatalError = null;
10
100
  function connectSSH(cfg) {
11
101
  return new Promise((resolve, reject) => {
12
102
  const known = lookupKnownHosts(cfg.hostKeyName, cfg.knownHostsFiles);
@@ -78,6 +168,54 @@ function connectSSH(cfg) {
78
168
  client.connect(connectConfig);
79
169
  });
80
170
  }
171
+ async function reconnect(cfg) {
172
+ for (let attempt = 1; attempt <= RECONNECT_MAX_ATTEMPTS; attempt++) {
173
+ if (shuttingDown) {
174
+ return;
175
+ }
176
+ const delay = RECONNECT_BASE_DELAY_MS * 2 ** (attempt - 1);
177
+ log('error', `[ssh] tunnel dropped; reconnect attempt ${attempt}/${RECONNECT_MAX_ATTEMPTS} in ${delay}ms`);
178
+ await new Promise((r) => setTimeout(r, delay));
179
+ if (shuttingDown) {
180
+ return;
181
+ }
182
+ try {
183
+ const client = await connectSSH(cfg);
184
+ sshClient = client;
185
+ fatalError = null;
186
+ attachDropHandler(client, cfg);
187
+ log('info', `[ssh] tunnel reconnected on attempt ${attempt}`);
188
+ return;
189
+ }
190
+ catch (err) {
191
+ log('error', `[ssh] reconnect attempt ${attempt} failed: ${err.message}`);
192
+ }
193
+ }
194
+ fatalError = new Error(`SSH tunnel to ${cfg.sshUser}@${cfg.sshHost}:${cfg.sshPort} could not be re-established after ${RECONNECT_MAX_ATTEMPTS} attempts. ` +
195
+ `Restart the MCP server once the bastion is reachable again.`);
196
+ log('error', `[ssh] ${fatalError.message}`);
197
+ }
198
+ let reconnecting = false;
199
+ function attachDropHandler(client, cfg) {
200
+ const onDrop = () => {
201
+ if (shuttingDown || reconnecting) {
202
+ return;
203
+ }
204
+ if (sshClient !== client) {
205
+ return;
206
+ }
207
+ sshClient = null;
208
+ reconnecting = true;
209
+ void reconnect(cfg).finally(() => {
210
+ reconnecting = false;
211
+ });
212
+ };
213
+ client.once('close', onDrop);
214
+ client.once('error', (err) => {
215
+ log('error', `[ssh] transport error: ${err.message}`);
216
+ onDrop();
217
+ });
218
+ }
81
219
  export function forwardSocket(socket, client, cfg, unavailable = null) {
82
220
  socket.on('error', (err) => {
83
221
  log('error', `[ssh] local tunnel socket closed with error: ${err.message}`);
@@ -103,172 +241,117 @@ export function forwardSocket(socket, client, cfg, unavailable = null) {
103
241
  stream.once('close', () => socket.destroy());
104
242
  });
105
243
  }
106
- export function resolveBastion(bastion, options = {}) {
107
- const where = `bastions.${bastion.name}`;
108
- let alias = null;
109
- if (bastion.sshConfigHost) {
110
- alias = readSSHConfigHost(bastion.sshConfigHost, options.sshConfigPath);
111
- if (!alias) {
112
- throw new Error(`${where}.sshConfigHost: "${bastion.sshConfigHost}" was not found as a Host alias in ` +
113
- `${options.sshConfigPath ?? '~/.ssh/config'}. Add the alias or set "host" and "user" under ${where}.`);
114
- }
115
- }
116
- const sshHost = bastion.host ?? alias?.hostName;
117
- const sshUser = bastion.user ?? alias?.user;
118
- const sshPort = bastion.port ?? alias?.port ?? 22;
119
- const missing = [];
120
- if (!sshHost) {
121
- missing.push('"host" (or a HostName line in the alias)');
122
- }
123
- if (!sshUser) {
124
- missing.push('"user" (or a User line in the alias)');
125
- }
126
- if (missing.length > 0) {
127
- throw new Error(`${where}: SSH target is underspecified. Missing: ${missing.join(', ')}.`);
128
- }
129
- const privateKeyPath = expandHome(bastion.privateKeyPath ?? alias?.identityFile ?? '~/.ssh/id_rsa');
130
- if (!fs.existsSync(privateKeyPath)) {
131
- throw new Error(`${where}: SSH private key not found at "${privateKeyPath}". ` +
132
- `Set "privateKeyPath" to the key that authenticates ${sshUser}@${sshHost}.`);
133
- }
134
- return {
135
- sshHost: sshHost,
136
- sshPort,
137
- sshUser: sshUser,
138
- privateKeyPath,
139
- knownHostsFiles: alias?.userKnownHostsFiles ?? DEFAULT_USER_KNOWN_HOSTS_FILES,
140
- hostKeyName: knownHostsName(sshHost, sshPort, alias?.hostKeyAlias),
141
- sshTarget: bastion.sshConfigHost ?? `${sshPort === 22 ? '' : `-p ${sshPort} `}${sshUser}@${sshHost}`,
142
- };
143
- }
144
- export class SshSession {
145
- config;
146
- connect;
147
- client = null;
148
- startPromise = null;
149
- listeners = new Map();
150
- reconnecting = false;
151
- closed = false;
152
- fatalError = null;
153
- constructor(config, connect = connectSSH) {
154
- this.config = config;
155
- this.connect = connect;
156
- }
157
- openListener(remoteHost, remotePort) {
158
- const key = `${remoteHost}:${remotePort}`;
159
- let pending = this.listeners.get(key);
160
- if (!pending) {
161
- pending = this.start().then(() => this.listen(remoteHost, remotePort));
162
- this.listeners.set(key, pending);
163
- pending.catch(() => {
164
- if (this.listeners.get(key) === pending) {
165
- this.listeners.delete(key);
166
- }
167
- });
168
- }
169
- return pending.then(({ endpoint }) => endpoint);
170
- }
171
- start() {
172
- if (!this.startPromise) {
173
- const cfg = this.config;
174
- log('info', `[ssh] opening ${cfg.sshUser}@${cfg.sshHost}:${cfg.sshPort}`);
175
- this.startPromise = this.connect(cfg).then((client) => {
176
- if (this.closed) {
177
- client.end();
178
- throw new Error('SSH session was closed while connecting.');
179
- }
180
- this.client = client;
181
- this.attachDropHandler(client);
182
- });
183
- this.startPromise.catch(() => {
184
- this.startPromise = null;
185
- });
186
- }
187
- return this.startPromise;
188
- }
189
- listen(remoteHost, remotePort) {
190
- return new Promise((resolve, reject) => {
191
- const server = net.createServer((socket) => forwardSocket(socket, this.client, { remoteHost, remotePort }, this.fatalError));
192
- server.once('error', (err) => reject(new Error(`Failed to open local tunnel listener: ${err.message}`)));
193
- server.listen(0, '127.0.0.1', () => {
194
- const address = server.address();
195
- if (!address || typeof address === 'string') {
196
- server.close();
197
- reject(new Error('Local tunnel listener reported no TCP address.'));
198
- return;
199
- }
200
- log('info', `[ssh] 127.0.0.1:${address.port} -> ${remoteHost}:${remotePort} via ${this.config.sshTarget}`);
201
- resolve({ endpoint: { host: '127.0.0.1', port: address.port }, server });
202
- });
244
+ function startLocalServer(cfg, requestedPort) {
245
+ return new Promise((resolve, reject) => {
246
+ const server = net.createServer((socket) => forwardSocket(socket, sshClient, cfg, fatalError));
247
+ server.once('error', (err) => {
248
+ if (err.code === 'EADDRINUSE') {
249
+ reject(new LocalPortTakenError(`Local port ${requestedPort} was claimed by another process.`));
250
+ return;
251
+ }
252
+ reject(new Error(`Failed to open local tunnel listener on port ${requestedPort}: ${err.message}`));
203
253
  });
204
- }
205
- attachDropHandler(client) {
206
- const onDrop = () => {
207
- if (this.closed || this.reconnecting || this.client !== client) {
254
+ server.listen(requestedPort, '127.0.0.1', () => {
255
+ const address = server.address();
256
+ if (!address || typeof address === 'string') {
257
+ reject(new Error('Local tunnel listener reported no TCP address.'));
208
258
  return;
209
259
  }
210
- this.client = null;
211
- this.reconnecting = true;
212
- void this.reconnect().finally(() => {
213
- this.reconnecting = false;
214
- });
215
- };
216
- client.once('close', onDrop);
217
- client.once('error', (err) => {
218
- log('error', `[ssh] transport error on ${this.config.sshTarget}: ${err.message}`);
219
- onDrop();
260
+ localServer = server;
261
+ resolve(address.port);
220
262
  });
263
+ });
264
+ }
265
+ export function ensureTunnel() {
266
+ if (!SSH_ENABLED) {
267
+ return Promise.resolve(null);
221
268
  }
222
- async reconnect() {
223
- const cfg = this.config;
224
- for (let attempt = 1; attempt <= RECONNECT_MAX_ATTEMPTS; attempt++) {
225
- const delay = RECONNECT_BASE_DELAY_MS * 2 ** (attempt - 1);
226
- log('error', `[ssh] ${cfg.sshTarget} dropped; reconnect attempt ${attempt}/${RECONNECT_MAX_ATTEMPTS} in ${delay}ms`);
227
- await new Promise((r) => setTimeout(r, delay));
228
- if (this.closed) {
229
- return;
269
+ if (!endpointPromise) {
270
+ endpointPromise = (async () => {
271
+ const cfg = resolveTunnelConfig();
272
+ activeConfig = cfg;
273
+ if (SSH_REUSE_EXISTING && cfg.localPort !== 0 && (await probeLocalPort(cfg.localPort))) {
274
+ log('error', `[ssh] 127.0.0.1:${cfg.localPort} is already accepting connections; reusing it (MYSQL_SSH_REUSE_EXISTING=true).`);
275
+ activeEndpoint = { host: '127.0.0.1', port: cfg.localPort, reused: true };
276
+ return activeEndpoint;
230
277
  }
278
+ log('info', `[ssh] opening tunnel ${cfg.sshUser}@${cfg.sshHost}:${cfg.sshPort} -> ${cfg.remoteHost}:${cfg.remotePort} ` +
279
+ `(local port ${cfg.localPort === 0 ? 'auto' : cfg.localPort})`);
280
+ const client = await connectSSH(cfg);
281
+ sshClient = client;
282
+ let port;
231
283
  try {
232
- const client = await this.connect(cfg);
233
- if (this.closed) {
234
- client.end();
235
- return;
236
- }
237
- this.client = client;
238
- this.fatalError = null;
239
- this.attachDropHandler(client);
240
- log('info', `[ssh] ${cfg.sshTarget} reconnected on attempt ${attempt}`);
241
- return;
284
+ port = await startLocalServer(cfg, cfg.localPort);
242
285
  }
243
286
  catch (err) {
244
- log('error', `[ssh] reconnect attempt ${attempt} failed: ${err.message}`);
287
+ if (!(err instanceof LocalPortTakenError)) {
288
+ client.destroy();
289
+ sshClient = null;
290
+ throw err;
291
+ }
292
+ log('error', `[ssh] local port ${cfg.localPort} is taken; opening our own tunnel on an auto-assigned port instead.`);
293
+ try {
294
+ port = await startLocalServer(cfg, 0);
295
+ }
296
+ catch (fallbackErr) {
297
+ client.destroy();
298
+ sshClient = null;
299
+ throw fallbackErr;
300
+ }
245
301
  }
246
- }
247
- this.fatalError = new Error(`SSH tunnel to ${cfg.sshUser}@${cfg.sshHost}:${cfg.sshPort} could not be re-established after ` +
248
- `${RECONNECT_MAX_ATTEMPTS} attempts. Restart the MCP server once the bastion is reachable again.`);
249
- log('error', `[ssh] ${this.fatalError.message}`);
302
+ attachDropHandler(client, cfg);
303
+ log('info', `[ssh] tunnel listening on 127.0.0.1:${port}`);
304
+ activeEndpoint = { host: '127.0.0.1', port, reused: false };
305
+ return activeEndpoint;
306
+ })();
307
+ endpointPromise.catch(() => {
308
+ endpointPromise = null;
309
+ activeConfig = null;
310
+ activeEndpoint = null;
311
+ });
250
312
  }
251
- async close() {
252
- this.closed = true;
253
- const opened = await Promise.allSettled(this.listeners.values());
254
- this.listeners.clear();
255
- await Promise.all(opened.map((result) => result.status === 'fulfilled'
256
- ? new Promise((resolve) => {
257
- result.value.server.close(() => resolve());
258
- result.value.server.unref();
259
- setTimeout(resolve, 1000).unref();
260
- })
261
- : undefined));
262
- const client = this.client;
263
- this.client = null;
264
- if (client) {
265
- try {
266
- client.end();
267
- client.destroy();
268
- }
269
- catch (err) {
270
- log('error', `[ssh] error closing SSH client: ${err.message}`);
271
- }
313
+ return endpointPromise;
314
+ }
315
+ export function getTunnelEndpoint() {
316
+ return activeEndpoint;
317
+ }
318
+ export function getTunnelFatalError() {
319
+ return fatalError;
320
+ }
321
+ export function describeTunnel() {
322
+ if (!SSH_ENABLED) {
323
+ return null;
324
+ }
325
+ if (!activeConfig) {
326
+ return 'ssh tunnel: enabled (not yet established)';
327
+ }
328
+ const { sshUser, sshHost, remoteHost, remotePort } = activeConfig;
329
+ return `ssh tunnel: ${sshUser}@${sshHost} -> ${remoteHost}:${remotePort}`;
330
+ }
331
+ export async function stopTunnel() {
332
+ shuttingDown = true;
333
+ const server = localServer;
334
+ localServer = null;
335
+ if (server) {
336
+ await new Promise((resolve) => {
337
+ server.close(() => resolve());
338
+ server.unref();
339
+ setTimeout(resolve, 1000);
340
+ });
341
+ }
342
+ const client = sshClient;
343
+ sshClient = null;
344
+ if (client) {
345
+ try {
346
+ client.end();
347
+ client.destroy();
348
+ }
349
+ catch (err) {
350
+ log('error', `[ssh] error closing SSH client: ${err.message}`);
272
351
  }
273
352
  }
353
+ endpointPromise = null;
354
+ activeConfig = null;
355
+ activeEndpoint = null;
356
+ shuttingDown = false;
274
357
  }
@@ -1,44 +1,13 @@
1
- export function tableResourceUri(connection, schema, table) {
2
- return `mysql://${connection}/tables/${encodeURIComponent(schema)}/${encodeURIComponent(table)}`;
3
- }
4
- export function parseResourceUri(uri) {
5
- const match = /^mysql:\/\/([^/]+)\/(.*)$/.exec(uri);
6
- if (!match) {
7
- return null;
8
- }
9
- const [, connection, rest] = match;
10
- if (rest === 'tables') {
11
- return { connection, kind: 'tables' };
12
- }
13
- if (rest === 'schemas') {
14
- return { connection, kind: 'schemas' };
15
- }
16
- const parts = rest.split('/');
17
- if (parts.length !== 3 || parts[0] !== 'tables' || !parts[1] || !parts[2]) {
18
- return null;
19
- }
20
- try {
21
- return {
22
- connection,
23
- kind: 'table',
24
- schema: decodeURIComponent(parts[1]),
25
- table: decodeURIComponent(parts[2]),
26
- };
27
- }
28
- catch {
29
- return null;
30
- }
1
+ import { ENABLE_LOGGING } from '../config/index.js';
2
+ export function tableResourceUri(schema, table) {
3
+ return `mysql://tables/${encodeURIComponent(schema)}/${encodeURIComponent(table)}`;
31
4
  }
32
5
  export function sharedOnce(fn) {
33
6
  let running;
34
7
  return (...args) => (running ??= fn(...args));
35
8
  }
36
- let loggingEnabled = false;
37
- export function setLogging(enabled) {
38
- loggingEnabled = enabled;
39
- }
40
9
  export function log(type = 'info', ...args) {
41
- if (!loggingEnabled) {
10
+ if (!ENABLE_LOGGING) {
42
11
  return;
43
12
  }
44
13
  const prefix = type === 'error' ? '[error]' : '[info]';
package/package.json CHANGED
@@ -1,7 +1,7 @@
1
1
  {
2
2
  "name": "@ecubelabs/mysql-mcp",
3
- "version": "1.0.0-next.7",
4
- "description": "Read-only MySQL MCP server that reaches its databases through an SSH bastion, one process per environment with many connections",
3
+ "version": "1.0.0",
4
+ "description": "Read-only MySQL MCP server that reaches its database through an SSH bastion, with per-environment profiles",
5
5
  "license": "MIT",
6
6
  "repository": {
7
7
  "url": "https://github.com/Ecube-Labs/skynet.git",
@@ -28,8 +28,8 @@
28
28
  "watch": "tsc --watch",
29
29
  "test": "tsc -p tsconfig.test.json && vitest run",
30
30
  "test:watch": "vitest",
31
- "start:stage": "node dist/index.js --env stage",
32
- "start:prod": "node dist/index.js --env prod"
31
+ "start:stage": "./bin/mcp-mysql-stage.sh",
32
+ "start:prod": "./bin/mcp-mysql-prod.sh"
33
33
  },
34
34
  "dependencies": {
35
35
  "@modelcontextprotocol/sdk": "^1.31.0",