smoonb 0.0.74 → 0.0.75

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

@@ -246,6 +246,332 @@
   "quickHelp.tokenStep3": "3. Copie o token (formato: sbp_...)",
   "quickHelp.tokenStep4": "4. Adicione ao .env.local como SUPABASE_ACCESS_TOKEN",
   "quickHelp.update": "ATUALIZAR PARA ÚLTIMA VERSÃO:",
-  "quickHelp.updateCommand": "npm install smoonb@latest"
+  "quickHelp.updateCommand": "npm install smoonb@latest",
+
+  "docker.validation.title": "Validação Docker",
+  "docker.validation.checking": "Verificando dependências Docker...",
+  "docker.validation.detected": "Docker Desktop detectado e funcionando",
+  "docker.validation.version": "Versão: {version}",
+
+  "env.mapping.title": "Mapeando variável: {variable}",
+  "env.mapping.selectKey": "Selecione a chave correspondente para: {expected}",
+  "env.mapping.addNew": "Adicione uma nova chave para mim",
+  "env.mapping.currentValue": "Valor atual: {value}",
+  "env.mapping.isCorrect": "Este é o valor correto do projeto alvo?",
+  "env.mapping.notFound": "Não foi encontrada uma entrada para a variável {variable}.",
+  "env.mapping.backupCreated": "Backup do .env.local: {path}",
+  "env.mapping.fileNotFound": "Arquivo .env.local não encontrado. Será criado durante o mapeamento.",
+  "env.mapping.updated": ".env.local atualizado com sucesso. Nenhuma chave renomeada; valores sincronizados.",
+
+  "backup.components.edgeFunctions.title": "Edge Functions:",
+  "backup.components.edgeFunctions.description1": "Vamos apagar as funções existentes na pasta supabase/functions, fazer um reset no link",
+  "backup.components.edgeFunctions.description2": "entre a ferramenta e o projeto, e baixar novamente as funções do servidor.",
+  "backup.components.edgeFunctions.description3": "Você terá a opção de manter ou apagar as funções na pasta após o backup.",
+  "backup.components.edgeFunctions.include": "Deseja incluir Edge Functions",
+  "backup.components.edgeFunctions.cleanup": "Deseja limpar supabase/functions após o backup",
+
+  "backup.components.temp.title": "Supabase .temp:",
+  "backup.components.temp.description1": "Vamos copiar os arquivos existentes (se existirem) na pasta supabase/.temp.",
+  "backup.components.temp.description2": "Você terá a opção de manter ou apagar os arquivos nesta pasta após o backup.",
+  "backup.components.temp.include": "Deseja incluir Supabase .temp",
+  "backup.components.temp.cleanup": "Deseja apagar supabase/.temp após o backup",
+
+  "backup.components.migrations.title": "Migrations:",
+  "backup.components.migrations.description1": "Vamos apagar as migrations existentes (se existirem) na pasta supabase/migrations,",
+  "backup.components.migrations.description2": "fazer um reset no link entre a ferramenta e o projeto, e baixar novamente as migrations",
+  "backup.components.migrations.description3": "do servidor. Você terá a opção de manter ou apagar as migrations na pasta após o backup.",
+  "backup.components.migrations.include": "Deseja incluir Migrations",
+  "backup.components.migrations.cleanup": "Deseja apagar supabase/migrations após o backup",
+
+  "backup.components.storage.include": "Deseja incluir Storage",
+  "backup.components.auth.include": "Deseja incluir Auth",
+  "backup.components.realtime.include": "Deseja incluir Realtime",
+
+  "backup.summary.title": "RESUMO DAS CONFIGURAÇÕES:",
+  "backup.summary.edgeFunctions": "Edge Functions: {value}",
+  "backup.summary.edgeFunctionsCleanup": "Limpar após backup: {value}",
+  "backup.summary.temp": "Supabase .temp: {value}",
+  "backup.summary.tempCleanup": "Apagar após backup: {value}",
+  "backup.summary.migrations": "Migrations: {value}",
+  "backup.summary.migrationsCleanup": "Apagar após backup: {value}",
+  "backup.summary.storage": "Storage: {value}",
+  "backup.summary.auth": "Auth: {value}",
+  "backup.summary.realtime": "Realtime: {value}",
+  "backup.summary.backupDir": "Diretório de backup: {path}",
+  "backup.summary.confirm": "Deseja iniciar o backup com estas configurações?",
+  "backup.summary.yes": "Sim",
+  "backup.summary.no": "Não",
+
+  "backup.start.title": "Iniciando backup do projeto: {projectId}",
+  "backup.start.directory": "Diretório: {path}",
+  "backup.start.docker": "Backup via Docker Desktop",
+
+  "backup.steps.database.title": "Backup da Database PostgreSQL via pg_dumpall Docker...",
+  "backup.steps.database.creating": "Criando backup completo via pg_dumpall...",
+  "backup.steps.database.executing": "Executando pg_dumpall via Docker...",
+  "backup.steps.database.separated.title": "Backup da Database PostgreSQL (arquivos SQL separados)...",
+  "backup.steps.database.separated.creating": "Criando backups SQL separados via Supabase CLI...",
+  "backup.steps.database.separated.exportingSchema": "Exportando schema...",
+  "backup.steps.database.separated.exportingData": "Exportando dados...",
+  "backup.steps.database.separated.exportingRoles": "Exportando roles...",
+
+  "backup.steps.databaseSettings.title": "Backup das Database Extensions and Settings via SQL...",
+  "backup.steps.databaseSettings.capturing": "Capturando Database Extensions and Settings...",
+  "backup.steps.databaseSettings.executing": "Executando queries de configurações via Docker...",
+
+  "backup.steps.auth.title": "Backup das Auth Settings via API...",
+  "backup.steps.auth.exporting": "Exportando configurações de Auth via Management API...",
+
+  "backup.steps.realtime.title": "Backup das Realtime Settings via Captura Interativa...",
+  "backup.steps.realtime.capturing": "Capturando Realtime Settings interativamente...",
+  "backup.steps.realtime.previousFound": "Foi identificada uma gravação anterior de Realtime Settings.",
+  "backup.steps.realtime.reuse": "Deseja reutilizar as configurações anteriores?",
+  "backup.steps.realtime.configTitle": "Configurações de Realtime Settings",
+  "backup.steps.realtime.access": "Acesse: {url}",
+  "backup.steps.realtime.note": "Anote os valores dos 7 parâmetros abaixo:",
+  "backup.steps.realtime.questions": "Responda as perguntas abaixo (pressione Enter para usar o valor padrão):",
+  "backup.steps.realtime.saved": "Configurações de Realtime Settings salvas!",
+
+  "backup.steps.storage.title": "Backup do Storage via API...",
+  "backup.steps.storage.listing": "Listando buckets de Storage via Management API...",
+  "backup.steps.storage.found": "Encontrados {count} buckets",
+  "backup.steps.storage.processing": "Processando bucket: {bucketName}",
+  "backup.steps.storage.listingFiles": "Listando arquivos do bucket {bucketName}...",
+  "backup.steps.storage.downloading": "Baixando {count} arquivo(s) do bucket {bucketName}...",
+  "backup.steps.storage.downloaded": "Baixados {current}/{total} arquivo(s)...",
+  "backup.steps.storage.bucketDone": "Bucket {bucketName}: {downloaded}/{total} arquivo(s) baixado(s)",
+  "backup.steps.storage.creatingZip": "Criando arquivo ZIP no padrão do Dashboard...",
+  "backup.steps.storage.zipCreated": "Arquivo ZIP criado: {fileName} ({size} MB)",
+  "backup.steps.storage.cleanup": "Deseja limpar storage_temp após o backup",
+  "backup.steps.storage.tempKept": "Estrutura temporária mantida em: {path}",
+  "backup.steps.storage.done": "Storage backupado: {buckets} buckets, {files} arquivo(s) baixado(s)",
+
+  "backup.steps.roles.title": "Backup dos Custom Roles via SQL...",
+  "backup.steps.roles.exporting": "Exportando Custom Roles via Docker...",
+
+  "backup.steps.functions.title": "Backup das Edge Functions via Docker...",
+  "backup.steps.functions.linking": "Zerando vínculo e linkando projeto: {projectId}...",
+  "backup.steps.functions.validation": "Validação: linked-ref = {linkedRef} (esperado = {expected})",
+  "backup.steps.functions.prepared": "Pasta supabase/functions preparada (será preservada após backup).",
+  "backup.steps.functions.listing": "Listando Edge Functions via Management API...",
+  "backup.steps.functions.noneFound": "Nenhuma Edge Function encontrada",
+
+  "backup.steps.temp.title": "Backup do Supabase .temp...",
+  "backup.steps.temp.copying": "Copiando supabase/.temp → {path} ({count} arquivos)...",
+
+  "backup.steps.migrations.title": "Backup das Migrations...",
+  "backup.steps.migrations.linking": "Zerando vínculo e linkando projeto: {projectId}...",
+  "backup.steps.migrations.validation": "Validação: linked-ref = {linkedRef} (esperado = {expected})",
+  "backup.steps.migrations.cleaning": "Limpando supabase/migrations...",
+  "backup.steps.migrations.downloading": "Baixando todas as migrations do servidor usando migration fetch...",
+  "backup.steps.migrations.downloaded": "Arquivos baixados: {count} migrations",
+  "backup.steps.migrations.copying": "Copiando supabase/migrations → {path} ({count} arquivos)...",
+
+  "backup.complete.title": "BACKUP COMPLETO FINALIZADO VIA DOCKER!",
+  "backup.complete.location": "Localização: {path}",
+  "backup.complete.database": "Database: {fileName} ({size}) - Idêntico ao Dashboard",
+  "backup.complete.databaseSql": "Database SQL: {count} arquivos separados ({size}) - Para troubleshooting",
+  "backup.complete.databaseSettings": "Database Settings: {fileName} ({size}) - Extensions e Configurações",
+  "backup.complete.auth": "Auth Settings: Exportadas via API",
+  "backup.complete.realtime": "Realtime: Configurações capturadas interativamente",
+  "backup.complete.storage": "Storage: {buckets} buckets, {files} arquivo(s) baixado(s), ZIP: {zipFile} ({size})",
+  "backup.complete.roles": "Custom Roles: {count} roles exportados via SQL",
+  "backup.complete.functions": "Edge Functions: {downloaded}/{total} functions baixadas via Docker",
+  "backup.complete.temp": "Supabase .temp: {count} arquivo(s) copiado(s)",
+  "backup.complete.migrations": "Migrations: {count} migration(s) copiada(s)",
+
+  "backup.error.databaseUrlNotConfigured": "DATABASE_URL NÃO CONFIGURADA",
+  "backup.error.databaseUrlInstructions": "Para fazer backup completo do Supabase, você precisa:",
+  "backup.error.databaseUrlStep1": "1. Configurar SUPABASE_DB_URL no .env.local",
+  "backup.error.databaseUrlStep2": "2. Repetir o comando de backup",
+  "backup.error.databaseUrlExample": "Exemplo de configuração:",
+  "backup.error.databaseUrlExampleValue": "\"databaseUrl\": \"postgresql://postgres:[senha]@db.[projeto].supabase.co:5432/postgres\"",
+  "backup.error.databaseUrlCancelled": "Backup cancelado - Configuração incompleta",
+
+  "backup.error.accessTokenNotConfigured": "ACCESS_TOKEN NÃO CONFIGURADO",
+  "backup.error.accessTokenInstructions": "Para fazer backup completo do Supabase, você precisa:",
+  "backup.error.accessTokenStep1": "1. Obter Personal Access Token do Supabase",
+  "backup.error.accessTokenStep2": "2. Configurar SUPABASE_ACCESS_TOKEN no .env.local",
+  "backup.error.accessTokenStep3": "3. Repetir o comando de backup",
+  "backup.error.accessTokenHowTo": "Como obter o token:",
+  "backup.error.accessTokenStep1Detail": "1. Acesse: https://supabase.com/dashboard/account/tokens",
+  "backup.error.accessTokenStep2Detail": "2. Clique: \"Generate new token\"",
+  "backup.error.accessTokenStep3Detail": "3. Copie o token (formato: sbp_...)",
+  "backup.error.accessTokenCancelled": "Backup cancelado - Token não configurado",
+
+  "backup.steps.storage.noBuckets": "Nenhum bucket encontrado",
+  "backup.steps.storage.credentialsNotAvailable": "Credenciais do Supabase não disponíveis. Fazendo backup apenas de metadados...",
+  "backup.steps.storage.cleanupRemoving": "Limpando estrutura temporária...",
+  "backup.steps.storage.cleanupRemoved": "Estrutura temporária removida",
+  "backup.steps.storage.cleanupError": "Erro ao limpar estrutura temporária: {message}",
+  "backup.steps.storage.listError": "Erro ao listar {path}: {message}",
+  "backup.steps.storage.processError": "Erro ao processar {path}: {message}",
+  "backup.steps.storage.error": "Erro no backup do Storage: {message}",
+  "backup.steps.storage.listBucketsError": "Erro ao listar buckets: {status} {statusText}",
+  "backup.steps.storage.downloadError": "Erro ao baixar {path}: {message}",
+  "backup.steps.storage.processFileError": "Erro ao processar arquivo {path}: {message}",
+  "backup.steps.storage.processBucketError": "Erro ao processar bucket {bucketName}: {message}",
+  "backup.steps.database.error": "Erro no backup do database: {message}",
+  "backup.steps.database.separated.error": "Erro nos backups SQL separados: {message}",
+  "backup.steps.database.separated.schemaError": "Erro no schema: {message}",
+  "backup.steps.database.separated.dataError": "Erro nos dados: {message}",
+  "backup.steps.database.separated.rolesError": "Erro nos roles: {message}",
+  "backup.steps.databaseSettings.error": "Erro no backup das Database Settings: {message}",
+  "backup.steps.auth.error": "Erro no backup das Auth Settings: {message}",
+  "backup.steps.auth.getError": "Erro ao obter Auth Settings: {status} {statusText}",
+  "backup.steps.realtime.error": "Erro ao capturar Realtime Settings: {message}",
+  "backup.steps.roles.error": "Erro no backup dos Custom Roles: {message}",
+  "backup.steps.roles.exportError": "Erro ao exportar Custom Roles via Docker: {message}",
+  "backup.steps.functions.error": "Erro durante backup de Edge Functions: {message}",
+  "backup.steps.functions.listError": "Erro ao listar Edge Functions: {status} {statusText}",
+  "backup.steps.functions.downloadError": "Erro ao baixar {funcName}: {message}",
+  "backup.steps.temp.error": "Erro no backup do supabase/.temp: {message}",
+  "backup.steps.migrations.error": "Erro no backup das migrations: {message}",
+
+  "backup.steps.functions.cleanBefore": "Pasta supabase/functions limpa antes do backup.",
+  "backup.steps.functions.preserving": "Preservando {count} função(ões) existente(s) na pasta supabase/functions.",
+  "backup.steps.functions.cleanAfter": "supabase/functions limpo após o backup.",
+  "backup.steps.functions.preserved": "supabase/functions preservada conforme solicitado.",
+
+  "backup.steps.migrations.cleaning": "Limpando supabase/migrations...",
+  "backup.steps.migrations.downloading": "Baixando todas as migrations do servidor usando migration fetch...",
+  "backup.steps.migrations.fetchError": "Erro ao executar migration fetch: {message}",
+  "backup.steps.migrations.fetchTip": "Verifique se o projeto está linkado corretamente e se o token está válido.",
+  "backup.steps.migrations.downloaded": "Arquivos baixados: {count} migrations",
+  "backup.steps.migrations.copying": "Copiando supabase/migrations → {path} ({count} arquivos)...",
+  "backup.steps.migrations.copied": "{count} migration(s) copiada(s)",
+  "backup.steps.migrations.cleaned": "supabase/migrations apagado.",
+
+  "backup.steps.temp.noFiles": "Nenhum arquivo encontrado em supabase/.temp",
+  "backup.steps.temp.copied": "{count} arquivo(s) copiado(s)",
+  "backup.steps.temp.cleaned": "supabase/.temp apagado.",
+
+  "restore.steps.components.edgeFunctions.title": "Edge Functions:",
+  "restore.steps.components.edgeFunctions.description1": "As Edge Functions serão copiadas para supabase/functions e implantadas no projeto destino.",
+  "restore.steps.components.edgeFunctions.description2": "A pasta supabase/functions será limpa antes do processo.",
+  "restore.steps.components.edgeFunctions.include": "Deseja restaurar Edge Functions",
+
+  "restore.steps.components.auth.title": "Auth Settings:",
+  "restore.steps.components.auth.description1": "As configurações de Auth serão exibidas para configuração manual no Dashboard.",
+  "restore.steps.components.auth.description2": "Algumas configurações não podem ser aplicadas automaticamente por questões de segurança.",
+  "restore.steps.components.auth.include": "Deseja restaurar Auth",
+
+  "restore.steps.components.storage.title": "Storage:",
+  "restore.steps.components.storage.zipFound": "Arquivo .storage.zip encontrado: {fileName}",
+  "restore.steps.components.storage.withZip.description1": "Os buckets e arquivos serão restaurados automaticamente no projeto destino.",
+  "restore.steps.components.storage.withZip.description2": "O arquivo ZIP será extraído, buckets criados e arquivos enviados via API.",
+  "restore.steps.components.storage.metadataOnly.description1": "Apenas metadados dos buckets encontrados (pasta storage).",
+  "restore.steps.components.storage.metadataOnly.description2": "Para restaurar os arquivos, é necessário o arquivo .storage.zip do Dashboard.",
+  "restore.steps.components.storage.metadataOnly.description3": "Apenas informações dos buckets serão exibidas.",
+  "restore.steps.components.storage.include": "Deseja restaurar Storage",
+
+  "restore.steps.components.databaseSettings.title": "Database Extensions and Settings:",
+  "restore.steps.components.databaseSettings.description1": "As extensões e configurações do banco de dados serão restauradas via SQL.",
+  "restore.steps.components.databaseSettings.description2": "Isso inclui extensões PostgreSQL e configurações específicas do projeto.",
+  "restore.steps.components.databaseSettings.include": "Deseja restaurar Database Settings",
+
+  "restore.steps.components.realtime.title": "Realtime Settings:",
+  "restore.steps.components.realtime.description1": "As configurações de Realtime serão exibidas para configuração manual no Dashboard.",
+  "restore.steps.components.realtime.description2": "Algumas configurações precisam ser aplicadas manualmente.",
+  "restore.steps.components.realtime.include": "Deseja restaurar Realtime",
+  "restore.steps.components.database.include": "Deseja restaurar Database",
+
+  "restore.steps.database.detectedGz": "Arquivo .backup.gz detectado",
+  "restore.steps.database.extractingGz": "Extraindo arquivo .gz...",
+  "restore.steps.database.uncompressed": "Arquivo descompactado: {file}",
+  "restore.steps.database.detectedBackup": "Arquivo .backup detectado (já descompactado)",
+  "restore.steps.database.proceeding": "Prosseguindo com restauração direta",
+  "restore.steps.database.executing": "Executando psql via Docker...",
+  "restore.steps.database.followingDocs": "Seguindo documentação oficial Supabase",
+  "restore.steps.database.warning": "AVISO: Erros como \"object already exists\" são ESPERADOS",
+  "restore.steps.database.warningReason1": "Isto acontece porque o backup contém CREATE para todos os schemas",
+  "restore.steps.database.warningReason2": "Supabase já tem auth e storage criados, então esses erros são normais",
+  "restore.steps.database.success": "Database restaurada com sucesso!",
+  "restore.steps.database.normalErrors": "Erros \"already exists\" são normais e não afetam a restauração",
+  "restore.steps.database.expectedErrors": "Erros esperados encontrados (conforme documentação Supabase)",
+  "restore.steps.database.errorsIgnored": "Erros são ignorados pois são comandos de CREATE que já existem",
+  "restore.steps.database.error": "Erro ao restaurar database: {message}",
+
+  "restore.steps.storage.noBuckets": "Nenhum bucket de Storage encontrado no backup",
+  "restore.steps.storage.zipNotFound": "Arquivo .storage.zip não encontrado",
+  "restore.steps.storage.metadataOnly": "Apenas metadados dos buckets foram encontrados",
+  "restore.steps.storage.zipRequired": "Para restaurar os arquivos, é necessário o arquivo .storage.zip do Dashboard",
+  "restore.steps.storage.bucketInfo": "{name} ({visibility})",
+  "restore.steps.storage.public": "público",
+  "restore.steps.storage.private": "privado",
+  "restore.steps.storage.noBucketsInBackup": "Nenhum bucket de Storage encontrado no backup",
+  "restore.steps.storage.projectIdNotFound": "Project ID do projeto origem não encontrado no manifest. Continuando sem substituição...",
+  "restore.steps.storage.extracting": "Extraindo arquivo .storage.zip...",
+  "restore.steps.storage.extracted": "Arquivo extraído com sucesso",
+  "restore.steps.storage.replacing": "Substituindo referências ao Project ID antigo nos arquivos extraídos...",
+  "restore.steps.storage.replacingProjectId": "Substituindo Project ID: {source} → {target}",
+  "restore.steps.storage.replaced": "Substituição de Project ID concluída",
+  "restore.steps.storage.noBucketsInZip": "Nenhum bucket encontrado no arquivo .storage.zip",
+  "restore.steps.storage.bucketConfig": "Configurações: {visibility}, limite: {limit}, tipos: {types}",
+  "restore.steps.storage.noLimit": "sem limite",
+  "restore.steps.storage.allTypes": "todos",
+  "restore.steps.storage.fileFound": "Arquivo de storage encontrado: {fileName}",
+  "restore.steps.storage.bucketsFoundInZip": "Encontrados {count} bucket(s) no arquivo ZIP",
+  "restore.steps.storage.processingBucket": "Processando bucket: {bucketName}",
+  "restore.steps.storage.creatingBucket": "Criando bucket {bucketName}...",
+  "restore.steps.storage.bucketCreated": "Bucket {bucketName} criado com configurações do backup",
+  "restore.steps.storage.bucketUpdated": "Configurações do bucket atualizadas",
+  "restore.steps.storage.bucketConfigCorrect": "Configurações do bucket já estão corretas",
+  "restore.steps.storage.filesFoundForUpload": "Encontrados {count} arquivo(s) para upload",
+  "restore.steps.storage.bucketDone": "Bucket {bucketName}: {uploaded}/{total} arquivo(s) enviado(s)",
+  "restore.steps.storage.bucketError": "Erro ao processar bucket {bucketName}: {message}",
+  "restore.steps.storage.uploadError": "Erro ao fazer upload de {path}: {message}",
+  "restore.steps.storage.restoreComplete": "Restauração de Storage concluída: {success}/{total} bucket(s) processado(s), {files} arquivo(s) enviado(s)",
+  "restore.steps.storage.bucketsFoundMetadata": "{count} bucket(s) encontrado(s) no backup (apenas metadados)",
+  "restore.steps.storage.noBucketsInSubfolders": "Erro: Nenhum bucket encontrado nas subpastas de {rootDir}",
+  "restore.steps.storage.updateError": "Não foi possível atualizar configurações: {errorText}",
+  "restore.steps.storage.uploadProgress": "Upload: {path}{metaInfo}",
+  "restore.steps.storage.metadataPreserved": "(metadados preservados)",
+  "restore.steps.storage.fileError": "Erro ao processar arquivo {path}: {message}",
+  "restore.steps.storage.rootIsProjectId": "A pasta raiz é um Project ID e não deve ser tratada como bucket",
+  "restore.steps.storage.bucketExists": "Bucket {bucketName} já existe",
+  "restore.steps.storage.updating": "Atualizando configurações do bucket para corresponder ao backup...",
+  "restore.steps.storage.detectedProjectId": "Detectada pasta raiz com Project ID: {projectId}{reason}",
+  "restore.steps.storage.searchingBuckets": "Buscando buckets nas subpastas...",
+  "restore.steps.storage.error": "Erro ao processar Storage: {message}",
+
+  "restore.steps.edgeFunctions.notFound": "Nenhuma Edge Function encontrada no backup",
+  "restore.steps.edgeFunctions.found": "Encontradas {count} Edge Function(s)",
+  "restore.steps.edgeFunctions.cleaningBefore": "Limpando supabase/functions antes de copiar...",
+  "restore.steps.edgeFunctions.linkMayExist": "Link pode já existir, continuando...",
+  "restore.steps.edgeFunctions.cleaningAfter": "Limpando supabase/functions após deploy...",
+  "restore.steps.edgeFunctions.success": "Edge Functions restauradas com sucesso!",
+  "restore.steps.edgeFunctions.error": "Erro ao restaurar Edge Functions: {message}",
+  "restore.steps.edgeFunctions.listBucketsError": "Erro ao listar buckets: {message}",
+  "restore.steps.edgeFunctions.createBucketError": "Erro ao criar bucket: {status} {errorText}",
+  "restore.steps.edgeFunctions.copying": "Copiando {funcName} para supabase/functions...",
+  "restore.steps.edgeFunctions.linking": "Linkando com projeto {projectId}...",
+  "restore.steps.edgeFunctions.deploying": "Deployando {funcName}...",
+  "restore.steps.edgeFunctions.deployed": "{funcName} deployada com sucesso!",
+  "restore.steps.edgeFunctions.deployFailed": "{funcName} - deploy falhou: {message}",
+
+  "restore.steps.auth.notFound": "Nenhuma configuração de Auth encontrada no backup",
+  "restore.steps.auth.error": "Erro ao processar Auth Settings: {message}",
+  "restore.steps.auth.urlTitle": "URL para configuração manual:",
+  "restore.steps.auth.configureTitle": "Configure manualmente as seguintes opções:",
+  "restore.steps.auth.pressEnter": "Após configurar, pressione Enter para continuar...",
+  "restore.steps.auth.success": "Auth Settings processados",
+
+  "restore.steps.databaseSettings.notFound": "Nenhuma configuração de Database encontrada no backup",
+  "restore.steps.databaseSettings.success": "Database Settings restaurados com sucesso!",
+  "restore.steps.databaseSettings.error": "Erro ao restaurar Database Settings: {message}",
+  "restore.steps.databaseSettings.enabling": "Habilitando {count} extension(s)...",
+  "restore.steps.databaseSettings.extension": "- {extName}",
+  "restore.steps.databaseSettings.invalidUrl": "URL inválida para {extName}",
+  "restore.steps.databaseSettings.extensionExists": "{extName} - extension já existe ou não pode ser habilitada",
+
+  "restore.steps.realtime.notFound": "Nenhuma configuração de Realtime encontrada no backup",
+  "restore.steps.realtime.urlTitle": "URL para configuração manual:",
+  "restore.steps.realtime.configureTitle": "Configure manualmente as seguintes opções:",
+  "restore.steps.realtime.pressEnter": "Após configurar, pressione Enter para continuar...",
+  "restore.steps.realtime.success": "Realtime Settings processados",
+
+  "restore.steps.backupSelection.title": "Backups disponíveis:",
+  "restore.steps.backupSelection.separator": "═══════════════════════════════════════════════════════════════════════════════"
 }
 

