spindb 0.46.5 → 0.47.0

package/dist/engines/mysql/index.js

@@ -2,7 +2,7 @@
  * MySQL Engine implementation
  * Manages MySQL database containers using pre-built binaries from hostdb
  */
-import { spawn, exec } from 'child_process';
+import { spawn, exec, execFile } from 'child_process';
 import { promisify } from 'util';
 import { existsSync, createReadStream } from 'fs';
 import { mkdir, writeFile, readFile, unlink, rm } from 'fs/promises';
@@ -12,6 +12,7 @@ import { paths } from '../../config/paths.js';
 import { getEngineDefaults } from '../../config/defaults.js';
 import { platformService, isWindows, getWindowsSpawnOptions, } from '../../core/platform-service.js';
 import { configManager } from '../../core/config-manager.js';
+import { getDefaultUsername, loadCredentials, } from '../../core/credential-manager.js';
 import { logDebug, logWarning, ErrorCodes, SpinDBError, assertValidDatabaseName, assertValidUsername, } from '../../core/error-handler.js';
 import { mysqlBinaryManager } from './binary-manager.js';
 import { getBinaryUrl } from './binary-urls.js';
@@ -19,11 +20,21 @@ import { fetchAvailableVersions, getLatestVersion, fetchDeprecatedVersions, } fr
 import { SUPPORTED_MAJOR_VERSIONS, FALLBACK_VERSION_MAP } from './version-maps.js';
 import { detectBackupFormat as detectBackupFormatImpl, restoreBackup, parseConnectionString, } from './restore.js';
 import { createBackup } from './backup.js';
-import { Platform, } from '../../types/index.js';
+import { Engine, Platform, } from '../../types/index.js';
 import { parseTSVToQueryResult } from '../../core/query-parser.js';
-const execAsync = promisify(exec);
+const execFileAsync = promisify(execFile);
 const ENGINE = 'mysql';
 const engineDef = getEngineDefaults(ENGINE);
