smoonb 0.0.87 → 0.0.89

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smoonb",
-  "version": "0.0.87",
+  "version": "0.0.89",
   "description": "Complete Supabase backup and migration tool - EXPERIMENTAL VERSION - USE AT YOUR OWN RISK",
   "preferGlobal": false,
   "preventGlobalInstall": true,

package/src/commands/backup/index.js

@@ -9,18 +9,19 @@ const { saveEnvMap } = require('../../utils/envMap');
 const { mapEnvVariablesInteractively, askComponentsFlags } = require('../../interactive/envMapper');
 const { confirm } = require('../../utils/prompt');
 
-// Importar todas as etapas
+// Importar todas as etapas (arquivos 00..11)
 const step00DockerValidation = require('./steps/00-docker-validation');
-const step01Database = require('./steps/01-database');
-const step02DatabaseSeparated = require('./steps/02-database-separated');
-const step03DatabaseSettings = require('./steps/03-database-settings');
-const step04AuthSettings = require('./steps/04-auth-settings');
-const step05RealtimeSettings = require('./steps/05-realtime-settings');
-const step06Storage = require('./steps/06-storage');
-const step07CustomRoles = require('./steps/07-custom-roles');
-const step08EdgeFunctions = require('./steps/08-edge-functions');
-const step09SupabaseTemp = require('./steps/09-supabase-temp');
-const step10Migrations = require('./steps/10-migrations');
+const step01PostgresVersion = require('./steps/01-postgres-version');
+const step02Database = require('./steps/02-database');
+const step03DatabaseSeparated = require('./steps/03-database-separated');
+const step04DatabaseSettings = require('./steps/04-database-settings');
+const step05AuthSettings = require('./steps/05-auth-settings');
+const step06RealtimeSettings = require('./steps/06-realtime-settings');
+const step07Storage = require('./steps/07-storage');
+const step08CustomRoles = require('./steps/08-custom-roles');
+const step09EdgeFunctions = require('./steps/09-edge-functions');
+const step10SupabaseTemp = require('./steps/10-supabase-temp');
+const step11Migrations = require('./steps/11-migrations');
 
 // Exportar FUNÇÃO em vez de objeto Command
 module.exports = async (options) => {
@@ -218,21 +219,26 @@ module.exports = async (options) => {
     console.log(chalk.white(`🐳 ${getT('backup.start.docker')}`));
 
     // Contar etapas totais para numeração
-    // Etapas fixas: Database, Database Separado, Database Settings, Custom Roles (4)
+    // Etapas fixas: Postgres version, Database, Database Separado, Database Settings, Custom Roles (5)
     // Etapas condicionais: Auth, Realtime, Storage, Functions, Temp, Migrations
     let stepNumber = 0;
-    const totalSteps = 4 + (flags?.includeAuth ? 1 : 0) + (flags?.includeRealtime ? 1 : 0) + (flags?.includeStorage ? 1 : 0) + (flags?.includeFunctions ? 1 : 0) + (flags?.includeTemp ? 1 : 0) + (flags?.includeMigrations ? 1 : 0);
+    const totalSteps = 5 + (flags?.includeAuth ? 1 : 0) + (flags?.includeRealtime ? 1 : 0) + (flags?.includeStorage ? 1 : 0) + (flags?.includeFunctions ? 1 : 0) + (flags?.includeTemp ? 1 : 0) + (flags?.includeMigrations ? 1 : 0);
 
-    // 1. Backup Database via pg_dumpall Docker
+    // 1. Postgres version (detect + optional override)
+    stepNumber++;
+    console.log(chalk.blue(`\n📊 ${stepNumber}/${totalSteps} - ${getT('backup.steps.postgresVersion.title')}`));
+    await step01PostgresVersion(context);
+
+    // 2. Backup Database via pg_dumpall Docker
     stepNumber++;
     console.log(chalk.blue(`\n📊 ${stepNumber}/${totalSteps} - ${getT('backup.steps.database.title')}`));
-    const databaseResult = await step01Database(context);
+    const databaseResult = await step02Database(context);
     manifest.components.database = databaseResult;
 
-    // 2. Backup Database Separado
+    // 3. Backup Database Separado
     stepNumber++;
     console.log(chalk.blue(`\n📊 ${stepNumber}/${totalSteps} - ${getT('backup.steps.database.separated.title')}`));
-    const dbSeparatedResult = await step02DatabaseSeparated(context);
+    const dbSeparatedResult = await step03DatabaseSeparated(context);
     manifest.components.database_separated = {
       success: dbSeparatedResult.success,
       method: 'supabase-cli',
@@ -240,63 +246,63 @@ module.exports = async (options) => {
       total_size_kb: dbSeparatedResult.totalSizeKB || '0.0'
     };
 
-    // 3. Backup Database Settings
+    // 4. Backup Database Settings
     stepNumber++;
     console.log(chalk.blue(`\n🔧 ${stepNumber}/${totalSteps} - ${getT('backup.steps.databaseSettings.title')}`));
-    const databaseSettingsResult = await step03DatabaseSettings(context);
+    const databaseSettingsResult = await step04DatabaseSettings(context);
     manifest.components.database_settings = databaseSettingsResult;
 
-    // 4. Backup Auth Settings
+    // 5. Backup Auth Settings
     if (flags?.includeAuth) {
       stepNumber++;
       console.log(chalk.blue(`\n🔐 ${stepNumber}/${totalSteps} - ${getT('backup.steps.auth.title')}`));
-      const authResult = await step04AuthSettings(context);
+      const authResult = await step05AuthSettings(context);
       manifest.components.auth_settings = authResult;
     }
 
-    // 5. Backup Realtime Settings
+    // 6. Backup Realtime Settings
     if (flags?.includeRealtime) {
       stepNumber++;
       console.log(chalk.blue(`\n🔄 ${stepNumber}/${totalSteps} - ${getT('backup.steps.realtime.title')}`));
-      const realtimeResult = await step05RealtimeSettings(context);
+      const realtimeResult = await step06RealtimeSettings(context);
       manifest.components.realtime = realtimeResult;
     }
 
-    // 6. Backup Storage
+    // 7. Backup Storage
     if (flags?.includeStorage) {
       stepNumber++;
       console.log(chalk.blue(`\n📦 ${stepNumber}/${totalSteps} - ${getT('backup.steps.storage.title')}`));
-      const storageResult = await step06Storage(context);
+      const storageResult = await step07Storage(context);
       manifest.components.storage = storageResult;
     }
 
-    // 7. Backup Custom Roles
+    // 8. Backup Custom Roles
     stepNumber++;
     console.log(chalk.blue(`\n👥 ${stepNumber}/${totalSteps} - ${getT('backup.steps.roles.title')}`));
-    const rolesResult = await step07CustomRoles(context);
+    const rolesResult = await step08CustomRoles(context);
     manifest.components.custom_roles = rolesResult;
 
-    // 8. Backup Edge Functions
+    // 9. Backup Edge Functions
     if (flags?.includeFunctions) {
       stepNumber++;
       console.log(chalk.blue(`\n⚡ ${stepNumber}/${totalSteps} - ${getT('backup.steps.functions.title')}`));
-      const functionsResult = await step08EdgeFunctions(context);
+      const functionsResult = await step09EdgeFunctions(context);
       manifest.components.edge_functions = functionsResult;
     }
 
-    // 9. Backup Supabase .temp
+    // 10. Backup Supabase .temp
     if (flags?.includeTemp) {
       stepNumber++;
       console.log(chalk.blue(`\n📁 ${stepNumber}/${totalSteps} - ${getT('backup.steps.temp.title')}`));
-      const supabaseTempResult = await step09SupabaseTemp(context);
+      const supabaseTempResult = await step10SupabaseTemp(context);
       manifest.components.supabase_temp = supabaseTempResult;
     }
 
-    // 10. Backup Migrations
+    // 11. Backup Migrations
     if (flags?.includeMigrations) {
       stepNumber++;
       console.log(chalk.blue(`\n📋 ${stepNumber}/${totalSteps} - ${getT('backup.steps.migrations.title')}`));
-      const migrationsResult = await step10Migrations(context);
+      const migrationsResult = await step11Migrations(context);
       manifest.components.migrations = migrationsResult;
     }
 

package/src/commands/backup/steps/01-postgres-version.js

@@ -0,0 +1,54 @@
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const { getPostgresServerMajor } = require('../utils');
+const { t } = require('../../../i18n');
+
+const POSSIBLE_MAJORS = [15, 16, 17, 18];
+
+/**
+ * Step: Mostra a versão do Postgres detectada e permite ao usuário sobrescrever com um menu.
+ * Preenche context.postgresMajor para o step 02-database usar.
+ */
+module.exports = async (context) => {
+  const getT = global.smoonbI18n?.t || t;
+  const { databaseUrl } = context;
+
+  if (!databaseUrl) {
+    context.postgresMajor = 17;
+    return { success: true, postgresMajor: 17 };
+  }
+
+  let detectedMajor = null;
+  try {
+    detectedMajor = await getPostgresServerMajor(databaseUrl);
+  } catch (err) {
+    console.log(chalk.yellow(`   ⚠️ ${getT('backup.steps.postgresVersion.detectError', { message: err.message })}`));
+    console.log(chalk.white(`   - ${getT('backup.steps.postgresVersion.usingDefault')}`));
+    context.postgresMajor = 17;
+    return { success: true, postgresMajor: 17 };
+  }
+
+  const major = detectedMajor != null ? detectedMajor : 17;
+  const choices = [
+    { name: getT('backup.steps.postgresVersion.useDetected', { major, image: `postgres:${major}` }), value: major },
+    ...POSSIBLE_MAJORS.filter(m => m !== major).map(m => ({
+      name: `postgres:${m}`,
+      value: m
+    }))
+  ];
+
+  console.log(chalk.white(`   - ${getT('backup.steps.postgresVersion.found', { major, image: `postgres:${major}` })}`));
+  console.log(chalk.white(`   - ${getT('backup.steps.postgresVersion.proceedWith')}`));
+
+  const { postgresMajor } = await inquirer.prompt([{
+    type: 'list',
+    name: 'postgresMajor',
+    message: getT('backup.steps.postgresVersion.selectVersion'),
+    choices,
+    default: major
+  }]);
+
+  context.postgresMajor = postgresMajor;
+  console.log(chalk.green(`   ✅ ${getT('backup.steps.postgresVersion.selected', { image: `postgres:${postgresMajor}` })}`));
+  return { success: true, postgresMajor };
+};

package/src/commands/backup/steps/02-database.js

@@ -0,0 +1,365 @@
+const chalk = require('chalk');
+const path = require('path');
+const fs = require('fs').promises;
+const readline = require('readline');
+const { spawn } = require('child_process');
+const { t } = require('../../../i18n');
+const { getPostgresServerMajor } = require('../utils');
+
+const DUMP_SIZE_FACTOR_DEFAULT = 1.4;
+const BAR_WIDTH = 24;
+const EMA_ALPHA = 0.25;
+const ETA_MIN_TICKS = 4;
+const ESTIMATE_TIMEOUT_MS = 10000;
+
+function formatBytes(bytes) {
+  if (bytes === 0) return '0 B';
+  const k = 1024;
+  const sizes = ['B', 'KB', 'MB', 'GB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(2))} ${sizes[i]}`;
+}
+
+function formatDuration(ms) {
+  if (ms < 1000) return `${ms}ms`;
+  const s = Math.floor(ms / 1000);
+  const m = Math.floor(s / 60);
+  const h = Math.floor(m / 60);
+  if (h > 0) return `${h}h ${m % 60}m ${s % 60}s`;
+  if (m > 0) return `${m}m ${s % 60}s`;
+  return `${s}s`;
+}
+
+async function exists(filePath) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Estima tamanho total do cluster (soma dos bancos) via SQL. Timeout 10s; falha = null (fallback sem estimativa).
+ * @returns {Promise<number|null>} bytes ou null
+ */
+async function estimateClusterBytes({ postgresImage, username, password, host, port }) {
+  const query = "SELECT COALESCE(sum(pg_database_size(datname)),0) FROM pg_database WHERE datistemplate = false;";
+  const args = [
+    'run', '--rm', '--network', 'host',
+    '-e', `PGPASSWORD=${password}`,
+    postgresImage, 'psql',
+    '-h', host, '-p', port, '-U', username, '-d', 'postgres',
+    '-t', '-A', '-c', query
+  ];
+  return new Promise((resolve) => {
+    const proc = spawn('docker', args, { stdio: ['ignore', 'pipe', 'pipe'] });
+    let stdout = '';
+    let done = false;
+    const timeout = setTimeout(() => {
+      if (done) return;
+      done = true;
+      try { proc.kill('SIGKILL'); } catch { }
+      resolve(null); // timeout: seguir sem estimativa
+    }, ESTIMATE_TIMEOUT_MS);
+    proc.stdout.on('data', (chunk) => { stdout += chunk.toString(); });
+    proc.on('close', (code) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timeout);
+      if (code !== 0) {
+        resolve(null);
+        return;
+      }
+      const trimmed = stdout.trim();
+      const bytes = parseInt(trimmed, 10);
+      if (Number.isNaN(bytes) || bytes < 0) {
+        resolve(null);
+        return;
+      }
+      resolve(bytes);
+    });
+    proc.on('error', () => {
+      if (done) return;
+      done = true;
+      clearTimeout(timeout);
+      resolve(null);
+    });
+  });
+}
+
+/**
+ * Monta uma linha de progresso: barra opcional + tamanho, tempo, velocidade, ETA (quando estimado).
+ * percent/etaSeconds null = modo indeterminado (sem % nem ETA).
+ */
+function renderProgressLine({ percent, width, sizeBytes, elapsedMs, speedBps, etaSeconds, estimated, getT }) {
+  const sizeStr = formatBytes(sizeBytes);
+  const elapsedStr = formatDuration(elapsedMs);
+  const speedStr = formatBytes(Math.max(0, speedBps)) + '/s';
+  let bar = '';
+  if (estimated && percent != null && percent >= 0) {
+    const filled = Math.round((percent / 100) * width);
+    const n = Math.min(filled, width);
+    bar = `[${'#'.repeat(n)}${'-'.repeat(width - n)}] ${Math.min(99, Math.floor(percent))}% (~) `;
+  } else {
+    bar = '     … ';
+  }
+  let etaStr = '';
+  if (estimated && etaSeconds != null && etaSeconds > 0) {
+    const etaLabel = getT ? getT('backup.steps.database.progress.eta') : 'ETA';
+    etaStr = ` | ${etaLabel} ~${formatDuration(etaSeconds * 1000)}`;
+  }
+  return `     ${bar}| ${sizeStr} | ${elapsedStr} | ${speedStr}${etaStr}`;
+}
+
+/**
+ * Etapa 2: Backup Database via pg_dumpall Docker (idêntico ao Dashboard)
+ * Com feedback de progresso: tamanho do arquivo, velocidade e tempo decorrido.
+ * Usa context.postgresMajor (definido no step Postgres version) ou detecta se não definido.
+ */
+module.exports = async ({ databaseUrl, backupDir, postgresMajor: contextMajor }) => {
+  try {
+    const getT = global.smoonbI18n?.t || t;
+    console.log(chalk.white(`   - ${getT('backup.steps.database.creating')}`));
+
+    const urlMatch = databaseUrl.match(/postgresql:\/\/([^:]+):([^@]+)@([^:]+):(\d+)\/(.+)/);
+
+    if (!urlMatch) {
+      const getT = global.smoonbI18n?.t || t;
+      throw new Error(getT('error.databaseUrlInvalidSimple'));
+    }
+
+    const [, username, password, host, port] = urlMatch;
+
+    let postgresMajor = contextMajor;
+    if (postgresMajor == null && databaseUrl) {
+      try {
+        postgresMajor = await getPostgresServerMajor(databaseUrl);
+      } catch {
+        postgresMajor = 17;
+      }
+    }
+    if (postgresMajor == null) postgresMajor = 17;
+    const postgresImage = `postgres:${postgresMajor}`;
+    console.log(chalk.white(`   - ${getT('backup.steps.database.postgresImage', { image: postgresImage, major: postgresMajor })}`));
+
+    const now = new Date();
+    const day = String(now.getDate()).padStart(2, '0');
+    const month = String(now.getMonth() + 1).padStart(2, '0');
+    const year = now.getFullYear();
+    const hours = String(now.getHours()).padStart(2, '0');
+    const minutes = String(now.getMinutes()).padStart(2, '0');
+    const seconds = String(now.getSeconds()).padStart(2, '0');
+
+    const fileName = `db_cluster-${day}-${month}-${year}@${hours}-${minutes}-${seconds}.backup`;
+    const backupDirAbs = path.resolve(backupDir);
+    const outputPath = path.join(backupDirAbs, fileName);
+
+    // Estimativa opcional: tamanho do cluster * fator (dump lógico costuma ser maior). Falha = sem %/ETA.
+    let expectedBytes = null;
+    try {
+      const clusterBytes = await estimateClusterBytes({ postgresImage, username, password, host, port });
+      if (clusterBytes != null && clusterBytes > 0) {
+        const factor = parseFloat(process.env.SMOONB_DUMP_SIZE_FACTOR || '', 10) || DUMP_SIZE_FACTOR_DEFAULT;
+        expectedBytes = Math.floor(clusterBytes * factor);
+      }
+    } catch {
+      expectedBytes = null;
+    }
+
+    const dockerArgs = [
+      'run', '--rm', '--network', 'host',
+      '-v', `${backupDirAbs}:/host`,
+      '-e', `PGPASSWORD=${password}`,
+      postgresImage, 'pg_dumpall',
+      '-h', host,
+      '-p', port,
+      '-U', username,
+      '-f', `/host/${fileName}`
+    ];
+
+    console.log(chalk.white(`   - ${getT('backup.steps.database.executing')}`));
+
+    const startTime = Date.now();
+    let lastSize = 0;
+    let lastTime = startTime;
+    let ticker = null;
+    let tickCount = 0;
+    let smoothedSpeed = 0;
+    const useTty = Boolean(process.stdout.isTTY);
+    let lastProgressLine = '';
+
+    const runDump = () => new Promise((resolve, reject) => {
+      const proc = spawn('docker', dockerArgs, { stdio: ['ignore', 'pipe', 'pipe'] });
+
+      proc.stderr.on('data', (chunk) => {
+        process.stderr.write(chunk);
+        if (useTty && lastProgressLine) {
+          readline.cursorTo(process.stdout, 0);
+          process.stdout.write(lastProgressLine);
+        }
+      });
+
+      const pollFile = async () => {
+        if (!(await exists(outputPath))) return;
+        const stat = await fs.stat(outputPath).catch(() => null);
+        if (!stat) return;
+        tickCount++;
+        const currentSize = stat.size;
+        const now = Date.now();
+        const elapsed = now - startTime;
+        const deltaTime = (now - lastTime) / 1000;
+        const speed = deltaTime > 0 ? (currentSize - lastSize) / deltaTime : 0;
+        if (speed > 0) {
+          smoothedSpeed = tickCount === 1 ? speed : EMA_ALPHA * speed + (1 - EMA_ALPHA) * smoothedSpeed;
+        }
+        lastSize = currentSize;
+        lastTime = now;
+
+        const estimated = expectedBytes != null && expectedBytes > 0;
+        let percent = null;
+        let etaSeconds = null;
+        if (estimated) {
+          percent = Math.min(99, Math.floor((currentSize / expectedBytes) * 100));
+          if (smoothedSpeed > 0 && currentSize < expectedBytes && tickCount >= ETA_MIN_TICKS) {
+            etaSeconds = (expectedBytes - currentSize) / smoothedSpeed;
+          }
+        }
+
+        const line = renderProgressLine({
+          percent,
+          width: BAR_WIDTH,
+          sizeBytes: currentSize,
+          elapsedMs: elapsed,
+          speedBps: smoothedSpeed || speed,
+          etaSeconds,
+          estimated,
+          getT
+        });
+        lastProgressLine = line;
+
+        if (useTty) {
+          readline.clearLine(process.stdout, 0);
+          readline.cursorTo(process.stdout, 0);
+          process.stdout.write(chalk.white(line));
+        } else if (tickCount % 30 === 1 && elapsed >= 15000) {
+          process.stdout.write(chalk.white(line) + '\n');
+        }
+      };
+
+      ticker = setInterval(pollFile, 500);
+
+      proc.on('close', async (code) => {
+        if (ticker) {
+          clearInterval(ticker);
+          ticker = null;
+        }
+        if (useTty) {
+          readline.clearLine(process.stdout, 0);
+          readline.cursorTo(process.stdout, 0);
+        }
+        if (code !== 0) {
+          reject(new Error(`pg_dumpall exited with code ${code}`));
+          return;
+        }
+        // Sucesso: mostrar 100% uma vez (estimativa) com tamanho final real
+        if (expectedBytes != null && expectedBytes > 0) {
+          let finalSize = lastSize;
+          try {
+            const stat = await fs.stat(outputPath).catch(() => null);
+            if (stat) finalSize = stat.size;
+          } catch { }
+          const finalLine = renderProgressLine({
+            percent: 100,
+            width: BAR_WIDTH,
+            sizeBytes: finalSize,
+            elapsedMs: Date.now() - startTime,
+            speedBps: smoothedSpeed,
+            etaSeconds: null,
+            estimated: true,
+            getT
+          });
+          process.stdout.write(chalk.white(finalLine) + '\n');
+        }
+        if (useTty) {
+          readline.cursorTo(process.stdout, 0);
+        }
+        resolve();
+      });
+
+      proc.on('error', (err) => {
+        if (ticker) clearInterval(ticker);
+        reject(err);
+      });
+    });
+
+    await runDump();
+
+    const gzipArgs = [
+      'run', '--rm',
+      '-v', `${backupDirAbs}:/host`,
+      postgresImage, 'gzip', `/host/${fileName}`
+    ];
+
+    const gzipStart = Date.now();
+    let gzipTicker = null;
+    const finalFileName = `${fileName}.gz`;
+    const gzipOutputPath = path.join(backupDirAbs, finalFileName);
+
+    const runGzip = () => new Promise((resolve, reject) => {
+      const proc = spawn('docker', gzipArgs, { stdio: ['ignore', 'pipe', 'pipe'] });
+
+      proc.stderr.on('data', (chunk) => process.stderr.write(chunk));
+
+      const pollGzip = async () => {
+        if (!(await exists(gzipOutputPath))) return;
+        const stat = await fs.stat(gzipOutputPath).catch(() => null);
+        if (!stat) return;
+        const size = stat.size;
+        const elapsed = Date.now() - gzipStart;
+        if (process.stdout.isTTY) {
+          readline.clearLine(process.stdout, 0);
+          readline.cursorTo(process.stdout, 0);
+        }
+        process.stdout.write(`     📦 ${formatBytes(size)} | ${formatDuration(elapsed)}`);
+        if (process.stdout.isTTY) process.stdout.write('\r');
+      };
+
+      gzipTicker = setInterval(pollGzip, 300);
+
+      proc.on('close', (code) => {
+        if (gzipTicker) {
+          clearInterval(gzipTicker);
+          gzipTicker = null;
+        }
+        if (process.stdout.isTTY) {
+          readline.clearLine(process.stdout, 0);
+          readline.cursorTo(process.stdout, 0);
+        }
+        if (code !== 0) {
+          reject(new Error(`gzip exited with code ${code}`));
+        } else {
+          resolve();
+        }
+      });
+
+      proc.on('error', (err) => {
+        if (gzipTicker) clearInterval(gzipTicker);
+        reject(err);
+      });
+    });
+
+    await runGzip();
+
+    const stats = await fs.stat(path.join(backupDir, finalFileName));
+    const sizeKB = (stats.size / 1024).toFixed(1);
+
+    console.log(chalk.green(`     ✅ Database backup: ${finalFileName} (${sizeKB} KB)`));
+
+    return { success: true, size: sizeKB, fileName: finalFileName };
+  } catch (error) {
+    const getT = global.smoonbI18n?.t || t;
+    console.log(chalk.yellow(`     ⚠️ ${getT('backup.steps.database.error', { message: error.message })}`));
+    return { success: false };
+  }
+};

package/src/commands/backup/utils.js

@@ -1,6 +1,43 @@
 const chalk = require('chalk');
+const { spawn } = require('child_process');
 const { t } = require('../../i18n');
 
+/**
+ * Obtém a versão major do Postgres no servidor (ex: 17) via psql em container.
+ * @param {string} databaseUrl
+ * @returns {Promise<number|null>} major (15, 17, 18, ...) ou null
+ */
+async function getPostgresServerMajor(databaseUrl) {
+  const urlMatch = databaseUrl.match(/postgresql:\/\/([^:]+):([^@]+)@([^:]+):(\d+)\/(.+)/);
+  if (!urlMatch) return null;
+  const [, username, password, host, port, database] = urlMatch;
+  const bootstrapImage = 'postgres:17';
+  const args = [
+    'run', '--rm', '--network', 'host',
+    '-e', `PGPASSWORD=${password}`,
+    bootstrapImage, 'psql',
+    '-h', host, '-p', port, '-U', username, '-d', (database && database.trim()) || 'postgres',
+    '-t', '-A', '-c', "SELECT current_setting('server_version_num')"
+  ];
+  const stdout = await new Promise((resolve, reject) => {
+    const proc = spawn('docker', args, { stdio: ['ignore', 'pipe', 'pipe'] });
+    let out = '';
+    let err = '';
+    proc.stdout.on('data', (chunk) => { out += chunk.toString(); });
+    proc.stderr.on('data', (chunk) => { err += chunk.toString(); });
+    proc.on('close', (code) => {
+      if (code !== 0) reject(new Error(err.trim() || `psql exited with code ${code}`));
+      else resolve(out.trim());
+    });
+    proc.on('error', reject);
+  });
+  const versionNum = parseInt(stdout, 10);
+  if (Number.isNaN(versionNum) || versionNum < 10000) {
+    throw new Error(`Invalid server_version_num: ${stdout}`);
+  }
+  return Math.floor(versionNum / 10000);
+}
+
 /**
  * Função para mostrar mensagens educativas e encerrar elegantemente
  * @param {string} reason - Motivo do bloqueio
@@ -54,7 +91,9 @@ function showDockerMessagesAndExit(reason, data = {}) {
       console.log(chalk.red(`❌ ${getT('supabase.cliOutdated', { version: data.supabaseCliVersion || '?', latest: data.supabaseCliLatest || '?' })}`));
       console.log('');
       console.log(chalk.yellow(`📋 ${getT('supabase.cliUpdateInstructions')}`));
-      console.log(chalk.cyan(`   ${getT('supabase.cliUpdateCommand')}`));
+      console.log(chalk.cyan(`   ${getT('supabase.cliUpdateCommandExamples')}`));
+      console.log(chalk.cyan(`   ${getT('supabase.cliUpdateCommandGlobal')}`));
+      console.log(chalk.cyan(`   ${getT('supabase.cliUpdateCommandLocal')}`));
       console.log('');
       console.log(chalk.gray(`💡 ${getT('supabase.cliUpdateLink')}`));
       break;
@@ -78,6 +117,7 @@ function showDockerMessagesAndExit(reason, data = {}) {
 }
 
 module.exports = {
-  showDockerMessagesAndExit
+  showDockerMessagesAndExit,
+  getPostgresServerMajor
 };
 

package/src/i18n/locales/en.json

@@ -75,7 +75,9 @@
   "supabase.cliUpdateRecommended": "Supabase CLI {version} detected. We recommend v2.72 or newer for new features and bug fixes: https://supabase.com/docs/guides/cli/getting-started#updating-the-supabase-cli",
   "supabase.cliOutdated": "Supabase CLI {version} is not the latest ({latest}). Update to the latest version.",
   "supabase.cliUpdateInstructions": "Update the Supabase CLI and run smoonb again:",
-  "supabase.cliUpdateCommand": "npm install -g supabase@latest",
+  "supabase.cliUpdateCommandExamples": "Examples (depending on how you installed):",
+  "supabase.cliUpdateCommandGlobal": "npm install -g supabase@latest   (global)",
+  "supabase.cliUpdateCommandLocal": "npm install supabase@latest   (local/project)",
   "supabase.cliUpdateLink": "Docs: https://supabase.com/docs/guides/cli/getting-started#updating-the-supabase-cli",
   "supabase.cliLatestUnknown": "Could not fetch the latest Supabase CLI version. Cannot continue.",
   "supabase.cliLatestErrorLabel": "Error:",
@@ -319,9 +321,20 @@
   "backup.start.directory": "Directory: {path}",
   "backup.start.docker": "Backup via Docker Desktop",
 
+  "backup.steps.postgresVersion.title": "Postgres version",
+  "backup.steps.postgresVersion.found": "Postgres version found: major {major} (image {image}).",
+  "backup.steps.postgresVersion.proceedWith": "We will proceed with this version. You can override below.",
+  "backup.steps.postgresVersion.selectVersion": "Select Postgres image version to use for dump:",
+  "backup.steps.postgresVersion.useDetected": "Use detected (postgres:{major})",
+  "backup.steps.postgresVersion.selected": "Using image: {image}",
+  "backup.steps.postgresVersion.detectError": "Could not detect server version: {message}",
+  "backup.steps.postgresVersion.usingDefault": "Using default postgres:17",
+
   "backup.steps.database.title": "PostgreSQL Database Backup via pg_dumpall Docker...",
   "backup.steps.database.creating": "Creating full backup via pg_dumpall...",
+  "backup.steps.database.postgresImage": "Postgres server major {major} detected. Using image: {image}",
   "backup.steps.database.executing": "Executing pg_dumpall via Docker...",
+  "backup.steps.database.progress.eta": "ETA",
   "backup.steps.database.separated.title": "PostgreSQL Database Backup (separate SQL files)...",
   "backup.steps.database.separated.creating": "Creating separate SQL backups via Supabase CLI...",
   "backup.steps.database.separated.exportingSchema": "Exporting schema...",

package/src/i18n/locales/pt-BR.json

@@ -75,7 +75,9 @@
   "supabase.cliUpdateRecommended": "Supabase CLI {version} detectado. Recomendamos v2.72 ou mais recente para novos recursos e correções: https://supabase.com/docs/guides/cli/getting-started#updating-the-supabase-cli",
   "supabase.cliOutdated": "Supabase CLI {version} não é a versão mais recente ({latest}). Atualize para a última versão.",
   "supabase.cliUpdateInstructions": "Atualize o Supabase CLI e execute o smoonb novamente:",
-  "supabase.cliUpdateCommand": "npm install -g supabase@latest",
+  "supabase.cliUpdateCommandExamples": "Exemplos (conforme a forma de instalação):",
+  "supabase.cliUpdateCommandGlobal": "npm install -g supabase@latest   (global)",
+  "supabase.cliUpdateCommandLocal": "npm install supabase@latest   (local/projeto)",
   "supabase.cliUpdateLink": "Documentação: https://supabase.com/docs/guides/cli/getting-started#updating-the-supabase-cli",
   "supabase.cliLatestUnknown": "Não foi possível obter a última versão do Supabase CLI. Não é possível continuar.",
   "supabase.cliLatestErrorLabel": "Erro:",
@@ -319,9 +321,20 @@
   "backup.start.directory": "Diretório: {path}",
   "backup.start.docker": "Backup via Docker Desktop",
 
+  "backup.steps.postgresVersion.title": "Versão do Postgres",
+  "backup.steps.postgresVersion.found": "Versão do Postgres encontrada: major {major} (imagem {image}).",
+  "backup.steps.postgresVersion.proceedWith": "Seguiremos com esta versão. Você pode sobrescrever abaixo.",
+  "backup.steps.postgresVersion.selectVersion": "Selecione a versão da imagem Postgres para o dump:",
+  "backup.steps.postgresVersion.useDetected": "Usar detectada (postgres:{major})",
+  "backup.steps.postgresVersion.selected": "Usando imagem: {image}",
+  "backup.steps.postgresVersion.detectError": "Não foi possível detectar a versão do servidor: {message}",
+  "backup.steps.postgresVersion.usingDefault": "Usando padrão postgres:17",
+
   "backup.steps.database.title": "Backup da Database PostgreSQL via pg_dumpall Docker...",
   "backup.steps.database.creating": "Criando backup completo via pg_dumpall...",
+  "backup.steps.database.postgresImage": "Postgres servidor major {major} detectado. Usando imagem: {image}",
   "backup.steps.database.executing": "Executando pg_dumpall via Docker...",
+  "backup.steps.database.progress.eta": "ETA",
   "backup.steps.database.separated.title": "Backup da Database PostgreSQL (arquivos SQL separados)...",
   "backup.steps.database.separated.creating": "Criando backups SQL separados via Supabase CLI...",
   "backup.steps.database.separated.exportingSchema": "Exportando schema...",

package/src/commands/backup/steps/01-database.js

@@ -1,183 +0,0 @@
-const chalk = require('chalk');
-const path = require('path');
-const fs = require('fs').promises;
-const { spawn } = require('child_process');
-const { t } = require('../../../i18n');
-
-function formatBytes(bytes) {
-  if (bytes === 0) return '0 B';
-  const k = 1024;
-  const sizes = ['B', 'KB', 'MB', 'GB'];
-  const i = Math.floor(Math.log(bytes) / Math.log(k));
-  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(2))} ${sizes[i]}`;
-}
-
-function formatDuration(ms) {
-  if (ms < 1000) return `${ms}ms`;
-  const s = Math.floor(ms / 1000);
-  const m = Math.floor(s / 60);
-  const h = Math.floor(m / 60);
-  if (h > 0) return `${h}h ${m % 60}m ${s % 60}s`;
-  if (m > 0) return `${m}m ${s % 60}s`;
-  return `${s}s`;
-}
-
-async function exists(filePath) {
-  try {
-    await fs.access(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Etapa 1: Backup Database via pg_dumpall Docker (idêntico ao Dashboard)
- * Com feedback de progresso: tamanho do arquivo, velocidade e tempo decorrido.
- */
-module.exports = async ({ databaseUrl, backupDir }) => {
-  try {
-    const getT = global.smoonbI18n?.t || t;
-    console.log(chalk.white(`   - ${getT('backup.steps.database.creating')}`));
-
-    const urlMatch = databaseUrl.match(/postgresql:\/\/([^:]+):([^@]+)@([^:]+):(\d+)\/(.+)/);
-
-    if (!urlMatch) {
-      const getT = global.smoonbI18n?.t || t;
-      throw new Error(getT('error.databaseUrlInvalidSimple'));
-    }
-
-    const [, username, password, host, port] = urlMatch;
-
-    const now = new Date();
-    const day = String(now.getDate()).padStart(2, '0');
-    const month = String(now.getMonth() + 1).padStart(2, '0');
-    const year = now.getFullYear();
-    const hours = String(now.getHours()).padStart(2, '0');
-    const minutes = String(now.getMinutes()).padStart(2, '0');
-    const seconds = String(now.getSeconds()).padStart(2, '0');
-
-    const fileName = `db_cluster-${day}-${month}-${year}@${hours}-${minutes}-${seconds}.backup`;
-    const backupDirAbs = path.resolve(backupDir);
-    const outputPath = path.join(backupDirAbs, fileName);
-
-    const dockerArgs = [
-      'run', '--rm', '--network', 'host',
-      '-v', `${backupDirAbs}:/host`,
-      '-e', `PGPASSWORD=${password}`,
-      'postgres:17', 'pg_dumpall',
-      '-h', host,
-      '-p', port,
-      '-U', username,
-      '-f', `/host/${fileName}`
-    ];
-
-    console.log(chalk.white(`   - ${getT('backup.steps.database.executing')}`));
-
-    const startTime = Date.now();
-    let lastSize = 0;
-    let lastTime = startTime;
-    let ticker = null;
-
-    const runDump = () => new Promise((resolve, reject) => {
-      const proc = spawn('docker', dockerArgs, { stdio: ['ignore', 'pipe', 'pipe'] });
-
-      proc.stderr.on('data', (chunk) => process.stderr.write(chunk));
-
-      const pollFile = async () => {
-        if (!(await exists(outputPath))) return;
-        const stat = await fs.stat(outputPath).catch(() => null);
-        if (!stat) return;
-        const size = stat.size;
-        const elapsed = Date.now() - startTime;
-        const deltaTime = (Date.now() - lastTime) / 1000;
-        const speed = deltaTime > 0 ? (size - lastSize) / deltaTime : 0;
-        lastSize = size;
-        lastTime = Date.now();
-        const line = `     📦 ${formatBytes(size)} | ${formatDuration(elapsed)} | ${formatBytes(speed)}/s`;
-        process.stdout.write(`\r${line}`);
-      };
-
-      ticker = setInterval(pollFile, 500);
-
-      proc.on('close', (code) => {
-        if (ticker) {
-          clearInterval(ticker);
-          ticker = null;
-        }
-        process.stdout.write('\r' + ' '.repeat(80) + '\r');
-        if (code !== 0) {
-          reject(new Error(`pg_dumpall exited with code ${code}`));
-        } else {
-          resolve();
-        }
-      });
-
-      proc.on('error', (err) => {
-        if (ticker) clearInterval(ticker);
-        reject(err);
-      });
-    });
-
-    await runDump();
-
-    const gzipArgs = [
-      'run', '--rm',
-      '-v', `${backupDirAbs}:/host`,
-      'postgres:17', 'gzip', `/host/${fileName}`
-    ];
-
-    const gzipStart = Date.now();
-    let gzipTicker = null;
-    const finalFileName = `${fileName}.gz`;
-    const gzipOutputPath = path.join(backupDirAbs, finalFileName);
-
-    const runGzip = () => new Promise((resolve, reject) => {
-      const proc = spawn('docker', gzipArgs, { stdio: ['ignore', 'pipe', 'pipe'] });
-
-      proc.stderr.on('data', (chunk) => process.stderr.write(chunk));
-
-      const pollGzip = async () => {
-        if (!(await exists(gzipOutputPath))) return;
-        const stat = await fs.stat(gzipOutputPath).catch(() => null);
-        if (!stat) return;
-        const size = stat.size;
-        const elapsed = Date.now() - gzipStart;
-        process.stdout.write(`\r     📦 ${formatBytes(size)} | ${formatDuration(elapsed)}\r`);
-      };
-
-      gzipTicker = setInterval(pollGzip, 300);
-
-      proc.on('close', (code) => {
-        if (gzipTicker) {
-          clearInterval(gzipTicker);
-          gzipTicker = null;
-        }
-        process.stdout.write('\r' + ' '.repeat(80) + '\r');
-        if (code !== 0) {
-          reject(new Error(`gzip exited with code ${code}`));
-        } else {
-          resolve();
-        }
-      });
-
-      proc.on('error', (err) => {
-        if (gzipTicker) clearInterval(gzipTicker);
-        reject(err);
-      });
-    });
-
-    await runGzip();
-
-    const stats = await fs.stat(path.join(backupDir, finalFileName));
-    const sizeKB = (stats.size / 1024).toFixed(1);
-
-    console.log(chalk.green(`     ✅ Database backup: ${finalFileName} (${sizeKB} KB)`));
-
-    return { success: true, size: sizeKB, fileName: finalFileName };
-  } catch (error) {
-    const getT = global.smoonbI18n?.t || t;
-    console.log(chalk.yellow(`     ⚠️ ${getT('backup.steps.database.error', { message: error.message })}`));
-    return { success: false };
-  }
-};