package/src/interactive/envMapper.js

@@ -1,6 +1,7 @@
 const inquirer = require('inquirer');
 const chalk = require('chalk');
 const { confirm } = require('../utils/prompt');
+const { t } = require('../i18n');
 
 async function mapEnvVariablesInteractively(env, expectedKeys) {
   const finalEnv = { ...env };
@@ -83,8 +84,10 @@ async function mapEnvVariablesInteractively(env, expectedKeys) {
     };
   }
 
+  const getT = global.smoonbI18n?.t || t;
+  
   for (const expected of expectedKeys) {
-    console.log(chalk.blue(`\n🔧 Mapeando variável: ${expected}`));
+    console.log(chalk.blue(`\n🔧 ${getT('env.mapping.title', { variable: expected })}`));
 
     let clientKey = undefined;
 
@@ -96,13 +99,13 @@ async function mapEnvVariablesInteractively(env, expectedKeys) {
       const choices = [
         ...allKeys.map((k, idx) => ({ name: `${idx + 1}. ${k}`, value: k })),
         new inquirer.Separator(),
-        { name: 'Adicione uma nova chave para mim', value: '__ADD_NEW__' }
+        { name: getT('env.mapping.addNew'), value: '__ADD_NEW__' }
       ];
 
       const { chosen } = await inquirer.prompt([{
         type: 'list',
         name: 'chosen',
-        message: `Selecione a chave correspondente para: ${expected}`,
+        message: getT('env.mapping.selectKey', { expected }),
         choices,
         loop: false,
         prefix: ''
@@ -131,7 +134,7 @@ async function mapEnvVariablesInteractively(env, expectedKeys) {
 
     // Se não tem valor, mostrar mensagem específica e pular confirmação
     if (!currentValue) {
-      console.log(chalk.yellow(instructions.notFound));
+      console.log(chalk.yellow(getT('env.mapping.notFound', { variable: expected })));
       if (instructions.help) {
         // Se o help contém link (https://), mostrar como link
         if (instructions.help.includes('https://')) {
@@ -148,7 +151,7 @@ async function mapEnvVariablesInteractively(env, expectedKeys) {
       }
     } else {
       // Se tem valor, perguntar se está correto
-      const isCorrect = await confirm(`Valor atual: ${currentValue}\nEste é o valor correto do projeto alvo?`, true);
+      const isCorrect = await confirm(`${getT('env.mapping.currentValue', { value: currentValue })}\n${getT('env.mapping.isCorrect')}`, true);
       if (isCorrect) {
         finalEnv[clientKey] = currentValue;
         if (expected === 'SUPABASE_PROJECT_ID') {
@@ -209,51 +212,53 @@ async function mapEnvVariablesInteractively(env, expectedKeys) {
 }
 
 async function askComponentsFlags() {
+  const getT = global.smoonbI18n?.t || t;
+  
   // Explicação sobre Edge Functions
-  console.log(chalk.cyan('\n⚡ Edge Functions:'));
-  console.log(chalk.white('   Vamos apagar as funções existentes na pasta supabase/functions, fazer um reset no link'));
-  console.log(chalk.white('   entre a ferramenta e o projeto, e baixar novamente as funções do servidor.'));
-  console.log(chalk.white('   Você terá a opção de manter ou apagar as funções na pasta após o backup.\n'));
+  console.log(chalk.cyan(`\n⚡ ${getT('backup.components.edgeFunctions.title')}`));
+  console.log(chalk.white(`   ${getT('backup.components.edgeFunctions.description1')}`));
+  console.log(chalk.white(`   ${getT('backup.components.edgeFunctions.description2')}`));
+  console.log(chalk.white(`   ${getT('backup.components.edgeFunctions.description3')}\n`));
 
-  const includeFunctions = await confirm('Deseja incluir Edge Functions', true);
+  const includeFunctions = await confirm(getT('backup.components.edgeFunctions.include'), true);
   
   // Pergunta de limpeza de functions imediatamente após
   let cleanFunctions = false;
   if (includeFunctions) {
-    cleanFunctions = await confirm('Deseja limpar supabase/functions após o backup', false);
+    cleanFunctions = await confirm(getT('backup.components.edgeFunctions.cleanup'), false);
   }
 
   // Explicação sobre .temp
-  console.log(chalk.cyan('\n📁 Supabase .temp:'));
-  console.log(chalk.white('   Vamos copiar os arquivos existentes (se existirem) na pasta supabase/.temp.'));
-  console.log(chalk.white('   Você terá a opção de manter ou apagar os arquivos nesta pasta após o backup.\n'));
+  console.log(chalk.cyan(`\n📁 ${getT('backup.components.temp.title')}`));
+  console.log(chalk.white(`   ${getT('backup.components.temp.description1')}`));
+  console.log(chalk.white(`   ${getT('backup.components.temp.description2')}\n`));
 
-  const includeTemp = await confirm('Deseja incluir Supabase .temp', true);
+  const includeTemp = await confirm(getT('backup.components.temp.include'), true);
   
   // Pergunta de limpeza de .temp imediatamente após
   let cleanTemp = false;
   if (includeTemp) {
-    cleanTemp = await confirm('Deseja apagar supabase/.temp após o backup', false);
+    cleanTemp = await confirm(getT('backup.components.temp.cleanup'), false);
   }
 
   // Explicação sobre Migrations
-  console.log(chalk.cyan('\n📋 Migrations:'));
-  console.log(chalk.white('   Vamos apagar as migrations existentes (se existirem) na pasta supabase/migrations,'));
-  console.log(chalk.white('   fazer um reset no link entre a ferramenta e o projeto, e baixar novamente as migrations'));
-  console.log(chalk.white('   do servidor. Você terá a opção de manter ou apagar as migrations na pasta após o backup.\n'));
+  console.log(chalk.cyan(`\n📋 ${getT('backup.components.migrations.title')}`));
+  console.log(chalk.white(`   ${getT('backup.components.migrations.description1')}`));
+  console.log(chalk.white(`   ${getT('backup.components.migrations.description2')}`));
+  console.log(chalk.white(`   ${getT('backup.components.migrations.description3')}\n`));
 
-  const includeMigrations = await confirm('Deseja incluir Migrations', true);
+  const includeMigrations = await confirm(getT('backup.components.migrations.include'), true);
   
   // Pergunta de limpeza de migrations imediatamente após
   let cleanMigrations = false;
   if (includeMigrations) {
-    cleanMigrations = await confirm('Deseja apagar supabase/migrations após o backup', false);
+    cleanMigrations = await confirm(getT('backup.components.migrations.cleanup'), false);
   }
 
   // Continuar com outras perguntas
-  const includeStorage = await confirm('Deseja incluir Storage', true);
-  const includeAuth = await confirm('Deseja incluir Auth', true);
-  const includeRealtime = await confirm('Deseja incluir Realtime', true);
+  const includeStorage = await confirm(getT('backup.components.storage.include'), true);
+  const includeAuth = await confirm(getT('backup.components.auth.include'), true);
+  const includeRealtime = await confirm(getT('backup.components.realtime.include'), true);
 
   return {
     includeFunctions,