smoonb 0.0.74 → 0.0.76

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

@@ -5,6 +5,7 @@ const AdmZip = require('adm-zip');
 const { createClient } = require('@supabase/supabase-js');
 const { ensureDir, writeJson } = require('../../../utils/fsx');
 const { confirm } = require('../../../utils/prompt');
+const { t } = require('../../../i18n');
 
 /**
  * Etapa 6: Backup Storage via Supabase API
@@ -12,10 +13,11 @@ const { confirm } = require('../../../utils/prompt');
  */
 module.exports = async ({ projectId, accessToken, backupDir, supabaseUrl, supabaseServiceKey }) => {
   try {
+    const getT = global.smoonbI18n?.t || t;
     const storageDir = path.join(backupDir, 'storage');
     await ensureDir(storageDir);
 
-    console.log(chalk.white('   - Listando buckets de Storage via Management API...'));
+    console.log(chalk.white(`   - ${getT('backup.steps.storage.listing')}`));
     
     // Usar fetch direto para Management API com Personal Access Token
     const storageResponse = await fetch(`https://api.supabase.com/v1/projects/${projectId}/storage/buckets`, {
@@ -26,25 +28,25 @@ module.exports = async ({ projectId, accessToken, backupDir, supabaseUrl, supaba
     });
     
     if (!storageResponse.ok) {
-      console.log(chalk.yellow(`     ⚠️ Erro ao listar buckets: ${storageResponse.status} ${storageResponse.statusText}`));
+      console.log(chalk.yellow(`     ⚠️ ${getT('backup.steps.storage.listBucketsError', { status: storageResponse.status, statusText: storageResponse.statusText })}`));
       return { success: false, buckets: [] };
     }
 
     const buckets = await storageResponse.json();
 
     if (!buckets || buckets.length === 0) {
-      console.log(chalk.white('   - Nenhum bucket encontrado'));
+      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: [] };
     }
 
-    console.log(chalk.white(`   - Encontrados ${buckets.length} buckets`));
+    console.log(chalk.white(`   - ${getT('backup.steps.storage.found', { count: buckets.length })}`));
 
     // Validar credenciais do Supabase para download de arquivos
     if (!supabaseUrl || !supabaseServiceKey) {
-      console.log(chalk.yellow('   ⚠️  Credenciais do Supabase não disponíveis. Fazendo backup apenas de metadados...'));
+      console.log(chalk.yellow(`   ⚠️  ${getT('backup.steps.storage.credentialsNotAvailable')}`));
       return await backupMetadataOnly(buckets, storageDir, projectId, accessToken);
     }
 
@@ -64,7 +66,7 @@ module.exports = async ({ projectId, accessToken, backupDir, supabaseUrl, supaba
 
     for (const bucket of buckets || []) {
       try {
-        console.log(chalk.white(`   - Processando bucket: ${bucket.name}`));
+        console.log(chalk.white(`   - ${getT('backup.steps.storage.processing', { bucketName: bucket.name })}`));
         
         // Listar objetos do bucket via Management API com Personal Access Token
         const objectsResponse = await fetch(`https://api.supabase.com/v1/projects/${projectId}/storage/buckets/${bucket.name}/objects`, {
@@ -97,12 +99,12 @@ module.exports = async ({ projectId, accessToken, backupDir, supabaseUrl, supaba
         await ensureDir(bucketDir);
         
         // Listar todos os arquivos recursivamente usando Supabase client
-        console.log(chalk.white(`     - Listando arquivos do bucket ${bucket.name}...`));
+        console.log(chalk.white(`     - ${getT('backup.steps.storage.listingFiles', { bucketName: bucket.name })}`));
         const allFiles = await listAllFilesRecursively(supabase, bucket.name, '');
         
         let filesDownloaded = 0;
         if (allFiles.length > 0) {
-          console.log(chalk.white(`     - Baixando ${allFiles.length} arquivo(s) do bucket ${bucket.name}...`));
+          console.log(chalk.white(`     - ${getT('backup.steps.storage.downloading', { count: allFiles.length, bucketName: bucket.name })}`));
           
           for (const filePath of allFiles) {
             try {
@@ -112,7 +114,7 @@ module.exports = async ({ projectId, accessToken, backupDir, supabaseUrl, supaba
                 .download(filePath);
 
               if (downloadError) {
-                console.log(chalk.yellow(`       ⚠️  Erro ao baixar ${filePath}: ${downloadError.message}`));
+                console.log(chalk.yellow(`       ⚠️  ${getT('backup.steps.storage.downloadError', { path: filePath, message: downloadError.message })}`));
                 continue;
               }
 
@@ -129,10 +131,10 @@ module.exports = async ({ projectId, accessToken, backupDir, supabaseUrl, supaba
 
               // Mostrar progresso a cada 10 arquivos ou se for o último
               if (filesDownloaded % 10 === 0 || filesDownloaded === allFiles.length) {
-                console.log(chalk.white(`       - Baixados ${filesDownloaded}/${allFiles.length} arquivo(s)...`));
+                console.log(chalk.white(`       - ${getT('backup.steps.storage.downloaded', { current: filesDownloaded, total: allFiles.length })}`));
               }
             } catch (fileError) {
-              console.log(chalk.yellow(`       ⚠️  Erro ao processar arquivo ${filePath}: ${fileError.message}`));
+              console.log(chalk.yellow(`       ⚠️  ${getT('backup.steps.storage.processFileError', { path: filePath, message: fileError.message })}`));
             }
           }
         }
@@ -145,14 +147,14 @@ module.exports = async ({ projectId, accessToken, backupDir, supabaseUrl, supaba
           totalFiles: allFiles.length
         });
 
-        console.log(chalk.green(`     ✅ Bucket ${bucket.name}: ${filesDownloaded}/${allFiles.length} arquivo(s) baixado(s)`));
+        console.log(chalk.green(`     ✅ ${getT('backup.steps.storage.bucketDone', { bucketName: bucket.name, downloaded: filesDownloaded, total: allFiles.length })}`));
       } catch (error) {
-        console.log(chalk.yellow(`     ⚠️ Erro ao processar bucket ${bucket.name}: ${error.message}`));
+        console.log(chalk.yellow(`     ⚠️ ${getT('backup.steps.storage.processBucketError', { bucketName: bucket.name, message: error.message })}`));
       }
     }
 
     // Criar ZIP no padrão do Dashboard: {project-id}.storage.zip
-    console.log(chalk.white('\n   - Criando arquivo ZIP no padrão do Dashboard...'));
+    console.log(chalk.white(`\n   - ${getT('backup.steps.storage.creatingZip')}`));
     const zipFileName = `${projectId}.storage.zip`;
     const zipFilePath = path.join(backupDir, zipFileName);
     
@@ -167,25 +169,24 @@ module.exports = async ({ projectId, accessToken, backupDir, supabaseUrl, supaba
     const zipStats = await fs.stat(zipFilePath);
     const zipSizeMB = (zipStats.size / (1024 * 1024)).toFixed(2);
     
-    console.log(chalk.green(`   ✅ Arquivo ZIP criado: ${zipFileName} (${zipSizeMB} MB)`));
+    console.log(chalk.green(`   ✅ ${getT('backup.steps.storage.zipCreated', { fileName: zipFileName, size: zipSizeMB })}`));
 
     // Perguntar ao usuário se deseja limpar a estrutura temporária
-    const tempDirName = path.basename(tempStorageDir);
-    const shouldCleanup = await confirm(`   Deseja limpar ${tempDirName} após o backup`, false);
+    const shouldCleanup = await confirm(`   ${getT('backup.steps.storage.cleanup')}`, false);
     
     if (shouldCleanup) {
-      console.log(chalk.white(`   - Limpando estrutura temporária...`));
+      console.log(chalk.white(`   - ${getT('backup.steps.storage.cleanupRemoving')}`));
       try {
         await fs.rm(tempStorageDir, { recursive: true, force: true });
-        console.log(chalk.green(`   ✅ Estrutura temporária removida`));
+        console.log(chalk.green(`   ✅ ${getT('backup.steps.storage.cleanupRemoved')}`));
       } catch (cleanupError) {
-        console.log(chalk.yellow(`   ⚠️  Erro ao limpar estrutura temporária: ${cleanupError.message}`));
+        console.log(chalk.yellow(`   ⚠️  ${getT('backup.steps.storage.cleanupError', { message: cleanupError.message })}`));
       }
     } else {
-      console.log(chalk.white(`   ℹ️  Estrutura temporária mantida em: ${path.relative(process.cwd(), tempStorageDir)}`));
+      console.log(chalk.white(`   ℹ️  ${getT('backup.steps.storage.tempKept', { path: path.relative(process.cwd(), tempStorageDir) })}`));
     }
 
-    console.log(chalk.green(`✅ Storage backupado: ${processedBuckets.length} buckets, ${totalFilesDownloaded} arquivo(s) baixado(s)`));
+    console.log(chalk.green(`✅ ${getT('backup.steps.storage.done', { buckets: processedBuckets.length, files: totalFilesDownloaded })}`));
     return { 
       success: true, 
       buckets: processedBuckets,
@@ -195,7 +196,8 @@ module.exports = async ({ projectId, accessToken, backupDir, supabaseUrl, supaba
       tempDirCleaned: shouldCleanup
     };
   } catch (error) {
-    console.log(chalk.yellow(`⚠️ Erro no backup do Storage: ${error.message}`));
+    const getT = global.smoonbI18n?.t || t;
+    console.log(chalk.yellow(`⚠️ ${getT('backup.steps.storage.error', { message: error.message })}`));
     return { success: false, buckets: [] };
   }
 };
@@ -254,6 +256,7 @@ async function backupMetadataOnly(buckets, storageDir, projectId, accessToken) {
  */
 async function listAllFilesRecursively(supabase, bucketName, folderPath = '') {
   const allFiles = [];
+  const getT = global.smoonbI18n?.t || t;
   
   try {
     // Listar arquivos e pastas no caminho atual
@@ -265,7 +268,7 @@ async function listAllFilesRecursively(supabase, bucketName, folderPath = '') {
       });
 
     if (error) {
-      console.log(chalk.yellow(`       ⚠️  Erro ao listar ${folderPath || 'raiz'}: ${error.message}`));
+      console.log(chalk.yellow(`       ⚠️  ${getT('backup.steps.storage.listError', { path: folderPath || 'raiz', message: error.message })}`));
       return allFiles;
     }
 
@@ -286,7 +289,7 @@ async function listAllFilesRecursively(supabase, bucketName, folderPath = '') {
       }
     }
   } catch (error) {
-    console.log(chalk.yellow(`       ⚠️  Erro ao processar ${folderPath || 'raiz'}: ${error.message}`));
+    console.log(chalk.yellow(`       ⚠️  ${getT('backup.steps.storage.processError', { path: folderPath || 'raiz', message: error.message })}`));
   }
 
   return allFiles;

package/src/commands/backup/steps/07-custom-roles.js

@@ -3,6 +3,7 @@ const path = require('path');
 const fs = require('fs').promises;
 const { promisify } = require('util');
 const { exec } = require('child_process');
+const { t } = require('../../../i18n');
 
 const execAsync = promisify(exec);
 
@@ -11,7 +12,8 @@ const execAsync = promisify(exec);
  */
 module.exports = async ({ databaseUrl, backupDir, accessToken }) => {
   try {
-    console.log(chalk.white('   - Exportando Custom Roles via Docker...'));
+    const getT = global.smoonbI18n?.t || t;
+    console.log(chalk.white(`   - ${getT('backup.steps.roles.exporting')}`));
     
     const customRolesFile = path.join(backupDir, 'custom-roles.sql');
     
@@ -28,11 +30,12 @@ module.exports = async ({ databaseUrl, backupDir, accessToken }) => {
       
       return { success: true, roles: [{ filename: 'custom-roles.sql', sizeKB }] };
     } catch (error) {
-      console.log(chalk.yellow(`     ⚠️ Erro ao exportar Custom Roles via Docker: ${error.message}`));
+      console.log(chalk.yellow(`     ⚠️ ${getT('backup.steps.roles.exportError', { message: error.message })}`));
       return { success: false, roles: [] };
     }
   } catch (error) {
-    console.log(chalk.yellow(`     ⚠️ Erro no backup dos Custom Roles: ${error.message}`));
+    const getT = global.smoonbI18n?.t || t;
+    console.log(chalk.yellow(`     ⚠️ ${getT('backup.steps.roles.error', { message: error.message })}`));
     return { success: false, roles: [] };
   }
 };

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

@@ -4,6 +4,7 @@ const fs = require('fs').promises;
 const { ensureDir, writeJson } = require('../../../utils/fsx');
 const { extractPasswordFromDbUrl, ensureCleanLink } = require('../../../utils/supabaseLink');
 const { cleanDir } = require('../../../utils/fsExtra');
+const { t } = require('../../../i18n');
 
 /**
  * Etapa 8: Backup Edge Functions via Docker (reset link + limpeza opcional)
@@ -42,21 +43,23 @@ module.exports = async (context) => {
     
     // Se o usuário escolheu limpar APÓS, podemos limpar ANTES também para garantir ambiente limpo
     // Mas se escolheu NÃO limpar, preservamos o que já existe
+    const getT = global.smoonbI18n?.t || t;
+    
     if (shouldCleanAfter) {
       // Limpar antes se o usuário escolheu limpar após (garante ambiente limpo)
       await cleanDir(supabaseFunctionsDir);
-      console.log(chalk.white('   - Pasta supabase/functions limpa antes do backup.'));
+      console.log(chalk.white(`   - ${getT('backup.steps.functions.cleanBefore')}`));
     } else {
       // Apenas garantir que o diretório existe
       await fs.mkdir(supabaseFunctionsDir, { recursive: true });
       if (existingFunctionsBefore.length > 0) {
-        console.log(chalk.white(`   - Preservando ${existingFunctionsBefore.length} função(ões) existente(s) na pasta supabase/functions.`));
+        console.log(chalk.white(`   - ${getT('backup.steps.functions.preserving', { count: existingFunctionsBefore.length })}`));
       } else {
-        console.log(chalk.white('   - Pasta supabase/functions preparada (será preservada após backup).'));
+        console.log(chalk.white(`   - ${getT('backup.steps.functions.prepared')}`));
       }
     }
 
-    console.log(chalk.white('   - Listando Edge Functions via Management API...'));
+    console.log(chalk.white(`   - ${getT('backup.steps.functions.listing')}`));
     
     // Usar fetch direto para Management API com Personal Access Token
     const functionsResponse = await fetch(`https://api.supabase.com/v1/projects/${projectId}/functions`, {
@@ -67,16 +70,16 @@ module.exports = async (context) => {
     });
     
     if (!functionsResponse.ok) {
-      console.log(chalk.yellow(`     ⚠️ Erro ao listar Edge Functions: ${functionsResponse.status} ${functionsResponse.statusText}`));
+      console.log(chalk.yellow(`     ⚠️ ${getT('backup.steps.functions.listError', { status: functionsResponse.status, statusText: functionsResponse.statusText })}`));
       return { success: false, reason: 'api_error', functions: [] };
     }
 
     const functions = await functionsResponse.json();
     
     if (!functions || functions.length === 0) {
-      console.log(chalk.white('   - Nenhuma Edge Function encontrada'));
+      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: [] };
     }
@@ -154,7 +157,7 @@ module.exports = async (context) => {
         });
         
       } catch (error) {
-        console.log(chalk.yellow(`     ⚠️ Erro ao baixar ${func.name}: ${error.message}`));
+        console.log(chalk.yellow(`     ⚠️ ${getT('backup.steps.functions.downloadError', { funcName: func.name, message: error.message })}`));
         errorCount++;
       }
     }
@@ -167,11 +170,11 @@ module.exports = async (context) => {
     // Nota: shouldCleanAfter já foi definido acima
     if (shouldCleanAfter) {
       await cleanDir(supabaseFunctionsDir);
-      console.log(chalk.white('   - supabase/functions limpo após o backup.'));
+      console.log(chalk.white(`   - ${getT('backup.steps.functions.cleanAfter')}`));
     } else {
       // Preservar tudo: tanto as funções que já existiam quanto as que foram baixadas
       // As funções baixadas não foram removidas individualmente (linha acima foi ajustada)
-      console.log(chalk.white('   - supabase/functions preservada conforme solicitado.'));
+      console.log(chalk.white(`   - ${getT('backup.steps.functions.preserved')}`));
     }
     
     return { 
@@ -185,7 +188,8 @@ module.exports = async (context) => {
     };
 
   } catch (error) {
-    console.log(chalk.yellow(`   ⚠️ Erro durante backup de Edge Functions: ${error.message}`));
+    const getT = global.smoonbI18n?.t || t;
+    console.log(chalk.yellow(`   ⚠️ ${getT('backup.steps.functions.error', { message: error.message })}`));
     console.log('⏭️  Continuando com outros componentes...');
     return { success: false, reason: 'download_error', error: error.message, functions: [] };
   }

package/src/commands/backup/steps/09-supabase-temp.js

@@ -2,6 +2,7 @@ const chalk = require('chalk');
 const path = require('path');
 const { copyDirSafe } = require('../../../utils/fsExtra');
 const { cleanDir } = require('../../../utils/fsExtra');
+const { t } = require('../../../i18n');
 
 /**
  * Etapa 9: Backup Supabase .temp (NOVA ETAPA INDEPENDENTE)
@@ -9,17 +10,18 @@ const { cleanDir } = require('../../../utils/fsExtra');
 module.exports = async (context) => {
   const { backupDir } = context;
   try {
+    const getT = global.smoonbI18n?.t || t;
     const tempDir = path.join(process.cwd(), 'supabase', '.temp');
     const backupTempDir = path.join(backupDir, 'supabase-temp');
     
     const fileCount = await copyDirSafe(tempDir, backupTempDir);
-    
-    console.log(chalk.white(`   - Copiando supabase/.temp → backups/backup-${path.basename(backupDir)}/supabase-temp (${fileCount} arquivos)...`));
+    const relativePath = path.relative(process.cwd(), backupTempDir);
+    console.log(chalk.white(`   - ${getT('backup.steps.temp.copying', { path: relativePath, count: fileCount })}`));
     
     if (fileCount === 0) {
-      console.log(chalk.white('   - Nenhum arquivo encontrado em supabase/.temp'));
+      console.log(chalk.white(`   - ${getT('backup.steps.temp.noFiles')}`));
     } else {
-      console.log(chalk.green(`   ✅ ${fileCount} arquivo(s) copiado(s)`));
+      console.log(chalk.green(`   ✅ ${getT('backup.steps.temp.copied', { count: fileCount })}`));
     }
     
     // Usar flag de limpeza do contexto (já foi perguntado no início)
@@ -27,7 +29,7 @@ module.exports = async (context) => {
     
     if (shouldClean) {
       await cleanDir(tempDir);
-      console.log(chalk.white('   - supabase/.temp apagado.'));
+      console.log(chalk.white(`   - ${getT('backup.steps.temp.cleaned')}`));
     }
     
     return {
@@ -35,7 +37,8 @@ module.exports = async (context) => {
       file_count: fileCount
     };
   } catch (error) {
-    console.log(chalk.yellow(`   ⚠️ Erro no backup do supabase/.temp: ${error.message}`));
+    const getT = global.smoonbI18n?.t || t;
+    console.log(chalk.yellow(`   ⚠️ ${getT('backup.steps.temp.error', { message: error.message })}`));
     return { success: false };
   }
 };

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

@@ -3,13 +3,15 @@ const path = require('path');
 const { execSync } = require('child_process');
 const { extractPasswordFromDbUrl, ensureCleanLink } = require('../../../utils/supabaseLink');
 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;
   try {
+    const getT = global.smoonbI18n?.t || t;
     // Reset de link ao projeto de ORIGEM
     const dbPassword = extractPasswordFromDbUrl(databaseUrl);
     await ensureCleanLink(projectId, accessToken, dbPassword);
@@ -17,10 +19,10 @@ module.exports = async (context) => {
     // Limpar migrations local (opcional, mas recomendado para garantir servidor como fonte da verdade)
     const migrationsDir = path.join(process.cwd(), 'supabase', 'migrations');
     await cleanDir(migrationsDir);
-    console.log(chalk.white('   - Limpando supabase/migrations...'));
+    console.log(chalk.white(`   - ${getT('backup.steps.migrations.cleaning')}`));
     
     // Baixar todas as migrations do servidor usando migration fetch
-    console.log(chalk.white('   - Baixando todas as migrations do servidor usando migration fetch...'));
+    console.log(chalk.white(`   - ${getT('backup.steps.migrations.downloading')}`));
     
     const env = {
       ...process.env,
@@ -36,22 +38,23 @@ module.exports = async (context) => {
         env
       });
     } catch (error) {
-      console.log(chalk.yellow(`   ⚠️ Erro ao executar migration fetch: ${error.message}`));
-      console.log(chalk.yellow('   💡 Verifique se o projeto está linkado corretamente e se o token está válido.'));
+      console.log(chalk.yellow(`   ⚠️ ${getT('backup.steps.migrations.fetchError', { message: error.message })}`));
+      console.log(chalk.yellow(`   💡 ${getT('backup.steps.migrations.fetchTip')}`));
       return { success: false };
     }
     
     // Contar arquivos baixados
     const fileCount = await countFiles(migrationsDir);
-    console.log(chalk.white(`   - Arquivos baixados: ${fileCount} migrations`));
+    console.log(chalk.white(`   - ${getT('backup.steps.migrations.downloaded', { count: fileCount })}`));
     
     // Copiar migrations para o backup
     const backupMigrationsDir = path.join(backupDir, 'migrations');
     const copiedCount = await copyDirSafe(migrationsDir, backupMigrationsDir);
-    console.log(chalk.white(`   - Copiando supabase/migrations → backups/backup-${path.basename(backupDir)}/migrations (${copiedCount} arquivos)...`));
+    const relativePath = path.relative(process.cwd(), backupMigrationsDir);
+    console.log(chalk.white(`   - ${getT('backup.steps.migrations.copying', { path: relativePath, count: copiedCount })}`));
     
     if (copiedCount > 0) {
-      console.log(chalk.green(`   ✅ ${copiedCount} migration(s) copiada(s)`));
+      console.log(chalk.green(`   ✅ ${getT('backup.steps.migrations.copied', { count: copiedCount })}`));
     }
     
     // Usar flag de limpeza do contexto (já foi perguntado no início)
@@ -59,7 +62,7 @@ module.exports = async (context) => {
     
     if (shouldClean) {
       await cleanDir(migrationsDir);
-      console.log(chalk.gray('   - supabase/migrations apagado.'));
+      console.log(chalk.gray(`   - ${getT('backup.steps.migrations.cleaned')}`));
     }
     
     return {
@@ -67,7 +70,8 @@ module.exports = async (context) => {
       file_count: copiedCount
     };
   } catch (error) {
-    console.log(chalk.yellow(`   ⚠️ Erro no backup das migrations: ${error.message}`));
+    const getT = global.smoonbI18n?.t || t;
+    console.log(chalk.yellow(`   ⚠️ ${getT('backup.steps.migrations.error', { message: error.message })}`));
     return { success: false };
   }
 };

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 }) };
   }
 }