smoonb 0.0.86 → 0.0.88

package/README.md

@@ -91,6 +91,8 @@ docker ps
 npm install -g supabase
 ```
 
+We recommend **Supabase CLI v2.72 or newer** for new features and bug fixes. To update: [Updating the Supabase CLI](https://supabase.com/docs/guides/cli/getting-started#updating-the-supabase-cli).
+
 ### 3. Supabase Personal Access Token
 You need to obtain a Supabase personal access token to use the Management API:
 

package/README.pt-BR.md

@@ -91,6 +91,8 @@ docker ps
 npm install -g supabase
 ```
 
+Recomendamos **Supabase CLI v2.72 ou mais recente** para novos recursos e correções. Para atualizar: [Atualizando o Supabase CLI](https://supabase.com/docs/guides/cli/getting-started#updating-the-supabase-cli).
+
 ### 3. Personal Access Token do Supabase
 É necessário obter um token de acesso pessoal do Supabase para usar a Management API:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smoonb",
-  "version": "0.0.86",
+  "version": "0.0.88",
   "description": "Complete Supabase backup and migration tool - EXPERIMENTAL VERSION - USE AT YOUR OWN RISK",
   "preferGlobal": false,
   "preventGlobalInstall": true,
@@ -34,7 +34,7 @@
     "node": ">=16.0.0"
   },
   "dependencies": {
-    "@supabase/supabase-js": "^2.38.0",
+    "@supabase/supabase-js": "^2.93.0",
     "adm-zip": "^0.5.16",
     "chalk": "^4.1.2",
     "commander": "^11.1.0",

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/00-docker-validation.js

@@ -15,7 +15,7 @@ module.exports = async () => {
   const backupCapability = await canPerformCompleteBackup();
 
   if (!backupCapability.canBackupComplete) {
-    showDockerMessagesAndExit(backupCapability.reason);
+    showDockerMessagesAndExit(backupCapability.reason, backupCapability);
   }
   
   console.log(chalk.green(`✅ ${getT('docker.validation.detected')}`));

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/{01-database.js → 02-database.js}

@@ -3,6 +3,7 @@ const path = require('path');
 const fs = require('fs').promises;
 const { spawn } = require('child_process');
 const { t } = require('../../../i18n');
+const { getPostgresServerMajor } = require('../utils');
 
 function formatBytes(bytes) {
   if (bytes === 0) return '0 B';
@@ -32,10 +33,11 @@ async function exists(filePath) {
 }
 
 /**
- * Etapa 1: Backup Database via pg_dumpall Docker (idêntico ao Dashboard)
+ * 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 }) => {
+module.exports = async ({ databaseUrl, backupDir, postgresMajor: contextMajor }) => {
   try {
     const getT = global.smoonbI18n?.t || t;
     console.log(chalk.white(`   - ${getT('backup.steps.database.creating')}`));
@@ -49,6 +51,18 @@ module.exports = async ({ databaseUrl, backupDir }) => {
 
     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');
@@ -65,7 +79,7 @@ module.exports = async ({ databaseUrl, backupDir }) => {
       'run', '--rm', '--network', 'host',
       '-v', `${backupDirAbs}:/host`,
       '-e', `PGPASSWORD=${password}`,
-      'postgres:17', 'pg_dumpall',
+      postgresImage, 'pg_dumpall',
       '-h', host,
       '-p', port,
       '-U', username,
@@ -124,7 +138,7 @@ module.exports = async ({ databaseUrl, backupDir }) => {
     const gzipArgs = [
       'run', '--rm',
       '-v', `${backupDirAbs}:/host`,
-      'postgres:17', 'gzip', `/host/${fileName}`
+      postgresImage, 'gzip', `/host/${fileName}`
     ];
 
     const gzipStart = Date.now();

package/src/commands/backup/utils.js

@@ -1,10 +1,49 @@
 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
+ * @param {object} [data] - Dados extras (ex: { supabaseCliVersion } para supabase_cli_outdated)
  */
-function showDockerMessagesAndExit(reason) {
+function showDockerMessagesAndExit(reason, data = {}) {
   const getT = global.smoonbI18n?.t || t;
   
   console.log('');
@@ -47,6 +86,26 @@ function showDockerMessagesAndExit(reason) {
       console.log('');
       console.log(chalk.gray(`💡 ${getT('supabase.requiredComponents')}`));
       break;
+
+    case 'supabase_cli_outdated':
+      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.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;
+
+    case 'supabase_cli_latest_unknown':
+      console.log(chalk.red(`❌ ${getT('supabase.cliLatestUnknown')}`));
+      console.log('');
+      console.log(chalk.yellow(`📋 ${getT('supabase.cliLatestErrorLabel')}`));
+      console.log(chalk.gray(`   ${data.latestError || getT('supabase.cliLatestErrorUnknown')}`));
+      console.log('');
+      console.log(chalk.gray(`💡 ${getT('supabase.cliUpdateLink')}`));
+      break;
   }
 
   console.log('');
@@ -58,6 +117,7 @@ function showDockerMessagesAndExit(reason) {
 }
 
 module.exports = {
-  showDockerMessagesAndExit
+  showDockerMessagesAndExit,
+  getPostgresServerMajor
 };
 

package/src/i18n/locales/en.json

@@ -72,6 +72,16 @@
   "supabase.installLink": "Installation: npm install -g supabase",
   "supabase.required": "Supabase CLI is required for full Supabase backup",
   "supabase.requiredComponents": "Supabase CLI is required for full Supabase backup\n   - PostgreSQL Database\n   - Edge Functions\n   - All components via Docker",
+  "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.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:",
+  "supabase.cliLatestErrorUnknown": "Unknown error",
 
   "backup.components": "Backup Components:",
   "backup.database": "Database PostgreSQL (pg_dumpall + separate SQL)",
@@ -311,8 +321,18 @@
   "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.separated.title": "PostgreSQL Database Backup (separate SQL files)...",
   "backup.steps.database.separated.creating": "Creating separate SQL backups via Supabase CLI...",

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

@@ -72,6 +72,16 @@
   "supabase.installLink": "Instalação: npm install -g supabase",
   "supabase.required": "Supabase CLI é obrigatório para backup completo do Supabase",
   "supabase.requiredComponents": "Supabase CLI é obrigatório para backup completo do Supabase\n   - Database PostgreSQL\n   - Edge Functions\n   - Todos os componentes via Docker",
+  "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.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:",
+  "supabase.cliLatestErrorUnknown": "Erro desconhecido",
 
   "backup.components": "Componentes de Backup:",
   "backup.database": "Database PostgreSQL (pg_dumpall + SQL separados)",
@@ -311,8 +321,18 @@
   "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.separated.title": "Backup da Database PostgreSQL (arquivos SQL separados)...",
   "backup.steps.database.separated.creating": "Criando backups SQL separados via Supabase CLI...",

package/src/utils/docker.js

@@ -37,7 +37,6 @@ async function detectDockerRunning() {
  */
 async function detectSupabaseCLI() {
   try {
-    // Tentar executar supabase --version
     await execAsync('supabase --version');
     return true;
   } catch {
@@ -45,6 +44,62 @@ async function detectSupabaseCLI() {
   }
 }
 
+/**
+ * Obtém a versão instalada do Supabase CLI (ex: "2.51.0").
+ * @returns {Promise<string|null>} Semver ou null se não disponível
+ */
+async function getSupabaseCLIVersion() {
+  try {
+    const { stdout } = await execAsync('supabase --version');
+    const match = stdout.match(/(\d+)\.(\d+)\.(\d+)/);
+    return match ? `${match[1]}.${match[2]}.${match[3]}` : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Obtém a versão latest do Supabase CLI no npm.
+ * @returns {Promise<{version: string|null, error: string|null}>} version ou error preenchido
+ */
+async function getSupabaseCLILatestVersion() {
+  try {
+    const res = await fetch('https://registry.npmjs.org/supabase/latest', {
+      headers: { Accept: 'application/json' }
+    });
+    if (!res.ok) {
+      return { version: null, error: `HTTP ${res.status} ${res.statusText}` };
+    }
+    const data = await res.json();
+    const version = data.version || null;
+    if (!version) {
+      return { version: null, error: 'Resposta do registro npm sem campo version' };
+    }
+    return { version, error: null };
+  } catch (err) {
+    const message = err && typeof err.message === 'string' ? err.message : String(err);
+    return { version: null, error: message };
+  }
+}
+
+/**
+ * Compara duas versões semver (ex: "2.51.0", "2.72.7").
+ * @param {string} a
+ * @param {string} b
+ * @returns {number} -1 se a < b, 0 se a === b, 1 se a > b
+ */
+function compareSemver(a, b) {
+  const pa = a.split('.').map(Number);
+  const pb = b.split('.').map(Number);
+  for (let i = 0; i < 3; i++) {
+    const va = pa[i] || 0;
+    const vb = pb[i] || 0;
+    if (va < vb) return -1;
+    if (va > vb) return 1;
+  }
+  return 0;
+}
+
 /**
  * Detecta Docker Desktop completo com versão
  * @returns {Promise<{installed: boolean, running: boolean, version: string}>}
@@ -133,6 +188,27 @@ async function canPerformCompleteBackup() {
       dockerStatus
     };
   }
+
+  const supabaseCliVersion = await getSupabaseCLIVersion();
+  const latestResult = await getSupabaseCLILatestVersion();
+  if (latestResult.error) {
+    return {
+      canBackupComplete: false,
+      reason: 'supabase_cli_latest_unknown',
+      latestError: latestResult.error,
+      supabaseCliVersion: supabaseCliVersion || null,
+      dockerStatus
+    };
+  }
+  if (supabaseCliVersion && latestResult.version && compareSemver(supabaseCliVersion, latestResult.version) < 0) {
+    return {
+      canBackupComplete: false,
+      reason: 'supabase_cli_outdated',
+      supabaseCliVersion,
+      supabaseCliLatest: latestResult.version,
+      dockerStatus
+    };
+  }
   
   return {
     canBackupComplete: true,
@@ -147,5 +223,8 @@ module.exports = {
   detectDockerDependencies,
   detectDockerDesktop,
   getDockerVersion,
+  getSupabaseCLIVersion,
+  getSupabaseCLILatestVersion,
+  compareSemver,
   canPerformCompleteBackup
 };