+function buildMysqlEnv(password) {
+    const env = { ...process.env };
+    if (password !== undefined) {
+        env.MYSQL_PWD = password;
+    }
+    else {
+        delete env.MYSQL_PWD;
+    }
+    return env;
+}
 /**
  * Build a Windows-safe mysql command string for either a file or inline SQL.
  * This is exported for unit testing.
@@ -68,6 +79,28 @@ export class MySQLEngine extends BaseEngine {
     displayName = 'MySQL';
     defaultPort = engineDef.defaultPort;
     supportedVersions = SUPPORTED_MAJOR_VERSIONS;
+    async getLocalAdminAuth(containerName) {
+        const savedCreds = await loadCredentials(containerName, Engine.MySQL, getDefaultUsername(Engine.MySQL));
+        return {
+            user: savedCreds?.username || engineDef.superuser,
+            password: savedCreds?.password,
+        };
+    }
+    async pingLocalAdmin(containerName, port) {
+        const mysql = await this.getMysqlClientPath();
+        const auth = await this.getLocalAdminAuth(containerName);
+        await execFileAsync(mysql, ['-h', '127.0.0.1', '-P', String(port), '-u', auth.user, '-N', '-e', 'SELECT 1'], {
+            env: buildMysqlEnv(auth.password),
+        });
+    }
+    async shutdownLocalAdmin(containerName, port) {
+        const mysql = await this.getMysqlClientPath();
+        const auth = await this.getLocalAdminAuth(containerName);
+        await execFileAsync(mysql, ['-h', '127.0.0.1', '-P', String(port), '-u', auth.user, '-N', '-e', 'SHUTDOWN'], {
+            env: buildMysqlEnv(auth.password),
+            timeout: 5000,
+        });
+    }
     async fetchAvailableVersions() {
         return fetchAvailableVersions();
     }
@@ -334,16 +367,10 @@ export class MySQLEngine extends BaseEngine {
         let proc = null;
         if (isWindows()) {
             proc = spawn(mysqld, args, {
-                stdio: ['ignore', 'pipe', 'pipe'],
+                stdio: ['ignore', 'ignore', 'ignore'],
                 detached: true,
                 windowsHide: true,
             });
-            proc.stdout?.on('data', (data) => {
-                logDebug(`mysqld stdout: ${data.toString()}`);
-            });
-            proc.stderr?.on('data', (data) => {
-                logDebug(`mysqld stderr: ${data.toString()}`);
-            });
             proc.unref();
         }
         else {
@@ -386,8 +413,7 @@ export class MySQLEngine extends BaseEngine {
                         return;
                     attempts++;
                     try {
-                        const mysqladmin = await this.getMysqladminPath();
-                        await execAsync(`"${mysqladmin}" -h 127.0.0.1 -P ${port} -u root ping`);
+                        await this.pingLocalAdmin(container.name, port);
                         if (settled)
                             return;
                         settled = true;
@@ -441,17 +467,20 @@ export class MySQLEngine extends BaseEngine {
         if (pid === null) {
             logDebug('No valid PID, checking if MySQL is responding on port');
             try {
-                const mysqladmin = await this.getMysqladminPath();
-                await execAsync(`"${mysqladmin}" -h 127.0.0.1 -P ${port} -u root ping`, { timeout: 2000 });
-                logWarning(`MySQL responding on port ${port} but no valid PID file`);
-                await this.gracefulShutdown(port);
+                await this.pingLocalAdmin(name, port);
             }
             catch {
                 logDebug('MySQL not responding, nothing to stop');
+                return;
+            }
+            logWarning(`MySQL responding on port ${port} but no valid PID file`);
+            const gracefulSuccess = await this.gracefulShutdown(name, port);
+            if (!gracefulSuccess) {
+                throw new SpinDBError(ErrorCodes.PROCESS_STOP_TIMEOUT, `MySQL on port ${port} responded to ping but did not shut down cleanly`, 'error', 'Check credentials and stop the process manually if it is still running.');
             }
             return;
         }
-        const gracefulSuccess = await this.gracefulShutdown(port, pid);
+        const gracefulSuccess = await this.gracefulShutdown(name, port, pid);
         if (gracefulSuccess) {
             await this.cleanupPidFile(pidFile);
             logDebug('MySQL stopped gracefully');
@@ -490,15 +519,14 @@ export class MySQLEngine extends BaseEngine {
             return null;
         }
     }
-    async gracefulShutdown(port, pid, timeoutMs = 10000) {
+    async gracefulShutdown(containerName, port, pid, timeoutMs = 30000) {
         try {
-            const mysqladmin = await this.getMysqladminPath();
-            logDebug('Attempting mysqladmin shutdown');
-            await execAsync(`"${mysqladmin}" -h 127.0.0.1 -P ${port} -u root shutdown`, { timeout: 5000 });
+            logDebug('Attempting authenticated MySQL shutdown');
+            await this.shutdownLocalAdmin(containerName, port);
         }
         catch (error) {
             const e = error;
-            logDebug(`mysqladmin shutdown failed: ${e.message}`);
+            logDebug(`Authenticated shutdown failed: ${e.message}`);
             if (pid) {
                 try {
                     await platformService.terminateProcess(pid, false);
@@ -514,6 +542,7 @@ export class MySQLEngine extends BaseEngine {
                     return false;
                 }
             }
+            return false;
         }
         if (pid) {
             const startTime = Date.now();
@@ -594,8 +623,7 @@ export class MySQLEngine extends BaseEngine {
             return { running: false, message: 'MySQL is not running' };
         }
         try {
-            const mysqladmin = await this.getMysqladminPath();
-            await execAsync(`"${mysqladmin}" -h 127.0.0.1 -P ${port} -u root ping`);
+            await this.pingLocalAdmin(name, port);
             return { running: true, message: 'MySQL is running' };
         }
         catch {
@@ -606,16 +634,19 @@ export class MySQLEngine extends BaseEngine {
         return detectBackupFormatImpl(filePath);
     }
     async restore(container, backupPath, options = {}) {
-        const { port, version } = container;
+        const { name, port, version } = container;
         const database = options.database || container.database;
         const binPath = this.getBinaryPath(version);
+        const auth = await this.getLocalAdminAuth(name);
         if (options.createDatabase !== false) {
             await this.createDatabase(container, database);
         }
         return restoreBackup(backupPath, {
+            containerName: name,
             port,
             database,
-            user: engineDef.superuser,
+            user: auth.user,
+            password: auth.password,
             createDatabase: false,
             validateVersion: options.validateVersion !== false,
             binPath,
@@ -642,26 +673,39 @@ export class MySQLEngine extends BaseEngine {
             '  spindb engines download mysql');
     }
     async connect(container, database) {
-        const { port } = container;
+        const { name, port } = container;
         const db = database || container.database || 'mysql';
         const mysql = await this.getMysqlClientPath();
+        const auth = await this.getLocalAdminAuth(name);
         const spawnOptions = {
             stdio: 'inherit',
+            env: buildMysqlEnv(auth.password),
             ...getWindowsSpawnOptions(),
         };
         return new Promise((resolve, reject) => {
-            const proc = spawn(mysql, ['-h', '127.0.0.1', '-P', String(port), '-u', engineDef.superuser, db], spawnOptions);
+            const proc = spawn(mysql, ['-h', '127.0.0.1', '-P', String(port), '-u', auth.user, db], spawnOptions);
             proc.on('error', reject);
             proc.on('close', () => resolve());
         });
     }
     async createDatabase(container, database) {
         assertValidDatabaseName(database);
-        const { port } = container;
+        const { name, port } = container;
         const mysql = await this.getMysqlClientPath();
+        const auth = await this.getLocalAdminAuth(name);
         try {
-            const cmd = buildMysqlInlineCommand(mysql, port, engineDef.superuser, `CREATE DATABASE IF NOT EXISTS \`${database}\``);
-            await execAsync(cmd);
+            await execFileAsync(mysql, [
+                '-h',
+                '127.0.0.1',
+                '-P',
+                String(port),
+                '-u',
+                auth.user,
+                '-e',
+                `CREATE DATABASE IF NOT EXISTS \`${database}\``,
+            ], {
+                env: buildMysqlEnv(auth.password),
+            });
         }
         catch (error) {
             const err = error;
@@ -672,11 +716,22 @@ export class MySQLEngine extends BaseEngine {
     }
     async dropDatabase(container, database) {
         assertValidDatabaseName(database);
-        const { port } = container;
+        const { name, port } = container;
         const mysql = await this.getMysqlClientPath();
+        const auth = await this.getLocalAdminAuth(name);
         try {
-            const cmd = buildMysqlInlineCommand(mysql, port, engineDef.superuser, `DROP DATABASE IF EXISTS \`${database}\``);
-            await execAsync(cmd);
+            await execFileAsync(mysql, [
+                '-h',
+                '127.0.0.1',
+                '-P',
+                String(port),
+                '-u',
+                auth.user,
+                '-e',
+                `DROP DATABASE IF EXISTS \`${database}\``,
+            ], {
+                env: buildMysqlEnv(auth.password),
+            });
         }
         catch (error) {
             const err = error;
@@ -686,12 +741,25 @@ export class MySQLEngine extends BaseEngine {
         }
     }
     async getDatabaseSize(container) {
-        const { port, database } = container;
+        const { name, port, database } = container;
         const db = database || 'mysql';
         assertValidDatabaseName(db);
         try {
             const mysql = await this.getMysqlClientPath();
-            const { stdout } = await execAsync(`"${mysql}" -h 127.0.0.1 -P ${port} -u ${engineDef.superuser} -N -e "SELECT COALESCE(SUM(data_length + index_length), 0) FROM information_schema.tables WHERE table_schema = '${db}'"`);
+            const auth = await this.getLocalAdminAuth(name);
+            const { stdout } = await execFileAsync(mysql, [
+                '-h',
+                '127.0.0.1',
+                '-P',
+                String(port),
+                '-u',
+                auth.user,
+                '-N',
+                '-e',
+                `SELECT COALESCE(SUM(data_length + index_length), 0) FROM information_schema.tables WHERE table_schema = '${db}'`,
+            ], {
+                env: buildMysqlEnv(auth.password),
+            });
             const size = parseInt(stdout.trim(), 10);
             return isNaN(size) ? null : size;
         }
@@ -702,26 +770,6 @@ export class MySQLEngine extends BaseEngine {
     async dumpFromConnectionString(connectionString, outputPath) {
         const dumpPath = await this.getDumpPath();
         const { host, port, user, password, database } = parseConnectionString(connectionString);
-        if (isWindows()) {
-            const cmd = `"${dumpPath}" -h ${host} -P ${port} -u ${user} --result-file "${outputPath}" ${database}`;
-            const execOptions = {};
-            if (password) {
-                execOptions.env = { ...process.env, MYSQL_PWD: password };
-            }
-            try {
-                logDebug('Executing mysqldump command', { cmd });
-                await execAsync(cmd, execOptions);
-                return {
-                    filePath: outputPath,
-                    stdout: '',
-                    stderr: '',
-                    code: 0,
-                };
-            }
-            catch (error) {
-                throw new Error(error.message);
-            }
-        }
         const args = [
             '-h',
             host,
@@ -735,7 +783,6 @@ export class MySQLEngine extends BaseEngine {
         ];
         const spawnOptions = {
             stdio: ['pipe', 'pipe', 'pipe'],
-            ...getWindowsSpawnOptions(),
             env: password ? { ...process.env, MYSQL_PWD: password } : process.env,
         };
         return new Promise((resolve, reject) => {
@@ -776,13 +823,25 @@ export class MySQLEngine extends BaseEngine {
     }
     async terminateConnections(container, database) {
         assertValidDatabaseName(database);
-        const { port } = container;
+        const { name, port } = container;
         const mysql = await this.getMysqlClientPath();
+        const auth = await this.getLocalAdminAuth(name);
         // Get all connection IDs for the target database and kill them
         // We need to do this in two steps since MySQL doesn't support subqueries in KILL
-        const getIdsCmd = buildMysqlInlineCommand(mysql, port, engineDef.superuser, `SELECT ID FROM information_schema.PROCESSLIST WHERE DB = '${database}' AND ID != CONNECTION_ID()`);
         try {
-            const { stdout } = await execAsync(getIdsCmd);
+            const { stdout } = await execFileAsync(mysql, [
+                '-h',
+                '127.0.0.1',
+                '-P',
+                String(port),
+                '-u',
+                auth.user,
+                '-N',
+                '-e',
+                `SELECT ID FROM information_schema.PROCESSLIST WHERE DB = '${database}' AND ID != CONNECTION_ID()`,
+            ], {
+                env: buildMysqlEnv(auth.password),
+            });
             const lines = stdout
                 .trim()
                 .split('\n')
@@ -793,9 +852,19 @@ export class MySQLEngine extends BaseEngine {
                 .map((l) => l.trim())
                 .filter((l) => /^\d+$/.test(l));
             for (const id of ids) {
-                const killCmd = buildMysqlInlineCommand(mysql, port, engineDef.superuser, `KILL CONNECTION ${id}`);
                 try {
-                    await execAsync(killCmd);
+                    await execFileAsync(mysql, [
+                        '-h',
+                        '127.0.0.1',
+                        '-P',
+                        String(port),
+                        '-u',
+                        auth.user,
+                        '-e',
+                        `KILL CONNECTION ${id}`,
+                    ], {
+                        env: buildMysqlEnv(auth.password),
+                    });
                 }
                 catch {
                     // Connection may already be gone
@@ -807,38 +876,25 @@ export class MySQLEngine extends BaseEngine {
         }
     }
     async runScript(container, options) {
-        const { port } = container;
+        const { name, port } = container;
         const db = options.database || container.database || 'mysql';
         assertValidDatabaseName(db);
         const mysql = await this.getMysqlClientPath();
-        if (isWindows()) {
-            const cmd = buildWindowsMysqlCommand(mysql, port, engineDef.superuser, db, options);
-            try {
-                const { stdout, stderr } = await execAsync(cmd);
-                if (stdout)
-                    process.stdout.write(stdout);
-                if (stderr)
-                    process.stderr.write(stderr);
-                return;
-            }
-            catch (error) {
-                const err = error;
-                throw new Error(`mysql client failed: ${err.message}`);
-            }
-        }
+        const auth = await this.getLocalAdminAuth(name);
         const args = [
             '-h',
             '127.0.0.1',
             '-P',
             String(port),
             '-u',
-            engineDef.superuser,
+            auth.user,
             db,
         ];
         if (options.sql) {
             args.push('-e', options.sql);
             const spawnOptions = {
                 stdio: 'inherit',
+                env: buildMysqlEnv(auth.password),
             };
             return new Promise((resolve, reject) => {
                 const proc = spawn(mysql, args, spawnOptions);
@@ -856,6 +912,7 @@ export class MySQLEngine extends BaseEngine {
         else if (options.file) {
             const spawnOptions = {
                 stdio: ['pipe', 'inherit', 'inherit'],
+                env: buildMysqlEnv(auth.password),
             };
             return new Promise((resolve, reject) => {
                 const fileStream = createReadStream(options.file);
@@ -881,12 +938,17 @@ export class MySQLEngine extends BaseEngine {
         }
     }
     async executeQuery(container, query, options) {
-        const { port } = container;
+        const { name, port } = container;
         const db = options?.database || container.database || 'mysql';
         assertValidDatabaseName(db);
         const mysql = await this.getMysqlClientPath();
         const host = options?.host ?? '127.0.0.1';
-        const user = options?.username || engineDef.superuser;
+        const localAuth = !options?.username &&
+            !options?.password &&
+            (host === '127.0.0.1' || host === 'localhost')
+            ? await this.getLocalAdminAuth(name)
+            : null;
+        const user = options?.username || localAuth?.user || engineDef.superuser;
         // Use -B (batch mode) for tab-separated output
         const args = [
             '-h',
@@ -904,9 +966,7 @@ export class MySQLEngine extends BaseEngine {
             args.push('--ssl-mode=REQUIRED');
         }
         // Pass password via env to avoid exposing it in process listings
-        const env = options?.password
-            ? { ...process.env, MYSQL_PWD: options.password }
-            : process.env;
+        const env = buildMysqlEnv(options?.password ?? localAuth?.password);
         return new Promise((resolve, reject) => {
             const proc = spawn(mysql, args, {
                 stdio: ['pipe', 'pipe', 'pipe'],
@@ -936,8 +996,9 @@ export class MySQLEngine extends BaseEngine {
      * (information_schema, mysql, performance_schema, sys).
      */
     async listDatabases(container) {
-        const { port } = container;
+        const { name, port } = container;
         const mysql = await this.getMysqlClientPath();
+        const auth = await this.getLocalAdminAuth(name);
         // Query for all non-system databases
         const sql = `SHOW DATABASES WHERE \`Database\` NOT IN ('information_schema', 'mysql', 'performance_schema', 'sys')`;
         const args = [
@@ -946,7 +1007,7 @@ export class MySQLEngine extends BaseEngine {
             '-P',
             String(port),
             '-u',
-            engineDef.superuser,
+            auth.user,
             '-N', // Skip column names
             '-B', // Batch mode (no formatting)
             '-e',
@@ -955,6 +1016,7 @@ export class MySQLEngine extends BaseEngine {
         return new Promise((resolve, reject) => {
             const proc = spawn(mysql, args, {
                 stdio: ['pipe', 'pipe', 'pipe'],
+                env: buildMysqlEnv(auth.password),
             });
             let stdout = '';
             let stderr = '';
@@ -983,13 +1045,14 @@ export class MySQLEngine extends BaseEngine {
     async createUser(container, options) {
         const { username, password, database } = options;
         assertValidUsername(username);
-        const { port } = container;
+        const { name, port } = container;
         const db = database || container.database;
         if (!db) {
             throw new Error('No target database specified. Provide a database name with --database or ensure the container has a default database.');
         }
         assertValidDatabaseName(db);
         const mysql = await this.getMysqlClientPath();
+        const auth = await this.getLocalAdminAuth(name);
         // Check if NO_BACKSLASH_ESCAPES is enabled — if so, only escape single quotes
         let noBackslashEscapes = false;
         try {
@@ -999,7 +1062,7 @@ export class MySQLEngine extends BaseEngine {
                 '-P',
                 String(port),
                 '-u',
-                engineDef.superuser,
+                auth.user,
                 '-N',
                 '-B',
                 '-e',
@@ -1008,6 +1071,7 @@ export class MySQLEngine extends BaseEngine {
             const modeResult = await new Promise((resolve, reject) => {
                 const proc = spawn(mysql, modeArgs, {
                     stdio: ['pipe', 'pipe', 'pipe'],
+                    env: buildMysqlEnv(auth.password),
                 });
                 let stdout = '';
                 proc.stdout?.on('data', (data) => {
@@ -1041,11 +1105,12 @@ export class MySQLEngine extends BaseEngine {
             '-P',
             String(port),
             '-u',
-            engineDef.superuser,
+            auth.user,
         ];
         await new Promise((resolve, reject) => {
             const proc = spawn(mysql, args, {
                 stdio: ['pipe', 'pipe', 'pipe'],
+                env: buildMysqlEnv(auth.password),
             });
             let stderr = '';
             proc.stderr?.on('data', (data) => {