@yunsoft/yuncms 0.1.2 → 0.1.5

package/README.md

@@ -1,6 +1,6 @@
 # @yunsoft/yuncms
 
-Command-line setup and runtime launcher for YunCMS.
+Command-line setup, runtime launcher and guarded upgrade tooling for YunCMS.
 
 ```bash
 npm install @yunsoft/yuncms
@@ -8,10 +8,23 @@ npx yuncms init
 npx yuncms start
 ```
 
-YunCMS requires Node.js 24 LTS and MySQL for V1. See the [project repository](https://github.com/Yunsoft-Software/yuncms) for setup, deployment and API documentation.
+Production maintenance commands:
+
+```bash
+npx yuncms backup
+npx yuncms update --dry-run
+npx yuncms update --to 0.2.0
+npx yuncms restore /path/to/backup --yes
+```
+
+`backup` and `update` require the YunCMS service supervisor to be stopped so database and local Files/extensions can be snapshotted consistently. Managed updates require a verified backup, inspect target migration compatibility, run the newly installed migration code, probe `/ready`, and attempt automatic rollback on failure.
+
+S3 objects are not copied by YunCMS backup; use provider-side versioning/snapshots and verify recovery before acknowledging an S3 update.
+
+YunCMS requires Node.js 24 LTS and MySQL for V1. See the [project repository](https://github.com/Yunsoft-Software/yuncms), `docs/setup-cli.md` and `docs/upgrades.md` for setup, deployment and upgrade documentation.
 
 ## Project status
 
 YunCMS is developed and maintained by [Yunsoft Software](https://yunsoft.com). It is under active development, so interfaces and behavior may change between releases. Test upgrades and keep verified backups before production use.
 
-Use YunCMS at your own risk. This package is provided under the [MIT License](https://github.com/Yunsoft-Software/yuncms/blob/16-08-2026/LICENSE) without warranty.
+Use YunCMS at your own risk. This package is provided under the [MIT License](https://github.com/Yunsoft-Software/yuncms/blob/22-08-2026/LICENSE) without warranty.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yunsoft/yuncms",
-  "version": "0.1.2",
+  "version": "0.1.5",
   "description": "Command-line setup and runtime launcher for YunCMS.",
   "license": "MIT",
   "type": "module",
@@ -30,7 +30,7 @@
     "test": "node --test"
   },
   "dependencies": {
-    "@yunsoft/yuncms-api": "0.1.2",
-    "@yunsoft/yuncms-core": "0.1.2"
+    "@yunsoft/yuncms-api": "0.1.5",
+    "@yunsoft/yuncms-core": "0.1.5"
   }
 }

package/src/backup-command.js

@@ -0,0 +1,72 @@
+import { rm } from 'node:fs/promises';
+import { resolve } from 'node:path';
+
+import { loadConfig } from '@yunsoft/yuncms-core';
+
+import { parseCommandOptions } from './command-options.js';
+import { acquireDatabaseMaintenanceLock } from './maintenance-lock.js';
+import { createProjectBackup } from './project-backup.js';
+import { assertYunCmsStopped } from './service-state.js';
+import { acquireUpdateLock } from './update-lock.js';
+
+function assertLockContract(lock) {
+  if (!lock || typeof lock.assertHeld !== 'function' || typeof lock.release !== 'function') {
+    const error = new Error('Database maintenance lock implementation is invalid');
+    error.code = 'DATABASE_MAINTENANCE_LOCK_INVALID';
+    throw error;
+  }
+  return lock;
+}
+
+export async function runBackupCommand({
+  args = [],
+  cwd = process.cwd(),
+  env = process.env,
+  output = console,
+  createBackup = createProjectBackup,
+  assertStopped = assertYunCmsStopped,
+  acquireProjectLock = acquireUpdateLock,
+  acquireMaintenanceLock = acquireDatabaseMaintenanceLock,
+  fetchFn = globalThis.fetch,
+} = {}) {
+  const { values } = parseCommandOptions(args, {
+    string: ['--output'],
+    maxPositionals: 0,
+  });
+
+  const config = loadConfig(env);
+  const assertServiceStopped = () => assertStopped({
+    host: config.server.host,
+    port: config.server.port,
+    fetchFn,
+  });
+  await assertServiceStopped();
+
+  const projectLock = await acquireProjectLock({ cwd });
+  let maintenanceLock = null;
+  let backup = null;
+  try {
+    maintenanceLock = assertLockContract(await acquireMaintenanceLock({ env }));
+    await assertServiceStopped();
+    await maintenanceLock.assertHeld();
+
+    const backupPath = values['--output'] ? resolve(cwd, values['--output']) : null;
+    backup = await createBackup({ cwd, env, output, backupPath });
+
+    try {
+      await assertServiceStopped();
+      await maintenanceLock.assertHeld();
+    } catch (error) {
+      if (backup?.backupPath) {
+        await rm(backup.backupPath, { recursive: true, force: true }).catch(() => {});
+        error.backupDiscarded = true;
+      }
+      throw error;
+    }
+
+    return backup;
+  } finally {
+    if (maintenanceLock) await maintenanceLock.release();
+    await projectLock.release();
+  }
+}

package/src/backup-integrity.js

@@ -0,0 +1,118 @@
+import { createHash } from 'node:crypto';
+import { createReadStream } from 'node:fs';
+import { lstat, readdir } from 'node:fs/promises';
+import { relative, resolve, sep } from 'node:path';
+
+function backupError(code, message, details = {}) {
+  const error = new Error(message);
+  error.code = code;
+  Object.assign(error, details);
+  return error;
+}
+
+async function pathInfo(path, { optional = false, kind = null } = {}) {
+  let info;
+  try {
+    info = await lstat(path);
+  } catch (error) {
+    if (optional && error?.code === 'ENOENT') return null;
+    throw error;
+  }
+
+  if (info.isSymbolicLink()) {
+    throw backupError(
+      'BACKUP_SYMLINK_UNSUPPORTED',
+      `Managed backup/restore does not support symbolic links: ${path}`,
+      { path },
+    );
+  }
+
+  if (kind === 'file' && !info.isFile()) {
+    throw backupError('BACKUP_ASSET_TYPE_INVALID', `Expected a regular file: ${path}`, { path, kind });
+  }
+  if (kind === 'directory' && !info.isDirectory()) {
+    throw backupError('BACKUP_ASSET_TYPE_INVALID', `Expected a directory: ${path}`, { path, kind });
+  }
+  if (!info.isFile() && !info.isDirectory()) {
+    throw backupError('BACKUP_ASSET_TYPE_INVALID', `Unsupported backup asset type: ${path}`, { path, kind });
+  }
+
+  return info;
+}
+
+async function updateHashWithFile(hash, path) {
+  for await (const chunk of createReadStream(path)) hash.update(chunk);
+  hash.update('\0END\0');
+}
+
+export async function assertBackupAssetType(path, kind, { optional = false } = {}) {
+  const info = await pathInfo(path, { optional, kind });
+  return info !== null;
+}
+
+export async function hashFile(path) {
+  await pathInfo(path, { kind: 'file' });
+  const hash = createHash('sha256');
+  hash.update('YunCMS:file:v1\0');
+  await updateHashWithFile(hash, path);
+  return hash.digest('hex');
+}
+
+function compareEntryNames(left, right) {
+  if (left.name < right.name) return -1;
+  if (left.name > right.name) return 1;
+  return 0;
+}
+
+async function hashDirectoryEntry(root, path, hash) {
+  const info = await pathInfo(path);
+  const relativePath = relative(root, path).split(sep).join('/');
+
+  if (info.isDirectory()) {
+    hash.update(`D\0${relativePath}\0`);
+    const entries = await readdir(path, { withFileTypes: true });
+    entries.sort(compareEntryNames);
+    for (const entry of entries) {
+      await hashDirectoryEntry(root, resolve(path, entry.name), hash);
+    }
+    return;
+  }
+
+  hash.update(`F\0${relativePath}\0${info.size}\0`);
+  await updateHashWithFile(hash, path);
+}
+
+export async function hashDirectory(path) {
+  await pathInfo(path, { kind: 'directory' });
+  const root = resolve(path);
+  const hash = createHash('sha256');
+  hash.update('YunCMS:directory:v1\0');
+  await hashDirectoryEntry(root, root, hash);
+  return hash.digest('hex');
+}
+
+export async function hashOptionalAsset(path, kind) {
+  const present = await assertBackupAssetType(path, kind, { optional: true });
+  if (!present) return null;
+  return kind === 'directory' ? hashDirectory(path) : hashFile(path);
+}
+
+export async function verifyAssetDigest(path, kind, expectedDigest) {
+  if (typeof expectedDigest !== 'string' || !/^[0-9a-f]{64}$/i.test(expectedDigest)) {
+    throw backupError(
+      'BACKUP_MANIFEST_INVALID',
+      `Backup manifest contains an invalid SHA-256 digest for ${path}`,
+      { path },
+    );
+  }
+
+  const actualDigest = kind === 'directory' ? await hashDirectory(path) : await hashFile(path);
+  if (actualDigest.toLowerCase() !== expectedDigest.toLowerCase()) {
+    throw backupError(
+      'BACKUP_INTEGRITY_MISMATCH',
+      `Backup integrity check failed for ${path}`,
+      { path, expectedDigest, actualDigest },
+    );
+  }
+  return true;
+}

package/src/cli.js

@@ -1,6 +1,9 @@
+import { runBackupCommand } from './backup-command.js';
 import { runBootstrapCommand } from './bootstrap-command.js';
 import { runInitCommand } from './init-command.js';
+import { runRestoreCommand } from './restore-command.js';
 import { runStartCommand } from './start-command.js';
+import { runUpdateCommand } from './update-command.js';
 
 function assertSupportedNode(version = process.versions.node) {
   const major = Number(String(version).split('.')[0]);
@@ -11,8 +14,15 @@ function assertSupportedNode(version = process.versions.node) {
   }
 }
 
+function assertNoArguments(command, rest) {
+  if (rest.length === 0) return;
+  const error = new Error(`Unexpected arguments for ${command}: ${rest.join(' ')}`);
+  error.code = 'INVALID_CLI_ARGUMENTS';
+  throw error;
+}
+
 function printHelp(output) {
-  output.log?.(`YunCMS CLI\n\nCommands:\n  yuncms init        Configure MySQL, bootstrap schema and create the first administrator\n  yuncms bootstrap   Apply required core database migrations\n  yuncms start       Start the YunCMS API using the current project environment\n  yuncms help        Show this help`);
+  output.log?.(`YunCMS CLI\n\nCommands:\n  yuncms init                         Configure MySQL, bootstrap schema and create the first administrator\n  yuncms bootstrap                    Apply required core database migrations\n  yuncms start                        Start the YunCMS API using the current project environment\n  yuncms backup [--output PATH]       Create a database/project backup\n  yuncms restore PATH --yes           Restore an exact backup snapshot\n  yuncms update [--to VERSION]        Backup, update package, migrate, probe and rollback on failure\n  yuncms update --dry-run             Inspect update safety without changing the project\n  yuncms help                         Show this help`);
 }
 
 export async function runCli(argv = process.argv.slice(2), {
@@ -21,26 +31,33 @@ export async function runCli(argv = process.argv.slice(2), {
   cwd = process.cwd(),
   prompts,
   startCommand = runStartCommand,
+  backupCommand = runBackupCommand,
+  restoreCommand = runRestoreCommand,
+  updateCommand = runUpdateCommand,
 } = {}) {
   assertSupportedNode();
   const [command = 'help', ...rest] = argv;
 
-  if (rest.length > 0) {
-    const error = new Error(`Unexpected arguments for ${command}: ${rest.join(' ')}`);
-    error.code = 'INVALID_CLI_ARGUMENTS';
-    throw error;
-  }
-
   switch (command) {
     case 'init':
+      assertNoArguments(command, rest);
       return runInitCommand({ env, cwd, output, ...(prompts ? { prompts } : {}) });
     case 'bootstrap':
+      assertNoArguments(command, rest);
       return runBootstrapCommand({ env, output });
     case 'start':
+      assertNoArguments(command, rest);
       return startCommand({ env, cwd, output });
+    case 'backup':
+      return backupCommand({ args: rest, env, cwd, output });
+    case 'restore':
+      return restoreCommand({ args: rest, env, cwd, output });
+    case 'update':
+      return updateCommand({ args: rest, env, cwd, output });
     case 'help':
     case '--help':
     case '-h':
+      assertNoArguments(command, rest);
       printHelp(output);
       return null;
     default: {

package/src/command-options.js

@@ -0,0 +1,57 @@
+function argumentError(message) {
+  const error = new Error(message);
+  error.code = 'INVALID_CLI_ARGUMENTS';
+  return error;
+}
+
+export function parseCommandOptions(args = [], {
+  boolean = [],
+  string = [],
+  minPositionals = 0,
+  maxPositionals = 0,
+} = {}) {
+  const booleanOptions = new Set(boolean);
+  const stringOptions = new Set(string);
+  const values = {};
+  const positionals = [];
+
+  for (let index = 0; index < args.length; index += 1) {
+    const token = args[index];
+    if (!token.startsWith('--')) {
+      positionals.push(token);
+      continue;
+    }
+
+    const separator = token.indexOf('=');
+    const name = separator === -1 ? token : token.slice(0, separator);
+    const inlineValue = separator === -1 ? null : token.slice(separator + 1);
+
+    if (booleanOptions.has(name)) {
+      if (inlineValue !== null) throw argumentError(`${name} does not accept a value`);
+      if (Object.hasOwn(values, name)) throw argumentError(`Duplicate option: ${name}`);
+      values[name] = true;
+      continue;
+    }
+
+    if (stringOptions.has(name)) {
+      if (Object.hasOwn(values, name)) throw argumentError(`Duplicate option: ${name}`);
+      const value = inlineValue ?? args[++index];
+      if (value == null || value === '' || value.startsWith('--')) {
+        throw argumentError(`${name} requires a value`);
+      }
+      values[name] = value;
+      continue;
+    }
+
+    throw argumentError(`Unknown option: ${name}`);
+  }
+
+  if (positionals.length < minPositionals || positionals.length > maxPositionals) {
+    const range = minPositionals === maxPositionals
+      ? `${minPositionals}`
+      : `${minPositionals}-${maxPositionals}`;
+    throw argumentError(`Expected ${range} positional arguments, received ${positionals.length}`);
+  }
+
+  return { values, positionals };
+}

package/src/database-backup.js

@@ -0,0 +1,336 @@
+import { spawn } from 'node:child_process';
+import { createReadStream, createWriteStream } from 'node:fs';
+import { Writable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import { createGunzip, createGzip } from 'node:zlib';
+
+const MAX_STDERR_BYTES = 64 * 1024;
+export const DEFAULT_DATABASE_TOOL_TIMEOUT_MS = 2 * 60 * 60 * 1000;
+const MAX_DATABASE_TOOL_TIMEOUT_MS = 24 * 60 * 60 * 1000;
+const DEFAULT_KILL_GRACE_MS = 5_000;
+
+function delay(ms) {
+  return new Promise((resolveDelay) => setTimeout(resolveDelay, ms));
+}
+
+function databaseArgs(config, { dump = false } = {}) {
+  const args = [
+    '--protocol=TCP',
+    `--host=${config.host}`,
+    `--port=${config.port}`,
+    `--user=${config.user}`,
+    '--default-character-set=utf8mb4',
+  ];
+
+  if (config.ssl) args.push('--ssl-mode=REQUIRED');
+  if (dump) {
+    args.push(
+      '--single-transaction',
+      '--quick',
+      '--hex-blob',
+      '--triggers',
+      '--no-tablespaces',
+    );
+  }
+
+  args.push(config.database);
+  return args;
+}
+
+function childEnvironment(config, env = process.env) {
+  return {
+    ...env,
+    MYSQL_PWD: config.password,
+  };
+}
+
+function positiveInteger(value, code, label, max) {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed <= 0 || parsed > max) {
+    const error = new Error(`${label} must be an integer between 1 and ${max}`);
+    error.code = code;
+    throw error;
+  }
+  return parsed;
+}
+
+export function resolveDatabaseToolTimeoutMs(env = process.env, explicitTimeoutMs = null) {
+  const value = explicitTimeoutMs ?? env.YUNCMS_DB_TOOL_TIMEOUT_MS ?? DEFAULT_DATABASE_TOOL_TIMEOUT_MS;
+  return positiveInteger(
+    value,
+    'DATABASE_TOOL_TIMEOUT_INVALID',
+    'YunCMS database tool timeout',
+    MAX_DATABASE_TOOL_TIMEOUT_MS,
+  );
+}
+
+function collectStderr(stream) {
+  let stderr = '';
+  stream?.setEncoding?.('utf8');
+  stream?.on?.('data', (chunk) => {
+    if (stderr.length >= MAX_STDERR_BYTES) return;
+    stderr += String(chunk).slice(0, MAX_STDERR_BYTES - stderr.length);
+  });
+  return () => stderr.trim();
+}
+
+function databaseTimeoutError(command, timeoutMs, readStderr) {
+  const detail = readStderr();
+  const error = new Error(
+    `${command} exceeded the ${timeoutMs}ms YunCMS database tool timeout${detail ? `: ${detail}` : ''}`,
+  );
+  error.code = 'DATABASE_TOOL_TIMEOUT';
+  error.command = command;
+  error.timeoutMs = timeoutMs;
+  error.stderr = detail;
+  return error;
+}
+
+function waitForChild(child, command, readStderr, { timeoutMs, killGraceMs }) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    let timedOut = false;
+    let timeoutHandle = null;
+    let forceKillHandle = null;
+    let forceRejectHandle = null;
+
+    function clearTimers() {
+      if (timeoutHandle) clearTimeout(timeoutHandle);
+      if (forceKillHandle) clearTimeout(forceKillHandle);
+      if (forceRejectHandle) clearTimeout(forceRejectHandle);
+    }
+
+    function finish(callback) {
+      if (settled) return;
+      settled = true;
+      clearTimers();
+      callback();
+    }
+
+    function requestKill(signal) {
+      try {
+        child.kill?.(signal);
+      } catch {
+        // The bounded timeout path still rejects if signalling the child handle fails.
+      }
+    }
+
+    timeoutHandle = setTimeout(() => {
+      if (settled) return;
+      timedOut = true;
+      requestKill('SIGTERM');
+      forceKillHandle = setTimeout(() => {
+        if (settled) return;
+        requestKill('SIGKILL');
+        forceRejectHandle = setTimeout(() => {
+          finish(() => reject(databaseTimeoutError(command, timeoutMs, readStderr)));
+        }, killGraceMs);
+      }, killGraceMs);
+    }, timeoutMs);
+
+    child.once('error', (error) => {
+      finish(() => {
+        if (timedOut) {
+          reject(databaseTimeoutError(command, timeoutMs, readStderr));
+          return;
+        }
+        error.code ||= 'BACKUP_PROCESS_START_FAILED';
+        error.command = command;
+        reject(error);
+      });
+    });
+
+    child.once('exit', (code, signal) => {
+      finish(() => {
+        if (timedOut) {
+          const error = databaseTimeoutError(command, timeoutMs, readStderr);
+          error.exitCode = code;
+          error.signal = signal;
+          reject(error);
+          return;
+        }
+        if (code === 0) {
+          resolve();
+          return;
+        }
+        const detail = readStderr();
+        const error = new Error(
+          `${command} failed${signal ? ` with signal ${signal}` : ` with exit code ${code}`}${detail ? `: ${detail}` : ''}`,
+        );
+        error.code = 'BACKUP_PROCESS_FAILED';
+        error.command = command;
+        error.exitCode = code;
+        error.signal = signal;
+        error.stderr = detail;
+        reject(error);
+      });
+    });
+  });
+}
+
+async function terminateChild(child, childPromise, killGraceMs) {
+  let settled = false;
+  const observedChild = childPromise.then(
+    () => { settled = true; },
+    () => { settled = true; },
+  );
+
+  try {
+    child.kill?.('SIGTERM');
+  } catch {
+    // Continue to bounded wait/SIGKILL.
+  }
+  await Promise.race([observedChild, delay(killGraceMs)]);
+  if (settled) return;
+
+  try {
+    child.kill?.('SIGKILL');
+  } catch {
+    // The caller will still receive the original pipeline error.
+  }
+  await Promise.race([observedChild, delay(killGraceMs)]);
+}
+
+async function runDatabasePipeline({ child, command, streamPromise, timeoutMs, killGraceMs, readStderr }) {
+  const childPromise = waitForChild(child, command, readStderr, { timeoutMs, killGraceMs });
+  let streamFailed = false;
+  const observedStream = streamPromise.catch((error) => {
+    streamFailed = true;
+    throw error;
+  });
+
+  try {
+    await Promise.all([childPromise, observedStream]);
+  } catch (error) {
+    if (streamFailed) await terminateChild(child, childPromise, killGraceMs);
+    throw error;
+  }
+}
+
+function spawnDatabaseProcess(spawnProcess, command, args, options) {
+  try {
+    return spawnProcess(command, args, options);
+  } catch (error) {
+    error.code ||= 'BACKUP_PROCESS_START_FAILED';
+    error.command = command;
+    throw error;
+  }
+}
+
+export function buildDatabaseClientArgs(config, options = {}) {
+  return databaseArgs(config, options);
+}
+
+export async function dumpDatabase({
+  config,
+  outputPath,
+  env = process.env,
+  spawnProcess = spawn,
+  timeoutMs = null,
+  killGraceMs = DEFAULT_KILL_GRACE_MS,
+} = {}) {
+  if (!config || !outputPath) throw new Error('Database config and output path are required');
+  const resolvedTimeoutMs = resolveDatabaseToolTimeoutMs(env, timeoutMs);
+  const resolvedKillGraceMs = positiveInteger(
+    killGraceMs,
+    'DATABASE_TOOL_KILL_GRACE_INVALID',
+    'Database tool kill grace period',
+    60_000,
+  );
+
+  const child = spawnDatabaseProcess(
+    spawnProcess,
+    'mysqldump',
+    databaseArgs(config, { dump: true }),
+    {
+      env: childEnvironment(config, env),
+      stdio: ['ignore', 'pipe', 'pipe'],
+    },
+  );
+  const readStderr = collectStderr(child.stderr);
+  const streamPromise = pipeline(
+    child.stdout,
+    createGzip({ level: 6 }),
+    createWriteStream(outputPath, { mode: 0o600 }),
+  );
+
+  await runDatabasePipeline({
+    child,
+    command: 'mysqldump',
+    streamPromise,
+    timeoutMs: resolvedTimeoutMs,
+    killGraceMs: resolvedKillGraceMs,
+    readStderr,
+  });
+
+  return outputPath;
+}
+
+export async function verifyDatabaseDump({ inputPath } = {}) {
+  if (!inputPath) throw new Error('Database dump path is required');
+  let decompressedBytes = 0;
+  const sink = new Writable({
+    write(chunk, _encoding, callback) {
+      decompressedBytes += chunk.length;
+      callback();
+    },
+  });
+
+  try {
+    await pipeline(createReadStream(inputPath), createGunzip(), sink);
+  } catch (error) {
+    const invalid = new Error(`Database backup is not a valid gzip stream: ${inputPath}`);
+    invalid.code = 'BACKUP_DATABASE_INVALID';
+    invalid.cause = error;
+    throw invalid;
+  }
+
+  if (decompressedBytes === 0) {
+    const error = new Error(`Database backup decompressed to an empty dump: ${inputPath}`);
+    error.code = 'BACKUP_DATABASE_EMPTY';
+    throw error;
+  }
+
+  return { decompressedBytes };
+}
+
+export async function restoreDatabase({
+  config,
+  inputPath,
+  env = process.env,
+  spawnProcess = spawn,
+  timeoutMs = null,
+  killGraceMs = DEFAULT_KILL_GRACE_MS,
+} = {}) {
+  if (!config || !inputPath) throw new Error('Database config and input path are required');
+  const resolvedTimeoutMs = resolveDatabaseToolTimeoutMs(env, timeoutMs);
+  const resolvedKillGraceMs = positiveInteger(
+    killGraceMs,
+    'DATABASE_TOOL_KILL_GRACE_INVALID',
+    'Database tool kill grace period',
+    60_000,
+  );
+
+  const child = spawnDatabaseProcess(
+    spawnProcess,
+    'mysql',
+    databaseArgs(config),
+    {
+      env: childEnvironment(config, env),
+      stdio: ['pipe', 'ignore', 'pipe'],
+    },
+  );
+  const readStderr = collectStderr(child.stderr);
+  const streamPromise = pipeline(createReadStream(inputPath), createGunzip(), child.stdin);
+
+  await runDatabasePipeline({
+    child,
+    command: 'mysql',
+    streamPromise,
+    timeoutMs: resolvedTimeoutMs,
+    killGraceMs: resolvedKillGraceMs,
+    readStderr,
+  });
+
+  return true;
+}