smoonb 0.0.74 → 0.0.76

package/src/commands/restore/steps/05-auth-settings.js

@@ -2,6 +2,7 @@ const chalk = require('chalk');
 const path = require('path');
 const fs = require('fs');
 const inquirer = require('inquirer');
+const { t } = require('../../../i18n');
 
 /**
  * Etapa 5: Restaurar Auth Settings (interativo - exibir URL e valores)
@@ -9,19 +10,20 @@ const inquirer = require('inquirer');
 module.exports = async ({ backupPath, targetProject }) => {
   
   try {
+    const getT = global.smoonbI18n?.t || t;
     const authSettingsPath = path.join(backupPath, 'auth-settings.json');
     
     if (!fs.existsSync(authSettingsPath)) {
-      console.log(chalk.yellow('   ⚠️  Nenhuma configuração de Auth encontrada no backup'));
+      console.log(chalk.yellow(`   ⚠️  ${getT('restore.steps.auth.notFound')}`));
       return;
     }
     
     const authSettings = JSON.parse(fs.readFileSync(authSettingsPath, 'utf8'));
     const dashboardUrl = `https://supabase.com/dashboard/project/${targetProject.targetProjectId}/auth/url-config`;
     
-    console.log(chalk.green('\n   ✅ URL para configuração manual:'));
+    console.log(chalk.green(`\n   ✅ ${getT('restore.steps.auth.urlTitle')}`));
     console.log(chalk.cyan(`   ${dashboardUrl}`));
-    console.log(chalk.yellow('\n   📋 Configure manualmente as seguintes opções:'));
+    console.log(chalk.yellow(`\n   📋 ${getT('restore.steps.auth.configureTitle')}`));
     
     if (authSettings.settings?.auth_url_config) {
       Object.entries(authSettings.settings.auth_url_config).forEach(([key, value]) => {
@@ -33,18 +35,19 @@ module.exports = async ({ backupPath, targetProject }) => {
       });
     }
     
-    console.log(chalk.yellow('\n   ⚠️  Após configurar, pressione Enter para continuar...'));
+    console.log(chalk.yellow(`\n   ⚠️  ${getT('restore.steps.auth.pressEnter')}`));
     
     await inquirer.prompt([{
       type: 'input',
       name: 'continue',
-      message: 'Pressione Enter para continuar'
+      message: getT('restore.steps.auth.pressEnter')
     }]);
     
-    console.log(chalk.green('   ✅ Auth Settings processados'));
+    console.log(chalk.green(`   ✅ ${getT('restore.steps.auth.success')}`));
     
   } catch (error) {
-    console.error(chalk.red(`   ❌ Erro ao processar Auth Settings: ${error.message}`));
+    const getT = global.smoonbI18n?.t || t;
+    console.error(chalk.red(`   ❌ ${getT('restore.steps.auth.error', { message: error.message })}`));
   }
 };
 

package/src/commands/restore/steps/06-storage.js

@@ -3,6 +3,7 @@ const path = require('path');
 const fs = require('fs').promises;
 const AdmZip = require('adm-zip');
 const { createClient } = require('@supabase/supabase-js');
+const { t } = require('../../../i18n');
 
 /**
  * Etapa 6: Restaurar Storage Buckets e arquivos
@@ -12,6 +13,7 @@ const { createClient } = require('@supabase/supabase-js');
 module.exports = async ({ backupPath, targetProject }) => {
   
   try {
+    const getT = global.smoonbI18n?.t || t;
     // 1. Verificar se existe arquivo .storage.zip na pasta do backup
     const storageZipFiles = await fs.readdir(backupPath).then(files => 
       files.filter(f => f.endsWith('.storage.zip'))
@@ -79,21 +81,22 @@ module.exports = async ({ backupPath, targetProject }) => {
         const buckets = manifest?.components?.storage?.buckets || [];
         
         if (buckets.length === 0) {
-          console.log(chalk.yellow('   ⚠️  Nenhum bucket de Storage encontrado no backup'));
+          console.log(chalk.yellow(`   ⚠️  ${getT('restore.steps.storage.noBuckets')}`));
           return { success: false, buckets_count: 0 };
         }
         
-        console.log(chalk.yellow('\n   ⚠️  Arquivo .storage.zip não encontrado'));
-        console.log(chalk.white('   ℹ️  Apenas metadados dos buckets foram encontrados'));
-        console.log(chalk.white('   ℹ️  Para restaurar os arquivos, é necessário o arquivo .storage.zip do Dashboard'));
-        console.log(chalk.green(`\n   ✅ ${buckets.length} bucket(s) encontrado(s) no backup (apenas metadados)`));
+        console.log(chalk.yellow(`\n   ⚠️  ${getT('restore.steps.storage.zipNotFound')}`));
+        console.log(chalk.white(`   ℹ️  ${getT('restore.steps.storage.metadataOnly')}`));
+        console.log(chalk.white(`   ℹ️  ${getT('restore.steps.storage.zipRequired')}`));
+        console.log(chalk.green(`\n   ✅ ${getT('restore.steps.storage.bucketsFoundMetadata', { count: buckets.length })}`));
         buckets.forEach(bucket => {
-          console.log(chalk.white(`   - ${bucket.name} (${bucket.public ? 'público' : 'privado'})`));
+          const visibility = bucket.public ? getT('restore.steps.storage.public') : getT('restore.steps.storage.private');
+          console.log(chalk.white(`   - ${getT('restore.steps.storage.bucketInfo', { name: bucket.name, visibility })}`));
         });
         
         return { success: true, buckets_count: buckets.length, files_restored: false };
       } catch {
-        console.log(chalk.yellow('   ⚠️  Nenhum bucket de Storage encontrado no backup'));
+        console.log(chalk.yellow(`   ⚠️  ${getT('restore.steps.storage.noBucketsInBackup')}`));
         return { success: false, buckets_count: 0 };
       }
     }
@@ -101,26 +104,27 @@ module.exports = async ({ backupPath, targetProject }) => {
     // 3. Selecionar o primeiro arquivo .storage.zip encontrado
     const storageZipFile = path.join(backupPath, storageZipFiles[0]);
     const storageZipBaseName = path.basename(storageZipFiles[0], '.storage.zip');
-    console.log(chalk.white(`   - Arquivo de storage encontrado: ${storageZipFiles[0]}`));
+    console.log(chalk.white(`   - ${getT('restore.steps.storage.fileFound', { fileName: storageZipFiles[0] })}`));
     
     // 4. Validar credenciais do projeto destino
     if (!targetProject.targetProjectId || !targetProject.targetAccessToken) {
-      throw new Error('Credenciais do projeto destino não configuradas. É necessário SUPABASE_PROJECT_ID e SUPABASE_ACCESS_TOKEN');
+      const getT = global.smoonbI18n?.t || t;
+      throw new Error(getT('error.storageCredentialsNotConfigured'));
     }
     
     if (!targetProject.targetUrl || !targetProject.targetServiceKey) {
-      throw new Error('Credenciais do Supabase não configuradas. É necessário NEXT_PUBLIC_SUPABASE_URL e SUPABASE_SERVICE_ROLE_KEY');
+      throw new Error(getT('error.supabaseCredentialsNotConfigured'));
     }
     
     // 4.1 Obter project ID do projeto origem e validar substituição
     if (sourceProjectId && sourceProjectId !== targetProject.targetProjectId) {
-      console.log(chalk.cyan(`   🔄 Substituindo Project ID: ${sourceProjectId} → ${targetProject.targetProjectId}`));
+      console.log(chalk.cyan(`   🔄 ${getT('restore.steps.storage.replacingProjectId', { source: sourceProjectId, target: targetProject.targetProjectId })}`));
     } else if (!sourceProjectId) {
-      console.log(chalk.yellow('   ⚠️  Project ID do projeto origem não encontrado no manifest. Continuando sem substituição...'));
+      console.log(chalk.yellow(`   ⚠️  ${getT('restore.steps.storage.projectIdNotFound')}`));
     }
     
     // 5. Extrair arquivo ZIP
-    console.log(chalk.white('   - Extraindo arquivo .storage.zip...'));
+    console.log(chalk.white(`   - ${getT('restore.steps.storage.extracting')}`));
     const extractDir = path.join(backupPath, 'storage_extracted');
     
     try {
@@ -131,14 +135,14 @@ module.exports = async ({ backupPath, targetProject }) => {
     
     const zip = new AdmZip(storageZipFile);
     zip.extractAllTo(extractDir, true);
-    console.log(chalk.green('   ✅ Arquivo extraído com sucesso'));
+    console.log(chalk.green(`   ✅ ${getT('restore.steps.storage.extracted')}`));
     
     // 5.1 Substituir Project ID antigo pelo novo nos diretórios e arquivos extraídos
     // O Supabase pode incluir o project ID nos caminhos dentro do ZIP
     if (sourceProjectId && sourceProjectId !== targetProject.targetProjectId) {
-      console.log(chalk.white('   - Substituindo referências ao Project ID antigo nos arquivos extraídos...'));
+      console.log(chalk.white(`   - ${getT('restore.steps.storage.replacing')}`));
       await replaceProjectIdInExtractedFiles(extractDir, sourceProjectId, targetProject.targetProjectId);
-      console.log(chalk.green('   ✅ Substituição de Project ID concluída'));
+      console.log(chalk.green(`   ✅ ${getT('restore.steps.storage.replaced')}`));
     }
     
     // 6. Ler estrutura de diretórios extraídos
@@ -179,8 +183,8 @@ module.exports = async ({ backupPath, targetProject }) => {
           if (matchesZipFileName) reasons.push('nome do arquivo ZIP');
           if (matchesProjectIdPattern) reasons.push('formato de Project ID');
           const reasonText = reasons.length ? ` (${reasons.join(', ')})` : '';
-          console.log(chalk.white(`   - Detectada pasta raiz com Project ID: ${firstItem}${reasonText}`));
-          console.log(chalk.white(`   - Buscando buckets nas subpastas...`));
+          console.log(chalk.white(`   - ${getT('restore.steps.storage.detectedProjectId', { projectId: firstItem, reason: reasonText })}`));
+          console.log(chalk.white(`   - ${getT('restore.steps.storage.searchingBuckets')}`));
         }
       }
     }
@@ -204,8 +208,8 @@ module.exports = async ({ backupPath, targetProject }) => {
       
       // Se não encontrou buckets nas subpastas, avisar e retornar erro
       if (bucketDirs.length === 0) {
-        console.log(chalk.red(`   ❌ Erro: Nenhum bucket encontrado nas subpastas de ${rootDir}`));
-        console.log(chalk.red(`   ❌ A pasta raiz é um Project ID e não deve ser tratada como bucket`));
+        console.log(chalk.red(`   ❌ ${getT('restore.steps.storage.noBucketsInSubfolders', { rootDir })}`));
+        console.log(chalk.red(`   ❌ ${getT('restore.steps.storage.rootIsProjectId')}`));
         return { success: false, buckets_count: 0 };
       }
     } else {
@@ -224,11 +228,11 @@ module.exports = async ({ backupPath, targetProject }) => {
     }
     
     if (bucketDirs.length === 0) {
-      console.log(chalk.yellow('   ⚠️  Nenhum bucket encontrado no arquivo .storage.zip'));
+      console.log(chalk.yellow(`   ⚠️  ${getT('restore.steps.storage.noBucketsInZip')}`));
       return { success: false, buckets_count: 0 };
     }
     
-    console.log(chalk.white(`   - Encontrados ${bucketDirs.length} bucket(s) no arquivo ZIP`));
+    console.log(chalk.white(`   - ${getT('restore.steps.storage.bucketsFoundInZip', { count: bucketDirs.length })}`));
     
     // 7. Criar cliente Supabase para o projeto destino
     const supabase = createClient(targetProject.targetUrl, targetProject.targetServiceKey);
@@ -242,7 +246,7 @@ module.exports = async ({ backupPath, targetProject }) => {
       const bucketPath = bucketInfo.path;
       
       try {
-        console.log(chalk.white(`\n   - Processando bucket: ${bucketName}`));
+        console.log(chalk.white(`\n   - ${getT('restore.steps.storage.processingBucket', { bucketName })}`));
         
         // 8.1 Obter metadados do bucket do backup (se disponíveis)
         const bucketMeta = bucketMetadata[bucketName] || {
@@ -255,7 +259,7 @@ module.exports = async ({ backupPath, targetProject }) => {
         const { data: existingBuckets, error: listError } = await supabase.storage.listBuckets();
         
         if (listError) {
-          throw new Error(`Erro ao listar buckets: ${listError.message}`);
+          throw new Error(getT('restore.steps.edgeFunctions.listBucketsError', { message: listError.message }));
         }
         
         const existingBucket = existingBuckets?.find(b => b.name === bucketName);
@@ -263,8 +267,11 @@ module.exports = async ({ backupPath, targetProject }) => {
         
         if (!bucketExists) {
           // Criar bucket via Management API com configurações do backup
-          console.log(chalk.white(`     - Criando bucket ${bucketName}...`));
-          console.log(chalk.white(`       Configurações: ${bucketMeta.public ? 'público' : 'privado'}, limite: ${bucketMeta.file_size_limit || 'sem limite'}, tipos: ${bucketMeta.allowed_mime_types?.join(', ') || 'todos'}`));
+          console.log(chalk.white(`     - ${getT('restore.steps.storage.creatingBucket', { bucketName })}`));
+          const visibility = bucketMeta.public ? getT('restore.steps.storage.public') : getT('restore.steps.storage.private');
+          const limit = bucketMeta.file_size_limit || getT('restore.steps.storage.noLimit');
+          const types = bucketMeta.allowed_mime_types?.join(', ') || getT('restore.steps.storage.allTypes');
+          console.log(chalk.white(`       ${getT('restore.steps.storage.bucketConfig', { visibility, limit, types })}`));
           
           const createResponse = await fetch(
             `https://api.supabase.com/v1/projects/${targetProject.targetProjectId}/storage/buckets`,
@@ -285,13 +292,13 @@ module.exports = async ({ backupPath, targetProject }) => {
           
           if (!createResponse.ok) {
             const errorText = await createResponse.text();
-            throw new Error(`Erro ao criar bucket: ${createResponse.status} ${errorText}`);
+            throw new Error(getT('restore.steps.edgeFunctions.createBucketError', { status: createResponse.status, errorText }));
           }
           
-          console.log(chalk.green(`     ✅ Bucket ${bucketName} criado com configurações do backup`));
+          console.log(chalk.green(`     ✅ ${getT('restore.steps.storage.bucketCreated', { bucketName })}`));
         } else {
           // Bucket já existe - verificar e atualizar configurações se necessário
-          console.log(chalk.white(`     - Bucket ${bucketName} já existe`));
+          console.log(chalk.white(`     - ${getT('restore.steps.storage.bucketExists', { bucketName })}`));
           
           const needsUpdate = 
             existingBucket.public !== bucketMeta.public ||
@@ -299,7 +306,7 @@ module.exports = async ({ backupPath, targetProject }) => {
             JSON.stringify(existingBucket.allowed_mime_types || []) !== JSON.stringify(bucketMeta.allowed_mime_types || []);
           
           if (needsUpdate) {
-            console.log(chalk.white(`     - Atualizando configurações do bucket para corresponder ao backup...`));
+            console.log(chalk.white(`     - ${getT('restore.steps.storage.updating')}`));
             
             const updateResponse = await fetch(
               `https://api.supabase.com/v1/projects/${targetProject.targetProjectId}/storage/buckets/${bucketName}`,
@@ -319,12 +326,12 @@ module.exports = async ({ backupPath, targetProject }) => {
             
             if (!updateResponse.ok) {
               const errorText = await updateResponse.text();
-              console.log(chalk.yellow(`       ⚠️  Não foi possível atualizar configurações: ${errorText}`));
+              console.log(chalk.yellow(`       ⚠️  ${getT('restore.steps.storage.updateError', { errorText })}`));
             } else {
-              console.log(chalk.green(`       ✅ Configurações do bucket atualizadas`));
+              console.log(chalk.green(`       ✅ ${getT('restore.steps.storage.bucketUpdated')}`));
             }
           } else {
-            console.log(chalk.white(`     - Configurações do bucket já estão corretas`));
+            console.log(chalk.white(`     - ${getT('restore.steps.storage.bucketConfigCorrect')}`));
           }
         }
         
@@ -356,7 +363,7 @@ module.exports = async ({ backupPath, targetProject }) => {
         }
         
         const filesToUpload = await getAllFiles(bucketPath);
-        console.log(chalk.white(`     - Encontrados ${filesToUpload.length} arquivo(s) para upload`));
+        console.log(chalk.white(`     - ${getT('restore.steps.storage.filesFoundForUpload', { count: filesToUpload.length })}`));
         
         // 8.4 Fazer upload de cada arquivo
         // Criar mapa de metadados dos objetos do backup (se disponível)
@@ -427,25 +434,25 @@ module.exports = async ({ backupPath, targetProject }) => {
               .upload(storagePath, fileContent, uploadOptions);
             
             if (uploadError) {
-              console.log(chalk.yellow(`       ⚠️  Erro ao fazer upload de ${storagePath}: ${uploadError.message}`));
+              console.log(chalk.yellow(`       ⚠️  ${getT('restore.steps.storage.uploadError', { path: storagePath, message: uploadError.message })}`));
             } else {
               filesUploaded++;
               if (filesToUpload.length <= 10 || filesUploaded % Math.ceil(filesToUpload.length / 10) === 0) {
-                const metaInfo = objectMeta ? ' (metadados preservados)' : '';
-                console.log(chalk.white(`       - Upload: ${storagePath}${metaInfo}`));
+                const metaInfo = objectMeta ? ` ${getT('restore.steps.storage.metadataPreserved')}` : '';
+                console.log(chalk.white(`       - ${getT('restore.steps.storage.uploadProgress', { path: storagePath, metaInfo })}`));
               }
             }
           } catch (fileError) {
-            console.log(chalk.yellow(`       ⚠️  Erro ao processar arquivo ${file.storagePath}: ${fileError.message}`));
+            console.log(chalk.yellow(`       ⚠️  ${getT('restore.steps.storage.fileError', { path: file.storagePath, message: fileError.message })}`));
           }
         }
         
-        console.log(chalk.green(`     ✅ Bucket ${bucketName}: ${filesUploaded}/${filesToUpload.length} arquivo(s) enviado(s)`));
+        console.log(chalk.green(`     ✅ ${getT('restore.steps.storage.bucketDone', { bucketName, uploaded: filesUploaded, total: filesToUpload.length })}`));
         successCount++;
         totalFilesUploaded += filesUploaded;
         
       } catch (bucketError) {
-        console.log(chalk.red(`     ❌ Erro ao processar bucket ${bucketName}: ${bucketError.message}`));
+        console.log(chalk.red(`     ❌ ${getT('restore.steps.storage.bucketError', { bucketName, message: bucketError.message })}`));
       }
     }
     
@@ -456,7 +463,7 @@ module.exports = async ({ backupPath, targetProject }) => {
       // Ignorar erro de limpeza
     }
     
-    console.log(chalk.green(`\n   ✅ Restauração de Storage concluída: ${successCount}/${bucketDirs.length} bucket(s) processado(s), ${totalFilesUploaded} arquivo(s) enviado(s)`));
+    console.log(chalk.green(`\n   ✅ ${getT('restore.steps.storage.restoreComplete', { success: successCount, total: bucketDirs.length, files: totalFilesUploaded })}`));
     
     return {
       success: true,
@@ -466,7 +473,8 @@ module.exports = async ({ backupPath, targetProject }) => {
     };
     
   } catch (error) {
-    console.error(chalk.red(`   ❌ Erro ao processar Storage: ${error.message}`));
+    const getT = global.smoonbI18n?.t || t;
+    console.error(chalk.red(`   ❌ ${getT('restore.steps.storage.error', { message: error.message })}`));
     throw error;
   }
 };

package/src/commands/restore/steps/07-database-settings.js

@@ -2,17 +2,19 @@ const chalk = require('chalk');
 const path = require('path');
 const fs = require('fs');
 const { execSync } = require('child_process');
+const { t } = require('../../../i18n');
 
 /**
  * Etapa 7: Restaurar Database Settings (via SQL)
  */
 module.exports = async ({ backupPath, targetProject }) => {
   try {
+    const getT = global.smoonbI18n?.t || t;
     const files = fs.readdirSync(backupPath);
     const dbSettingsFile = files.find(f => f.startsWith('database-settings-') && f.endsWith('.json'));
     
     if (!dbSettingsFile) {
-      console.log(chalk.yellow('   ⚠️  Nenhuma configuração de Database encontrada no backup'));
+      console.log(chalk.yellow(`   ⚠️  ${getT('restore.steps.databaseSettings.notFound')}`));
       return { success: false };
     }
     
@@ -22,18 +24,18 @@ module.exports = async ({ backupPath, targetProject }) => {
     const extensions = dbSettings.extensions || [];
     
     if (extensions.length > 0) {
-      console.log(chalk.white(`   - Habilitando ${extensions.length} extension(s)...`));
+      console.log(chalk.white(`   - ${getT('restore.steps.databaseSettings.enabling', { count: extensions.length })}`));
       
       for (const ext of extensions) {
         const extName = typeof ext === 'string' ? ext : ext.name;
-        console.log(chalk.white(`     - ${extName}`));
+        console.log(chalk.white(`     ${getT('restore.steps.databaseSettings.extension', { extName })}`));
         
         const sqlCommand = `CREATE EXTENSION IF NOT EXISTS ${extName};`;
         
         const urlMatch = targetProject.targetDatabaseUrl.match(/postgresql:\/\/([^@:]+):([^@]+)@(.+)$/);
         
         if (!urlMatch) {
-          console.log(chalk.yellow(`     ⚠️  URL inválida para ${extName}`));
+          console.log(chalk.yellow(`     ⚠️  ${getT('restore.steps.databaseSettings.invalidUrl', { extName })}`));
           continue;
         }
         
@@ -49,17 +51,18 @@ module.exports = async ({ backupPath, targetProject }) => {
         try {
           execSync(dockerCmd, { stdio: 'pipe', encoding: 'utf8' });
         } catch {
-          console.log(chalk.yellow(`     ⚠️  ${extName} - extension já existe ou não pode ser habilitada`));
+          console.log(chalk.yellow(`     ⚠️  ${getT('restore.steps.databaseSettings.extensionExists', { extName })}`));
         }
       }
     }
     
-    console.log(chalk.green('   ✅ Database Settings restaurados com sucesso!'));
+    console.log(chalk.green(`   ✅ ${getT('restore.steps.databaseSettings.success')}`));
     
     return { success: true, extensions_count: extensions.length };
     
   } catch (error) {
-    console.error(chalk.red(`   ❌ Erro ao restaurar Database Settings: ${error.message}`));
+    const getT = global.smoonbI18n?.t || t;
+    console.error(chalk.red(`   ❌ ${getT('restore.steps.databaseSettings.error', { message: error.message })}`));
     throw error;
   }
 };

package/src/commands/restore/steps/08-realtime-settings.js

@@ -2,6 +2,7 @@ const chalk = require('chalk');
 const path = require('path');
 const fs = require('fs');
 const inquirer = require('inquirer');
+const { t } = require('../../../i18n');
 
 /**
  * Etapa 8: Restaurar Realtime Settings (interativo - exibir URL e valores)
@@ -9,19 +10,20 @@ const inquirer = require('inquirer');
 module.exports = async ({ backupPath, targetProject }) => {
   
   try {
+    const getT = global.smoonbI18n?.t || t;
     const realtimeSettingsPath = path.join(backupPath, 'realtime-settings.json');
     
     if (!fs.existsSync(realtimeSettingsPath)) {
-      console.log(chalk.yellow('   ⚠️  Nenhuma configuração de Realtime encontrada no backup'));
+      console.log(chalk.yellow(`   ⚠️  ${getT('restore.steps.realtime.notFound')}`));
       return;
     }
     
     const realtimeSettings = JSON.parse(fs.readFileSync(realtimeSettingsPath, 'utf8'));
     const dashboardUrl = `https://supabase.com/dashboard/project/${targetProject.targetProjectId}/realtime/settings`;
     
-    console.log(chalk.green('\n   ✅ URL para configuração manual:'));
+    console.log(chalk.green(`\n   ✅ ${getT('restore.steps.realtime.urlTitle')}`));
     console.log(chalk.cyan(`   ${dashboardUrl}`));
-    console.log(chalk.yellow('\n   📋 Configure manualmente as seguintes opções:'));
+    console.log(chalk.yellow(`\n   📋 ${getT('restore.steps.realtime.configureTitle')}`));
     
     if (realtimeSettings.realtime_settings?.settings) {
       Object.values(realtimeSettings.realtime_settings.settings).forEach((setting) => {
@@ -32,18 +34,19 @@ module.exports = async ({ backupPath, targetProject }) => {
       });
     }
     
-    console.log(chalk.yellow('\n   ⚠️  Após configurar, pressione Enter para continuar...'));
+    console.log(chalk.yellow(`\n   ⚠️  ${getT('restore.steps.realtime.pressEnter')}`));
     
     await inquirer.prompt([{
       type: 'input',
       name: 'continue',
-      message: 'Pressione Enter para continuar'
+      message: getT('restore.steps.realtime.pressEnter')
     }]);
     
-    console.log(chalk.green('   ✅ Realtime Settings processados'));
+    console.log(chalk.green(`   ✅ ${getT('restore.steps.realtime.success')}`));
     
   } catch (error) {
-    console.error(chalk.red(`   ❌ Erro ao processar Realtime Settings: ${error.message}`));
+    const getT = global.smoonbI18n?.t || t;
+    console.error(chalk.red(`   ❌ ${getT('restore.steps.realtime.error', { message: error.message })}`));
   }
 };
 

package/src/commands/restore/utils.js

@@ -1,6 +1,7 @@
 const chalk = require('chalk');
 const fs = require('fs');
 const path = require('path');
+const { t } = require('../../i18n');
 
 /**
  * Listar backups válidos (aceita .backup.gz e .backup)
@@ -67,17 +68,18 @@ function formatBytes(bytes) {
  * Mostrar resumo da restauração
  */
 function showRestoreSummary(backup, components, targetProject) {
-  console.log(chalk.blue('\n📋 Resumo da Restauração:'));
-  console.log(chalk.blue('═'.repeat(80)));
-  console.log(chalk.cyan(`📦 Backup: ${backup.name}`));
-  console.log(chalk.cyan(`📤 Projeto Origem: ${backup.projectId}`));
-  console.log(chalk.cyan(`📥 Projeto Destino: ${targetProject.targetProjectId}`));
+  const getT = global.smoonbI18n?.t || t;
+  console.log(chalk.blue(`\n📋 ${getT('restore.utils.summaryTitle')}`));
+  console.log(chalk.blue(getT('restore.utils.summarySeparator')));
+  console.log(chalk.cyan(`📦 ${getT('restore.utils.backup', { name: backup.name })}`));
+  console.log(chalk.cyan(`📤 ${getT('restore.utils.sourceProject', { projectId: backup.projectId })}`));
+  console.log(chalk.cyan(`📥 ${getT('restore.utils.targetProject', { projectId: targetProject.targetProjectId })}`));
   console.log('');
-  console.log(chalk.cyan('Componentes que serão restaurados:'));
+  console.log(chalk.cyan(getT('restore.utils.componentsTitle')));
   console.log('');
   
   if (components.database) {
-    console.log('✅ Database (psql -f via Docker)');
+    console.log(`✅ ${getT('restore.utils.database')}`);
   }
   
   if (components.edgeFunctions) {
@@ -85,30 +87,30 @@ function showRestoreSummary(backup, components, targetProject) {
     const functions = fs.readdirSync(edgeFunctionsDir).filter(item => 
       fs.statSync(path.join(edgeFunctionsDir, item)).isDirectory()
     );
-    console.log(`⚡ Edge Functions: ${functions.length} function(s)`);
+    console.log(`⚡ ${getT('restore.utils.edgeFunctions', { count: functions.length })}`);
     functions.forEach(func => console.log(`   - ${func}`));
   }
   
   if (components.authSettings) {
-    console.log('🔐 Auth Settings: Exibir URL e valores para configuração manual');
+    console.log(`🔐 ${getT('restore.utils.authSettings')}`);
   }
   
   if (components.storage) {
     const backupPath = backup.path;
     const storageZipFiles = fs.readdirSync(backupPath).filter(f => f.endsWith('.storage.zip'));
     if (storageZipFiles.length > 0) {
-      console.log('📦 Storage Buckets: Restauração automática de buckets e arquivos via API');
+      console.log(`📦 ${getT('restore.utils.storageBuckets')}`);
     } else {
-      console.log('📦 Storage Buckets: Exibir informações (apenas metadados - arquivo .storage.zip não encontrado)');
+      console.log(`📦 ${getT('restore.utils.storageMetadataOnly')}`);
     }
   }
   
   if (components.databaseSettings) {
-    console.log('🔧 Database Extensions and Settings: Restaurar via SQL');
+    console.log(`🔧 ${getT('restore.utils.databaseSettings')}`);
   }
   
   if (components.realtimeSettings) {
-    console.log('🔄 Realtime Settings: Exibir URL e valores para configuração manual');
+    console.log(`🔄 ${getT('restore.utils.realtimeSettings')}`);
   }
   
   console.log('');