smoonb 0.0.74 → 0.0.76

package/src/commands/restore/index.js

@@ -25,16 +25,19 @@ const step08RealtimeSettings = require('./steps/08-realtime-settings');
  * Função auxiliar para importar arquivo de backup e storage (reutiliza lógica do comando import)
  */
 async function importBackupFile(sourceFile, sourceStorageFile, outputDir) {
+  const { t } = require('../../i18n');
+  const getT = global.smoonbI18n?.t || t;
+  
   // Validar arquivo de backup
   try {
     await fsPromises.access(sourceFile);
   } catch {
-    throw new Error(`Arquivo de backup não encontrado: ${sourceFile}`);
+    throw new Error(getT('restore.import.fileNotFound', { path: sourceFile }));
   }
 
   // Verificar se é um arquivo .backup.gz ou .backup
   if (!sourceFile.endsWith('.backup.gz') && !sourceFile.endsWith('.backup')) {
-    throw new Error('Arquivo de backup deve ser .backup.gz ou .backup');
+    throw new Error(getT('restore.import.invalidFormat'));
   }
 
   // Validar arquivo de storage se fornecido
@@ -42,12 +45,12 @@ async function importBackupFile(sourceFile, sourceStorageFile, outputDir) {
     try {
       await fsPromises.access(sourceStorageFile);
     } catch {
-      throw new Error(`Arquivo de storage não encontrado: ${sourceStorageFile}`);
+      throw new Error(getT('restore.import.storageNotFound', { path: sourceStorageFile }));
     }
 
     // Verificar se é um arquivo .storage.zip
     if (!sourceStorageFile.endsWith('.storage.zip')) {
-      throw new Error('Arquivo de storage deve ser .storage.zip');
+      throw new Error(getT('restore.import.storageInvalidFormat'));
     }
   }
 
@@ -57,7 +60,7 @@ async function importBackupFile(sourceFile, sourceStorageFile, outputDir) {
   const match = fileName.match(/db_cluster-(\d{2})-(\d{2})-(\d{4})@(\d{2})-(\d{2})-(\d{2})\.backup(\.gz)?/);
   
   if (!match) {
-    throw new Error('Nome do arquivo de backup não está no formato esperado do Dashboard. Formato esperado: db_cluster-DD-MM-YYYY@HH-MM-SS.backup.gz');
+    throw new Error(getT('restore.import.invalidFileName'));
   }
 
   const [, day, month, year, hour, minute, second] = match;
@@ -68,7 +71,7 @@ async function importBackupFile(sourceFile, sourceStorageFile, outputDir) {
   
   // Criar diretório de backup
   await ensureDir(backupDir);
-  console.log(chalk.blue(`📁 Importando backup para: ${backupDirName}`));
+  console.log(chalk.blue(`📁 ${getT('restore.import.importing', { name: backupDirName })}`));
   
   // Copiar arquivo de backup para o diretório de backup
   const destFile = path.join(backupDir, fileName);
@@ -78,7 +81,7 @@ async function importBackupFile(sourceFile, sourceStorageFile, outputDir) {
   const stats = await fsPromises.stat(destFile);
   const sizeMB = (stats.size / (1024 * 1024)).toFixed(2);
   
-  console.log(chalk.green(`✅ Arquivo de backup importado: ${fileName} (${sizeMB} MB)`));
+  console.log(chalk.green(`✅ ${getT('restore.import.backupImported', { fileName, size: sizeMB })}`));
   
   // Copiar arquivo de storage se fornecido
   if (sourceStorageFile) {
@@ -89,7 +92,7 @@ async function importBackupFile(sourceFile, sourceStorageFile, outputDir) {
     const storageStats = await fsPromises.stat(destStorageFile);
     const storageSizeMB = (storageStats.size / (1024 * 1024)).toFixed(2);
     
-    console.log(chalk.green(`✅ Arquivo de storage importado: ${storageFileName} (${storageSizeMB} MB)`));
+    console.log(chalk.green(`✅ ${getT('restore.import.storageImported', { fileName: storageFileName, size: storageSizeMB })}`));
   }
   
   return backupDir;
@@ -141,10 +144,10 @@ module.exports = async (options) => {
     try {
       await fsPromises.access(envPath);
       await backupEnvFile(envPath, envBackupPath);
-      console.log(chalk.blue(`📁 Backup do .env.local: ${path.relative(process.cwd(), envBackupPath)}`));
+      console.log(chalk.blue(`📁 ${getT('restore.import.envBackup', { path: path.relative(process.cwd(), envBackupPath) })}`));
     } catch {
       // Arquivo não existe, não fazer backup
-      console.log(chalk.yellow('⚠️  Arquivo .env.local não encontrado. Será criado durante o mapeamento.'));
+      console.log(chalk.yellow(getT('restore.import.envNotFound')));
     }
 
     // Leitura e mapeamento interativo
@@ -161,7 +164,7 @@ module.exports = async (options) => {
     const { finalEnv, dePara } = await mapEnvVariablesInteractively(currentEnv, expectedKeys);
     await writeEnvFile(envPath, finalEnv);
     await saveEnvMap(dePara, path.join(processDir, 'env', 'env-map.json'));
-    console.log(chalk.green('✅ .env.local atualizado com sucesso. Nenhuma chave renomeada; valores sincronizados.'));
+    console.log(chalk.green(`✅ ${getT('restore.index.envUpdated')}`));
 
     // Resolver valores esperados a partir do de-para
     function getValue(expectedKey) {
@@ -187,7 +190,7 @@ module.exports = async (options) => {
       const sourceFile = path.resolve(options.file);
       const sourceStorageFile = options.storage ? path.resolve(options.storage) : null;
       
-      console.log(chalk.blue(`📁 Importando arquivo de backup...`));
+      console.log(chalk.blue(`📁 ${getT('restore.import.importingFile')}`));
       const importedBackupDir = await importBackupFile(sourceFile, sourceStorageFile, outputDir);
       
       // Listar backups válidos para encontrar o backup importado
@@ -195,20 +198,20 @@ module.exports = async (options) => {
       selectedBackup = validBackups.find(b => b.path === importedBackupDir);
       
       if (!selectedBackup) {
-        throw new Error('Não foi possível encontrar o backup importado');
+        throw new Error(getT('restore.import.cannotFind'));
       }
       
-      console.log(chalk.green(`✅ Backup importado e selecionado automaticamente: ${path.basename(selectedBackup.path)}`));
+      console.log(chalk.green(`✅ ${getT('restore.import.importedSelected', { name: path.basename(selectedBackup.path) })}`));
     } else {
       // Fluxo normal: listar e selecionar backup interativamente
-      console.log(chalk.blue(`📁 Buscando backups em: ${outputDir}`));
+      console.log(chalk.blue(`📁 ${getT('restore.index.searchingBackups', { path: outputDir })}`));
       
       // 1. Listar backups válidos (.backup.gz)
       const validBackups = await listValidBackups(outputDir);
       
       if (validBackups.length === 0) {
-        console.error(chalk.red('❌ Nenhum backup válido encontrado'));
-        console.log(chalk.yellow('💡 Execute primeiro: npx smoonb backup'));
+        console.error(chalk.red(`❌ ${getT('restore.index.noBackupsFound')}`));
+        console.log(chalk.yellow(`💡 ${getT('restore.index.runBackupFirst')}`));
         process.exit(1);
       }
       
@@ -221,33 +224,33 @@ module.exports = async (options) => {
     
     // Validar que pelo menos um componente foi selecionado
     if (!Object.values(components).some(Boolean)) {
-      console.error(chalk.red('\n❌ Nenhum componente selecionado para restauração!'));
+      console.error(chalk.red(getT('restore.import.noComponents')));
       process.exit(1);
     }
     
     // 4. Mostrar resumo detalhado
-    console.log(chalk.cyan('\n📋 RESUMO DA RESTAURAÇÃO:\n'));
-    console.log(chalk.white(`   📁 Backup selecionado: ${path.basename(selectedBackup.path)}`));
-    console.log(chalk.white(`   🎯 Projeto destino: ${targetProject.targetProjectId || '(não configurado)'}`));
-    console.log(chalk.white(`   📊 Database: ${components.database ? 'Sim' : 'Não'}`));
-    console.log(chalk.white(`   ⚡ Edge Functions: ${components.edgeFunctions ? 'Sim' : 'Não'}`));
-    console.log(chalk.white(`   🔐 Auth Settings: ${components.authSettings ? 'Sim' : 'Não'}`));
-    console.log(chalk.white(`   📦 Storage: ${components.storage ? 'Sim' : 'Não'}`));
-    console.log(chalk.white(`   🔧 Database Settings: ${components.databaseSettings ? 'Sim' : 'Não'}`));
-    console.log(chalk.white(`   🔄 Realtime Settings: ${components.realtimeSettings ? 'Sim' : 'Não'}\n`));
+    console.log(chalk.cyan(`\n📋 ${getT('restore.index.summaryTitle')}\n`));
+    console.log(chalk.white(`   📁 ${getT('restore.index.selectedBackup', { name: path.basename(selectedBackup.path) })}`));
+    console.log(chalk.white(`   🎯 ${getT('restore.index.targetProject', { projectId: targetProject.targetProjectId || getT('restore.index.notConfigured') })}`));
+    console.log(chalk.white(`   📊 ${getT('restore.index.database', { value: components.database ? getT('restore.index.yes') : getT('restore.index.no') })}`));
+    console.log(chalk.white(`   ⚡ ${getT('restore.index.edgeFunctions', { value: components.edgeFunctions ? getT('restore.index.yes') : getT('restore.index.no') })}`));
+    console.log(chalk.white(`   🔐 ${getT('restore.index.authSettings', { value: components.authSettings ? getT('restore.index.yes') : getT('restore.index.no') })}`));
+    console.log(chalk.white(`   📦 ${getT('restore.index.storage', { value: components.storage ? getT('restore.index.yes') : getT('restore.index.no') })}`));
+    console.log(chalk.white(`   🔧 ${getT('restore.index.databaseSettings', { value: components.databaseSettings ? getT('restore.index.yes') : getT('restore.index.no') })}`));
+    console.log(chalk.white(`   🔄 ${getT('restore.index.realtimeSettings', { value: components.realtimeSettings ? getT('restore.index.yes') : getT('restore.index.no') })}\n`));
     
     // Mostrar resumo técnico adicional
     showRestoreSummary(selectedBackup, components, targetProject);
     
     // 5. Confirmar execução
-    const finalOk = await confirm('Deseja iniciar a restauração com estas configurações?', true);
+    const finalOk = await confirm(getT('restore.index.confirmRestore'), true);
     if (!finalOk) {
-      console.log(chalk.yellow('🚫 Restauração cancelada.'));
+      console.log(chalk.yellow(`🚫 ${getT('restore.index.restoreCancelled')}`));
       process.exit(0);
     }
     
     // 6. Executar restauração
-    console.log(chalk.blue('\n🚀 Iniciando restauração...'));
+    console.log(chalk.blue(`\n🚀 ${getT('restore.index.startingRestore')}`));
     
     // Contar etapas totais para numeração dinâmica
     let stepNumber = 0;
@@ -264,7 +267,7 @@ module.exports = async (options) => {
     // 6.1 Database (se selecionado)
     if (components.database) {
       stepNumber++;
-      console.log(chalk.blue(`\n📊 ${stepNumber}/${totalSteps} - Restaurando Database...`));
+      console.log(chalk.blue(`\n📊 ${stepNumber}/${totalSteps} - ${getT('restore.index.restoringDatabase')}`));
       await step03Database({
         backupFilePath: path.join(selectedBackup.path, selectedBackup.backupFile),
         targetDatabaseUrl: targetProject.targetDatabaseUrl
@@ -275,7 +278,7 @@ module.exports = async (options) => {
     // 6.2 Edge Functions (se selecionado)
     if (components.edgeFunctions) {
       stepNumber++;
-      console.log(chalk.blue(`\n⚡ ${stepNumber}/${totalSteps} - Restaurando Edge Functions...`));
+      console.log(chalk.blue(`\n⚡ ${stepNumber}/${totalSteps} - ${getT('restore.index.restoringEdgeFunctions')}`));
       const edgeFunctionsResult = await step04EdgeFunctions({
         backupPath: selectedBackup.path,
         targetProject
@@ -286,7 +289,7 @@ module.exports = async (options) => {
     // 6.3 Auth Settings (se selecionado)
     if (components.authSettings) {
       stepNumber++;
-      console.log(chalk.blue(`\n🔐 ${stepNumber}/${totalSteps} - Restaurando Auth Settings...`));
+      console.log(chalk.blue(`\n🔐 ${stepNumber}/${totalSteps} - ${getT('restore.index.restoringAuthSettings')}`));
       await step05AuthSettings({
         backupPath: selectedBackup.path,
         targetProject
@@ -297,7 +300,7 @@ module.exports = async (options) => {
     // 6.4 Storage Buckets (se selecionado)
     if (components.storage) {
       stepNumber++;
-      console.log(chalk.blue(`\n📦 ${stepNumber}/${totalSteps} - Restaurando Storage Buckets...`));
+      console.log(chalk.blue(`\n📦 ${stepNumber}/${totalSteps} - ${getT('restore.index.restoringStorageBuckets')}`));
       const storageResult = await step06Storage({
         backupPath: selectedBackup.path,
         targetProject
@@ -308,7 +311,7 @@ module.exports = async (options) => {
     // 6.5 Database Settings (se selecionado)
     if (components.databaseSettings) {
       stepNumber++;
-      console.log(chalk.blue(`\n🔧 ${stepNumber}/${totalSteps} - Restaurando Database Settings...`));
+      console.log(chalk.blue(`\n🔧 ${stepNumber}/${totalSteps} - ${getT('restore.index.restoringDatabaseSettings')}`));
       await step07DatabaseSettings({
         backupPath: selectedBackup.path,
         targetProject
@@ -319,7 +322,7 @@ module.exports = async (options) => {
     // 6.6 Realtime Settings (se selecionado)
     if (components.realtimeSettings) {
       stepNumber++;
-      console.log(chalk.blue(`\n🔄 ${stepNumber}/${totalSteps} - Restaurando Realtime Settings...`));
+      console.log(chalk.blue(`\n🔄 ${stepNumber}/${totalSteps} - ${getT('restore.index.restoringRealtimeSettings')}`));
       await step08RealtimeSettings({
         backupPath: selectedBackup.path,
         targetProject
@@ -349,21 +352,21 @@ module.exports = async (options) => {
     }
 
     // Exibir resumo final
-    console.log(chalk.green('\n🎉 RESTAURAÇÃO COMPLETA FINALIZADA!'));
-    console.log(chalk.blue(`🎯 Projeto destino: ${targetProject.targetProjectId || '(não configurado)'}`));
+    console.log(chalk.green(`\n🎉 ${getT('restore.index.restoreComplete')}`));
+    console.log(chalk.blue(`🎯 ${getT('restore.index.targetProjectFinal', { projectId: targetProject.targetProjectId || getT('restore.index.notConfigured') })}`));
     
     if (restoreResults.database) {
-      console.log(chalk.green(`📊 Database: Restaurada com sucesso via Docker`));
+      console.log(chalk.green(`📊 ${getT('restore.index.databaseRestored')}`));
     }
     
     if (restoreResults.edgeFunctions) {
       const funcCount = restoreResults.edgeFunctions.functions_count || 0;
       const successCount = restoreResults.edgeFunctions.success_count || 0;
-      console.log(chalk.green(`⚡ Edge Functions: ${successCount}/${funcCount} functions restauradas`));
+      console.log(chalk.green(`⚡ ${getT('restore.index.edgeFunctionsRestored', { success: successCount, total: funcCount })}`));
     }
     
     if (restoreResults.authSettings) {
-      console.log(chalk.green(`🔐 Auth Settings: Configurações exibidas para configuração manual`));
+      console.log(chalk.green(`🔐 ${getT('restore.index.authSettingsRestored')}`));
     }
     
     if (restoreResults.storage) {
@@ -372,22 +375,24 @@ module.exports = async (options) => {
       const totalFiles = restoreResults.storage.total_files || 0;
       
       if (filesRestored) {
-        console.log(chalk.green(`📦 Storage: ${bucketCount} bucket(s) restaurado(s), ${totalFiles} arquivo(s) enviado(s)`));
+        console.log(chalk.green(`📦 ${getT('restore.index.storageRestored', { buckets: bucketCount, files: totalFiles })}`));
       } else {
-        console.log(chalk.green(`📦 Storage: ${bucketCount} bucket(s) encontrado(s) - apenas metadados (arquivo .storage.zip não encontrado)`));
+        console.log(chalk.green(`📦 ${getT('restore.index.storageMetadataOnly', { buckets: bucketCount })}`));
       }
     }
     
     if (restoreResults.databaseSettings) {
-      console.log(chalk.green(`🔧 Database Settings: Extensões e configurações restauradas via SQL`));
+      console.log(chalk.green(`🔧 ${getT('restore.index.databaseSettingsRestored')}`));
     }
     
     if (restoreResults.realtimeSettings) {
-      console.log(chalk.green(`🔄 Realtime Settings: Configurações exibidas para configuração manual`));
+      console.log(chalk.green(`🔄 ${getT('restore.index.realtimeSettingsRestored')}`));
     }
     
   } catch (error) {
-    console.error(chalk.red(`❌ Erro na restauração: ${error.message}`));
+    const { t } = require('../../i18n');
+    const getT = global.smoonbI18n?.t || t;
+    console.error(chalk.red(`❌ ${getT('restore.index.error', { message: error.message })}`));
     process.exit(1);
   }
 };

package/src/commands/restore/steps/00-backup-selection.js

@@ -1,12 +1,14 @@
 const chalk = require('chalk');
 const readline = require('readline');
+const { t } = require('../../../i18n');
 
 /**
  * Etapa 0: Seleção interativa de backup
  */
 module.exports = async (backups) => {
-  console.log(chalk.blue('\n📋 Backups disponíveis:'));
-  console.log(chalk.blue('═'.repeat(80)));
+  const getT = global.smoonbI18n?.t || t;
+  console.log(chalk.blue(`\n📋 ${getT('restore.steps.backupSelection.title')}`));
+  console.log(chalk.blue(getT('restore.steps.backupSelection.separator')));
   
   backups.forEach((backup, index) => {
     const date = new Date(backup.created).toLocaleString('pt-BR');
@@ -24,13 +26,13 @@ module.exports = async (backups) => {
   
   const question = (query) => new Promise(resolve => rl.question(query, resolve));
   
-  const choice = await question(`\nDigite o número do backup para restaurar (1-${backups.length}): `);
+  const choice = await question(`\n${getT('restore.steps.backupSelection.input', { min: 1, max: backups.length })} `);
   rl.close();
   
   const backupIndex = parseInt(choice) - 1;
   
   if (backupIndex < 0 || backupIndex >= backups.length) {
-    throw new Error('Número inválido');
+    throw new Error(getT('restore.steps.backupSelection.invalid'));
   }
   
   return backups[backupIndex];

package/src/commands/restore/steps/01-components-selection.js

@@ -2,31 +2,33 @@ const path = require('path');
 const fs = require('fs');
 const chalk = require('chalk');
 const { confirm } = require('../../../utils/prompt');
+const { t } = require('../../../i18n');
 
 /**
  * Etapa 1: Perguntar quais componentes restaurar
  */
 module.exports = async (backupPath) => {
+  const getT = global.smoonbI18n?.t || t;
   // Database (sempre disponível)
-  const restoreDatabase = await confirm('Deseja restaurar Database', true);
+  const restoreDatabase = await confirm(getT('restore.steps.components.database.include'), true);
   
   // Edge Functions
   const edgeFunctionsDir = path.join(backupPath, 'edge-functions');
   let restoreEdgeFunctions = false;
   if (fs.existsSync(edgeFunctionsDir) && fs.readdirSync(edgeFunctionsDir).length > 0) {
-    console.log(chalk.cyan('\n⚡ Edge Functions:'));
-    console.log(chalk.white('   As Edge Functions serão copiadas para supabase/functions e implantadas no projeto destino.'));
-    console.log(chalk.white('   A pasta supabase/functions será limpa antes do processo.\n'));
-    restoreEdgeFunctions = await confirm('Deseja restaurar Edge Functions', true);
+    console.log(chalk.cyan(`\n⚡ ${getT('restore.steps.components.edgeFunctions.title')}`));
+    console.log(chalk.white(`   ${getT('restore.steps.components.edgeFunctions.description1')}`));
+    console.log(chalk.white(`   ${getT('restore.steps.components.edgeFunctions.description2')}\n`));
+    restoreEdgeFunctions = await confirm(getT('restore.steps.components.edgeFunctions.include'), true);
   }
-  
+
   // Auth Settings
   let restoreAuthSettings = false;
   if (fs.existsSync(path.join(backupPath, 'auth-settings.json'))) {
-    console.log(chalk.cyan('\n🔐 Auth Settings:'));
-    console.log(chalk.white('   As configurações de Auth serão exibidas para configuração manual no Dashboard.'));
-    console.log(chalk.white('   Algumas configurações não podem ser aplicadas automaticamente por questões de segurança.\n'));
-    restoreAuthSettings = await confirm('Deseja ver as configurações de Auth Settings', true);
+    console.log(chalk.cyan(`\n🔐 ${getT('restore.steps.components.auth.title')}`));
+    console.log(chalk.white(`   ${getT('restore.steps.components.auth.description1')}`));
+    console.log(chalk.white(`   ${getT('restore.steps.components.auth.description2')}\n`));
+    restoreAuthSettings = await confirm(getT('restore.steps.components.auth.include'), true);
   }
   
   // Storage Buckets
@@ -49,37 +51,37 @@ module.exports = async (backupPath) => {
   const hasStorageFiles = hasStorageDir && fs.readdirSync(storageDir).length > 0;
   
   if (storageZipFiles.length > 0 || hasStorageFiles) {
-    console.log(chalk.cyan('\n📦 Storage:'));
+    console.log(chalk.cyan(`\n📦 ${getT('restore.steps.components.storage.title')}`));
     if (storageZipFiles.length > 0) {
-      console.log(chalk.white(`   Arquivo .storage.zip encontrado: ${storageZipFiles[0]}`));
-      console.log(chalk.white('   Os buckets e arquivos serão restaurados automaticamente no projeto destino.'));
-      console.log(chalk.white('   O arquivo ZIP será extraído, buckets criados e arquivos enviados via API.\n'));
+      console.log(chalk.white(`   ${getT('restore.steps.components.storage.zipFound', { fileName: storageZipFiles[0] })}`));
+      console.log(chalk.white(`   ${getT('restore.steps.components.storage.withZip.description1')}`));
+      console.log(chalk.white(`   ${getT('restore.steps.components.storage.withZip.description2')}\n`));
     } else {
-      console.log(chalk.white('   Apenas metadados dos buckets encontrados (pasta storage).'));
-      console.log(chalk.white('   Para restaurar os arquivos, é necessário o arquivo .storage.zip do Dashboard.'));
-      console.log(chalk.white('   Apenas informações dos buckets serão exibidas.\n'));
+      console.log(chalk.white(`   ${getT('restore.steps.components.storage.metadataOnly.description1')}`));
+      console.log(chalk.white(`   ${getT('restore.steps.components.storage.metadataOnly.description2')}`));
+      console.log(chalk.white(`   ${getT('restore.steps.components.storage.metadataOnly.description3')}\n`));
     }
-    restoreStorage = await confirm('Deseja restaurar Storage Buckets', true);
+    restoreStorage = await confirm(getT('restore.steps.components.storage.include'), true);
   }
-  
+
   // Database Extensions and Settings
   const dbSettingsFiles = fs.readdirSync(backupPath)
     .filter(file => file.startsWith('database-settings-') && file.endsWith('.json'));
   let restoreDatabaseSettings = false;
   if (dbSettingsFiles.length > 0) {
-    console.log(chalk.cyan('\n🔧 Database Extensions and Settings:'));
-    console.log(chalk.white('   As extensões e configurações do banco de dados serão restauradas via SQL.'));
-    console.log(chalk.white('   Isso inclui extensões PostgreSQL e configurações específicas do projeto.\n'));
-    restoreDatabaseSettings = await confirm('Deseja restaurar Database Extensions and Settings', true);
+    console.log(chalk.cyan(`\n🔧 ${getT('restore.steps.components.databaseSettings.title')}`));
+    console.log(chalk.white(`   ${getT('restore.steps.components.databaseSettings.description1')}`));
+    console.log(chalk.white(`   ${getT('restore.steps.components.databaseSettings.description2')}\n`));
+    restoreDatabaseSettings = await confirm(getT('restore.steps.components.databaseSettings.include'), true);
   }
-  
+
   // Realtime Settings
   let restoreRealtimeSettings = false;
   if (fs.existsSync(path.join(backupPath, 'realtime-settings.json'))) {
-    console.log(chalk.cyan('\n🔄 Realtime Settings:'));
-    console.log(chalk.white('   As configurações de Realtime serão exibidas para configuração manual no Dashboard.'));
-    console.log(chalk.white('   Algumas configurações precisam ser aplicadas manualmente.\n'));
-    restoreRealtimeSettings = await confirm('Deseja ver as configurações de Realtime Settings', true);
+    console.log(chalk.cyan(`\n🔄 ${getT('restore.steps.components.realtime.title')}`));
+    console.log(chalk.white(`   ${getT('restore.steps.components.realtime.description1')}`));
+    console.log(chalk.white(`   ${getT('restore.steps.components.realtime.description2')}\n`));
+    restoreRealtimeSettings = await confirm(getT('restore.steps.components.realtime.include'), true);
   }
   
   return {

package/src/commands/restore/steps/03-database.js

@@ -1,20 +1,22 @@
 const chalk = require('chalk');
 const path = require('path');
 const { execSync } = require('child_process');
+const { t } = require('../../../i18n');
 
 /**
  * Etapa 3: Restaurar Database via psql
  */
 module.exports = async ({ backupFilePath, targetDatabaseUrl }) => {
   try {
+    const getT = global.smoonbI18n?.t || t;
     const backupDirAbs = path.resolve(path.dirname(backupFilePath));
     const fileName = path.basename(backupFilePath);
     let uncompressedFile = fileName;
     
     // Verificar se é arquivo .backup.gz (compactado) ou .backup (descompactado)
     if (fileName.endsWith('.backup.gz')) {
-      console.log(chalk.white('   - Arquivo .backup.gz detectado'));
-      console.log(chalk.white('   - Extraindo arquivo .gz...'));
+      console.log(chalk.white(`   - ${getT('restore.steps.database.detectedGz')}`));
+      console.log(chalk.white(`   - ${getT('restore.steps.database.extractingGz')}`));
       
       const unzipCmd = [
         'docker run --rm',
@@ -24,10 +26,10 @@ module.exports = async ({ backupFilePath, targetDatabaseUrl }) => {
       
       execSync(unzipCmd, { stdio: 'pipe' });
       uncompressedFile = fileName.replace('.gz', '');
-      console.log(chalk.white('   - Arquivo descompactado: ' + uncompressedFile));
+      console.log(chalk.white(`   - ${getT('restore.steps.database.uncompressed', { file: uncompressedFile })}`));
     } else if (fileName.endsWith('.backup')) {
-      console.log(chalk.white('   - Arquivo .backup detectado (já descompactado)'));
-      console.log(chalk.white('   - Prosseguindo com restauração direta'));
+      console.log(chalk.white(`   - ${getT('restore.steps.database.detectedBackup')}`));
+      console.log(chalk.white(`   - ${getT('restore.steps.database.proceeding')}`));
     } else {
       throw new Error(`Formato de arquivo inválido. Esperado .backup.gz ou .backup, recebido: ${fileName}`);
     }
@@ -36,7 +38,8 @@ module.exports = async ({ backupFilePath, targetDatabaseUrl }) => {
     const urlMatch = targetDatabaseUrl.match(/postgresql:\/\/([^@:]+):([^@]+)@(.+)$/);
     
     if (!urlMatch) {
-      throw new Error('Database URL inválida. Formato esperado: postgresql://user:password@host/database');
+      const getT = global.smoonbI18n?.t || t;
+      throw new Error(getT('error.databaseUrlInvalid'));
     }
     
     // Comando psql conforme documentação oficial Supabase
@@ -49,29 +52,30 @@ module.exports = async ({ backupFilePath, targetDatabaseUrl }) => {
       `-f /host/${uncompressedFile}`
     ].join(' ');
     
-    console.log(chalk.cyan('   - Executando psql via Docker...'));
-    console.log(chalk.cyan('   ℹ️ Seguindo documentação oficial Supabase'));
-    console.log(chalk.yellow('   ⚠️ AVISO: Erros como "object already exists" são ESPERADOS'));
-    console.log(chalk.yellow('   ⚠️ Isto acontece porque o backup contém CREATE para todos os schemas'));
-    console.log(chalk.yellow('   ⚠️ Supabase já tem auth e storage criados, então esses erros são normais'));
+    console.log(chalk.cyan(`   - ${getT('restore.steps.database.executing')}`));
+    console.log(chalk.cyan(`   ℹ️ ${getT('restore.steps.database.followingDocs')}`));
+    console.log(chalk.yellow(`   ⚠️ ${getT('restore.steps.database.warning')}`));
+    console.log(chalk.yellow(`   ⚠️ ${getT('restore.steps.database.warningReason1')}`));
+    console.log(chalk.yellow(`   ⚠️ ${getT('restore.steps.database.warningReason2')}`));
     
     // Executar comando de restauração
     execSync(restoreCmd, { stdio: 'inherit', encoding: 'utf8' });
     
-    console.log(chalk.green('   ✅ Database restaurada com sucesso!'));
-    console.log(chalk.gray('   ℹ️ Erros "already exists" são normais e não afetam a restauração'));
+    console.log(chalk.green(`   ✅ ${getT('restore.steps.database.success')}`));
+    console.log(chalk.gray(`   ℹ️ ${getT('restore.steps.database.normalErrors')}`));
     
   } catch (error) {
     // Erros esperados conforme documentação oficial Supabase
+    const getT = global.smoonbI18n?.t || t;
     if (error.message.includes('already exists') || 
         error.message.includes('constraint') ||
         error.message.includes('duplicate') ||
         error.stdout?.includes('already exists')) {
-      console.log(chalk.yellow('   ⚠️ Erros esperados encontrados (conforme documentação Supabase)'));
-      console.log(chalk.green('   ✅ Database restaurada com sucesso!'));
-      console.log(chalk.gray('   ℹ️ Erros são ignorados pois são comandos de CREATE que já existem'));
+      console.log(chalk.yellow(`   ⚠️ ${getT('restore.steps.database.expectedErrors')}`));
+      console.log(chalk.green(`   ✅ ${getT('restore.steps.database.success')}`));
+      console.log(chalk.gray(`   ℹ️ ${getT('restore.steps.database.errorsIgnored')}`));
     } else {
-      console.error(chalk.red(`   ❌ Erro inesperado na restauração: ${error.message}`));
+      console.error(chalk.red(`   ❌ ${getT('restore.steps.database.error', { message: error.message })}`));
       throw error;
     }
   }

package/src/commands/restore/steps/04-edge-functions.js

@@ -3,16 +3,18 @@ const path = require('path');
 const fs = require('fs').promises;
 const { execSync } = require('child_process');
 const { copyDirectoryRecursive } = require('../utils');
+const { t } = require('../../../i18n');
 
 /**
  * Etapa 4: Restaurar Edge Functions via supabase functions deploy
  */
 module.exports = async ({ backupPath, targetProject }) => {
   try {
+    const getT = global.smoonbI18n?.t || t;
     const edgeFunctionsDir = path.join(backupPath, 'edge-functions');
     
     if (!await fs.access(edgeFunctionsDir).then(() => true).catch(() => false)) {
-      console.log(chalk.yellow('   ⚠️  Nenhuma Edge Function encontrada no backup'));
+      console.log(chalk.yellow(`   ⚠️  ${getT('restore.steps.edgeFunctions.notFound')}`));
       return { success: false, functions_count: 0, success_count: 0 };
     }
     
@@ -28,11 +30,11 @@ module.exports = async ({ backupPath, targetProject }) => {
     }
     
     if (functions.length === 0) {
-      console.log(chalk.yellow('   ⚠️  Nenhuma Edge Function encontrada no backup'));
+      console.log(chalk.yellow(`   ⚠️  ${getT('restore.steps.edgeFunctions.notFound')}`));
       return { success: false, functions_count: 0, success_count: 0 };
     }
     
-    console.log(chalk.white(`   - Encontradas ${functions.length} Edge Function(s)`));
+    console.log(chalk.white(`   - ${getT('restore.steps.edgeFunctions.found', { count: functions.length })}`));
     
     // COPIAR Edge Functions de backups/backup-XXX/edge-functions para supabase/functions
     const supabaseFunctionsDir = path.join(process.cwd(), 'supabase', 'functions');
@@ -41,7 +43,7 @@ module.exports = async ({ backupPath, targetProject }) => {
     await fs.mkdir(supabaseFunctionsDir, { recursive: true });
     
     // Limpar supabase/functions antes de copiar (necessário para garantir ambiente limpo)
-    console.log(chalk.cyan('   - Limpando supabase/functions antes de copiar...'));
+    console.log(chalk.cyan(`   - ${getT('restore.steps.edgeFunctions.cleaningBefore')}`));
     try {
       await fs.rm(supabaseFunctionsDir, { recursive: true, force: true });
       await fs.mkdir(supabaseFunctionsDir, { recursive: true });
@@ -54,13 +56,13 @@ module.exports = async ({ backupPath, targetProject }) => {
       const backupFuncPath = path.join(edgeFunctionsDir, funcName);
       const targetFuncPath = path.join(supabaseFunctionsDir, funcName);
       
-      console.log(chalk.white(`   - Copiando ${funcName} para supabase/functions...`));
+      console.log(chalk.white(`   - ${getT('restore.steps.edgeFunctions.copying', { funcName })}`));
       
       // Copiar recursivamente
       await copyDirectoryRecursive(backupFuncPath, targetFuncPath);
     }
     
-    console.log(chalk.white(`   - Linkando com projeto ${targetProject.targetProjectId}...`));
+    console.log(chalk.white(`   - ${getT('restore.steps.edgeFunctions.linking', { projectId: targetProject.targetProjectId })}`));
     
     // Linkar com o projeto destino
     try {
@@ -71,13 +73,13 @@ module.exports = async ({ backupPath, targetProject }) => {
         env: { ...process.env, SUPABASE_ACCESS_TOKEN: targetProject.targetAccessToken || '' }
       });
     } catch {
-      console.log(chalk.yellow('   ⚠️  Link pode já existir, continuando...'));
+      console.log(chalk.yellow(`   ⚠️  ${getT('restore.steps.edgeFunctions.linkMayExist')}`));
     }
     
     // Deploy das Edge Functions
     let successCount = 0;
     for (const funcName of functions) {
-      console.log(chalk.white(`   - Deployando ${funcName}...`));
+      console.log(chalk.white(`   - ${getT('restore.steps.edgeFunctions.deploying', { funcName })}`));
       
       try {
         execSync(`supabase functions deploy ${funcName}`, {
@@ -88,22 +90,22 @@ module.exports = async ({ backupPath, targetProject }) => {
           env: { ...process.env, SUPABASE_ACCESS_TOKEN: targetProject.targetAccessToken || '' }
         });
         
-        console.log(chalk.green(`   ✅ ${funcName} deployada com sucesso!`));
+        console.log(chalk.green(`   ✅ ${getT('restore.steps.edgeFunctions.deployed', { funcName })}`));
         successCount++;
       } catch (deployError) {
-        console.log(chalk.yellow(`   ⚠️  ${funcName} - deploy falhou: ${deployError.message}`));
+        console.log(chalk.yellow(`   ⚠️  ${getT('restore.steps.edgeFunctions.deployFailed', { funcName, message: deployError.message })}`));
       }
     }
     
     // Limpar supabase/functions após deploy (arquivos temporários não são mais necessários)
-    console.log(chalk.cyan('   - Limpando supabase/functions após deploy...'));
+    console.log(chalk.cyan(`   - ${getT('restore.steps.edgeFunctions.cleaningAfter')}`));
     try {
       await fs.rm(supabaseFunctionsDir, { recursive: true, force: true });
     } catch {
       // Ignorar erro de limpeza
     }
     
-    console.log(chalk.green('   ✅ Edge Functions restauradas com sucesso!'));
+    console.log(chalk.green(`   ✅ ${getT('restore.steps.edgeFunctions.success')}`));
     
     return {
       success: true,
@@ -112,7 +114,8 @@ module.exports = async ({ backupPath, targetProject }) => {
     };
     
   } catch (error) {
-    console.error(chalk.red(`   ❌ Erro ao restaurar Edge Functions: ${error.message}`));
+    const getT = global.smoonbI18n?.t || t;
+    console.error(chalk.red(`   ❌ ${getT('restore.steps.edgeFunctions.error', { message: error.message })}`));
     throw error;
   }
 };