spindb 0.37.2 → 0.38.0

package/dist/cli/commands/menu/container-handlers.js

@@ -0,0 +1,1788 @@
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { existsSync, renameSync, statSync, mkdirSync, copyFileSync, unlinkSync, } from 'fs';
+import { stat, mkdir, rm } from 'fs/promises';
+import { dirname, basename, join, resolve } from 'path';
+import { homedir } from 'os';
+import { containerManager } from '../../../core/container-manager.js';
+import { getMissingDependencies } from '../../../core/dependency-manager.js';
+import { platformService } from '../../../core/platform-service.js';
+import { portManager } from '../../../core/port-manager.js';
+import { processManager } from '../../../core/process-manager.js';
+import { getEngine } from '../../../engines/index.js';
+import { BaseEngine } from '../../../engines/base-engine.js';
+import { sqliteRegistry } from '../../../engines/sqlite/registry.js';
+import { duckdbRegistry } from '../../../engines/duckdb/registry.js';
+import { defaults } from '../../../config/defaults.js';
+import { getEngineConfig } from '../../../config/engines-registry.js';
+import { getPageSize } from '../../constants.js';
+import { paths } from '../../../config/paths.js';
+import { promptContainerName, promptContainerSelect, promptInstallDependencies, promptConfirm, promptEngine, promptVersion, promptPort, promptDatabaseName, promptFileDatabasePath, escapeablePrompt, filterableListPrompt, BACK_VALUE, MAIN_MENU_VALUE, TOGGLE_PREFIX, } from '../../ui/prompts.js';
+import { getEngineDefaults } from '../../../config/defaults.js';
+import { createSpinner } from '../../ui/spinner.js';
+import { header, uiSuccess, uiError, uiWarning, uiInfo, connectionBox, formatBytes, box, } from '../../ui/theme.js';
+import { handleOpenShell, handleCopyConnectionString, stopPgwebProcess, } from './shell-handlers.js';
+import { getPgwebStatus } from '../../../core/pgweb-utils.js';
+import { generatePassword } from '../../../core/credential-generator.js';
+import { saveCredentials, credentialsExist, getDefaultUsername, } from '../../../core/credential-manager.js';
+import { UnsupportedOperationError, isValidUsername, } from '../../../core/error-handler.js';
+import { handleRunSql, handleViewLogs } from './sql-handlers.js';
+import { handleBackupForContainer, handleRestoreForContainer, } from './backup-handlers.js';
+import { exportToDocker, getExportBackupPath, dockerExportExists, getDockerConnectionString, } from '../../../core/docker-exporter.js';
+import { getDefaultFormat } from '../../../config/backup-formats.js';
+import { Engine, isFileBasedEngine } from '../../../types/index.js';
+import { pressEnterToContinue } from './shared.js';
+import { getEngineIcon } from '../../constants.js';
+export async function handleCreate() {
+    console.log();
+    console.log(header('Create New Database Container'));
+    console.log();
+    // Wizard state - all values start as null
+    let selectedEngine = null;
+    let selectedVersion = null;
+    let containerName = null;
+    // Step 1: Engine selection (back returns to main menu)
+    while (selectedEngine === null) {
+        const result = await promptEngine({ includeBack: true });
+        if (result === MAIN_MENU_VALUE)
+            return 'main';
+        if (result === BACK_VALUE)
+            return; // Back to parent menu
+        selectedEngine = result;
+    }
+    // Step 2: Version selection (back returns to engine)
+    while (selectedVersion === null) {
+        const result = await promptVersion(selectedEngine, { includeBack: true });
+        if (result === MAIN_MENU_VALUE)
+            return 'main';
+        if (result === BACK_VALUE) {
+            selectedEngine = null;
+            continue;
+        }
+        selectedVersion = result;
+    }
+    // Step 3: Container name (back returns to version)
+    while (containerName === null) {
+        const result = await promptContainerName(undefined, { allowBack: true });
+        if (result === null) {
+            selectedVersion = null;
+            continue;
+        }
+        containerName = result;
+    }
+    // At this point, all wizard values are guaranteed to be set
+    const engine = selectedEngine;
+    const version = selectedVersion;
+    const name = containerName;
+    // Step 4: Database name (defaults to container name, sanitized)
+    // Redis and Valkey use numbered databases 0-15, so skip prompt and default to "0"
+    // Qdrant uses collections (not databases), so default to "default"
+    // Meilisearch uses indexes (not databases), so default to "default"
+    let database;
+    if (engine === 'redis' || engine === 'valkey') {
+        database = '0';
+    }
+    else if (engine === 'qdrant' || engine === 'meilisearch') {
+        database = 'default';
+    }
+    else if (engine === 'influxdb') {
+        database = 'mydb';
+    }
+    else {
+        database = await promptDatabaseName(name, engine);
+    }
+    // Step 5: Port or file path (SQLite/DuckDB)
+    const isSQLite = engine === 'sqlite';
+    const isDuckDB = engine === 'duckdb';
+    const isFileBasedDB = isSQLite || isDuckDB;
+    let port;
+    let filePath = undefined;
+    if (isFileBasedDB) {
+        // File-based databases don't need a port, but need a path
+        const defaultExtension = isDuckDB ? '.duckdb' : '.sqlite';
+        filePath = await promptFileDatabasePath(name, defaultExtension);
+        port = 0;
+    }
+    else {
+        const engineDefaults = getEngineDefaults(engine);
+        port = await promptPort(engineDefaults.defaultPort, engine);
+    }
+    // Now we have all values - proceed with container creation
+    let containerNameFinal = name;
+    console.log();
+    console.log(header('Creating Database Container'));
+    console.log();
+    const dbEngine = getEngine(engine);
+    const isPostgreSQL = engine === 'postgresql';
+    // For PostgreSQL and file-based DBs, download binaries FIRST
+    // They include client tools needed for subsequent operations
+    let portAvailable = true;
+    if (isPostgreSQL || isFileBasedDB) {
+        if (!isFileBasedDB) {
+            portAvailable = await portManager.isPortAvailable(port);
+        }
+        const binarySpinner = createSpinner(`Checking ${dbEngine.displayName} ${version} binaries...`);
+        binarySpinner.start();
+        try {
+            const isInstalled = await dbEngine.isBinaryInstalled(version);
+            if (isInstalled) {
+                binarySpinner.succeed(`${dbEngine.displayName} ${version} binaries ready (cached)`);
+            }
+            else {
+                binarySpinner.text = `Downloading ${dbEngine.displayName} ${version} binaries...`;
+                await dbEngine.ensureBinaries(version, ({ message }) => {
+                    binarySpinner.text = message;
+                });
+                binarySpinner.succeed(`${dbEngine.displayName} ${version} binaries downloaded`);
+            }
+        }
+        catch (error) {
+            binarySpinner.fail(`Failed to download ${dbEngine.displayName} binaries`);
+            const e = error;
+            console.log();
+            console.log(uiError(e.message));
+            console.log();
+            await pressEnterToContinue();
+            return;
+        }
+    }
+    // Check dependencies (all engines need this)
+    // For PostgreSQL, this runs AFTER binary download so client tools are available
+    const depsSpinner = createSpinner('Checking required tools...');
+    depsSpinner.start();
+    let missingDeps = await getMissingDependencies(engine);
+    if (missingDeps.length > 0) {
+        depsSpinner.warn(`Missing tools: ${missingDeps.map((d) => d.name).join(', ')}`);
+        const installed = await promptInstallDependencies(missingDeps[0].binary, engine);
+        if (!installed) {
+            console.log();
+            console.log(uiWarning('Container creation cancelled - required tools not installed.'));
+            await pressEnterToContinue();
+            return;
+        }
+        missingDeps = await getMissingDependencies(engine);
+        if (missingDeps.length > 0) {
+            console.log(uiError(`Still missing tools: ${missingDeps.map((d) => d.name).join(', ')}`));
+            await pressEnterToContinue();
+            return;
+        }
+        console.log(chalk.green('  ✓ All required tools are now available'));
+        console.log();
+    }
+    else {
+        depsSpinner.succeed('Required tools available');
+    }
+    // Server databases (MySQL): check port and binaries
+    // PostgreSQL already handled above
+    if (!isFileBasedDB && !isPostgreSQL) {
+        portAvailable = await portManager.isPortAvailable(port);
+        const binarySpinner = createSpinner(`Checking ${dbEngine.displayName} ${version} binaries...`);
+        binarySpinner.start();
+        try {
+            const isInstalled = await dbEngine.isBinaryInstalled(version);
+            if (isInstalled) {
+                binarySpinner.succeed(`${dbEngine.displayName} ${version} binaries ready (cached)`);
+            }
+            else {
+                binarySpinner.text = `Downloading ${dbEngine.displayName} ${version} binaries...`;
+                await dbEngine.ensureBinaries(version, ({ message }) => {
+                    binarySpinner.text = message;
+                });
+                binarySpinner.succeed(`${dbEngine.displayName} ${version} binaries downloaded`);
+            }
+        }
+        catch (error) {
+            binarySpinner.fail(`Failed to download ${dbEngine.displayName} binaries`);
+            const e = error;
+            console.log();
+            console.log(uiError(e.message));
+            console.log();
+            await pressEnterToContinue();
+            return;
+        }
+    }
+    while (await containerManager.exists(containerNameFinal)) {
+        console.log(chalk.yellow(`  Container "${containerNameFinal}" already exists.`));
+        const newName = await promptContainerName(undefined, { allowBack: true });
+        if (!newName) {
+            console.log(chalk.blue('  Container creation cancelled.'));
+            return;
+        }
+        containerNameFinal = newName;
+    }
+    const createSpinnerInstance = createSpinner('Creating container...');
+    createSpinnerInstance.start();
+    await containerManager.create(containerNameFinal, {
+        engine: dbEngine.name,
+        version,
+        port,
+        database,
+    });
+    createSpinnerInstance.succeed('Container created');
+    const initSpinner = createSpinner(isFileBasedDB
+        ? 'Creating database file...'
+        : 'Initializing database cluster...');
+    initSpinner.start();
+    await dbEngine.initDataDir(containerNameFinal, version, {
+        superuser: defaults.superuser,
+        path: filePath, // File-based DB path (undefined for server databases)
+    });
+    initSpinner.succeed(isFileBasedDB ? 'Database file created' : 'Database cluster initialized');
+    // File-based databases (SQLite/DuckDB): show file path, no start needed
+    if (isFileBasedDB) {
+        const config = await containerManager.getConfig(containerNameFinal);
+        if (config) {
+            const connectionString = dbEngine.getConnectionString(config);
+            console.log();
+            console.log(uiSuccess('Database Created'));
+            console.log();
+            console.log(chalk.gray(`  Container: ${containerNameFinal}`));
+            console.log(chalk.gray(`  Engine: ${dbEngine.displayName} ${version}`));
+            console.log(chalk.gray(`  File: ${config.database}`));
+            console.log();
+            console.log(uiSuccess(`Available at ${config.database}`));
+            console.log();
+            console.log(chalk.gray('  Connection string:'));
+            console.log(chalk.cyan(`  ${connectionString}`));
+            try {
+                const copied = await platformService.copyToClipboard(connectionString);
+                if (copied) {
+                    console.log(chalk.gray('  ✓ Connection string copied to clipboard'));
+                }
+                else {
+                    console.log(chalk.gray('  (Could not copy to clipboard)'));
+                }
+            }
+            catch {
+                console.log(chalk.gray('  (Could not copy to clipboard)'));
+            }
+            console.log();
+            await escapeablePrompt([
+                {
+                    type: 'input',
+                    name: 'continue',
+                    message: chalk.gray('Press Enter to continue...'),
+                },
+            ]);
+        }
+        return containerNameFinal;
+    }
+    // Server databases: start and create database
+    if (portAvailable) {
+        const startSpinner = createSpinner(`Starting ${dbEngine.displayName}...`);
+        startSpinner.start();
+        const config = await containerManager.getConfig(containerNameFinal);
+        if (config) {
+            try {
+                await dbEngine.start(config);
+            }
+            catch (error) {
+                startSpinner.fail(`${dbEngine.displayName} failed to start`);
+                const e = error;
+                console.log();
+                console.log(uiError(e.message));
+                console.log();
+                // Clean up the container that was created but failed to start
+                try {
+                    await containerManager.delete(containerNameFinal, { force: true });
+                }
+                catch {
+                    // Ignore cleanup errors
+                }
+                await pressEnterToContinue();
+                return;
+            }
+            await containerManager.updateConfig(containerNameFinal, {
+                status: 'running',
+            });
+        }
+        startSpinner.succeed(`${dbEngine.displayName} started`);
+        // Skip creating 'postgres' database for PostgreSQL - it's created by initdb
+        // For other engines (MySQL, SQLite), allow creating a database named 'postgres'
+        if (config &&
+            !(config.engine === Engine.PostgreSQL && database === 'postgres')) {
+            const dbSpinner = createSpinner(`Creating database "${database}"...`);
+            dbSpinner.start();
+            await dbEngine.createDatabase(config, database);
+            dbSpinner.succeed(`Database "${database}" created`);
+        }
+        if (config) {
+            const connectionString = dbEngine.getConnectionString(config);
+            console.log();
+            console.log(uiSuccess('Database Created'));
+            console.log();
+            console.log(chalk.gray(`  Container: ${containerNameFinal}`));
+            console.log(chalk.gray(`  Engine: ${dbEngine.displayName} ${version}`));
+            console.log(chalk.gray(`  Database: ${database}`));
+            console.log(chalk.gray(`  Port: ${port}`));
+            console.log();
+            console.log(uiSuccess(`Running on port ${port}`));
+            console.log();
+            console.log(chalk.gray('  Connection string:'));
+            console.log(chalk.cyan(`  ${connectionString}`));
+            try {
+                const copied = await platformService.copyToClipboard(connectionString);
+                if (copied) {
+                    console.log(chalk.gray('  ✓ Connection string copied to clipboard'));
+                }
+                else {
+                    console.log(chalk.gray('  (Could not copy to clipboard)'));
+                }
+            }
+            catch {
+                console.log(chalk.gray('  (Could not copy to clipboard)'));
+            }
+            console.log();
+            await escapeablePrompt([
+                {
+                    type: 'input',
+                    name: 'continue',
+                    message: chalk.gray('Press Enter to continue...'),
+                },
+            ]);
+        }
+    }
+    else {
+        console.log();
+        console.log(uiWarning(`Port ${port} is currently in use. Container created but not started.`));
+        console.log(uiInfo(`Start it later with: ${chalk.cyan(`spindb start ${containerNameFinal}`)}`));
+        console.log();
+        await escapeablePrompt([
+            {
+                type: 'input',
+                name: 'continue',
+                message: chalk.gray('Press Enter to continue...'),
+            },
+        ]);
+    }
+    return containerNameFinal;
+}
+export async function handleList(showMainMenu, options) {
+    console.clear();
+    console.log(header('Containers'));
+    console.log();
+    const spinner = createSpinner('Loading containers...');
+    spinner.start();
+    const containers = await containerManager.list();
+    if (containers.length === 0) {
+        spinner.stop();
+        console.log(uiInfo('No containers found. Create one with the "Create" option.'));
+        console.log();
+        await escapeablePrompt([
+            {
+                type: 'input',
+                name: 'continue',
+                message: chalk.gray('Press Enter to return to the main menu...'),
+            },
+        ]);
+        return;
+    }
+    // Fetch sizes for running containers
+    const sizes = await Promise.all(containers.map(async (container) => {
+        if (container.status !== 'running')
+            return null;
+        try {
+            const engine = getEngine(container.engine);
+            return await engine.getDatabaseSize(container);
+        }
+        catch {
+            return null;
+        }
+    }));
+    spinner.stop();
+    // Column widths for formatting
+    const COL_NAME = 16;
+    const COL_ENGINE = 13;
+    const COL_VERSION = 8;
+    const COL_PORT = 6;
+    const COL_SIZE = 9;
+    // Build selectable choices with formatted display (like engines menu)
+    const containerChoices = containers.map((c, i) => {
+        const size = sizes[i];
+        const isFileBased = isFileBasedEngine(c.engine);
+        // Status display
+        const statusDisplay = isFileBased
+            ? c.status === 'running'
+                ? chalk.blue('● available')
+                : chalk.gray('○ missing')
+            : c.status === 'running'
+                ? chalk.green('● running')
+                : chalk.gray('○ stopped');
+        // Truncate name if too long
+        const displayName = c.name.length > COL_NAME - 1
+            ? c.name.slice(0, COL_NAME - 2) + '…'
+            : c.name;
+        // Port or dash for file-based
+        const portDisplay = isFileBased ? '—' : String(c.port);
+        // Size display
+        const sizeDisplay = size !== null ? formatBytes(size) : '—';
+        // Build formatted row
+        // Pad icon and engine name separately to avoid emoji width calculation issues
+        // (padEnd counts code points, not visual width)
+        const icon = getEngineIcon(c.engine);
+        const engineName = c.engine.padEnd(COL_ENGINE);
+        const isRunning = c.status === 'running';
+        const row = (isRunning
+            ? chalk.cyan.bold(displayName.padEnd(COL_NAME))
+            : chalk.cyan(displayName.padEnd(COL_NAME))) +
+            chalk.white(`${icon}${engineName}`) +
+            chalk.yellow(c.version.padEnd(COL_VERSION)) +
+            chalk.green(portDisplay.padEnd(COL_PORT)) +
+            chalk.magenta(sizeDisplay.padEnd(COL_SIZE)) +
+            statusDisplay;
+        return {
+            name: row,
+            value: c.name,
+            short: c.name,
+        };
+    });
+    // Calculate summary
+    const serverContainers = containers.filter((c) => !isFileBasedEngine(c.engine));
+    const fileBasedContainers = containers.filter((c) => isFileBasedEngine(c.engine));
+    const running = serverContainers.filter((c) => c.status === 'running').length;
+    const stopped = serverContainers.filter((c) => c.status !== 'running').length;
+    const available = fileBasedContainers.filter((c) => c.status === 'running').length;
+    const missing = fileBasedContainers.filter((c) => c.status !== 'running').length;
+    const parts = [];
+    if (serverContainers.length > 0) {
+        parts.push(`${running} running, ${stopped} stopped`);
+    }
+    if (fileBasedContainers.length > 0) {
+        parts.push(`${available} file-based available${missing > 0 ? `, ${missing} missing` : ''}`);
+    }
+    // Check if there are any server-based (toggleable) containers
+    const hasServerContainers = containers.some((c) => !isFileBasedEngine(c.engine));
+    // Build the full choice list with footer items
+    // IMPORTANT: Containers must come FIRST because filterableCount slices from index 0
+    const summary = `${containers.length} container(s): ${parts.join('; ')}`;
+    const headerItems = hasServerContainers
+        ? [
+            new inquirer.Separator(chalk.cyan('── [Shift+Tab] toggle start/stop ──')),
+        ]
+        : [];
+    const allChoices = [
+        ...containerChoices,
+        new inquirer.Separator(),
+        new inquirer.Separator(summary),
+        new inquirer.Separator(),
+        { name: `${chalk.green('+')} Create new`, value: 'create' },
+        {
+            name: `${chalk.blue('←')} Back to main menu ${chalk.gray('(esc)')}`,
+            value: 'back',
+        },
+        new inquirer.Separator(),
+    ];
+    const selectedContainer = await filterableListPrompt(allChoices, `Select a container: ${chalk.gray('↑↓ pick, type to filter')}`, {
+        filterableCount: containerChoices.length,
+        pageSize: getPageSize(),
+        emptyText: 'No containers match filter',
+        enableToggle: hasServerContainers,
+        defaultValue: options?.focusContainer,
+        headerItems,
+    });
+    // Handle toggle (Shift+Tab) - start/stop the container and refresh list
+    if (selectedContainer.startsWith(TOGGLE_PREFIX)) {
+        const containerName = selectedContainer.slice(TOGGLE_PREFIX.length);
+        const config = await containerManager.getConfig(containerName);
+        if (config && !isFileBasedEngine(config.engine)) {
+            const isRunning = await processManager.isRunning(containerName, {
+                engine: config.engine,
+            });
+            // Show inline status without clearing screen
+            console.log();
+            if (isRunning) {
+                await handleStopContainer(containerName);
+            }
+            else {
+                const result = await handleStartContainer(containerName);
+                if (result === 'home') {
+                    await showMainMenu();
+                    return;
+                }
+            }
+        }
+        // Refresh the container list with cursor on the same container
+        await handleList(showMainMenu, { focusContainer: containerName });
+        return;
+    }
+    // Back returns to main menu (escape is handled globally)
+    if (selectedContainer === 'back') {
+        return;
+    }
+    if (selectedContainer === 'create') {
+        const result = await handleCreate();
+        if (result === 'main') {
+            await showMainMenu();
+        }
+        else if (result) {
+            await showContainerSubmenu(result, showMainMenu);
+        }
+        else {
+            await handleList(showMainMenu);
+        }
+        return;
+    }
+    await showContainerSubmenu(selectedContainer, showMainMenu);
+}
+export async function showContainerSubmenu(containerName, showMainMenu, selectedDatabase) {
+    const config = await containerManager.getConfig(containerName);
+    if (!config) {
+        console.error(uiError(`Container "${containerName}" not found`));
+        return;
+    }
+    // File-based databases: Check file existence instead of running status
+    const isSQLite = config.engine === Engine.SQLite;
+    const isDuckDB = config.engine === Engine.DuckDB;
+    const isFileBasedDB = isSQLite || isDuckDB;
+    let isRunning;
+    let status;
+    let locationInfo;
+    if (isFileBasedDB) {
+        const fileExists = existsSync(config.database);
+        isRunning = fileExists; // For file-based DBs, "running" means "file exists"
+        status = fileExists ? 'available' : 'missing';
+        locationInfo = `at ${config.database}`;
+    }
+    else {
+        isRunning = await processManager.isRunning(containerName, {
+            engine: config.engine,
+        });
+        status = isRunning ? 'running' : 'stopped';
+        locationInfo = `on port ${config.port}`;
+    }
+    // Get list of databases in this container
+    const databases = config.databases || [config.database];
+    // Auto-select: use provided selection, or default to primary database from config
+    const activeDatabase = selectedDatabase || config.database;
+    // Header shows icon + container → database
+    const engineIcon = getEngineIcon(config.engine);
+    const headerText = `${engineIcon} ${containerName} ${chalk.gray('→')} ${activeDatabase}`;
+    console.clear();
+    console.log(header(headerText));
+    console.log(chalk.gray(`${config.engine} ${config.version} ${locationInfo} - ${status}`));
+    console.log();
+    // Build action choices based on engine type
+    const actionChoices = [];
+    // Helper for disabled menu items (hint shown in separator, not on each item)
+    function disabledItem(icon, label) {
+        return {
+            name: chalk.gray(`${icon} ${label}`),
+            value: '_disabled_',
+            disabled: '', // Empty string hides the "(Disabled)" text
+        };
+    }
+    // Determine if database-specific actions can be performed
+    // Requires: database selected + (running for server DBs OR file exists for file-based DBs)
+    const containerReady = isFileBasedDB ? existsSync(config.database) : isRunning;
+    const hasMultipleDatabases = databases.length > 1;
+    const canDoDbAction = !!activeDatabase && containerReady;
+    // Label for data section separator - shows state or required action
+    function getDataSectionLabel() {
+        if (!containerReady) {
+            return isFileBasedDB ? 'Database file missing' : 'Start container first';
+        }
+        if (!activeDatabase && hasMultipleDatabases) {
+            return 'Select database first';
+        }
+        // Show positive state when actions are available
+        return isFileBasedDB ? 'Available' : 'Running';
+    }
+    // Label for management section separator - shows state or required action
+    function getManageSectionLabel() {
+        if (!isFileBasedDB && isRunning) {
+            return 'Stop container first';
+        }
+        // Show positive state when actions are available
+        return isFileBasedDB ? 'Available' : 'Stopped';
+    }
+    // ─────────────────────────────────────────────────────────────────────────────
+    // SECTION 1: Container State
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Start/Stop buttons only for server databases (not file-based)
+    if (!isFileBasedDB) {
+        if (!isRunning) {
+            actionChoices.push({
+                name: `${chalk.green('▶')} Start container`,
+                value: 'start',
+            });
+        }
+        else {
+            actionChoices.push({
+                name: `${chalk.red('■')} Stop container`,
+                value: 'stop',
+            });
+            // Stop pgweb - only for PG-wire-protocol engines when pgweb is running
+            if (config.engine === 'postgresql' ||
+                config.engine === 'cockroachdb' ||
+                config.engine === 'ferretdb') {
+                const pgwebStatus = await getPgwebStatus(containerName, config.engine);
+                if (pgwebStatus.running) {
+                    actionChoices.push({
+                        name: `${chalk.redBright('■')} Stop pgweb (port ${pgwebStatus.port})`,
+                        value: 'stop-pgweb',
+                    });
+                }
+            }
+        }
+        // View logs - available anytime for server-based DBs
+        actionChoices.push({
+            name: `${chalk.gray('☰')} View logs`,
+            value: 'logs',
+        });
+    }
+    // Database selection - show current selection or prompt to select
+    // Only show if there are multiple databases
+    if (hasMultipleDatabases) {
+        const dbIndex = activeDatabase ? databases.indexOf(activeDatabase) + 1 : 0;
+        const dbLabel = activeDatabase
+            ? `${chalk.cyan('◉')} Set database ${chalk.gray('|')} Current: ${chalk.white(activeDatabase)} ${chalk.gray(`(${dbIndex} of ${databases.length})`)}`
+            : `${chalk.yellow('◉')} Set database`;
+        actionChoices.push({
+            name: dbLabel,
+            value: 'select-database',
+        });
+    }
+    // ─────────────────────────────────────────────────────────────────────────────
+    // SECTION 2: Data Operations
+    // Separator shows current state or required action
+    // ─────────────────────────────────────────────────────────────────────────────
+    const dataSectionLabel = getDataSectionLabel();
+    actionChoices.push(new inquirer.Separator(chalk.gray(`── ${dataSectionLabel} ──`)));
+    // Open console - requires database selection for multi-db containers
+    actionChoices.push(canDoDbAction
+        ? { name: `${chalk.blue('>')} Open console`, value: 'shell' }
+        : disabledItem('>', 'Open console'));
+    // Run script file - requires database selection for multi-db containers
+    // Label comes from engines.json scriptFileLabel; null means no script support (REST API engines)
+    const engineConfig = await getEngineConfig(config.engine);
+    if (engineConfig.scriptFileLabel) {
+        const runScriptLabel = engineConfig.scriptFileLabel;
+        actionChoices.push(canDoDbAction
+            ? { name: `${chalk.yellow('▷')} ${runScriptLabel}`, value: 'run-sql' }
+            : disabledItem('▷', runScriptLabel));
+    }
+    // Copy connection string - requires database selection for multi-db containers
+    actionChoices.push(canDoDbAction
+        ? { name: `${chalk.green('⎘')} Copy connection string`, value: 'copy' }
+        : disabledItem('⎘', 'Copy connection string'));
+    // Create user - only for engines that override createUser from BaseEngine
+    const engine = getEngine(config.engine);
+    const supportsUsers = engine.createUser !== BaseEngine.prototype.createUser;
+    if (supportsUsers) {
+        actionChoices.push(containerReady
+            ? {
+                name: `${chalk.yellow('+')} Create user`,
+                value: 'create_user',
+            }
+            : disabledItem('+', 'Create user'));
+    }
+    // Backup - requires database selection for multi-db containers
+    actionChoices.push(canDoDbAction
+        ? { name: `${chalk.magenta('↓')} Backup database`, value: 'backup' }
+        : disabledItem('↓', 'Backup database'));
+    // Restore - requires database selection for multi-db containers
+    actionChoices.push(canDoDbAction
+        ? { name: `${chalk.magenta('↑')} Restore from backup`, value: 'restore' }
+        : disabledItem('↑', 'Restore from backup'));
+    // Export - server-based DBs must be running, file-based must have the file
+    actionChoices.push(containerReady
+        ? { name: `${chalk.cyan('⬆')} Export`, value: 'export' }
+        : disabledItem('⬆', 'Export'));
+    // ─────────────────────────────────────────────────────────────────────────────
+    // SECTION 3: Container Management (requires stopped for server-based)
+    // Separator shows current state or required action
+    // ─────────────────────────────────────────────────────────────────────────────
+    const manageSectionLabel = getManageSectionLabel();
+    actionChoices.push(new inquirer.Separator(chalk.gray(`── ${manageSectionLabel} ──`)));
+    // Edit container - file-based DBs can always edit (no running state), server databases must be stopped
+    const canEdit = isFileBasedDB || !isRunning;
+    actionChoices.push(canEdit
+        ? { name: `${chalk.yellow('⚙')} Edit container`, value: 'edit' }
+        : disabledItem('⚙', 'Edit container'));
+    // Clone container - file-based DBs can always clone, server databases must be stopped
+    const canClone = isFileBasedDB || !isRunning;
+    actionChoices.push(canClone
+        ? { name: `${chalk.cyan('◇')} Clone container`, value: 'clone' }
+        : disabledItem('◇', 'Clone container'));
+    // Detach - only for file-based DBs (unregisters without deleting file)
+    if (isFileBasedDB) {
+        actionChoices.push({
+            name: `${chalk.yellow('⊘')} Detach from SpinDB`,
+            value: 'detach',
+        });
+    }
+    // Delete container - file-based DBs can always delete, server databases must be stopped
+    const canDelete = isFileBasedDB || !isRunning;
+    actionChoices.push(canDelete
+        ? { name: `${chalk.red('✕')} Delete container`, value: 'delete' }
+        : disabledItem('✕', 'Delete container'));
+    actionChoices.push(new inquirer.Separator());
+    // ─────────────────────────────────────────────────────────────────────────────
+    // SECTION 4: Navigation
+    // ─────────────────────────────────────────────────────────────────────────────
+    actionChoices.push({
+        name: `${chalk.blue('←')} Back to containers`,
+        value: 'back',
+    }, {
+        name: `${chalk.blue('⌂')} Back to main menu ${chalk.gray('(esc)')}`,
+        value: 'main',
+    }, new inquirer.Separator());
+    const { action } = await escapeablePrompt([
+        {
+            type: 'list',
+            name: 'action',
+            message: 'What would you like to do?',
+            choices: actionChoices,
+            pageSize: getPageSize(),
+        },
+    ]);
+    // Escape is handled globally by the menu loop
+    switch (action) {
+        case 'start': {
+            const result = await handleStartContainer(containerName);
+            if (result === 'home') {
+                await showMainMenu();
+                return;
+            }
+            await showContainerSubmenu(containerName, showMainMenu, activeDatabase);
+            return;
+        }
+        case 'stop':
+            await handleStopContainer(containerName);
+            await showContainerSubmenu(containerName, showMainMenu, activeDatabase);
+            return;
+        case 'select-database': {
+            const result = await handleSelectDatabase(containerName, databases, config.database);
+            if (result.action === 'home') {
+                await showMainMenu();
+                return;
+            }
+            if (result.action === 'back') {
+                await showContainerSubmenu(containerName, showMainMenu, activeDatabase);
+                return;
+            }
+            if (result.action === 'change-default') {
+                await handleChangeDefaultDatabase(containerName, databases, config.database);
+                await showContainerSubmenu(containerName, showMainMenu, activeDatabase);
+                return;
+            }
+            // action === 'select'
+            await showContainerSubmenu(containerName, showMainMenu, result.database);
+            return;
+        }
+        case 'shell':
+            await handleOpenShell(containerName, activeDatabase);
+            await showContainerSubmenu(containerName, showMainMenu, activeDatabase);
+            return;
+        case 'run-sql':
+            await handleRunSql(containerName, activeDatabase);
+            await showContainerSubmenu(containerName, showMainMenu, activeDatabase);
+            return;
+        case 'logs':
+            await handleViewLogs(containerName);
+            await showContainerSubmenu(containerName, showMainMenu, activeDatabase);
+            return;
+        case 'stop-pgweb':
+            await stopPgwebProcess(containerName, config.engine);
+            await showContainerSubmenu(containerName, showMainMenu, activeDatabase);
+            return;
+        case 'edit': {
+            const newName = await handleEditContainer(containerName);
+            if (newName === null) {
+                // User chose to go back to main menu
+                return;
+            }
+            if (newName !== containerName) {
+                // Container was renamed, show submenu with new name
+                await showContainerSubmenu(newName, showMainMenu, activeDatabase);
+            }
+            else {
+                await showContainerSubmenu(containerName, showMainMenu, activeDatabase);
+            }
+            return;
+        }
+        case 'clone':
+            await handleCloneFromSubmenu(containerName, showMainMenu);
+            return;
+        case 'copy':
+            await handleCopyConnectionString(containerName, activeDatabase);
+            await showContainerSubmenu(containerName, showMainMenu, activeDatabase);
+            return;
+        case 'create_user':
+            await handleCreateUser(containerName, activeDatabase);
+            await showContainerSubmenu(containerName, showMainMenu, activeDatabase);
+            return;
+        case 'backup':
+            await handleBackupForContainer(containerName, activeDatabase);
+            await showContainerSubmenu(containerName, showMainMenu, activeDatabase);
+            return;
+        case 'restore':
+            await handleRestoreForContainer(containerName, activeDatabase);
+            await showContainerSubmenu(containerName, showMainMenu, activeDatabase);
+            return;
+        case 'detach':
+            await handleDetachContainer(containerName, showMainMenu);
+            return; // Return to list after detach
+        case 'delete':
+            await handleDelete(containerName);
+            return; // Don't show submenu again after delete
+        case 'export':
+            await handleExportSubmenu(containerName, databases, showMainMenu);
+            return;
+        case 'back':
+            await handleList(showMainMenu);
+            return;
+        case 'main':
+            return; // Return to main menu
+    }
+}
+export async function handleStart() {
+    const containers = await containerManager.list();
+    // Filter for stopped containers, excluding file-based DBs (no server process to start)
+    const stopped = containers.filter((c) => c.status !== 'running' && !isFileBasedEngine(c.engine));
+    if (stopped.length === 0) {
+        console.log(uiWarning('All containers are already running'));
+        return;
+    }
+    const containerName = await promptContainerSelect(stopped, 'Select container to start:', { includeBack: true });
+    if (!containerName)
+        return;
+    // Reuse handleStartContainer for consistent port conflict handling
+    await handleStartContainer(containerName);
+}
+export async function handleStop() {
+    const containers = await containerManager.list();
+    // Filter for running containers, excluding file-based DBs (no server process to stop)
+    const running = containers.filter((c) => c.status === 'running' && !isFileBasedEngine(c.engine));
+    if (running.length === 0) {
+        console.log(uiWarning('No running containers'));
+        return;
+    }
+    const containerName = await promptContainerSelect(running, 'Select container to stop:', { includeBack: true });
+    if (!containerName)
+        return;
+    const config = await containerManager.getConfig(containerName);
+    if (!config) {
+        console.error(uiError(`Container "${containerName}" not found`));
+        return;
+    }
+    const engine = getEngine(config.engine);
+    const spinner = createSpinner(`Stopping ${containerName}...`);
+    spinner.start();
+    await engine.stop(config);
+    await containerManager.updateConfig(containerName, { status: 'stopped' });
+    spinner.succeed(`Container "${containerName}" stopped`);
+}
+async function handleStartContainer(containerName) {
+    const config = await containerManager.getConfig(containerName);
+    if (!config) {
+        console.error(uiError(`Container "${containerName}" not found`));
+        return 'back';
+    }
+    const portAvailable = await portManager.isPortAvailable(config.port);
+    if (!portAvailable) {
+        // Find next available port
+        let newPort;
+        try {
+            const result = await portManager.findAvailablePort({
+                preferredPort: config.port,
+            });
+            newPort = result.port;
+        }
+        catch {
+            console.log();
+            console.log(uiError('No available ports found. Free up a port and try again.'));
+            return 'back';
+        }
+        // Check if another SpinDB container is using this port
+        const allContainers = await containerManager.list();
+        const conflictingContainer = allContainers.find((c) => c.name !== containerName &&
+            c.port === config.port &&
+            c.status === 'running');
+        const conflictReason = conflictingContainer
+            ? `in use by "${conflictingContainer.name}"`
+            : 'in use by another process';
+        console.log();
+        console.log(uiWarning(`Port ${config.port} is ${conflictReason}`));
+        console.log();
+        const { action } = await escapeablePrompt([
+            {
+                type: 'list',
+                name: 'action',
+                message: 'What would you like to do?',
+                choices: [
+                    {
+                        name: `${chalk.green('▶')} Update to port ${newPort} and start ${chalk.gray('(recommended)')}`,
+                        value: 'update',
+                    },
+                    { name: `${chalk.blue('←')} Go back`, value: 'back' },
+                    {
+                        name: `${chalk.blue('⌂')} Back to main menu`,
+                        value: 'home',
+                    },
+                ],
+            },
+        ]);
+        if (action === 'back') {
+            return 'back';
+        }
+        if (action === 'home') {
+            return 'home';
+        }
+        // Update port and continue to start
+        config.port = newPort;
+        await containerManager.updateConfig(containerName, { port: newPort });
+        console.log(uiSuccess(`Updated port to ${newPort}`));
+    }
+    const engine = getEngine(config.engine);
+    const spinner = createSpinner(`Starting ${containerName}...`);
+    spinner.start();
+    try {
+        await engine.start(config);
+        await containerManager.updateConfig(containerName, { status: 'running' });
+        spinner.succeed(`Container "${containerName}" started`);
+        const connectionString = engine.getConnectionString(config);
+        console.log();
+        console.log(chalk.gray('  Connection string:'));
+        console.log(chalk.cyan(`  ${connectionString}`));
+        return 'started';
+    }
+    catch (error) {
+        spinner.fail(`Failed to start "${containerName}"`);
+        const e = error;
+        console.log();
+        console.log(uiError(e.message));
+        const logPath = paths.getContainerLogPath(containerName, {
+            engine: config.engine,
+        });
+        if (existsSync(logPath)) {
+            console.log();
+            console.log(uiInfo(`Check the log file for details: ${logPath}`));
+        }
+        return 'back';
+    }
+}
+async function handleStopContainer(containerName) {
+    const config = await containerManager.getConfig(containerName);
+    if (!config) {
+        console.error(uiError(`Container "${containerName}" not found`));
+        return;
+    }
+    const engine = getEngine(config.engine);
+    const spinner = createSpinner(`Stopping ${containerName}...`);
+    spinner.start();
+    await engine.stop(config);
+    await containerManager.updateConfig(containerName, { status: 'stopped' });
+    spinner.succeed(`Container "${containerName}" stopped`);
+}
+async function handleEditContainer(containerName) {
+    const config = await containerManager.getConfig(containerName);
+    if (!config) {
+        console.error(uiError(`Container "${containerName}" not found`));
+        return null;
+    }
+    const isSQLite = config.engine === Engine.SQLite;
+    const isDuckDB = config.engine === Engine.DuckDB;
+    const isFileBasedDB = isSQLite || isDuckDB;
+    console.clear();
+    console.log(header(`Edit: ${containerName}`));
+    console.log();
+    const editChoices = [
+        {
+            name: `Name: ${chalk.white(containerName)}`,
+            value: 'name',
+        },
+    ];
+    // File-based DBs: show relocate option with file path; others: show port
+    if (isFileBasedDB) {
+        editChoices.push({
+            name: `Location: ${chalk.white(config.database)}`,
+            value: 'relocate',
+        });
+    }
+    else {
+        editChoices.push({
+            name: `Port: ${chalk.white(String(config.port))}`,
+            value: 'port',
+        });
+    }
+    editChoices.push(new inquirer.Separator());
+    editChoices.push({
+        name: `${chalk.blue('←')} Back to container`,
+        value: 'back',
+    });
+    editChoices.push({
+        name: `${chalk.blue('⌂')} Back to main menu ${chalk.gray('(esc)')}`,
+        value: 'main',
+    });
+    const { field } = await escapeablePrompt([
+        {
+            type: 'list',
+            name: 'field',
+            message: 'Select field to edit:',
+            choices: editChoices,
+            pageSize: getPageSize(),
+        },
+    ]);
+    if (field === 'back') {
+        return containerName;
+    }
+    if (field === 'main') {
+        return null; // Signal to go back to main menu
+    }
+    if (field === 'name') {
+        const { newName } = await escapeablePrompt([
+            {
+                type: 'input',
+                name: 'newName',
+                message: 'New name:',
+                default: containerName,
+                validate: (input) => {
+                    if (!input)
+                        return 'Name is required';
+                    if (!/^[a-zA-Z][a-zA-Z0-9_-]*$/.test(input)) {
+                        return 'Name must start with a letter and contain only letters, numbers, hyphens, and underscores';
+                    }
+                    return true;
+                },
+            },
+        ]);
+        if (newName === containerName) {
+            console.log(uiInfo('Name unchanged'));
+            return await handleEditContainer(containerName);
+        }
+        if (await containerManager.exists(newName)) {
+            console.log(uiError(`Container "${newName}" already exists`));
+            return await handleEditContainer(containerName);
+        }
+        const spinner = createSpinner('Renaming container...');
+        spinner.start();
+        await containerManager.rename(containerName, newName);
+        spinner.succeed(`Renamed "${containerName}" to "${newName}"`);
+        // Continue editing with new name
+        return await handleEditContainer(newName);
+    }
+    if (field === 'port') {
+        const { newPort } = await escapeablePrompt([
+            {
+                type: 'input',
+                name: 'newPort',
+                message: 'New port:',
+                default: String(config.port),
+                validate: (input) => {
+                    const num = parseInt(input, 10);
+                    if (isNaN(num) || num < 1 || num > 65535) {
+                        return 'Port must be a number between 1 and 65535';
+                    }
+                    return true;
+                },
+                filter: (input) => parseInt(input, 10),
+            },
+        ]);
+        if (newPort === config.port) {
+            console.log(uiInfo('Port unchanged'));
+            return await handleEditContainer(containerName);
+        }
+        const portAvailable = await portManager.isPortAvailable(newPort);
+        if (!portAvailable) {
+            console.log(uiWarning(`Port ${newPort} is currently in use. You'll need to stop the process using it before starting this container.`));
+        }
+        await containerManager.updateConfig(containerName, { port: newPort });
+        console.log(uiSuccess(`Changed port from ${config.port} to ${newPort}`));
+        // Continue editing
+        return await handleEditContainer(containerName);
+    }
+    if (field === 'relocate') {
+        const currentFileName = basename(config.database);
+        const { inputPath } = await escapeablePrompt([
+            {
+                type: 'input',
+                name: 'inputPath',
+                message: 'New file path:',
+                default: config.database,
+                validate: (input) => {
+                    if (!input)
+                        return 'Path is required';
+                    return true;
+                },
+            },
+        ]);
+        // Expand ~ to home directory
+        let expandedPath = inputPath;
+        if (inputPath === '~') {
+            expandedPath = homedir();
+        }
+        else if (inputPath.startsWith('~/')) {
+            expandedPath = join(homedir(), inputPath.slice(2));
+        }
+        // Convert relative paths to absolute
+        if (!expandedPath.startsWith('/')) {
+            expandedPath = resolve(process.cwd(), expandedPath);
+        }
+        // Check if path looks like a file (has db extension) or directory
+        const hasDbExtension = /\.(sqlite3?|db|duckdb|ddb)$/i.test(expandedPath);
+        // Treat as directory if:
+        // - ends with /
+        // - exists and is a directory
+        // - doesn't have a database file extension (assume it's a directory path)
+        const isDirectory = expandedPath.endsWith('/') ||
+            (existsSync(expandedPath) && statSync(expandedPath).isDirectory()) ||
+            !hasDbExtension;
+        let finalPath;
+        if (isDirectory) {
+            // Remove trailing slash if present, then append filename
+            const dirPath = expandedPath.endsWith('/')
+                ? expandedPath.slice(0, -1)
+                : expandedPath;
+            finalPath = join(dirPath, currentFileName);
+        }
+        else {
+            finalPath = expandedPath;
+        }
+        if (finalPath === config.database) {
+            console.log(uiInfo('Location unchanged'));
+            return await handleEditContainer(containerName);
+        }
+        // Check if source file exists
+        if (!existsSync(config.database)) {
+            console.log(uiError(`Source file not found: ${config.database}`));
+            return await handleEditContainer(containerName);
+        }
+        // Check if destination already exists
+        if (existsSync(finalPath)) {
+            console.log(uiError(`Destination file already exists: ${finalPath}`));
+            return await handleEditContainer(containerName);
+        }
+        // Check if destination directory exists
+        const destDir = dirname(finalPath);
+        if (!existsSync(destDir)) {
+            console.log(uiWarning(`Directory does not exist: ${destDir}`));
+            const { createDir } = await escapeablePrompt([
+                {
+                    type: 'list',
+                    name: 'createDir',
+                    message: 'Create this directory?',
+                    choices: [
+                        { name: 'Yes, create it', value: 'yes' },
+                        { name: 'No, cancel', value: 'no' },
+                    ],
+                },
+            ]);
+            if (createDir !== 'yes') {
+                return await handleEditContainer(containerName);
+            }
+            try {
+                mkdirSync(destDir, { recursive: true });
+                console.log(uiSuccess(`Created directory: ${destDir}`));
+            }
+            catch (mkdirError) {
+                console.log(uiError(`Failed to create directory: ${mkdirError.message}`));
+                return await handleEditContainer(containerName);
+            }
+        }
+        const spinner = createSpinner('Moving database file...');
+        spinner.start();
+        try {
+            // Try rename first (fast, same filesystem)
+            try {
+                renameSync(config.database, finalPath);
+            }
+            catch (renameErr) {
+                const e = renameErr;
+                // EXDEV = cross-device link, need to copy+delete
+                if (e.code === 'EXDEV') {
+                    try {
+                        // Copy file preserving mode/permissions
+                        copyFileSync(config.database, finalPath);
+                        // Only delete source after successful copy
+                        unlinkSync(config.database);
+                    }
+                    catch (copyErr) {
+                        // Clean up partial target on failure
+                        if (existsSync(finalPath)) {
+                            try {
+                                unlinkSync(finalPath);
+                            }
+                            catch {
+                                // Ignore cleanup errors
+                            }
+                        }
+                        throw copyErr;
+                    }
+                }
+                else {
+                    throw renameErr;
+                }
+            }
+            // Update the container config and registry
+            await containerManager.updateConfig(containerName, {
+                database: finalPath,
+            });
+            // Use appropriate registry based on engine
+            if (isSQLite) {
+                await sqliteRegistry.update(containerName, { filePath: finalPath });
+            }
+            else if (isDuckDB) {
+                await duckdbRegistry.update(containerName, { filePath: finalPath });
+            }
+            spinner.succeed(`Moved database to ${finalPath}`);
+            // Wait for user to see success message before refreshing
+            await pressEnterToContinue();
+        }
+        catch (error) {
+            spinner.fail('Failed to move database file');
+            console.log(uiError(error.message));
+            await pressEnterToContinue();
+        }
+        // Continue editing (will fetch fresh config)
+        return await handleEditContainer(containerName);
+    }
+    return containerName;
+}
+async function handleSelectDatabase(containerName, databases, primaryDatabase) {
+    console.clear();
+    console.log(header(`${containerName} - Select Database`));
+    console.log();
+    const choices = databases.map((db) => ({
+        name: db === primaryDatabase ? `${db} ${chalk.gray('(default)')}` : db,
+        value: db,
+    }));
+    choices.push(new inquirer.Separator());
+    choices.push({
+        name: `${chalk.yellow('★')} Change default database`,
+        value: '_change-default',
+    });
+    choices.push({
+        name: `${chalk.blue('←')} Back`,
+        value: '_back',
+    });
+    choices.push({
+        name: `${chalk.blue('⌂')} Home ${chalk.gray('(esc)')}`,
+        value: '_home',
+    });
+    const { database } = await escapeablePrompt([
+        {
+            type: 'list',
+            name: 'database',
+            message: 'Select a database:',
+            choices,
+            pageSize: getPageSize(),
+        },
+    ]);
+    if (database === '_back') {
+        return { action: 'back' };
+    }
+    if (database === '_home') {
+        return { action: 'home' };
+    }
+    if (database === '_change-default') {
+        return { action: 'change-default' };
+    }
+    return { action: 'select', database };
+}
+async function handleChangeDefaultDatabase(containerName, databases, currentDefault) {
+    console.clear();
+    console.log(header(`${containerName} - Change Default Database`));
+    console.log();
+    const choices = databases.map((db) => ({
+        name: db === currentDefault ? `${db} ${chalk.gray('(current default)')}` : db,
+        value: db,
+    }));
+    choices.push(new inquirer.Separator());
+    choices.push({
+        name: `${chalk.blue('←')} Cancel`,
+        value: '_cancel',
+    });
+    const { database } = await escapeablePrompt([
+        {
+            type: 'list',
+            name: 'database',
+            message: 'Select new default database:',
+            choices,
+            pageSize: getPageSize(),
+        },
+    ]);
+    if (database === '_cancel' || database === currentDefault) {
+        return;
+    }
+    // Update the container config
+    await containerManager.updateConfig(containerName, { database });
+    console.log();
+    console.log(uiSuccess(`Default database changed to "${database}"`));
+    await pressEnterToContinue();
+}
+async function handleCloneFromSubmenu(sourceName, showMainMenu) {
+    const sourceConfig = await containerManager.getConfig(sourceName);
+    if (!sourceConfig) {
+        console.log(uiError(`Container "${sourceName}" not found`));
+        return;
+    }
+    const { targetName } = await escapeablePrompt([
+        {
+            type: 'input',
+            name: 'targetName',
+            message: 'Name for the cloned container:',
+            default: `${sourceName}-copy`,
+            validate: (input) => {
+                if (!input)
+                    return 'Name is required';
+                if (!/^[a-zA-Z][a-zA-Z0-9_-]*$/.test(input)) {
+                    return 'Name must start with a letter and contain only letters, numbers, hyphens, and underscores';
+                }
+                return true;
+            },
+        },
+    ]);
+    // Check if target container already exists
+    if (await containerManager.exists(targetName, { engine: sourceConfig.engine })) {
+        console.log(uiError(`Container "${targetName}" already exists`));
+        return;
+    }
+    const spinner = createSpinner(`Cloning ${sourceName} to ${targetName}...`);
+    spinner.start();
+    try {
+        const newConfig = await containerManager.clone(sourceName, targetName);
+        spinner.succeed(`Cloned "${sourceName}" to "${targetName}"`);
+        const engine = getEngine(newConfig.engine);
+        const connectionString = engine.getConnectionString(newConfig);
+        console.log();
+        console.log(connectionBox(targetName, connectionString, newConfig.port));
+        await showContainerSubmenu(targetName, showMainMenu);
+    }
+    catch (error) {
+        spinner.fail(`Failed to clone "${sourceName}"`);
+        console.log(uiError(error.message));
+        await pressEnterToContinue();
+    }
+}
+async function handleDetachContainer(containerName, showMainMenu) {
+    const config = await containerManager.getConfig(containerName);
+    if (!config) {
+        console.log(uiError(`Container "${containerName}" not found`));
+        await pressEnterToContinue();
+        return;
+    }
+    const confirmed = await promptConfirm(`Detach "${containerName}" from SpinDB? (file will be kept on disk)`, true);
+    if (!confirmed) {
+        console.log(uiWarning('Cancelled'));
+        await pressEnterToContinue();
+        await showContainerSubmenu(containerName, showMainMenu);
+        return;
+    }
+    let filePath;
+    // Use appropriate registry based on engine
+    if (config.engine === Engine.SQLite) {
+        const entry = await sqliteRegistry.get(containerName);
+        filePath = entry?.filePath;
+        await sqliteRegistry.remove(containerName);
+    }
+    else if (config.engine === Engine.DuckDB) {
+        const entry = await duckdbRegistry.get(containerName);
+        filePath = entry?.filePath;
+        await duckdbRegistry.remove(containerName);
+    }
+    console.log(uiSuccess(`Detached "${containerName}" from SpinDB`));
+    if (filePath) {
+        console.log(chalk.gray(`  File remains at: ${filePath}`));
+        console.log();
+        console.log(chalk.gray('  Re-attach with:'));
+        console.log(chalk.cyan(`    spindb attach ${filePath}`));
+    }
+    await pressEnterToContinue();
+    await handleList(showMainMenu);
+}
+async function handleDelete(containerName) {
+    const config = await containerManager.getConfig(containerName);
+    if (!config) {
+        console.error(uiError(`Container "${containerName}" not found`));
+        return;
+    }
+    const confirmed = await promptConfirm(`Are you sure you want to delete "${containerName}"? This cannot be undone.`, false);
+    if (!confirmed) {
+        console.log(uiWarning('Deletion cancelled'));
+        return;
+    }
+    const isRunning = await processManager.isRunning(containerName, {
+        engine: config.engine,
+    });
+    if (isRunning) {
+        const stopSpinner = createSpinner(`Stopping ${containerName}...`);
+        stopSpinner.start();
+        const engine = getEngine(config.engine);
+        await engine.stop(config);
+        stopSpinner.succeed(`Stopped "${containerName}"`);
+    }
+    const deleteSpinner = createSpinner(`Deleting ${containerName}...`);
+    deleteSpinner.start();
+    await containerManager.delete(containerName, { force: true });
+    deleteSpinner.succeed(`Container "${containerName}" deleted`);
+}
+async function isDockerContainerRunning(containerName) {
+    try {
+        const { execSync } = await import('child_process');
+        const result = execSync(`docker ps --filter "name=spindb-${containerName}" --format "{{.Names}}"`, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] });
+        return result.trim().includes(`spindb-${containerName}`);
+    }
+    catch {
+        return false;
+    }
+}
+async function handleExportSubmenu(containerName, databases, showMainMenu) {
+    const config = await containerManager.getConfig(containerName);
+    if (!config) {
+        console.log(uiError(`Container "${containerName}" not found`));
+        await pressEnterToContinue();
+        return;
+    }
+    // Check if Docker export already exists
+    const hasDockerExport = dockerExportExists(containerName, config.engine);
+    // Check if Docker container is running (only if export exists)
+    let dockerRunning = false;
+    if (hasDockerExport) {
+        dockerRunning = await isDockerContainerRunning(containerName);
+    }
+    console.log();
+    console.log(header('Export'));
+    console.log();
+    // Build choices based on whether export exists
+    const choices = [];
+    if (hasDockerExport) {
+        // Export exists: show option to get connection string with running status
+        const runningStatus = dockerRunning
+            ? chalk.green('running')
+            : chalk.gray('not running');
+        choices.push({
+            name: `${chalk.green('⎘')} Get Docker connection string ${chalk.gray(`(${runningStatus})`)}`,
+            value: 'docker-url',
+        });
+        choices.push({
+            name: `${chalk.cyan('▣')} Docker ${chalk.gray('(Re-export - invalidates original credentials)')}`,
+            value: 'docker',
+        });
+    }
+    else {
+        // No export: just show Docker option
+        choices.push({ name: `${chalk.cyan('▣')} Docker`, value: 'docker' });
+    }
+    choices.push(new inquirer.Separator());
+    choices.push({ name: `${chalk.blue('←')} Back`, value: 'back' });
+    choices.push({ name: `${chalk.blue('⌂')} Back to main menu`, value: 'home' });
+    const { action } = await escapeablePrompt([
+        {
+            type: 'list',
+            name: 'action',
+            message: 'Export format:',
+            choices,
+        },
+    ]);
+    switch (action) {
+        case 'docker-url':
+            await handleGetDockerConnectionString(containerName, config.engine);
+            await handleExportSubmenu(containerName, databases, showMainMenu);
+            return;
+        case 'docker':
+            await handleExportDocker(containerName, databases, showMainMenu);
+            return;
+        case 'back':
+            await showContainerSubmenu(containerName, showMainMenu, undefined);
+            return;
+        case 'home':
+            await showMainMenu();
+            return;
+    }
+}
+async function handleGetDockerConnectionString(containerName, engine) {
+    const connectionString = await getDockerConnectionString(containerName, engine);
+    if (!connectionString) {
+        console.log();
+        console.log(uiError('Could not read Docker export credentials'));
+        await pressEnterToContinue();
+        return;
+    }
+    // Copy to clipboard
+    const copied = await platformService.copyToClipboard(connectionString);
+    console.log();
+    if (copied) {
+        console.log(uiSuccess('Connection string copied to clipboard'));
+    }
+    else {
+        console.log(uiWarning('Could not copy to clipboard'));
+    }
+    console.log();
+    console.log(chalk.gray('  Connection string:'));
+    console.log(chalk.cyan(`  ${connectionString}`));
+    console.log();
+    await pressEnterToContinue();
+}
+async function handleExportDocker(containerName, databases, showMainMenu) {
+    const config = await containerManager.getConfig(containerName);
+    if (!config) {
+        console.log(uiError(`Container "${containerName}" not found`));
+        await pressEnterToContinue();
+        await showContainerSubmenu(containerName, showMainMenu, undefined);
+        return;
+    }
+    const engine = getEngine(config.engine);
+    const engineDefaultPort = getEngineDefaults(config.engine).defaultPort;
+    // Determine output directory
+    const outputDir = join(paths.getContainerPath(containerName, { engine: config.engine }), 'docker');
+    // Check if output directory already exists
+    if (existsSync(outputDir)) {
+        console.log();
+        console.log(uiWarning(`Output directory already exists: ${outputDir}`));
+        const shouldOverwrite = await promptConfirm('Do you want to overwrite it?', false);
+        if (!shouldOverwrite) {
+            console.log(uiInfo('Export cancelled'));
+            await pressEnterToContinue();
+            await showContainerSubmenu(containerName, showMainMenu, undefined);
+            return;
+        }
+        // Remove existing directory
+        try {
+            await rm(outputDir, { recursive: true, force: true });
+        }
+        catch (error) {
+            console.log(uiError(`Failed to remove existing directory: ${error.message}`));
+            await pressEnterToContinue();
+            await showContainerSubmenu(containerName, showMainMenu, undefined);
+            return;
+        }
+    }
+    // Determine target port
+    let targetPort = engineDefaultPort;
+    if (config.port !== engineDefaultPort) {
+        console.log();
+        console.log(chalk.yellow(`Local container uses port ${chalk.cyan(String(config.port))}, but ${engine.displayName}'s standard port is ${chalk.cyan(String(engineDefaultPort))}.`));
+        const { selectedPort } = await escapeablePrompt([
+            {
+                type: 'list',
+                name: 'selectedPort',
+                message: 'Which port should the Docker container use?',
+                choices: [
+                    {
+                        name: `${engineDefaultPort} ${chalk.gray('(standard port - recommended)')}`,
+                        value: engineDefaultPort,
+                    },
+                    {
+                        name: `${config.port} ${chalk.gray('(same as local container)')}`,
+                        value: config.port,
+                    },
+                ],
+                default: engineDefaultPort,
+            },
+        ]);
+        targetPort = selectedPort;
+    }
+    console.log();
+    console.log(chalk.bold(`Exporting ${chalk.cyan(containerName)} to Docker...`));
+    console.log();
+    // Create backups for all databases (or copy file for file-based DBs)
+    const backupPaths = [];
+    const isFileBased = isFileBasedEngine(config.engine);
+    if (isFileBased) {
+        // File-based database: copy the database file directly
+        const copySpinner = createSpinner('Copying database file...');
+        copySpinner.start();
+        try {
+            await mkdir(join(outputDir, 'data'), { recursive: true });
+            // Get the database file path from config.database
+            const dbFilePath = config.database;
+            if (!existsSync(dbFilePath)) {
+                throw new Error(`Database file not found: ${dbFilePath}`);
+            }
+            // Copy to data directory with original filename
+            const destPath = join(outputDir, 'data', basename(dbFilePath));
+            copyFileSync(dbFilePath, destPath);
+            const fileSize = (await stat(destPath)).size;
+            backupPaths.push({ database: config.database, path: destPath });
+            copySpinner.succeed(`Database file copied (${formatBytes(fileSize)})`);
+        }
+        catch (error) {
+            copySpinner.fail('Failed to copy database file');
+            console.log(uiError(error.message));
+            await pressEnterToContinue();
+            await showContainerSubmenu(containerName, showMainMenu, undefined);
+            return;
+        }
+    }
+    else {
+        // Server-based database: create backups using engine's backup method
+        const backupSpinner = createSpinner(databases.length > 1
+            ? `Creating backups for ${databases.length} databases...`
+            : 'Creating database backup...');
+        backupSpinner.start();
+        try {
+            await mkdir(join(outputDir, 'data'), { recursive: true });
+            for (const db of databases) {
+                const backupPath = getExportBackupPath(outputDir, containerName, db, config.engine);
+                const format = getDefaultFormat(config.engine);
+                const result = await engine.backup(config, backupPath, {
+                    database: db,
+                    format,
+                });
+                backupPaths.push({ database: db, path: result.path });
+            }
+            const totalSize = await Promise.all(backupPaths.map(async (bp) => (await stat(bp.path)).size)).then((sizes) => sizes.reduce((a, b) => a + b, 0));
+            backupSpinner.succeed(databases.length > 1
+                ? `Backups created for ${databases.length} databases (${formatBytes(totalSize)})`
+                : `Backup created (${formatBytes(totalSize)})`);
+        }
+        catch (error) {
+            backupSpinner.fail('Backup failed');
+            console.log(uiError(error.message));
+            await pressEnterToContinue();
+            await showContainerSubmenu(containerName, showMainMenu, undefined);
+            return;
+        }
+    }
+    // Generate Docker artifacts
+    const exportSpinner = createSpinner('Generating Docker artifacts...');
+    exportSpinner.start();
+    try {
+        const result = await exportToDocker(config, {
+            outputDir,
+            port: targetPort,
+            includeData: true,
+            backupPaths: backupPaths.length > 0 ? backupPaths : undefined,
+            skipTLS: isFileBased, // Skip TLS for file-based DBs (no network connection)
+        });
+        exportSpinner.succeed('Docker artifacts generated');
+        console.log();
+        console.log(uiSuccess(`Exported ${chalk.cyan(containerName)} to Docker`));
+        console.log();
+        // Display summary
+        const lines = [
+            `${chalk.bold(engine.displayName)} ${config.version}`,
+            `Port: ${chalk.green(String(targetPort))}`,
+            databases.length > 1
+                ? `Databases: ${chalk.cyan(databases.join(', '))}`
+                : `Database: ${chalk.cyan(config.database)}`,
+            '',
+            chalk.bold('Generated Credentials'),
+            chalk.gray('────────────────────────'),
+            `Username: ${chalk.white(result.credentials.username)}`,
+            `Password: ${chalk.white(result.credentials.password)}`,
+            chalk.gray('────────────────────────'),
+            '',
+            chalk.yellow('Save these credentials now - stored in .env'),
+        ];
+        // Simple box display using the theme's box function
+        console.log(box(lines));
+        console.log();
+        console.log(chalk.gray('  Output:'), chalk.cyan(result.outputDir));
+        console.log();
+        console.log(chalk.bold('  To run:'));
+        console.log(chalk.cyan(`    cd "${result.outputDir}" && docker compose up -d`));
+        console.log();
+    }
+    catch (error) {
+        exportSpinner.fail('Export failed');
+        console.log(uiError(error.message));
+    }
+    await pressEnterToContinue();
+    await showContainerSubmenu(containerName, showMainMenu, undefined);
+}
+async function handleCreateUser(containerName, activeDatabase) {
+    const config = await containerManager.getConfig(containerName);
+    if (!config) {
+        console.log(uiError(`Container "${containerName}" not found`));
+        await pressEnterToContinue();
+        return;
+    }
+    try {
+        // Prompt for username
+        const defaultUser = getDefaultUsername(config.engine);
+        const { username } = await escapeablePrompt([
+            {
+                type: 'input',
+                name: 'username',
+                message: 'Username:',
+                default: defaultUser,
+                validate: (input) => {
+                    if (!input.trim())
+                        return 'Username is required';
+                    if (!isValidUsername(input)) {
+                        return 'Must start with a letter, contain only letters/numbers/underscores';
+                    }
+                    return true;
+                },
+            },
+        ]);
+        // Check for existing credentials
+        if (credentialsExist(containerName, config.engine, username)) {
+            const overwrite = await promptConfirm(`Credentials for "${username}" already exist. Overwrite?`, false);
+            if (!overwrite) {
+                console.log(chalk.yellow('Credential creation cancelled.'));
+                await pressEnterToContinue();
+                return;
+            }
+        }
+        const password = generatePassword({ length: 20, alphanumericOnly: true });
+        const engine = getEngine(config.engine);
+        const spinner = createSpinner(`Creating user "${username}"...`);
+        spinner.start();
+        let credentials;
+        try {
+            credentials = await engine.createUser(config, {
+                username,
+                password,
+                database: activeDatabase || config.database,
+            });
+            spinner.succeed(`Created user "${username}"`);
+        }
+        catch (error) {
+            spinner.fail(`Failed to create user "${username}"`);
+            throw error;
+        }
+        // Save credentials (non-fatal — credentials are already created)
+        let credentialFile;
+        try {
+            credentialFile = await saveCredentials(containerName, config.engine, credentials);
+        }
+        catch (error) {
+            console.log(uiWarning(`Could not save credentials to disk: ${error.message}`));
+        }
+        console.log();
+        if (credentials.apiKey) {
+            console.log(`  ${chalk.gray('Key name:')}  ${credentials.username}`);
+            console.log(`  ${chalk.gray('API key:')}   ${credentials.apiKey}`);
+            console.log(`  ${chalk.gray('API URL:')}   ${credentials.connectionString}`);
+        }
+        else {
+            console.log(`  ${chalk.gray('Username:')}  ${credentials.username}`);
+            console.log(`  ${chalk.gray('Password:')}  ${credentials.password}`);
+            if (credentials.database) {
+                console.log(`  ${chalk.gray('Database:')}  ${credentials.database}`);
+            }
+            console.log(`  ${chalk.gray('URL:')}       ${credentials.connectionString}`);
+        }
+        if (credentialFile) {
+            console.log();
+            console.log(`  ${chalk.gray('Saved to:')} ${credentialFile}`);
+        }
+        console.log();
+        // Offer to copy to clipboard
+        try {
+            const copyText = credentials.apiKey || credentials.connectionString;
+            const copied = await platformService.copyToClipboard(copyText);
+            if (copied) {
+                console.log(uiSuccess(credentials.apiKey
+                    ? 'API key copied to clipboard'
+                    : 'Connection string copied to clipboard'));
+            }
+        }
+        catch {
+            // Clipboard failure is non-critical — credentials are already displayed above
+        }
+    }
+    catch (error) {
+        if (error instanceof UnsupportedOperationError) {
+            console.log(uiError('User management is not supported for this engine'));
+        }
+        else {
+            console.log(uiError(error.message));
+        }
+    }
+    await pressEnterToContinue();
+}
+//# sourceMappingURL=container-handlers.js.map