smoonb 0.0.75 → 0.0.77

package/package.json

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

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

@@ -16,7 +16,8 @@ module.exports = async ({ databaseUrl, backupDir }) => {
     const urlMatch = databaseUrl.match(/postgresql:\/\/([^:]+):([^@]+)@([^:]+):(\d+)\/(.+)/);
     
     if (!urlMatch) {
-      throw new Error('Database URL inválida');
+      const getT = global.smoonbI18n?.t || t;
+      throw new Error(getT('error.databaseUrlInvalidSimple'));
     }
     
     const [, username, password, host, port] = urlMatch;

package/src/commands/backup/steps/03-database-settings.js

@@ -16,7 +16,8 @@ module.exports = async ({ databaseUrl, projectId, backupDir }) => {
     const urlMatch = databaseUrl.match(/postgresql:\/\/([^:]+):([^@]+)@([^:]+):(\d+)\/(.+)/);
     
     if (!urlMatch) {
-      throw new Error('Database URL inválida');
+      const getT = global.smoonbI18n?.t || t;
+      throw new Error(getT('error.databaseUrlInvalidSimple'));
     }
     
     const [, username, password, host, port, database] = urlMatch;

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

@@ -37,7 +37,7 @@ module.exports = async ({ projectId, accessToken, backupDir, supabaseUrl, supaba
     if (!buckets || buckets.length === 0) {
       console.log(chalk.white(`   - ${getT('backup.steps.storage.noBuckets')}`));
       await writeJson(path.join(storageDir, 'README.md'), {
-        message: 'Nenhum bucket de Storage encontrado neste projeto'
+        message: getT('backup.steps.storage.noBucketsMessage')
       });
       return { success: true, buckets: [] };
     }

package/src/commands/backup/steps/08-edge-functions.js

@@ -79,7 +79,7 @@ module.exports = async (context) => {
     if (!functions || functions.length === 0) {
       console.log(chalk.white(`   - ${getT('backup.steps.functions.noneFound')}`));
       await writeJson(path.join(functionsDir, 'README.md'), {
-        message: 'Nenhuma Edge Function encontrada neste projeto'
+        message: getT('backup.steps.functions.noFunctionsMessage')
       });
       return { success: true, reason: 'no_functions', functions: [] };
     }

package/src/commands/backup/steps/10-migrations.js

@@ -6,7 +6,7 @@ const { cleanDir, countFiles, copyDirSafe } = require('../../../utils/fsExtra');
 const { t } = require('../../../i18n');
 
 /**
- * Etapa 10: Backup Migrations (NOVA ETAPA INDEPENDENTE)
+ * Etapa 10: Migrations Backup (NOVA ETAPA INDEPENDENTE)
  */
 module.exports = async (context) => {
   const { projectId, accessToken, databaseUrl, backupDir } = context;

package/src/commands/check.js

@@ -98,13 +98,15 @@ async function checkDatabaseConnection(databaseUrl) {
       `psql "${databaseUrl}" -t -c "SELECT 1 as test_connection;"`
     );
     
+    const getT = global.smoonbI18n?.t || t;
     if (stdout.trim() === '1') {
-      return { status: 'ok', message: 'Conexão estabelecida com sucesso' };
+      return { status: 'ok', message: getT('check.connectionSuccess') };
     } else {
-      return { status: 'error', message: 'Resposta inesperada da database' };
+      return { status: 'error', message: getT('check.unexpectedResponse') };
     }
   } catch (error) {
-    return { status: 'error', message: `Falha na conexão: ${error.message}` };
+    const getT = global.smoonbI18n?.t || t;
+    return { status: 'error', message: getT('check.connectionError', { message: error.message }) };
   }
 }
 

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

@@ -26,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/03-database.js

@@ -38,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

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

@@ -40,7 +40,8 @@ module.exports = async ({ backupPath, targetProject }) => {
     await inquirer.prompt([{
       type: 'input',
       name: 'continue',
-      message: 'Pressione Enter para continuar'
+      message: getT('restore.steps.auth.pressEnter'),
+      prefix: ''
     }]);
     
     console.log(chalk.green(`   ✅ ${getT('restore.steps.auth.success')}`));

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

@@ -108,11 +108,12 @@ module.exports = async ({ backupPath, targetProject }) => {
     
     // 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

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

@@ -39,7 +39,8 @@ module.exports = async ({ backupPath, targetProject }) => {
     await inquirer.prompt([{
       type: 'input',
       name: 'continue',
-      message: 'Pressione Enter para continuar'
+      message: getT('restore.steps.realtime.pressEnter'),
+      prefix: ''
     }]);
     
     console.log(chalk.green(`   ✅ ${getT('restore.steps.realtime.success')}`));

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('');

package/src/i18n/locales/en.json

@@ -364,7 +364,7 @@
   "backup.steps.migrations.validation": "Validation: linked-ref = {linkedRef} (expected = {expected})",
   "backup.steps.migrations.cleaning": "Cleaning supabase/migrations...",
   "backup.steps.migrations.downloading": "Downloading all migrations from server using migration fetch...",
-  "backup.steps.migrations.downloaded": "Files downloaded: {count} migrations",
+  "backup.steps.migrations.downloaded": "Downloaded files: {count} migrations",
   "backup.steps.migrations.copying": "Copying supabase/migrations → {path} ({count} files)...",
 
   "backup.complete.title": "FULL BACKUP COMPLETED VIA DOCKER!",
@@ -437,7 +437,7 @@
   "backup.steps.migrations.downloading": "Downloading all migrations from server using migration fetch...",
   "backup.steps.migrations.fetchError": "Error executing migration fetch: {message}",
   "backup.steps.migrations.fetchTip": "Verify that the project is correctly linked and the token is valid.",
-  "backup.steps.migrations.downloaded": "Files downloaded: {count} migrations",
+  "backup.steps.migrations.downloaded": "Downloaded files: {count} migrations",
   "backup.steps.migrations.copying": "Copying supabase/migrations → {path} ({count} files)...",
   "backup.steps.migrations.copied": "{count} migration(s) copied",
   "backup.steps.migrations.cleaned": "supabase/migrations deleted.",
@@ -573,6 +573,105 @@
   "restore.steps.realtime.success": "Realtime Settings processed",
 
   "restore.steps.backupSelection.title": "Available backups:",
-  "restore.steps.backupSelection.separator": "═══════════════════════════════════════════════════════════════════════════════"
+  "restore.steps.backupSelection.separator": "═══════════════════════════════════════════════════════════════════════════════",
+  "restore.steps.backupSelection.input": "Enter the backup number to restore ({min}-{max}):",
+  "restore.steps.backupSelection.invalid": "Invalid number",
+
+  "utils.realtime.previousFound": "A previous Realtime Settings recording was found.",
+  "utils.realtime.reuse": "Do you want to reuse the previous configurations?",
+  "utils.realtime.reusing": "Reusing Realtime Settings configurations from previous backup...",
+  "utils.realtime.configTitle": "Realtime Settings Configuration",
+  "utils.realtime.separator": "════════════════════════════════════════════════════════════════",
+  "utils.realtime.access": "Access: {url}",
+  "utils.realtime.note": "Note the values of the 7 parameters below:",
+  "utils.realtime.questions": "Answer the questions below (press Enter to use default value):",
+  "utils.realtime.saved": "Realtime Settings configurations saved!",
+  "utils.realtime.copying": "Copying Realtime Settings from previous backup...",
+
+  "utils.supabaseLink.linking": "Resetting link and linking project: {projectId}...",
+  "utils.supabaseLink.validation": "Validation: linked-ref = {linkedRef} (expected = {expected})",
+  "utils.supabaseLink.validationFailed": "Validation failed: linked-ref = {linkedRef} (expected = {expected}). The linked project does not match the expected project.",
+  "utils.supabaseLink.cannotValidate": "Could not validate link: {message}",
+  "utils.supabaseLink.linkFailed": "Failed to link project {projectId}: {message}",
+
+  "restore.index.envUpdated": ".env.local updated successfully. No keys renamed; values synchronized.",
+  "restore.index.searchingBackups": "Searching for backups in: {path}",
+  "restore.index.noBackupsFound": "No valid backups found",
+  "restore.index.runBackupFirst": "Run first: npx smoonb backup",
+  "restore.index.summaryTitle": "RESTORATION SUMMARY:",
+  "restore.index.selectedBackup": "Selected backup: {name}",
+  "restore.index.targetProject": "Target project: {projectId}",
+  "restore.index.database": "Database: {value}",
+  "restore.index.edgeFunctions": "Edge Functions: {value}",
+  "restore.index.authSettings": "Auth Settings: {value}",
+  "restore.index.storage": "Storage: {value}",
+  "restore.index.databaseSettings": "Database Settings: {value}",
+  "restore.index.realtimeSettings": "Realtime Settings: {value}",
+  "restore.index.yes": "Yes",
+  "restore.index.no": "No",
+  "restore.index.notConfigured": "(not configured)",
+  "restore.index.confirmRestore": "Do you want to start the restoration with these configurations?",
+  "restore.index.restoreCancelled": "Restoration cancelled.",
+  "restore.index.startingRestore": "Starting restoration...",
+  "restore.index.restoringDatabase": "Restoring Database...",
+  "restore.index.restoringEdgeFunctions": "Restoring Edge Functions...",
+  "restore.index.restoringAuthSettings": "Restoring Auth Settings...",
+  "restore.index.restoringStorageBuckets": "Restoring Storage Buckets...",
+  "restore.index.restoringDatabaseSettings": "Restoring Database Settings...",
+  "restore.index.restoringRealtimeSettings": "Restoring Realtime Settings...",
+  "restore.index.restoreComplete": "RESTORATION COMPLETE FINISHED!",
+  "restore.index.targetProjectFinal": "Target project: {projectId}",
+  "restore.index.databaseRestored": "Database: Restored successfully via Docker",
+  "restore.index.edgeFunctionsRestored": "Edge Functions: {success}/{total} functions restored",
+  "restore.index.authSettingsRestored": "Auth Settings: Settings displayed for manual configuration",
+  "restore.index.storageRestored": "Storage: {buckets} bucket(s) restored, {files} file(s) uploaded",
+  "restore.index.storageMetadataOnly": "Storage: {buckets} bucket(s) found - metadata only (.storage.zip file not found)",
+  "restore.index.databaseSettingsRestored": "Database Settings: Extensions and settings restored via SQL",
+  "restore.index.realtimeSettingsRestored": "Realtime Settings: Settings displayed for manual configuration",
+  "restore.index.error": "Error during restoration: {message}",
+
+  "restore.utils.componentsTitle": "Components that will be restored:",
+  "restore.utils.database": "Database (psql -f via Docker)",
+  "restore.utils.edgeFunctions": "Edge Functions: {count} function(s)",
+  "restore.utils.authSettings": "Auth Settings: Display URL and values for manual configuration",
+  "restore.utils.storageBuckets": "Storage Buckets: Automatic restoration of buckets and files via API",
+  "restore.utils.storageMetadataOnly": "Storage Buckets: Display information (metadata only - .storage.zip file not found)",
+  "restore.utils.databaseSettings": "Database Extensions and Settings: Restore via SQL",
+  "restore.utils.realtimeSettings": "Realtime Settings: Display URL and values for manual configuration",
+  "restore.utils.summaryTitle": "Restoration Summary:",
+  "restore.utils.summarySeparator": "═══════════════════════════════════════════════════════════════════════════════",
+  "restore.utils.backup": "Backup: {name}",
+  "restore.utils.sourceProject": "Source Project: {projectId}",
+  "restore.utils.targetProject": "Target Project: {projectId}",
+
+  "restore.steps.auth.pressEnter": "Press Enter to continue",
+  "restore.steps.realtime.pressEnter": "Press Enter to continue",
+
+  "restore.import.fileNotFound": "Backup file not found: {path}",
+  "restore.import.invalidFormat": "Backup file must be .backup.gz or .backup",
+  "restore.import.storageNotFound": "Storage file not found: {path}",
+  "restore.import.storageInvalidFormat": "Storage file must be .storage.zip",
+  "restore.import.invalidFileName": "Backup file name is not in the expected Dashboard format. Expected format: db_cluster-DD-MM-YYYY@HH-MM-SS.backup.gz",
+  "restore.import.importing": "Importing backup to: {name}",
+  "restore.import.backupImported": "Backup file imported: {fileName} ({size} MB)",
+  "restore.import.storageImported": "Storage file imported: {fileName} ({size} MB)",
+  "restore.import.importingFile": "Importing backup file...",
+  "restore.import.importedSelected": "Backup imported and automatically selected: {name}",
+  "restore.import.cannotFind": "Could not find the imported backup",
+  "restore.import.envBackup": "Backup of .env.local: {path}",
+  "restore.import.envNotFound": "⚠️  .env.local file not found. It will be created during mapping.",
+  "restore.import.noComponents": "\n❌ No components selected for restoration!",
+
+  "backup.steps.functions.noFunctionsMessage": "No Edge Functions found in this project",
+  "backup.steps.storage.noBucketsMessage": "No Storage buckets found in this project",
+
+  "check.connectionSuccess": "Connection established successfully",
+  "check.unexpectedResponse": "Unexpected response from database",
+  "check.connectionError": "Connection failed: {message}",
+
+  "error.databaseUrlInvalid": "Invalid Database URL. Expected format: postgresql://user:password@host/database",
+  "error.databaseUrlInvalidSimple": "Invalid Database URL",
+  "error.storageCredentialsNotConfigured": "Target project credentials not configured. SUPABASE_PROJECT_ID and SUPABASE_ACCESS_TOKEN are required",
+  "error.supabaseCredentialsNotConfigured": "Supabase credentials not configured. NEXT_PUBLIC_SUPABASE_URL and SUPABASE_SERVICE_ROLE_KEY are required"
 }
 

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

@@ -572,6 +572,105 @@
   "restore.steps.realtime.success": "Realtime Settings processados",
 
   "restore.steps.backupSelection.title": "Backups disponíveis:",
-  "restore.steps.backupSelection.separator": "═══════════════════════════════════════════════════════════════════════════════"
+  "restore.steps.backupSelection.separator": "═══════════════════════════════════════════════════════════════════════════════",
+  "restore.steps.backupSelection.input": "Digite o número do backup para restaurar ({min}-{max}):",
+  "restore.steps.backupSelection.invalid": "Número inválido",
+
+  "utils.realtime.previousFound": "Foi identificada uma gravação anterior de Realtime Settings.",
+  "utils.realtime.reuse": "Deseja reutilizar as configurações anteriores?",
+  "utils.realtime.reusing": "Reutilizando configurações de Realtime Settings do backup anterior...",
+  "utils.realtime.configTitle": "Configurações de Realtime Settings",
+  "utils.realtime.separator": "════════════════════════════════════════════════════════════════",
+  "utils.realtime.access": "Acesse: {url}",
+  "utils.realtime.note": "Anote os valores dos 7 parâmetros abaixo:",
+  "utils.realtime.questions": "Responda as perguntas abaixo (pressione Enter para usar o valor padrão):",
+  "utils.realtime.saved": "Configurações de Realtime Settings salvas!",
+  "utils.realtime.copying": "Copiando Realtime Settings do backup anterior...",
+
+  "utils.supabaseLink.linking": "Zerando vínculo e linkando projeto: {projectId}...",
+  "utils.supabaseLink.validation": "Validação: linked-ref = {linkedRef} (esperado = {expected})",
+  "utils.supabaseLink.validationFailed": "Validação falhou: linked-ref = {linkedRef} (esperado = {expected}). O projeto linkado não corresponde ao projeto esperado.",
+  "utils.supabaseLink.cannotValidate": "Não foi possível validar o vínculo: {message}",
+  "utils.supabaseLink.linkFailed": "Falha ao linkar projeto {projectId}: {message}",
+
+  "restore.index.envUpdated": ".env.local atualizado com sucesso. Nenhuma chave renomeada; valores sincronizados.",
+  "restore.index.searchingBackups": "Buscando backups em: {path}",
+  "restore.index.noBackupsFound": "Nenhum backup válido encontrado",
+  "restore.index.runBackupFirst": "Execute primeiro: npx smoonb backup",
+  "restore.index.summaryTitle": "RESUMO DA RESTAURAÇÃO:",
+  "restore.index.selectedBackup": "Backup selecionado: {name}",
+  "restore.index.targetProject": "Projeto destino: {projectId}",
+  "restore.index.database": "Database: {value}",
+  "restore.index.edgeFunctions": "Edge Functions: {value}",
+  "restore.index.authSettings": "Auth Settings: {value}",
+  "restore.index.storage": "Storage: {value}",
+  "restore.index.databaseSettings": "Database Settings: {value}",
+  "restore.index.realtimeSettings": "Realtime Settings: {value}",
+  "restore.index.yes": "Sim",
+  "restore.index.no": "Não",
+  "restore.index.notConfigured": "(não configurado)",
+  "restore.index.confirmRestore": "Deseja iniciar a restauração com estas configurações?",
+  "restore.index.restoreCancelled": "Restauração cancelada.",
+  "restore.index.startingRestore": "Iniciando restauração...",
+  "restore.index.restoringDatabase": "Restaurando Database...",
+  "restore.index.restoringEdgeFunctions": "Restaurando Edge Functions...",
+  "restore.index.restoringAuthSettings": "Restaurando Auth Settings...",
+  "restore.index.restoringStorageBuckets": "Restaurando Storage Buckets...",
+  "restore.index.restoringDatabaseSettings": "Restaurando Database Settings...",
+  "restore.index.restoringRealtimeSettings": "Restaurando Realtime Settings...",
+  "restore.index.restoreComplete": "RESTAURAÇÃO COMPLETA FINALIZADA!",
+  "restore.index.targetProjectFinal": "Projeto destino: {projectId}",
+  "restore.index.databaseRestored": "Database: Restaurada com sucesso via Docker",
+  "restore.index.edgeFunctionsRestored": "Edge Functions: {success}/{total} functions restauradas",
+  "restore.index.authSettingsRestored": "Auth Settings: Configurações exibidas para configuração manual",
+  "restore.index.storageRestored": "Storage: {buckets} bucket(s) restaurado(s), {files} arquivo(s) enviado(s)",
+  "restore.index.storageMetadataOnly": "Storage: {buckets} bucket(s) encontrado(s) - apenas metadados (arquivo .storage.zip não encontrado)",
+  "restore.index.databaseSettingsRestored": "Database Settings: Extensões e configurações restauradas via SQL",
+  "restore.index.realtimeSettingsRestored": "Realtime Settings: Configurações exibidas para configuração manual",
+  "restore.index.error": "Erro na restauração: {message}",
+
+  "restore.utils.componentsTitle": "Componentes que serão restaurados:",
+  "restore.utils.database": "Database (psql -f via Docker)",
+  "restore.utils.edgeFunctions": "Edge Functions: {count} function(s)",
+  "restore.utils.authSettings": "Auth Settings: Exibir URL e valores para configuração manual",
+  "restore.utils.storageBuckets": "Storage Buckets: Restauração automática de buckets e arquivos via API",
+  "restore.utils.storageMetadataOnly": "Storage Buckets: Exibir informações (apenas metadados - arquivo .storage.zip não encontrado)",
+  "restore.utils.databaseSettings": "Database Extensions and Settings: Restaurar via SQL",
+  "restore.utils.realtimeSettings": "Realtime Settings: Exibir URL e valores para configuração manual",
+  "restore.utils.summaryTitle": "Resumo da Restauração:",
+  "restore.utils.summarySeparator": "═══════════════════════════════════════════════════════════════════════════════",
+  "restore.utils.backup": "Backup: {name}",
+  "restore.utils.sourceProject": "Projeto Origem: {projectId}",
+  "restore.utils.targetProject": "Projeto Destino: {projectId}",
+
+  "restore.steps.auth.pressEnter": "Pressione Enter para continuar",
+  "restore.steps.realtime.pressEnter": "Pressione Enter para continuar",
+
+  "restore.import.fileNotFound": "Arquivo de backup não encontrado: {path}",
+  "restore.import.invalidFormat": "Arquivo de backup deve ser .backup.gz ou .backup",
+  "restore.import.storageNotFound": "Arquivo de storage não encontrado: {path}",
+  "restore.import.storageInvalidFormat": "Arquivo de storage deve ser .storage.zip",
+  "restore.import.invalidFileName": "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",
+  "restore.import.importing": "Importando backup para: {name}",
+  "restore.import.backupImported": "Arquivo de backup importado: {fileName} ({size} MB)",
+  "restore.import.storageImported": "Arquivo de storage importado: {fileName} ({size} MB)",
+  "restore.import.importingFile": "Importando arquivo de backup...",
+  "restore.import.importedSelected": "Backup importado e selecionado automaticamente: {name}",
+  "restore.import.cannotFind": "Não foi possível encontrar o backup importado",
+  "restore.import.envBackup": "Backup do .env.local: {path}",
+  "restore.import.envNotFound": "⚠️  Arquivo .env.local não encontrado. Será criado durante o mapeamento.",
+  "restore.import.noComponents": "\n❌ Nenhum componente selecionado para restauração!",
+
+  "backup.steps.functions.noFunctionsMessage": "Nenhuma Edge Function encontrada neste projeto",
+  "backup.steps.storage.noBucketsMessage": "Nenhum bucket de Storage encontrado neste projeto",
+
+  "check.connectionSuccess": "Conexão estabelecida com sucesso",
+  "check.unexpectedResponse": "Resposta inesperada da database",
+  "check.connectionError": "Falha na conexão: {message}",
+
+  "error.databaseUrlInvalid": "Database URL inválida. Formato esperado: postgresql://user:password@host/database",
+  "error.databaseUrlInvalidSimple": "Database URL inválida",
+  "error.storageCredentialsNotConfigured": "Credenciais do projeto destino não configuradas. É necessário SUPABASE_PROJECT_ID e SUPABASE_ACCESS_TOKEN",
+  "error.supabaseCredentialsNotConfigured": "Credenciais do Supabase não configuradas. É necessário NEXT_PUBLIC_SUPABASE_URL e SUPABASE_SERVICE_ROLE_KEY"
 }
 

package/src/utils/realtime-settings.js

@@ -1,6 +1,7 @@
 const readline = require('readline');
 const fs = require('fs').promises;
 const path = require('path');
+const { t } = require('../i18n');
 
 /**
  * Captura configurações de Realtime Settings interativamente
@@ -16,8 +17,10 @@ async function captureRealtimeSettings(projectId, backupDir, skipInteractive = f
   // Tentar ler configurações de backup anterior
   const previousSettings = await getPreviousRealtimeSettings(backupDir);
   
+  const getT = global.smoonbI18n?.t || t;
+  
   if (skipInteractive && previousSettings) {
-    console.log('📋 Copiando Realtime Settings do backup anterior...');
+    console.log(`📋 ${getT('utils.realtime.copying')}`);
     await fs.writeFile(settingsFile, JSON.stringify(previousSettings, null, 2));
     return previousSettings;
   }
@@ -25,23 +28,23 @@ async function captureRealtimeSettings(projectId, backupDir, skipInteractive = f
   if (previousSettings && !skipInteractive) {
     const shouldReuse = await askToReusePreviousSettings();
     if (shouldReuse) {
-      console.log('📋 Reutilizando configurações de Realtime Settings do backup anterior...');
+      console.log(`📋 ${getT('utils.realtime.reusing')}`);
       await fs.writeFile(settingsFile, JSON.stringify(previousSettings, null, 2));
       return previousSettings;
     }
   }
   
   // Capturar configurações interativamente
-  console.log('\n🔧 Configurações de Realtime Settings');
-  console.log('═'.repeat(50));
-  console.log(`📱 Acesse: ${dashboardUrl}`);
-  console.log('📝 Anote os valores dos 7 parâmetros abaixo:\n');
+  console.log(`\n🔧 ${getT('utils.realtime.configTitle')}`);
+  console.log(getT('utils.realtime.separator'));
+  console.log(`📱 ${getT('utils.realtime.access', { url: dashboardUrl })}`);
+  console.log(`📝 ${getT('utils.realtime.note')}\n`);
   
   const settings = await captureSettingsInteractively(projectId, previousSettings);
   
   // Salvar configurações
   await fs.writeFile(settingsFile, JSON.stringify(settings, null, 2));
-  console.log('\n✅ Configurações de Realtime Settings salvas!');
+  console.log(`\n✅ ${getT('utils.realtime.saved')}`);
   
   return settings;
 }
@@ -87,13 +90,14 @@ async function getPreviousRealtimeSettings(backupDir) {
  * @returns {Promise<boolean>} true se deve reutilizar
  */
 async function askToReusePreviousSettings() {
+  const getT = global.smoonbI18n?.t || t;
   const rl = readline.createInterface({
     input: process.stdin,
     output: process.stdout
   });
   
   return new Promise((resolve) => {
-    rl.question('🔄 Foi identificada uma gravação anterior de Realtime Settings.\n   Deseja reutilizar as configurações anteriores? (S/n): ', (answer) => {
+    rl.question(`🔄 ${getT('utils.realtime.previousFound')}\n   ${getT('utils.realtime.reuse')} (S/n): `, (answer) => {
       rl.close();
       const shouldReuse = !answer.toLowerCase().startsWith('n');
       resolve(shouldReuse);
@@ -121,8 +125,10 @@ async function captureSettingsInteractively(projectId, previousSettings) {
     });
   };
   
+  const getT = global.smoonbI18n?.t || t;
+  
   try {
-    console.log('📋 Responda as perguntas abaixo (pressione Enter para usar o valor padrão):\n');
+    console.log(`📋 ${getT('utils.realtime.questions')}\n`);
     
     // Valores padrão baseados na imagem ou configurações anteriores
     const defaults = previousSettings?.realtime_settings?.settings || {

package/src/utils/supabaseLink.js

@@ -2,6 +2,7 @@ const chalk = require('chalk');
 const path = require('path');
 const fs = require('fs').promises;
 const { execSync } = require('child_process');
+const { t } = require('../i18n');
 
 /**
  * Extrai a senha da URL de conexão PostgreSQL
@@ -9,9 +10,11 @@ const { execSync } = require('child_process');
  * @returns {string} - Senha extraída
  */
 function extractPasswordFromDbUrl(dbUrl) {
+  const { t } = require('../i18n');
+  const getT = global.smoonbI18n?.t || t;
   const urlMatch = dbUrl.match(/postgresql:\/\/([^:]+):([^@]+)@([^:]+):(\d+)\/(.+)/);
   if (!urlMatch) {
-    throw new Error('Database URL inválida');
+    throw new Error(getT('error.databaseUrlInvalidSimple'));
   }
   const [, , password] = urlMatch;
   return password;
@@ -25,10 +28,11 @@ function extractPasswordFromDbUrl(dbUrl) {
  * @returns {Promise<void>}
  */
 async function ensureCleanLink(projectRef, accessToken, dbPassword) {
+  const getT = global.smoonbI18n?.t || t;
   const tempDir = path.join(process.cwd(), 'supabase', '.temp');
   
   // Remover supabase/.temp completamente
-  console.log(chalk.white(`   - Zerando vínculo e linkando projeto: ${projectRef}...`));
+  console.log(chalk.white(`   - ${getT('utils.supabaseLink.linking', { projectId: projectRef })}`));
   
   try {
     await fs.rm(tempDir, { recursive: true, force: true });
@@ -50,7 +54,7 @@ async function ensureCleanLink(projectRef, accessToken, dbPassword) {
       env
     });
   } catch (error) {
-    throw new Error(`Falha ao linkar projeto ${projectRef}: ${error.message}`);
+    throw new Error(getT('utils.supabaseLink.linkFailed', { projectId: projectRef, message: error.message }));
   }
   
   // Validar: ler supabase/.temp/project-ref e verificar se == projectRef
@@ -60,18 +64,15 @@ async function ensureCleanLink(projectRef, accessToken, dbPassword) {
     const linkedRefTrimmed = linkedRef.trim();
     
     if (linkedRefTrimmed !== projectRef) {
-      throw new Error(
-        `Validação falhou: linked-ref = ${linkedRefTrimmed} (esperado = ${projectRef}). ` +
-        `O projeto linkado não corresponde ao projeto esperado.`
-      );
+      throw new Error(getT('utils.supabaseLink.validationFailed', { linkedRef: linkedRefTrimmed, expected: projectRef }));
     }
     
-    console.log(chalk.white(`   - Validação: linked-ref = ${linkedRefTrimmed} (esperado = ${projectRef})`));
+    console.log(chalk.white(`   - ${getT('utils.supabaseLink.validation', { linkedRef: linkedRefTrimmed, expected: projectRef })}`));
   } catch (error) {
-    if (error.message.includes('Validação falhou')) {
+    if (error.message.includes('Validation failed') || error.message.includes('Validação falhou')) {
       throw error;
     }
-    throw new Error(`Não foi possível validar o vínculo: ${error.message}`);
+    throw new Error(getT('utils.supabaseLink.cannotValidate', { message: error.message }));
   }
 }