spindb 0.40.0 → 0.42.4

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

@@ -4,7 +4,7 @@ import { existsSync, renameSync, statSync, mkdirSync, copyFileSync, unlinkSync,
 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 { containerManager, updateRenameTracking, } 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';
@@ -17,7 +17,7 @@ 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 { promptContainerName, promptContainerSelect, promptInstallDependencies, promptConfirm, promptEngine, promptVersion, promptPort, promptDatabaseName, promptFileDatabasePath, EscapeError, 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';
@@ -29,11 +29,20 @@ import { UnsupportedOperationError, isValidUsername, logDebug, } from '../../../
 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 { getDefaultFormat, getBackupExtension, } from '../../../config/backup-formats.js';
 import { parseConnectionString, detectEngineFromConnectionString, detectProvider, isLocalhost, generateRemoteContainerName, redactConnectionString, buildRemoteConfig, getDefaultPortForEngine, } from '../../../core/remote-container.js';
 import { Engine, isFileBasedEngine, isRemoteContainer } from '../../../types/index.js';
+import { canCreateDatabase, canDropDatabase, canRenameDatabase, getDatabaseCapabilities, } from '../../../core/database-capabilities.js';
 import { pressEnterToContinue } from './shared.js';
 import { getEngineIcon } from '../../constants.js';
+/** 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
+    };
+}
 export async function handleCreate() {
     console.log();
     console.log(header('Create New Database Container'));
@@ -674,7 +683,7 @@ export async function handleList(showMainMenu, options) {
     }
     await showContainerSubmenu(selectedContainer, showMainMenu);
 }
-export async function showContainerSubmenu(containerName, showMainMenu, selectedDatabase) {
+export async function showContainerSubmenu(containerName, showMainMenu) {
     const config = await containerManager.getConfig(containerName);
     if (!config) {
         console.error(uiError(`Container "${containerName}" not found`));
@@ -708,8 +717,8 @@ export async function showContainerSubmenu(containerName, showMainMenu, selected
     }
     // 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;
+    // Active database is always the default from config
+    const activeDatabase = config.database;
     // Header shows icon + container → database
     const engineIcon = getEngineIcon(config.engine);
     const headerText = `${engineIcon} ${containerName} ${chalk.gray('→')} ${activeDatabase}`;
@@ -719,14 +728,6 @@ export async function showContainerSubmenu(containerName, showMainMenu, selected
     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
-        };
-    }
     // Remote containers get a simplified action set
     if (isRemote) {
         actionChoices.push(new inquirer.Separator(chalk.gray(`── Linked ──`)));
@@ -767,11 +768,11 @@ export async function showContainerSubmenu(containerName, showMainMenu, selected
         switch (action) {
             case 'shell':
                 await handleOpenShell(containerName, activeDatabase);
-                await showContainerSubmenu(containerName, showMainMenu, activeDatabase);
+                await showContainerSubmenu(containerName, showMainMenu);
                 return;
             case 'copy':
                 await handleCopyConnectionString(containerName, activeDatabase);
-                await showContainerSubmenu(containerName, showMainMenu, activeDatabase);
+                await showContainerSubmenu(containerName, showMainMenu);
                 return;
             case 'delete':
                 await handleDelete(containerName);
@@ -785,7 +786,6 @@ export async function showContainerSubmenu(containerName, showMainMenu, selected
         return;
     }
     // 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;
@@ -794,10 +794,6 @@ export async function showContainerSubmenu(containerName, showMainMenu, selected
         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
@@ -843,61 +839,100 @@ export async function showContainerSubmenu(containerName, showMainMenu, selected
             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) {
+    if (hasMultipleDatabases) {
+        // Multi-db: show "Databases (N)" entry — per-db actions are in the databases submenu
         actionChoices.push(containerReady
             ? {
-                name: `${chalk.yellow('+')} Create user`,
-                value: 'create_user',
+                name: `${chalk.cyan('◉')} Databases (${databases.length})`,
+                value: 'databases',
             }
-            : disabledItem('+', 'Create user'));
+            : disabledItem('◉', `Databases (${databases.length})`));
     }
-    // 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
+    else {
+        // Single-db: all data actions inline
+        // Open console
+        actionChoices.push(canDoDbAction
+            ? { name: `${chalk.blue('>')} Open console`, value: 'shell' }
+            : disabledItem('>', 'Open console'));
+        // Run script file
+        // 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
+        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'));
+        }
+        // Create database - only for engines that support it, requires running
+        if (canCreateDatabase(config.engine)) {
+            actionChoices.push(containerReady
+                ? {
+                    name: `${chalk.green('+')} Create database`,
+                    value: 'create_database',
+                }
+                : disabledItem('+', 'Create database'));
+        }
+        // Rename database - only when engine supports it AND container has databases
+        if (canRenameDatabase(config.engine) && databases.length > 0) {
+            actionChoices.push(containerReady
+                ? {
+                    name: `${chalk.yellow('⇄')} Rename database`,
+                    value: 'rename_database',
+                }
+                : disabledItem('⇄', 'Rename database'));
+        }
+        // Drop database - only when engine supports it AND has >1 database (can't drop default)
+        if (canDropDatabase(config.engine) && databases.length > 1) {
+            actionChoices.push(containerReady
+                ? {
+                    name: `${chalk.red('−')} Drop database`,
+                    value: 'drop_database',
+                }
+                : disabledItem('−', 'Drop database'));
+        }
+        // Backup
+        actionChoices.push(canDoDbAction
+            ? {
+                name: `${chalk.magenta('↓')} Backup database`,
+                value: 'backup',
+            }
+            : disabledItem('↓', 'Backup database'));
+        // Restore
+        actionChoices.push(canDoDbAction
+            ? {
+                name: `${chalk.magenta('↑')} Restore from backup`,
+                value: 'restore',
+            }
+            : disabledItem('↑', 'Restore from backup'));
+    }
+    // Export - always container-level (server-based must be running, file-based must have the file)
     actionChoices.push(containerReady
         ? { name: `${chalk.cyan('⬆')} Export`, value: 'export' }
         : disabledItem('⬆', 'Export'));
@@ -957,47 +992,31 @@ export async function showContainerSubmenu(containerName, showMainMenu, selected
                 await showMainMenu();
                 return;
             }
-            await showContainerSubmenu(containerName, showMainMenu, activeDatabase);
+            await showContainerSubmenu(containerName, showMainMenu);
             return;
         }
         case 'stop':
             await handleStopContainer(containerName);
-            await showContainerSubmenu(containerName, showMainMenu, activeDatabase);
+            await showContainerSubmenu(containerName, showMainMenu);
             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);
+        case 'databases':
+            await showDatabasesSubmenu(containerName, showMainMenu);
             return;
-        }
         case 'shell':
             await handleOpenShell(containerName, activeDatabase);
-            await showContainerSubmenu(containerName, showMainMenu, activeDatabase);
+            await showContainerSubmenu(containerName, showMainMenu);
             return;
         case 'run-sql':
             await handleRunSql(containerName, activeDatabase);
-            await showContainerSubmenu(containerName, showMainMenu, activeDatabase);
+            await showContainerSubmenu(containerName, showMainMenu);
             return;
         case 'logs':
             await handleViewLogs(containerName);
-            await showContainerSubmenu(containerName, showMainMenu, activeDatabase);
+            await showContainerSubmenu(containerName, showMainMenu);
             return;
         case 'stop-pgweb':
             await stopPgwebProcess(containerName, config.engine);
-            await showContainerSubmenu(containerName, showMainMenu, activeDatabase);
+            await showContainerSubmenu(containerName, showMainMenu);
             return;
         case 'edit': {
             const newName = await handleEditContainer(containerName);
@@ -1007,10 +1026,10 @@ export async function showContainerSubmenu(containerName, showMainMenu, selected
             }
             if (newName !== containerName) {
                 // Container was renamed, show submenu with new name
-                await showContainerSubmenu(newName, showMainMenu, activeDatabase);
+                await showContainerSubmenu(newName, showMainMenu);
             }
             else {
-                await showContainerSubmenu(containerName, showMainMenu, activeDatabase);
+                await showContainerSubmenu(containerName, showMainMenu);
             }
             return;
         }
@@ -1019,19 +1038,31 @@ export async function showContainerSubmenu(containerName, showMainMenu, selected
             return;
         case 'copy':
             await handleCopyConnectionString(containerName, activeDatabase);
-            await showContainerSubmenu(containerName, showMainMenu, activeDatabase);
+            await showContainerSubmenu(containerName, showMainMenu);
             return;
         case 'create_user':
             await handleCreateUser(containerName, activeDatabase);
-            await showContainerSubmenu(containerName, showMainMenu, activeDatabase);
+            await showContainerSubmenu(containerName, showMainMenu);
+            return;
+        case 'create_database':
+            await handleCreateDatabase(containerName);
+            await showContainerSubmenu(containerName, showMainMenu);
+            return;
+        case 'rename_database':
+            await handleRenameDatabase(containerName);
+            await showContainerSubmenu(containerName, showMainMenu);
+            return;
+        case 'drop_database':
+            await handleDropDatabase(containerName);
+            await showContainerSubmenu(containerName, showMainMenu);
             return;
         case 'backup':
             await handleBackupForContainer(containerName, activeDatabase);
-            await showContainerSubmenu(containerName, showMainMenu, activeDatabase);
+            await showContainerSubmenu(containerName, showMainMenu);
             return;
         case 'restore':
             await handleRestoreForContainer(containerName, activeDatabase);
-            await showContainerSubmenu(containerName, showMainMenu, activeDatabase);
+            await showContainerSubmenu(containerName, showMainMenu);
             return;
         case 'detach':
             await handleDetachContainer(containerName, showMainMenu);
@@ -1049,6 +1080,272 @@ export async function showContainerSubmenu(containerName, showMainMenu, selected
             return; // Return to main menu
     }
 }
+async function showDatabasesSubmenu(containerName, showMainMenu) {
+    const config = await containerManager.getConfig(containerName);
+    if (!config) {
+        console.error(uiError(`Container "${containerName}" not found`));
+        return;
+    }
+    const databases = config.databases || [config.database];
+    // If only 1 database remains, return to container submenu (inline mode)
+    if (databases.length <= 1) {
+        await showContainerSubmenu(containerName, showMainMenu);
+        return;
+    }
+    const engineIcon = getEngineIcon(config.engine);
+    console.clear();
+    console.log(header(`${engineIcon} ${containerName} - Databases`));
+    console.log();
+    const choices = databases.map((db) => ({
+        name: db === config.database ? `${db} ${chalk.gray('(default)')}` : db,
+        value: db,
+    }));
+    choices.push(new inquirer.Separator());
+    // Create database - only if engine supports it AND container is running
+    const isFileBased = isFileBasedEngine(config.engine);
+    const containerReady = isFileBased
+        ? existsSync(config.database)
+        : await processManager.isRunning(containerName, { engine: config.engine });
+    if (canCreateDatabase(config.engine) && containerReady) {
+        choices.push({
+            name: `${chalk.green('+')} Create database`,
+            value: '_create_database',
+        });
+    }
+    choices.push({
+        name: `${chalk.blue('←')} Back`,
+        value: '_back',
+    });
+    choices.push({
+        name: `${chalk.blue('⌂')} Home ${chalk.gray('(esc)')}`,
+        value: '_home',
+    });
+    choices.push(new inquirer.Separator());
+    const { selection } = await escapeablePrompt([
+        {
+            type: 'list',
+            name: 'selection',
+            message: 'Select a database:',
+            choices,
+            pageSize: getPageSize(),
+        },
+    ]);
+    switch (selection) {
+        case '_create_database':
+            await handleCreateDatabase(containerName);
+            await showDatabasesSubmenu(containerName, showMainMenu);
+            return;
+        case '_back':
+            await showContainerSubmenu(containerName, showMainMenu);
+            return;
+        case '_home':
+            return;
+        default:
+            await showDatabaseActionMenu(containerName, selection, showMainMenu);
+            return;
+    }
+}
+async function showDatabaseActionMenu(containerName, database, showMainMenu) {
+    const config = await containerManager.getConfig(containerName);
+    if (!config) {
+        console.error(uiError(`Container "${containerName}" not found`));
+        return;
+    }
+    const databases = config.databases || [config.database];
+    // If the database no longer exists, return to databases submenu
+    if (!databases.includes(database)) {
+        await showDatabasesSubmenu(containerName, showMainMenu);
+        return;
+    }
+    const engineIcon = getEngineIcon(config.engine);
+    const headerText = `${engineIcon} ${containerName} ${chalk.gray('→')} ${database}`;
+    console.clear();
+    console.log(header(headerText));
+    const isFileBased = isFileBasedEngine(config.engine);
+    const isRunning = isFileBased
+        ? existsSync(config.database)
+        : await processManager.isRunning(containerName, { engine: config.engine });
+    const containerReady = isRunning;
+    console.log(chalk.gray(`${config.engine} ${config.version} - ${isRunning ? 'running' : 'stopped'}`));
+    console.log();
+    const actionChoices = [];
+    // Data operations section
+    const dataSectionLabel = containerReady
+        ? isFileBased
+            ? 'Available'
+            : 'Running'
+        : isFileBased
+            ? 'Database file missing'
+            : 'Start container first';
+    actionChoices.push(new inquirer.Separator(chalk.gray(`── ${dataSectionLabel} ──`)));
+    // Open console
+    actionChoices.push(containerReady
+        ? { name: `${chalk.blue('>')} Open console`, value: 'shell' }
+        : disabledItem('>', 'Open console'));
+    // Run script file
+    const engineConfig = await getEngineConfig(config.engine);
+    if (engineConfig.scriptFileLabel) {
+        actionChoices.push(containerReady
+            ? {
+                name: `${chalk.yellow('▷')} ${engineConfig.scriptFileLabel}`,
+                value: 'run-sql',
+            }
+            : disabledItem('▷', engineConfig.scriptFileLabel));
+    }
+    // Copy connection string
+    actionChoices.push(containerReady
+        ? {
+            name: `${chalk.green('⎘')} Copy connection string`,
+            value: 'copy',
+        }
+        : disabledItem('⎘', 'Copy connection string'));
+    // Create user
+    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'));
+    }
+    // Rename database
+    if (canRenameDatabase(config.engine)) {
+        actionChoices.push(containerReady
+            ? {
+                name: `${chalk.yellow('⇄')} Rename database`,
+                value: 'rename_database',
+            }
+            : disabledItem('⇄', 'Rename database'));
+    }
+    // Drop database - can't drop the default database
+    if (canDropDatabase(config.engine) && database !== config.database) {
+        actionChoices.push(containerReady
+            ? {
+                name: `${chalk.red('−')} Drop database`,
+                value: 'drop_database',
+            }
+            : disabledItem('−', 'Drop database'));
+    }
+    // Backup
+    actionChoices.push(containerReady
+        ? { name: `${chalk.magenta('↓')} Backup database`, value: 'backup' }
+        : disabledItem('↓', 'Backup database'));
+    // Restore
+    actionChoices.push(containerReady
+        ? {
+            name: `${chalk.magenta('↑')} Restore from backup`,
+            value: 'restore',
+        }
+        : disabledItem('↑', 'Restore from backup'));
+    actionChoices.push(new inquirer.Separator());
+    // Set as default
+    if (database !== config.database) {
+        actionChoices.push({
+            name: `${chalk.yellow('★')} Set as default`,
+            value: 'set_default',
+        });
+    }
+    // Navigation
+    actionChoices.push({
+        name: `${chalk.blue('←')} Back to databases`,
+        value: 'back',
+    });
+    actionChoices.push({
+        name: `${chalk.blue('⌂')} Home ${chalk.gray('(esc)')}`,
+        value: 'home',
+    });
+    actionChoices.push(new inquirer.Separator());
+    const { action } = await escapeablePrompt([
+        {
+            type: 'list',
+            name: 'action',
+            message: 'What would you like to do?',
+            choices: actionChoices,
+            pageSize: getPageSize(),
+        },
+    ]);
+    switch (action) {
+        case 'shell':
+            await handleOpenShell(containerName, database);
+            await showDatabaseActionMenu(containerName, database, showMainMenu);
+            return;
+        case 'run-sql':
+            await handleRunSql(containerName, database);
+            await showDatabaseActionMenu(containerName, database, showMainMenu);
+            return;
+        case 'copy':
+            await handleCopyConnectionString(containerName, database);
+            await showDatabaseActionMenu(containerName, database, showMainMenu);
+            return;
+        case 'create_user':
+            await handleCreateUser(containerName, database);
+            await showDatabaseActionMenu(containerName, database, showMainMenu);
+            return;
+        case 'rename_database': {
+            // After rename, the database name may have changed
+            const beforeDbs = [...databases];
+            await handleRenameDatabase(containerName, database);
+            const afterConfig = await containerManager.getConfig(containerName);
+            const afterDbs = afterConfig?.databases ||
+                [afterConfig?.database].filter(Boolean);
+            // Find the new database name (appeared after rename but not before)
+            const newDb = afterDbs.find((db) => !beforeDbs.includes(db));
+            if (newDb) {
+                // Database was renamed — show the new database's action menu
+                await showDatabaseActionMenu(containerName, newDb, showMainMenu);
+            }
+            else {
+                // Rename failed or user kept original — stay on current database
+                await showDatabaseActionMenu(containerName, database, showMainMenu);
+            }
+            return;
+        }
+        case 'drop_database': {
+            await handleDropDatabase(containerName, database);
+            // Check if the database still exists after drop
+            const freshConfig = await containerManager.getConfig(containerName);
+            if (!freshConfig) {
+                // Container was deleted — return to main menu
+                return;
+            }
+            const freshDbs = freshConfig.databases || [freshConfig.database];
+            if (!freshDbs.includes(database)) {
+                // Database was dropped
+                if ((freshDbs?.length ?? 0) <= 1) {
+                    // Only 1 database left — no longer multi-db, go to container submenu
+                    await showContainerSubmenu(containerName, showMainMenu);
+                }
+                else {
+                    await showDatabasesSubmenu(containerName, showMainMenu);
+                }
+            }
+            else {
+                // Database still exists (user cancelled) — stay in per-db menu
+                await showDatabaseActionMenu(containerName, database, showMainMenu);
+            }
+            return;
+        }
+        case 'backup':
+            await handleBackupForContainer(containerName, database);
+            await showDatabaseActionMenu(containerName, database, showMainMenu);
+            return;
+        case 'restore':
+            await handleRestoreForContainer(containerName, database);
+            await showDatabaseActionMenu(containerName, database, showMainMenu);
+            return;
+        case 'set_default':
+            await containerManager.updateConfig(containerName, { database });
+            console.log();
+            console.log(uiSuccess(`Default database changed to "${database}"`));
+            await pressEnterToContinue();
+            await showDatabaseActionMenu(containerName, database, showMainMenu);
+            return;
+        case 'back':
+            await showDatabasesSubmenu(containerName, showMainMenu);
+            return;
+        case 'home':
+            return;
+    }
+}
 export async function handleStart() {
     const containers = await containerManager.list();
     // Filter for stopped containers, excluding file-based DBs and linked containers
@@ -1454,78 +1751,6 @@ async function 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) {
@@ -1712,7 +1937,7 @@ async function handleExportSubmenu(containerName, databases, showMainMenu) {
             await handleExportDocker(containerName, databases, showMainMenu);
             return;
         case 'back':
-            await showContainerSubmenu(containerName, showMainMenu, undefined);
+            await showContainerSubmenu(containerName, showMainMenu);
             return;
         case 'home':
             await showMainMenu();
@@ -1747,7 +1972,7 @@ async function handleExportDocker(containerName, databases, showMainMenu) {
     if (!config) {
         console.log(uiError(`Container "${containerName}" not found`));
         await pressEnterToContinue();
-        await showContainerSubmenu(containerName, showMainMenu, undefined);
+        await showContainerSubmenu(containerName, showMainMenu);
         return;
     }
     const engine = getEngine(config.engine);
@@ -1762,7 +1987,7 @@ async function handleExportDocker(containerName, databases, showMainMenu) {
         if (!shouldOverwrite) {
             console.log(uiInfo('Export cancelled'));
             await pressEnterToContinue();
-            await showContainerSubmenu(containerName, showMainMenu, undefined);
+            await showContainerSubmenu(containerName, showMainMenu);
             return;
         }
         // Remove existing directory
@@ -1772,7 +1997,7 @@ async function handleExportDocker(containerName, databases, showMainMenu) {
         catch (error) {
             console.log(uiError(`Failed to remove existing directory: ${error.message}`));
             await pressEnterToContinue();
-            await showContainerSubmenu(containerName, showMainMenu, undefined);
+            await showContainerSubmenu(containerName, showMainMenu);
             return;
         }
     }
@@ -1829,7 +2054,7 @@ async function handleExportDocker(containerName, databases, showMainMenu) {
             copySpinner.fail('Failed to copy database file');
             console.log(uiError(error.message));
             await pressEnterToContinue();
-            await showContainerSubmenu(containerName, showMainMenu, undefined);
+            await showContainerSubmenu(containerName, showMainMenu);
             return;
         }
     }
@@ -1859,7 +2084,7 @@ async function handleExportDocker(containerName, databases, showMainMenu) {
             backupSpinner.fail('Backup failed');
             console.log(uiError(error.message));
             await pressEnterToContinue();
-            await showContainerSubmenu(containerName, showMainMenu, undefined);
+            await showContainerSubmenu(containerName, showMainMenu);
             return;
         }
     }
@@ -1908,7 +2133,7 @@ async function handleExportDocker(containerName, databases, showMainMenu) {
         console.log(uiError(error.message));
     }
     await pressEnterToContinue();
-    await showContainerSubmenu(containerName, showMainMenu, undefined);
+    await showContainerSubmenu(containerName, showMainMenu);
 }
 async function handleCreateUser(containerName, activeDatabase) {
     const config = await containerManager.getConfig(containerName);
@@ -2013,4 +2238,392 @@ async function handleCreateUser(containerName, activeDatabase) {
     }
     await pressEnterToContinue();
 }
+async function handleCreateDatabase(containerName) {
+    const config = await containerManager.getConfig(containerName);
+    if (!config) {
+        console.log(uiError(`Container "${containerName}" not found`));
+        await pressEnterToContinue();
+        return;
+    }
+    const isRunning = await processManager.isRunning(containerName, {
+        engine: config.engine,
+    });
+    if (!isRunning) {
+        console.log(uiError(`Container "${containerName}" is not running. Start it first with: spindb start ${containerName}`));
+        await pressEnterToContinue();
+        return;
+    }
+    // Prompt for name — Escape returns to submenu
+    let dbName;
+    try {
+        const result = await escapeablePrompt([
+            {
+                type: 'input',
+                name: 'dbName',
+                message: 'New database name:',
+                validate: (input) => {
+                    if (!input.trim())
+                        return 'Database name is required';
+                    if (/\s/.test(input))
+                        return 'Database name cannot contain spaces';
+                    return true;
+                },
+            },
+        ]);
+        dbName = result.dbName;
+    }
+    catch (error) {
+        if (error instanceof EscapeError)
+            return;
+        throw error;
+    }
+    // Check if already exists
+    const rawDatabases = config.databases || [];
+    const trackedDatabases = [...new Set([config.database, ...rawDatabases])];
+    if (trackedDatabases.includes(dbName)) {
+        console.log(uiError(`Database "${dbName}" already exists in "${containerName}"`));
+        await pressEnterToContinue();
+        return;
+    }
+    const engine = getEngine(config.engine);
+    // Check if database exists on the server (not just tracking)
+    try {
+        const serverDatabases = await engine.listDatabases(config);
+        if (serverDatabases.includes(dbName)) {
+            console.log(uiError(`Database "${dbName}" already exists on the server. Use "spindb databases add ${containerName} ${dbName}" to track it.`));
+            await pressEnterToContinue();
+            return;
+        }
+    }
+    catch {
+        // listDatabases not supported for all engines — proceed
+    }
+    try {
+        const spinner = createSpinner(`Creating database "${dbName}" in "${containerName}"...`);
+        spinner.start();
+        try {
+            await engine.createDatabase(config, dbName);
+            spinner.succeed(`Created database "${dbName}"`);
+        }
+        catch (error) {
+            spinner.fail(`Failed to create database "${dbName}"`);
+            throw error;
+        }
+        await containerManager.addDatabase(containerName, dbName);
+        const connectionString = engine.getConnectionString(config, dbName);
+        console.log();
+        console.log(uiSuccess(`Database "${dbName}" created in "${containerName}"`));
+        console.log();
+        console.log(chalk.gray('  Connection:'), chalk.cyan(connectionString));
+    }
+    catch (error) {
+        console.log(uiError(error.message));
+    }
+    await pressEnterToContinue();
+}
+async function handleRenameDatabase(containerName, targetDatabase) {
+    const config = await containerManager.getConfig(containerName);
+    if (!config) {
+        console.log(uiError(`Container "${containerName}" not found`));
+        await pressEnterToContinue();
+        return;
+    }
+    const isRunning = await processManager.isRunning(containerName, {
+        engine: config.engine,
+    });
+    if (!isRunning) {
+        console.log(uiError(`Container "${containerName}" is not running. Start it first with: spindb start ${containerName}`));
+        await pressEnterToContinue();
+        return;
+    }
+    const rawDatabases = config.databases || [];
+    const trackedDatabases = [...new Set([config.database, ...rawDatabases])];
+    if (trackedDatabases.length === 0) {
+        console.log(uiError(`No databases to rename in "${containerName}"`));
+        await pressEnterToContinue();
+        return;
+    }
+    // Select database to rename — skip prompt if targetDatabase provided
+    let oldName;
+    if (targetDatabase) {
+        oldName = targetDatabase;
+    }
+    else {
+        try {
+            const result = await escapeablePrompt([
+                {
+                    type: 'list',
+                    name: 'oldName',
+                    message: 'Select database to rename:',
+                    choices: trackedDatabases.map((db) => {
+                        const isDefault = db === config.database;
+                        return {
+                            name: isDefault ? `${db} (default)` : db,
+                            value: db,
+                        };
+                    }),
+                },
+            ]);
+            oldName = result.oldName;
+        }
+        catch (error) {
+            if (error instanceof EscapeError)
+                return;
+            throw error;
+        }
+    }
+    // Enter new name — Escape returns to submenu
+    let newName;
+    try {
+        const result = await escapeablePrompt([
+            {
+                type: 'input',
+                name: 'newName',
+                message: `New name for "${oldName}":`,
+                validate: (input) => {
+                    if (!input.trim())
+                        return 'Database name is required';
+                    if (/\s/.test(input))
+                        return 'Database name cannot contain spaces';
+                    if (input === oldName)
+                        return 'New name must be different';
+                    if (trackedDatabases.includes(input))
+                        return `"${input}" already exists`;
+                    return true;
+                },
+            },
+        ]);
+        newName = result.newName;
+    }
+    catch (error) {
+        if (error instanceof EscapeError)
+            return;
+        throw error;
+    }
+    try {
+        const isPrimaryRename = oldName === config.database;
+        if (isPrimaryRename) {
+            console.log(uiWarning(`This will rename the default database. The default will be updated to "${newName}".`));
+        }
+        const caps = getDatabaseCapabilities(config.engine);
+        const engine = getEngine(config.engine);
+        let shouldDrop = true;
+        let dropSucceeded = false;
+        let backupPath;
+        if (caps.supportsRename === 'native') {
+            // Native rename (PostgreSQL, ClickHouse, CockroachDB, Meilisearch) — instant, no backup needed
+            const spinner = createSpinner(`Renaming "${oldName}" to "${newName}"...`);
+            spinner.start();
+            try {
+                await engine.renameDatabase(config, oldName, newName);
+                spinner.succeed(`Renamed "${oldName}" to "${newName}"`);
+                dropSucceeded = true; // Native rename atomically replaces the old name
+            }
+            catch (error) {
+                spinner.fail(`Failed to rename database`);
+                throw error;
+            }
+        }
+        else {
+            // Backup/restore rename — explain strategy to user
+            console.log();
+            console.log(uiInfo(`${engine.displayName} does not support native database renaming.`));
+            console.log(chalk.gray(`  We'll clone "${oldName}" to a new database named "${newName}",`));
+            console.log(chalk.gray(`  then ask if you'd like to delete the original.`));
+            console.log();
+            await mkdir(paths.renameBackups, { recursive: true });
+            const format = getDefaultFormat(config.engine);
+            const extension = getBackupExtension(config.engine, format);
+            const timestamp = new Date()
+                .toISOString()
+                .replace(/[:.]/g, '')
+                .slice(0, 15);
+            const backupFileName = `${containerName}-${oldName}-rename-${timestamp}${extension}`;
+            backupPath = join(paths.renameBackups, backupFileName);
+            const spinner = createSpinner(`Backing up "${oldName}"...`);
+            spinner.start();
+            // Step 1: Backup
+            try {
+                await engine.backup(config, backupPath, {
+                    database: oldName,
+                    format,
+                });
+            }
+            catch (error) {
+                spinner.fail(`Failed to backup "${oldName}"`);
+                throw error;
+            }
+            // Step 2: Create new database
+            spinner.text = `Creating database "${newName}"...`;
+            try {
+                await engine.createDatabase(config, newName);
+            }
+            catch (error) {
+                spinner.fail(`Failed to create database "${newName}"`);
+                throw error;
+            }
+            // Step 3: Restore data
+            spinner.text = `Restoring data to "${newName}"...`;
+            try {
+                await engine.restore({ ...config, database: newName }, backupPath, {
+                    database: newName,
+                });
+            }
+            catch (error) {
+                spinner.fail(`Failed to restore data to "${newName}"`);
+                // Rollback: drop new DB, keep backup
+                try {
+                    await engine.dropDatabase(config, newName);
+                }
+                catch {
+                    console.log(uiWarning(`Could not remove partially-created database "${newName}" — manual cleanup may be needed`));
+                }
+                console.log(uiWarning(`Safety backup retained at: ${backupPath}`));
+                throw error;
+            }
+            spinner.succeed(`Cloned "${oldName}" to "${newName}"`);
+            // Ask whether to delete the original
+            console.log();
+            console.log(uiSuccess('Database clone successful.'));
+            try {
+                shouldDrop = await promptConfirm(`Delete the original database "${oldName}"?`, true);
+            }
+            catch (error) {
+                if (error instanceof EscapeError) {
+                    shouldDrop = false; // Escape = keep the original
+                }
+                else {
+                    throw error;
+                }
+            }
+            if (shouldDrop) {
+                const dropSpinner = createSpinner(`Dropping old database "${oldName}"...`);
+                dropSpinner.start();
+                try {
+                    await engine.terminateConnections(config, oldName);
+                    await engine.dropDatabase(config, oldName);
+                    dropSpinner.succeed(`Dropped old database "${oldName}"`);
+                    dropSucceeded = true;
+                }
+                catch (error) {
+                    dropSpinner.warn(`Could not drop "${oldName}": ${error.message}`);
+                    // Non-fatal — data is safely in new database
+                }
+            }
+            else {
+                console.log(chalk.gray(`  Kept "${oldName}" — both databases now exist.`));
+            }
+        }
+        // Update tracking
+        await updateRenameTracking(containerName, oldName, newName, {
+            shouldDrop: dropSucceeded,
+            isPrimaryRename,
+        });
+        // Summary
+        const connectionString = engine.getConnectionString({ ...config, database: newName }, newName);
+        console.log();
+        console.log(uiSuccess(`Renamed "${oldName}" → "${newName}"`));
+        console.log();
+        console.log(chalk.gray('  Connection:'), chalk.cyan(connectionString));
+        if (backupPath) {
+            console.log(chalk.gray('  Backup:    '), chalk.white(backupPath));
+        }
+        if (isPrimaryRename) {
+            console.log(chalk.gray(`  Default database updated to "${newName}".`));
+        }
+    }
+    catch (error) {
+        console.log(uiError(error.message));
+    }
+    await pressEnterToContinue();
+}
+async function handleDropDatabase(containerName, targetDatabase) {
+    const config = await containerManager.getConfig(containerName);
+    if (!config) {
+        console.log(uiError(`Container "${containerName}" not found`));
+        await pressEnterToContinue();
+        return;
+    }
+    const isRunning = await processManager.isRunning(containerName, {
+        engine: config.engine,
+    });
+    if (!isRunning) {
+        console.log(uiError(`Container "${containerName}" is not running. Start it first with: spindb start ${containerName}`));
+        await pressEnterToContinue();
+        return;
+    }
+    // Select database to drop — skip prompt if targetDatabase provided
+    let dbName;
+    if (targetDatabase) {
+        if (targetDatabase === config.database) {
+            console.log(uiError(`Cannot drop the default database. Use "spindb delete" to remove the container.`));
+            await pressEnterToContinue();
+            return;
+        }
+        dbName = targetDatabase;
+    }
+    else {
+        const rawDatabases = config.databases || [];
+        const trackedDatabases = [...new Set([config.database, ...rawDatabases])];
+        const droppable = trackedDatabases.filter((db) => db !== config.database);
+        if (droppable.length === 0) {
+            console.log(uiError(`No databases to drop. The default database cannot be dropped.`));
+            await pressEnterToContinue();
+            return;
+        }
+        try {
+            console.log(chalk.gray(`  Default database "${config.database}" is excluded — use "spindb delete" to remove the container.`));
+            const result = await escapeablePrompt([
+                {
+                    type: 'list',
+                    name: 'dbName',
+                    message: 'Select database to drop:',
+                    choices: droppable.map((db) => ({ name: db, value: db })),
+                },
+            ]);
+            dbName = result.dbName;
+        }
+        catch (error) {
+            if (error instanceof EscapeError)
+                return;
+            throw error;
+        }
+    }
+    // Confirm — Escape cancels
+    let confirm;
+    try {
+        confirm = await promptConfirm(`Drop database "${dbName}" from ${config.engine} container "${containerName}"? This cannot be undone.`, false);
+    }
+    catch (error) {
+        if (error instanceof EscapeError)
+            return;
+        throw error;
+    }
+    if (!confirm) {
+        console.log(chalk.gray('Cancelled.'));
+        await pressEnterToContinue();
+        return;
+    }
+    try {
+        const engine = getEngine(config.engine);
+        const spinner = createSpinner(`Dropping database "${dbName}" from "${containerName}"...`);
+        spinner.start();
+        try {
+            await engine.terminateConnections(config, dbName);
+            await engine.dropDatabase(config, dbName);
+            spinner.succeed(`Dropped database "${dbName}"`);
+        }
+        catch (error) {
+            spinner.fail(`Failed to drop database "${dbName}"`);
+            throw error;
+        }
+        await containerManager.removeDatabase(containerName, dbName);
+        console.log();
+        console.log(uiSuccess(`Database "${dbName}" dropped from "${containerName}"`));
+    }
+    catch (error) {
+        console.log(uiError(error.message));
+    }
+    await pressEnterToContinue();
+}
 //# sourceMappingURL=container-handlers.js.map