spindb 0.37.2 → 0.38.0

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

@@ -0,0 +1,1202 @@
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { existsSync } from 'fs';
+import { rm, mkdir } from 'fs/promises';
+import { join } from 'path';
+import { tmpdir } 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 { getEngine } from '../../../engines/index.js';
+import { defaults } from '../../../config/defaults.js';
+import { getBackupExtension, getBackupSpinnerLabel, getDefaultFormat, } from '../../../config/backup-formats.js';
+import { generateBackupTimestamp, estimateBackupSize, checkBackupSize, } from '../../../core/backup-restore.js';
+import { promptCreateOptions, promptContainerName, promptContainerSelect, promptDatabaseName, promptDatabaseSelect, promptBackupFormat, promptBackupFilename, promptBackupDirectory, promptInstallDependencies, promptConfirm, escapeablePrompt, filterableListPrompt, BACK_VALUE, MAIN_MENU_VALUE, ESCAPE_VALUE, } from '../../ui/prompts.js';
+import { createSpinner } from '../../ui/spinner.js';
+import { header, uiSuccess, uiError, uiWarning, connectionBox, formatBytes, } from '../../ui/theme.js';
+import { getEngineIcon, getPageSize } from '../../constants.js';
+import { Engine, assertExhaustive } from '../../../types/index.js';
+import { pressEnterToContinue } from './shared.js';
+import { SpinDBError, ErrorCodes } from '../../../core/error-handler.js';
+import { validateTypedbConnectionString } from './validators.js';
+// Strip surrounding quotes from paths (handles drag-and-drop paths)
+function stripQuotes(path) {
+    return path.replace(/^['"]|['"]$/g, '').trim();
+}
+/**
+ * Mask the password portion of a connection string for display.
+ * Example: postgresql://user:secretpass@host:5432/db → postgresql://user:****@host:5432/db
+ * Handles passwords containing '@' characters by using URL parsing.
+ */
+function maskConnectionStringPassword(connectionString) {
+    if (!connectionString)
+        return connectionString;
+    try {
+        // Use URL constructor for robust parsing (handles @ in passwords)
+        const url = new URL(connectionString);
+        if (url.password) {
+            url.password = '****';
+            return url.toString();
+        }
+        return connectionString;
+    }
+    catch {
+        // Fallback for malformed URLs - use greedy regex that captures everything up to last @
+        try {
+            return connectionString.replace(/^([a-z+]+:\/\/[^:]*:)(.+)(@[^@]+)$/i, (_, prefix, _password, suffix) => `${prefix}****${suffix}`);
+        }
+        catch {
+            return connectionString;
+        }
+    }
+}
+/**
+ * Validate a connection string for the given engine.
+ * Returns true if valid, or an error message string if invalid.
+ *
+ * Empty input is intentionally allowed (returns true) to support the
+ * "press Enter to go back" UX pattern. Callers must check for empty
+ * input after the prompt returns (e.g., `if (!connectionString.trim()) return`).
+ */
+function validateConnectionString(input, engine) {
+    // Allow empty input for "press Enter to go back" UX - callers handle this case
+    if (!input)
+        return true;
+    switch (engine) {
+        case Engine.PostgreSQL:
+            if (!input.startsWith('postgresql://') &&
+                !input.startsWith('postgres://')) {
+                return 'Connection string must start with postgresql:// or postgres://';
+            }
+            break;
+        case Engine.MySQL:
+            if (!input.startsWith('mysql://')) {
+                return 'Connection string must start with mysql://';
+            }
+            break;
+        case Engine.MariaDB:
+            if (!input.startsWith('mysql://') && !input.startsWith('mariadb://')) {
+                return 'Connection string must start with mysql:// or mariadb://';
+            }
+            break;
+        case Engine.MongoDB:
+        case Engine.FerretDB:
+            if (!input.startsWith('mongodb://') &&
+                !input.startsWith('mongodb+srv://')) {
+                return 'Connection string must start with mongodb:// or mongodb+srv://';
+            }
+            break;
+        case Engine.Redis:
+            if (!input.startsWith('redis://') && !input.startsWith('rediss://')) {
+                return 'Connection string must start with redis:// or rediss://';
+            }
+            break;
+        case Engine.Valkey:
+            if (!input.startsWith('redis://') &&
+                !input.startsWith('rediss://') &&
+                !input.startsWith('valkey://') &&
+                !input.startsWith('valkeys://')) {
+                return 'Connection string must start with redis://, rediss://, valkey://, or valkeys://';
+            }
+            break;
+        case Engine.ClickHouse:
+            if (!input.startsWith('clickhouse://') &&
+                !input.startsWith('http://') &&
+                !input.startsWith('https://')) {
+                return 'Connection string must start with clickhouse://, http://, or https://';
+            }
+            break;
+        case Engine.Qdrant:
+            if (!input.startsWith('qdrant://') &&
+                !input.startsWith('http://') &&
+                !input.startsWith('https://')) {
+                return 'Connection string must start with qdrant://, http://, or https://';
+            }
+            break;
+        case Engine.Meilisearch:
+            if (!input.startsWith('meilisearch://') &&
+                !input.startsWith('http://') &&
+                !input.startsWith('https://')) {
+                return 'Connection string must start with meilisearch://, http://, or https://';
+            }
+            break;
+        case Engine.CouchDB:
+            if (!input.startsWith('couchdb://') &&
+                !input.startsWith('http://') &&
+                !input.startsWith('https://')) {
+                return 'Connection string must start with couchdb://, http://, or https://';
+            }
+            break;
+        case Engine.CockroachDB:
+            if (!input.startsWith('postgresql://') &&
+                !input.startsWith('postgres://')) {
+                return 'Connection string must start with postgresql:// or postgres://';
+            }
+            break;
+        case Engine.SurrealDB:
+            if (!input.startsWith('surrealdb://') &&
+                !input.startsWith('ws://') &&
+                !input.startsWith('wss://') &&
+                !input.startsWith('http://') &&
+                !input.startsWith('https://')) {
+                return 'Connection string must start with surrealdb://, ws://, wss://, http://, or https://';
+            }
+            break;
+        case Engine.QuestDB:
+            // QuestDB uses PostgreSQL wire protocol
+            if (!input.startsWith('postgresql://') &&
+                !input.startsWith('postgres://')) {
+                return 'Connection string must start with postgresql:// or postgres://';
+            }
+            break;
+        case Engine.TypeDB:
+            {
+                const typedbError = validateTypedbConnectionString(input);
+                if (typedbError)
+                    return typedbError;
+            }
+            break;
+        case Engine.InfluxDB:
+            if (!input.startsWith('influxdb://') &&
+                !input.startsWith('http://') &&
+                !input.startsWith('https://')) {
+                return 'Connection string must start with influxdb://, http://, or https://';
+            }
+            break;
+        case Engine.Weaviate:
+            if (!input.startsWith('http://') && !input.startsWith('https://')) {
+                return 'Connection string must start with http:// or https://';
+            }
+            break;
+        case Engine.TigerBeetle:
+            return 'TigerBeetle does not support remote dumps (custom binary protocol)';
+        case Engine.SQLite:
+        case Engine.DuckDB:
+            return 'File-based engines do not support remote connection strings';
+        default:
+            assertExhaustive(engine);
+    }
+    return true;
+}
+/**
+ * Prompt for a connection string with validation and password masking.
+ * Shows a hint about pressing Enter to go back and Escape for main menu.
+ *
+ * @param engine - The database engine for connection string validation
+ * @returns The connection string, or null if empty/escaped
+ */
+async function promptConnectionString(engine) {
+    console.log(chalk.gray('  Enter connection string, or press Enter to go back (esc - main menu)'));
+    const { connectionString } = await escapeablePrompt([
+        {
+            type: 'input',
+            name: 'connectionString',
+            message: 'Connection string:',
+            transformer: (input) => maskConnectionStringPassword(input.trim()),
+            validate: (input) => validateConnectionString(input.trim(), engine),
+        },
+    ]);
+    const trimmed = connectionString.trim();
+    return trimmed || null;
+}
+export async function handleCreateForRestore() {
+    console.log();
+    const answers = await promptCreateOptions();
+    let { name: containerName } = answers;
+    const { engine, version, port, database } = answers;
+    console.log();
+    console.log(header('Creating Database Container'));
+    console.log();
+    const dbEngine = getEngine(engine);
+    const portAvailable = await portManager.isPortAvailable(port);
+    if (!portAvailable) {
+        console.log(uiError(`Port ${port} is in use. Please choose a different port.`));
+        return null;
+    }
+    const binarySpinner = createSpinner(`Checking ${dbEngine.displayName} ${version} binaries...`);
+    binarySpinner.start();
+    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`);
+    }
+    while (await containerManager.exists(containerName)) {
+        console.log(chalk.yellow(`  Container "${containerName}" already exists.`));
+        containerName = await promptContainerName();
+    }
+    const createSpinnerInstance = createSpinner('Creating container...');
+    createSpinnerInstance.start();
+    await containerManager.create(containerName, {
+        engine: dbEngine.name,
+        version,
+        port,
+        database,
+    });
+    createSpinnerInstance.succeed('Container created');
+    const initSpinner = createSpinner('Initializing database cluster...');
+    initSpinner.start();
+    await dbEngine.initDataDir(containerName, version, {
+        superuser: defaults.superuser,
+    });
+    initSpinner.succeed('Database cluster initialized');
+    const startSpinner = createSpinner(`Starting ${dbEngine.displayName}...`);
+    startSpinner.start();
+    const config = await containerManager.getConfig(containerName);
+    if (!config) {
+        startSpinner.fail('Failed to get container config');
+        return null;
+    }
+    await dbEngine.start(config);
+    await containerManager.updateConfig(containerName, { status: 'running' });
+    startSpinner.succeed(`${dbEngine.displayName} started`);
+    if (database !== 'postgres') {
+        const dbSpinner = createSpinner(`Creating database "${database}"...`);
+        dbSpinner.start();
+        await dbEngine.createDatabase(config, database);
+        dbSpinner.succeed(`Database "${database}" created`);
+    }
+    console.log();
+    console.log(uiSuccess('Container ready for restore'));
+    console.log();
+    return { name: containerName, config };
+}
+export async function handleRestore() {
+    // Use a loop instead of recursion for "back" navigation
+    while (true) {
+        const containers = await containerManager.list();
+        const running = containers.filter((c) => c.status === 'running');
+        // Build filterable container choices
+        const containerChoices = running.map((c) => ({
+            name: `${c.name} ${chalk.gray(`(${getEngineIcon(c.engine)}${c.engine} ${c.version}, port ${c.port})`)} ${chalk.green('● running')}`,
+            value: c.name,
+            short: c.name,
+        }));
+        // Build footer with action and navigation options
+        const footerChoices = [
+            new inquirer.Separator(),
+            {
+                name: `${chalk.green('➕')} Create new container`,
+                value: '__create_new__',
+                short: 'Create new',
+            },
+            new inquirer.Separator(),
+            { name: `${chalk.blue('←')} Back`, value: BACK_VALUE },
+            {
+                name: `${chalk.blue('⌂')} Back to main menu ${chalk.gray('(esc)')}`,
+                value: MAIN_MENU_VALUE,
+            },
+            new inquirer.Separator(),
+        ];
+        const allChoices = [...containerChoices, ...footerChoices];
+        const selectedContainer = await filterableListPrompt(allChoices, 'Select container to restore to:', {
+            filterableCount: containerChoices.length,
+            pageSize: getPageSize(),
+            emptyText: 'No containers match filter',
+        });
+        // Handle navigation (including escape)
+        if (selectedContainer === ESCAPE_VALUE ||
+            selectedContainer === BACK_VALUE ||
+            selectedContainer === MAIN_MENU_VALUE) {
+            return;
+        }
+        let containerName;
+        let config;
+        if (selectedContainer === '__create_new__') {
+            const createResult = await handleCreateForRestore();
+            if (!createResult)
+                return;
+            containerName = createResult.name;
+            config = createResult.config;
+        }
+        else {
+            containerName = selectedContainer;
+            config = await containerManager.getConfig(containerName);
+            if (!config) {
+                console.error(uiError(`Container "${containerName}" not found`));
+                return;
+            }
+        }
+        const depsSpinner = createSpinner('Checking required tools...');
+        depsSpinner.start();
+        let missingDeps = await getMissingDependencies(config.engine);
+        if (missingDeps.length > 0) {
+            depsSpinner.warn(`Missing tools: ${missingDeps.map((d) => d.name).join(', ')}`);
+            const installed = await promptInstallDependencies(missingDeps[0].binary, config.engine);
+            if (!installed) {
+                return;
+            }
+            missingDeps = await getMissingDependencies(config.engine);
+            if (missingDeps.length > 0) {
+                console.log(uiError(`Still missing tools: ${missingDeps.map((d) => d.name).join(', ')}`));
+                return;
+            }
+            console.log(chalk.green('  ✓ All required tools are now available'));
+            console.log();
+        }
+        else {
+            depsSpinner.succeed('Required tools available');
+        }
+        // All engines now support dumpFromConnectionString
+        const restoreChoices = [
+            {
+                name: `${chalk.magenta('☰')} Dump file (drag and drop or enter path)`,
+                value: 'file',
+            },
+        ];
+        restoreChoices.push({
+            name: `${chalk.cyan('↗')} Connection string ${chalk.gray('(pull from remote database)')}`,
+            value: 'connection',
+        });
+        restoreChoices.push(new inquirer.Separator(), {
+            name: `${chalk.blue('←')} Back`,
+            value: '__back__',
+        });
+        const { restoreSource } = await escapeablePrompt([
+            {
+                type: 'list',
+                name: 'restoreSource',
+                message: 'Restore from:',
+                choices: restoreChoices,
+            },
+        ]);
+        if (restoreSource === '__back__') {
+            continue; // Go back to container selection
+        }
+        let backupPath = '';
+        let isTempFile = false;
+        if (restoreSource === 'connection') {
+            const connectionString = await promptConnectionString(config.engine);
+            if (!connectionString) {
+                continue; // Return to container selection
+            }
+            const engine = getEngine(config.engine);
+            const timestamp = Date.now();
+            const defaultFormat = getDefaultFormat(config.engine);
+            const dumpExtension = getBackupExtension(config.engine, defaultFormat);
+            const tempDumpPath = join(tmpdir(), `spindb-dump-${timestamp}${dumpExtension}`);
+            let dumpSuccess = false;
+            let attempts = 0;
+            const maxAttempts = 2;
+            while (!dumpSuccess && attempts < maxAttempts) {
+                attempts++;
+                const dumpSpinner = createSpinner('Creating dump from remote database...');
+                dumpSpinner.start();
+                try {
+                    const dumpResult = await engine.dumpFromConnectionString(connectionString, tempDumpPath);
+                    dumpSpinner.succeed('Dump created from remote database');
+                    if (dumpResult.warnings?.length) {
+                        for (const warning of dumpResult.warnings) {
+                            console.log(chalk.yellow(`  ${warning}`));
+                        }
+                    }
+                    backupPath = tempDumpPath;
+                    isTempFile = true;
+                    dumpSuccess = true;
+                }
+                catch (error) {
+                    const e = error;
+                    dumpSpinner.fail('Failed to create dump');
+                    // Handle version mismatch errors with helpful message
+                    if (e instanceof SpinDBError &&
+                        e.code === ErrorCodes.VERSION_MISMATCH) {
+                        console.log();
+                        console.log(uiError('PostgreSQL version mismatch:'));
+                        console.log(chalk.gray(`  ${e.message}`));
+                        if (e.suggestion) {
+                            console.log();
+                            console.log(uiWarning('To fix this:'));
+                            console.log(chalk.yellow(`  ${e.suggestion}`));
+                        }
+                        console.log();
+                        try {
+                            await rm(tempDumpPath, { force: true });
+                        }
+                        catch {
+                            // Ignore cleanup errors
+                        }
+                        await pressEnterToContinue();
+                        return;
+                    }
+                    // Handle connection errors
+                    if (e instanceof SpinDBError &&
+                        e.code === ErrorCodes.CONNECTION_FAILED) {
+                        console.log();
+                        console.log(uiError('Connection failed:'));
+                        console.log(chalk.gray(`  ${e.message}`));
+                        if (e.suggestion) {
+                            console.log(chalk.yellow(`  ${e.suggestion}`));
+                        }
+                        console.log();
+                        await pressEnterToContinue();
+                        return;
+                    }
+                    // Handle missing tool errors
+                    if (e.message.includes('pg_dump not found') ||
+                        e.message.includes('mysqldump not found') ||
+                        e.message.includes('ENOENT')) {
+                        const missingTool = e.message.includes('mysqldump')
+                            ? 'mysqldump'
+                            : 'pg_dump';
+                        const toolEngine = missingTool === 'mysqldump' ? 'mysql' : 'postgresql';
+                        const installed = await promptInstallDependencies(missingTool, toolEngine);
+                        if (installed) {
+                            // Installation counts toward maxAttempts - retry with newly installed tools
+                            continue;
+                        }
+                    }
+                    else {
+                        const dumpTool = config.engine === 'mysql' ? 'mysqldump' : 'pg_dump';
+                        console.log();
+                        console.log(uiError(`${dumpTool} error:`));
+                        console.log(chalk.gray(`  ${e.message}`));
+                        console.log();
+                    }
+                    try {
+                        await rm(tempDumpPath, { force: true });
+                    }
+                    catch {
+                        // Ignore cleanup errors
+                    }
+                    await pressEnterToContinue();
+                    return;
+                }
+            }
+            if (!dumpSuccess) {
+                console.log(uiError('Failed to create dump after retries'));
+                return;
+            }
+        }
+        else {
+            console.log(chalk.gray('  Drag & drop, enter path (abs or rel), or press Enter to go back (esc - main menu)'));
+            const { backupPath: rawBackupPath } = await escapeablePrompt([
+                {
+                    type: 'input',
+                    name: 'backupPath',
+                    message: 'Backup file path:',
+                    validate: (input) => {
+                        if (!input)
+                            return true;
+                        const cleanPath = stripQuotes(input);
+                        if (!existsSync(cleanPath))
+                            return 'File not found';
+                        return true;
+                    },
+                },
+            ]);
+            if (!rawBackupPath.trim()) {
+                continue; // Return to container selection
+            }
+            backupPath = stripQuotes(rawBackupPath);
+        }
+        const engine = getEngine(config.engine);
+        // Get existing databases in this container
+        const existingDatabases = config.databases || [config.database];
+        // Redis uses numbered databases 0-15, so "create new" doesn't apply
+        const isRedis = config.engine === 'redis';
+        let restoreMode;
+        if (isRedis) {
+            // Redis: Always restore to existing database (0-15)
+            restoreMode = 'replace';
+        }
+        else {
+            const result = await escapeablePrompt([
+                {
+                    type: 'list',
+                    name: 'restoreMode',
+                    message: 'How would you like to restore?',
+                    choices: [
+                        {
+                            name: `${chalk.green('➕')} Create new database ${chalk.gray('(keeps existing databases intact)')}`,
+                            value: 'new',
+                        },
+                        {
+                            name: `${chalk.yellow('↻')} Replace existing database ${chalk.gray('(overwrites data)')}`,
+                            value: 'replace',
+                            disabled: existingDatabases.length === 0
+                                ? 'No existing databases'
+                                : false,
+                        },
+                        new inquirer.Separator(),
+                        {
+                            name: `${chalk.blue('←')} Back`,
+                            value: '__back__',
+                        },
+                    ],
+                },
+            ]);
+            restoreMode = result.restoreMode;
+        }
+        if (restoreMode === '__back__') {
+            continue; // Return to container selection
+        }
+        let databaseName;
+        if (restoreMode === 'new') {
+            // Show existing databases for context
+            if (existingDatabases.length > 0) {
+                console.log();
+                console.log(chalk.gray('  Existing databases in this container:'));
+                for (const db of existingDatabases) {
+                    console.log(chalk.gray(`    • ${db}`));
+                }
+                console.log();
+            }
+            // Prompt for new database name (must not already exist)
+            const result = await promptDatabaseName(containerName, config.engine, {
+                allowBack: true,
+                existingDatabases,
+                disallowExisting: true,
+            });
+            if (result === null) {
+                continue; // Return to container selection
+            }
+            databaseName = result;
+        }
+        else {
+            // Replace existing database - show selection
+            if (existingDatabases.length === 1) {
+                databaseName = existingDatabases[0];
+            }
+            else {
+                const result = await promptDatabaseSelect(existingDatabases, 'Select database to replace:', { includeBack: true });
+                if (result === null) {
+                    continue; // Return to container selection
+                }
+                databaseName = result;
+            }
+            // Confirm overwrite
+            const confirmed = await promptConfirm(`This will overwrite all data in "${databaseName}". Continue?`, false);
+            if (!confirmed) {
+                continue; // Return to container selection
+            }
+            // Redis doesn't need drop/create - databases 0-15 always exist
+            if (!isRedis) {
+                // Drop the existing database before restore
+                console.log();
+                const dropSpinner = createSpinner(`Dropping existing database "${databaseName}"...`);
+                dropSpinner.start();
+                try {
+                    await engine.dropDatabase(config, databaseName);
+                    dropSpinner.succeed(`Dropped database "${databaseName}"`);
+                }
+                catch (error) {
+                    dropSpinner.fail(`Failed to drop database "${databaseName}"`);
+                    console.log(uiError(error.message));
+                    await pressEnterToContinue();
+                    return;
+                }
+            }
+        }
+        const detectSpinner = createSpinner('Detecting backup format...');
+        detectSpinner.start();
+        const format = await engine.detectBackupFormat(backupPath);
+        detectSpinner.succeed(`Detected: ${format.description}`);
+        // For Redis .redis text files, ask about merge vs replace behavior
+        let flushBeforeRestore = false;
+        if (isRedis && format.format === 'redis') {
+            const { restoreBehavior } = await escapeablePrompt([
+                {
+                    type: 'list',
+                    name: 'restoreBehavior',
+                    message: 'How should existing data be handled?',
+                    choices: [
+                        {
+                            name: `${chalk.yellow('↻')} Replace all ${chalk.gray('(FLUSHDB - clear database first)')}`,
+                            value: 'replace',
+                        },
+                        {
+                            name: `${chalk.green('➕')} Merge ${chalk.gray('(add/update keys, keep others)')}`,
+                            value: 'merge',
+                        },
+                    ],
+                },
+            ]);
+            flushBeforeRestore = restoreBehavior === 'replace';
+        }
+        // Redis doesn't need createDatabase - databases 0-15 always exist
+        if (!isRedis) {
+            const dbSpinner = createSpinner(`Creating database "${databaseName}"...`);
+            dbSpinner.start();
+            await engine.createDatabase(config, databaseName);
+            dbSpinner.succeed(`Database "${databaseName}" ready`);
+        }
+        const restoreSpinner = createSpinner('Restoring backup...');
+        restoreSpinner.start();
+        const result = await engine.restore(config, backupPath, {
+            database: databaseName,
+            createDatabase: false,
+            flush: flushBeforeRestore,
+        });
+        if (result.code === 0) {
+            restoreSpinner.succeed('Backup restored successfully');
+        }
+        else {
+            const stderr = result.stderr || '';
+            if (stderr.includes('unsupported version') ||
+                stderr.includes('Archive version') ||
+                stderr.includes('too old')) {
+                restoreSpinner.fail('Version compatibility detected');
+                console.log();
+                console.log(uiError('PostgreSQL version incompatibility detected:'));
+                console.log(uiWarning('Your pg_restore version is too old for this backup file.'));
+                console.log(chalk.yellow('Cleaning up failed database...'));
+                try {
+                    await engine.dropDatabase(config, databaseName);
+                    console.log(chalk.gray(`✓ Removed database "${databaseName}"`));
+                }
+                catch {
+                    console.log(chalk.yellow(`Warning: Could not remove database "${databaseName}"`));
+                }
+                console.log();
+                const versionMatch = stderr.match(/PostgreSQL (\d+)/);
+                const requiredVersion = versionMatch ? versionMatch[1] : '17';
+                console.log(chalk.gray(`This backup was created with PostgreSQL ${requiredVersion}`));
+                console.log();
+                console.log();
+                console.log(uiWarning(`To restore this backup, download PostgreSQL ${requiredVersion} binaries:`));
+                console.log(chalk.cyan(`  spindb engines download postgresql ${requiredVersion}`));
+                console.log();
+                console.log(chalk.gray('Then create a new container with that version and try the restore again.'));
+                await pressEnterToContinue();
+                return;
+            }
+            else {
+                // Other restore errors - show warnings
+                restoreSpinner.warn('Restore completed with warnings');
+                if (result.stderr) {
+                    console.log();
+                    console.log(chalk.yellow('  Warnings/Errors:'));
+                    const lines = result.stderr.split('\n').filter((l) => l.trim());
+                    const displayLines = lines.slice(0, 20);
+                    for (const line of displayLines) {
+                        console.log(chalk.gray(`  ${line}`));
+                    }
+                    if (lines.length > 20) {
+                        console.log(chalk.gray(`  ... and ${lines.length - 20} more lines`));
+                    }
+                }
+            }
+        }
+        if (result.code === 0) {
+            const connectionString = engine.getConnectionString(config, databaseName);
+            console.log();
+            console.log(uiSuccess(`Database "${databaseName}" restored`));
+            console.log(chalk.gray('  Connection string:'));
+            console.log(chalk.cyan(`  ${connectionString}`));
+            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)'));
+            }
+            console.log();
+        }
+        if (isTempFile) {
+            try {
+                await rm(backupPath, { force: true });
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+        }
+        await pressEnterToContinue();
+        return; // Exit the wizard loop after successful restore
+    }
+}
+/**
+ * Shared backup flow for both main menu and container submenu
+ * Reduces code duplication between handleBackup and handleBackupForContainer
+ *
+ * @param containerName - The container to backup
+ * @param database - Optional database name (skips database selection if provided)
+ */
+async function performBackupFlow(containerName, database) {
+    const config = await containerManager.getConfig(containerName);
+    if (!config) {
+        console.log(uiError(`Container "${containerName}" not found`));
+        return;
+    }
+    const engine = getEngine(config.engine);
+    // Check dependencies
+    const depsSpinner = createSpinner('Checking required tools...');
+    depsSpinner.start();
+    let missingDeps = await getMissingDependencies(config.engine);
+    if (missingDeps.length > 0) {
+        depsSpinner.warn(`Missing tools: ${missingDeps.map((d) => d.name).join(', ')}`);
+        const installed = await promptInstallDependencies(missingDeps[0].binary, config.engine);
+        if (!installed) {
+            return;
+        }
+        missingDeps = await getMissingDependencies(config.engine);
+        if (missingDeps.length > 0) {
+            console.log(uiError(`Still missing tools: ${missingDeps.map((d) => d.name).join(', ')}`));
+            return;
+        }
+        console.log(chalk.green('  ✓ All required tools are now available'));
+        console.log();
+    }
+    else {
+        depsSpinner.succeed('Required tools available');
+    }
+    // Use provided database or select from available databases
+    const databases = config.databases || [config.database];
+    let databaseName;
+    if (database) {
+        // Use the pre-selected database from the container submenu
+        databaseName = database;
+    }
+    else if (databases.length > 1) {
+        databaseName = await promptDatabaseSelect(databases, 'Select database to backup:');
+    }
+    else {
+        databaseName = databases[0];
+    }
+    // Show estimated size
+    const estimatedSize = await estimateBackupSize(config);
+    if (estimatedSize !== null) {
+        console.log(chalk.gray(`  Estimated database size: ${formatBytes(estimatedSize)}`));
+        console.log();
+    }
+    // Select format
+    const format = await promptBackupFormat(config.engine);
+    // Select output directory
+    const outputDir = await promptBackupDirectory();
+    if (!outputDir)
+        return;
+    // Ensure directory exists
+    if (!existsSync(outputDir)) {
+        await mkdir(outputDir, { recursive: true });
+    }
+    // Get filename
+    const defaultFilename = `${containerName}-${databaseName}-backup-${generateBackupTimestamp()}`;
+    const filename = await promptBackupFilename(defaultFilename);
+    const extension = getBackupExtension(config.engine, format);
+    const outputPath = join(outputDir, `${filename}${extension}`);
+    const spinnerLabel = getBackupSpinnerLabel(config.engine, format);
+    const backupSpinner = createSpinner(`Creating ${spinnerLabel} backup of "${databaseName}"...`);
+    backupSpinner.start();
+    try {
+        const result = await engine.backup(config, outputPath, {
+            database: databaseName,
+            format,
+        });
+        backupSpinner.succeed('Backup created successfully');
+        console.log();
+        console.log(uiSuccess('Backup complete'));
+        console.log();
+        console.log(chalk.gray('  Saved to:'), chalk.cyan(result.path));
+        console.log(chalk.gray('  Size:'), chalk.white(formatBytes(result.size)));
+        console.log(chalk.gray('  Format:'), chalk.white(result.format));
+        console.log();
+    }
+    catch (error) {
+        const e = error;
+        backupSpinner.fail('Backup failed');
+        console.log();
+        console.log(uiError(e.message));
+        console.log();
+    }
+}
+export async function handleBackup() {
+    const containers = await containerManager.list();
+    const running = containers.filter((c) => c.status === 'running');
+    if (running.length === 0) {
+        console.log(uiWarning('No running containers. Start a container first.'));
+        await pressEnterToContinue();
+        return;
+    }
+    const containerName = await promptContainerSelect(running, 'Select container to backup:', { includeBack: true });
+    if (!containerName)
+        return;
+    await performBackupFlow(containerName);
+    await pressEnterToContinue();
+}
+/**
+ * Handle backup for a specific container (used from container submenu)
+ * Skips container selection since we already know which container
+ */
+export async function handleBackupForContainer(containerName, database) {
+    await performBackupFlow(containerName, database);
+    await pressEnterToContinue();
+}
+/**
+ * Handle restore for a specific container (used from container submenu)
+ * Skips container selection since we already know which container
+ *
+ * @param containerName - The container to restore to
+ * @param database - Optional database name (pre-selects target database if provided)
+ */
+export async function handleRestoreForContainer(containerName, database) {
+    const config = await containerManager.getConfig(containerName);
+    if (!config) {
+        console.log(uiError(`Container "${containerName}" not found`));
+        await pressEnterToContinue();
+        return;
+    }
+    const engine = getEngine(config.engine);
+    // Check dependencies
+    const depsSpinner = createSpinner('Checking required tools...');
+    depsSpinner.start();
+    let missingDeps = await getMissingDependencies(config.engine);
+    if (missingDeps.length > 0) {
+        depsSpinner.warn(`Missing tools: ${missingDeps.map((d) => d.name).join(', ')}`);
+        const installed = await promptInstallDependencies(missingDeps[0].binary, config.engine);
+        if (!installed) {
+            return;
+        }
+        missingDeps = await getMissingDependencies(config.engine);
+        if (missingDeps.length > 0) {
+            console.log(uiError(`Still missing tools: ${missingDeps.map((d) => d.name).join(', ')}`));
+            return;
+        }
+        console.log(chalk.green('  ✓ All required tools are now available'));
+        console.log();
+    }
+    else {
+        depsSpinner.succeed('Required tools available');
+    }
+    // Restore source selection (file or connection string)
+    // All engines now support dumpFromConnectionString
+    const restoreChoices = [
+        {
+            name: `${chalk.magenta('☰')} Dump file (drag and drop or enter path)`,
+            value: 'file',
+        },
+        {
+            name: `${chalk.cyan('↗')} Connection string ${chalk.gray('(pull from remote database)')}`,
+            value: 'connection',
+        },
+    ];
+    restoreChoices.push(new inquirer.Separator(), {
+        name: `${chalk.blue('←')} Back`,
+        value: '__back__',
+    });
+    const { restoreSource } = await escapeablePrompt([
+        {
+            type: 'list',
+            name: 'restoreSource',
+            message: 'Restore from:',
+            choices: restoreChoices,
+        },
+    ]);
+    if (restoreSource === '__back__') {
+        return;
+    }
+    let backupPath = '';
+    let isTempFile = false;
+    if (restoreSource === 'connection') {
+        const connectionString = await promptConnectionString(config.engine);
+        if (!connectionString) {
+            return;
+        }
+        const timestamp = Date.now();
+        const defaultFormat = getDefaultFormat(config.engine);
+        const dumpExtension = getBackupExtension(config.engine, defaultFormat);
+        const tempDumpPath = join(tmpdir(), `spindb-dump-${timestamp}${dumpExtension}`);
+        const dumpSpinner = createSpinner('Creating dump from remote database...');
+        dumpSpinner.start();
+        try {
+            const dumpResult = await engine.dumpFromConnectionString(connectionString, tempDumpPath);
+            dumpSpinner.succeed('Dump created from remote database');
+            if (dumpResult.warnings?.length) {
+                for (const warning of dumpResult.warnings) {
+                    console.log(chalk.yellow(`  ${warning}`));
+                }
+            }
+            backupPath = tempDumpPath;
+            isTempFile = true;
+        }
+        catch (error) {
+            const e = error;
+            dumpSpinner.fail('Failed to create dump');
+            console.log(uiError(e.message));
+            await pressEnterToContinue();
+            return;
+        }
+    }
+    else {
+        // Handle file restore
+        console.log(chalk.gray('  Drag & drop, enter path (abs or rel), or press Enter to go back (esc - main menu)'));
+        const { backupPath: rawBackupPath } = await escapeablePrompt([
+            {
+                type: 'input',
+                name: 'backupPath',
+                message: 'Backup file path:',
+                validate: (input) => {
+                    if (!input)
+                        return true;
+                    const cleanPath = stripQuotes(input);
+                    if (!existsSync(cleanPath))
+                        return 'File not found';
+                    return true;
+                },
+            },
+        ]);
+        if (!rawBackupPath.trim()) {
+            return;
+        }
+        backupPath = stripQuotes(rawBackupPath);
+    }
+    // Check backup file size and warn if large
+    const sizeCheck = checkBackupSize(backupPath);
+    if (sizeCheck.level === 'very_large') {
+        console.log();
+        console.log(chalk.yellow(`  ⚠ Large backup file: ${formatBytes(sizeCheck.size)}`));
+        console.log(chalk.gray('  This restore may take a while.'));
+        console.log();
+        const confirmed = await promptConfirm('Continue with restore?', true);
+        if (!confirmed) {
+            if (isTempFile) {
+                await rm(backupPath, { force: true }).catch(() => { });
+            }
+            return;
+        }
+    }
+    else if (sizeCheck.level === 'large') {
+        console.log(chalk.gray(`  Backup file size: ${formatBytes(sizeCheck.size)}`));
+    }
+    // Detect backup format
+    const format = await engine.detectBackupFormat(backupPath);
+    console.log(chalk.gray(`  Detected format: ${format.description}`));
+    console.log();
+    // Get existing databases in this container
+    const existingDatabases = config.databases || [config.database];
+    // Redis uses numbered databases 0-15, so "create new" doesn't apply
+    const isRedis = config.engine === 'redis';
+    let restoreMode;
+    if (isRedis) {
+        // Redis: Always restore to existing database (0-15)
+        restoreMode = 'replace';
+    }
+    else {
+        const result = await escapeablePrompt([
+            {
+                type: 'list',
+                name: 'restoreMode',
+                message: 'How would you like to restore?',
+                choices: [
+                    {
+                        name: `${chalk.green('➕')} Create new database ${chalk.gray('(keeps existing databases intact)')}`,
+                        value: 'new',
+                    },
+                    {
+                        name: `${chalk.yellow('↻')} Replace existing database ${chalk.gray('(overwrites data)')}`,
+                        value: 'replace',
+                        disabled: existingDatabases.length === 0 ? 'No existing databases' : false,
+                    },
+                    new inquirer.Separator(),
+                    {
+                        name: `${chalk.blue('←')} Back`,
+                        value: '__back__',
+                    },
+                ],
+            },
+        ]);
+        restoreMode = result.restoreMode;
+    }
+    if (restoreMode === '__back__') {
+        if (isTempFile) {
+            await rm(backupPath, { force: true }).catch(() => { });
+        }
+        return;
+    }
+    let databaseName;
+    if (restoreMode === 'new') {
+        // Show existing databases for context
+        if (existingDatabases.length > 0) {
+            console.log();
+            console.log(chalk.gray('  Existing databases in this container:'));
+            for (const db of existingDatabases) {
+                console.log(chalk.gray(`    • ${db}`));
+            }
+            console.log();
+        }
+        // Prompt for new database name
+        const result = await promptDatabaseName(containerName, config.engine, {
+            existingDatabases,
+        });
+        if (!result) {
+            if (isTempFile) {
+                await rm(backupPath, { force: true }).catch(() => { });
+            }
+            return;
+        }
+        databaseName = result;
+        // Create the new database
+        const createDbSpinner = createSpinner(`Creating database "${databaseName}"...`);
+        createDbSpinner.start();
+        try {
+            await engine.createDatabase(config, databaseName);
+            createDbSpinner.succeed(`Database "${databaseName}" created`);
+            // Update container config with new database
+            const updatedDbs = [...existingDatabases, databaseName];
+            await containerManager.updateConfig(containerName, {
+                databases: updatedDbs,
+            });
+        }
+        catch (error) {
+            const e = error;
+            createDbSpinner.fail('Failed to create database');
+            console.log(uiError(e.message));
+            if (isTempFile) {
+                await rm(backupPath, { force: true }).catch(() => { });
+            }
+            await pressEnterToContinue();
+            return;
+        }
+    }
+    else {
+        // Replace existing database - use pre-selected or auto-select if only one
+        if (database) {
+            // Use the pre-selected database from the container submenu
+            databaseName = database;
+            console.log(chalk.gray(`  Target database: ${databaseName}`));
+        }
+        else if (existingDatabases.length === 1) {
+            databaseName = existingDatabases[0];
+            console.log(chalk.gray(`  Using database: ${databaseName}`));
+        }
+        else {
+            const { database: selectedDb } = await escapeablePrompt([
+                {
+                    type: 'list',
+                    name: 'database',
+                    message: 'Select database to replace:',
+                    choices: existingDatabases.map((db) => ({ name: db, value: db })),
+                },
+            ]);
+            databaseName = selectedDb;
+        }
+    }
+    // For Redis .redis text files, ask about merge vs replace behavior
+    let flushBeforeRestore = false;
+    if (isRedis && format.format === 'redis') {
+        const { restoreBehavior } = await escapeablePrompt([
+            {
+                type: 'list',
+                name: 'restoreBehavior',
+                message: 'How should existing data be handled?',
+                choices: [
+                    {
+                        name: `${chalk.yellow('↻')} Replace all ${chalk.gray('(FLUSHDB - clear database first)')}`,
+                        value: 'replace',
+                    },
+                    {
+                        name: `${chalk.green('➕')} Merge ${chalk.gray('(add/update keys, keep others)')}`,
+                        value: 'merge',
+                    },
+                ],
+            },
+        ]);
+        flushBeforeRestore = restoreBehavior === 'replace';
+    }
+    // Perform restore
+    const restoreSpinner = createSpinner(`Restoring to "${databaseName}" in ${containerName}...`);
+    restoreSpinner.start();
+    try {
+        const result = await engine.restore(config, backupPath, {
+            database: databaseName,
+            flush: flushBeforeRestore,
+        });
+        if (result.code === 0) {
+            restoreSpinner.succeed('Restore completed successfully');
+            const connectionString = engine.getConnectionString(config, databaseName);
+            console.log();
+            console.log(uiSuccess(`Database "${databaseName}" restored`));
+            console.log(chalk.gray('  Connection string:'));
+            console.log(chalk.cyan(`  ${connectionString}`));
+            const copied = await platformService.copyToClipboard(connectionString);
+            if (copied) {
+                console.log(chalk.gray('  ✓ Connection string copied to clipboard'));
+            }
+            console.log();
+        }
+        else {
+            restoreSpinner.warn('Restore completed with warnings');
+            if (result.stderr) {
+                console.log();
+                console.log(chalk.yellow('  Warnings/Errors:'));
+                const lines = result.stderr.split('\n').filter((l) => l.trim());
+                const displayLines = lines.slice(0, 10);
+                for (const line of displayLines) {
+                    console.log(chalk.gray(`  ${line}`));
+                }
+                if (lines.length > 10) {
+                    console.log(chalk.gray(`  ... and ${lines.length - 10} more lines`));
+                }
+            }
+        }
+    }
+    catch (error) {
+        const e = error;
+        restoreSpinner.fail('Restore failed');
+        console.log();
+        console.log(uiError(e.message));
+        console.log();
+    }
+    await pressEnterToContinue();
+}
+export async function handleClone() {
+    const containers = await containerManager.list();
+    const stopped = containers.filter((c) => c.status !== 'running');
+    if (containers.length === 0) {
+        console.log(uiWarning('No containers found'));
+        return;
+    }
+    if (stopped.length === 0) {
+        console.log(uiWarning('All containers are running. Stop a container first to clone it.'));
+        return;
+    }
+    const sourceName = await promptContainerSelect(stopped, 'Select container to clone:', { includeBack: true });
+    if (!sourceName)
+        return;
+    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));
+    }
+    catch (error) {
+        const e = error;
+        spinner.fail(`Failed to clone "${sourceName}"`);
+        console.log(uiError(e.message));
+    }
+}
+//# sourceMappingURL=backup-handlers.js.map