smoonb 1.0.7 → 1.0.9

package/CHANGELOG.md

@@ -4,6 +4,49 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
+## [1.0.9] - 2026-10-10
+
+### Fixed
+
+- Treat SMTP passwords as write-only credentials. Never replay the protected SMTP value returned by the Management API from a legacy backup as the provider password.
+- Ask for the real SMTP password with hidden input before restoring any selected components. Fail before remote mutations if it is missing. Keep the entered password in memory only.
+- Verify readable Auth settings independently from password submission. Continue after the API accepts the supplied password, but report `applied_with_unverified_secrets` and require an authentication email test instead of claiming password or email-delivery verification.
+- Omit the protected SMTP value from new Auth snapshots and explicitly record that the provider password is required during restore. Existing backups remain usable.
+
+### Recovery from 1.0.8
+
+- If restore stopped at `Configuration verification failed: smtp_pass`, inspect its `report.json`. When Database and Edge Functions are already verified, run restore with those two components disabled and select Auth, Storage, Database Settings and Realtime as needed. Supply the real provider SMTP password when prompted; no new backup or destination project is required for this specific failure.
+
+### Tests
+
+- Cover legacy/new snapshots, hidden input, missing-password preflight, protected-value rejection, HTTP failures, readable-setting mismatches, partial verification reporting and continuation without reloading the database.
+
+## [1.0.8] - 2026-10-10
+
+### Fixed
+
+- Restore application and Auth data from the existing full dump in one checked transaction. Fail on SQL errors; compare restored columns and validate foreign keys before commit, including pre-existing Auth constraints.
+- Remove extra destination object grants before replaying source ACLs, preventing unintended anonymous/authenticated access to restricted functions and tables.
+- Apply and verify Auth configuration through the Management API, including SMTP and redirect configuration.
+- Remap source Supabase hostnames in application data and text objects when selected; preserve unrelated IDs and paths.
+- Recover Storage MIME types, cache directives, ownership and user metadata from the full dump even when legacy Storage JSON inventories are empty. Validate ZIP inventory, count empty buckets, and verify every uploaded file by download and SHA-256.
+- Use isolated temporary workspaces for Edge Function backup and deployment; preserve local modified sources and compressed backup archives. Address npm CLI shims on Windows without shell interpolation.
+- Persist stage results and failures; never report unsuccessful or unverified components as restored.
+
+### Changed
+
+- Apply and verify Realtime snapshots through the API; capture fresh Realtime settings for new backups instead of reusing interactive recordings.
+- Verify database settings and fail explicitly for incompatible platform settings rather than silently skipping them.
+- Require Node.js 20 or later. A new, empty destination is required for the database restore; platform-managed schemas and administrator defaults remain destination-managed.
+- Preserve Function JWT configuration in new backups. Legacy backups default to requiring JWT.
+
+### Tests
+
+- Add regression coverage for configuration readback, failure reporting, URL mapping, archive preservation, isolated Functions, and PostgreSQL arrays.
+- Add an opt-in Docker test of the actual restore step with cyclic references, Auth identities, broad destination defaults, invalid-data rollback, populated-target refusal and Storage metadata/content verification (mock HTTP, real PostgreSQL).
+
+---
+
 ## [1.0.7] - 2026-10-10
 
 ### Fixed

package/README.md

@@ -296,14 +296,32 @@ npx smoonb restore --skip-supabase-version-check
    - 🔄 Realtime Settings (if available in backup)
 9. **Detailed summary** - Shows selected backup, target project and components
 10. **Final confirmation** - Confirms before starting
-11. **Disclaimer** - Explains that errors during restore are expected; link to [Supabase Dashboard Restore docs](https://supabase.com/docs/guides/platform/migrating-within-supabase/dashboard-restore); you should wait for the process to finish and then test the result before accepting to proceed
+11. **Project URLs** - Confirms whether Supabase URLs in data and files should point to the new project
 12. **Restore execution:**
     - 📊 Database - Restores via `psql` (supports `.backup.gz` and `.backup`)
-    - ⚡ Edge Functions - Copies and deploys to target project
-    - 🔐 Auth Settings - Displays configurations for manual application
-    - 📦 Storage - Restores buckets and files from ZIP (if available) or displays information for manual migration
+    - ⚡ Edge Functions - Deploys from a temporary copy, preserving local sources
+    - 🔐 Auth Settings - Applies via API and verifies the resulting values
+    - 📦 Storage - Restores buckets and ZIP files, preserves metadata and verifies every download
     - 🔧 Database Settings - Restores extensions and settings via SQL
-    - 🔄 Realtime Settings - Displays configurations for manual application
+    - 🔄 Realtime Settings - Applies and verifies the snapshot recorded in the backup
+
+### Verified restoration (1.0.8)
+
+Use a new, empty destination project and Node.js 20 or later. Existing complete 1.0.7 backups can be reused without another capture. Version 1.0.8 uses the complete dump as one snapshot for application structure, Auth data, migration history, buckets and object metadata. Platform schemas and internal migrations remain at the destination's version.
+
+Database loading uses one transaction, stops on errors, suspends triggers only on its connection, compares every restored column and checks foreign keys before commit. Extra destination default grants are cleared before replaying the backup's grants. Failed SQL is never reported as success. Compressed archives and local function sources remain untouched.
+
+Optional URL remapping changes only the project's Supabase hostname, including URLs inside JSON and text files. It does not rename files or replace isolated project IDs. Historical URLs may also change; choose preservation when needed. Signed URLs, custom domains, external integrations and application API keys need separate validation. Destination platform keys are not replaced.
+
+Readable Auth and Realtime settings are applied through the Management API and verified by reading them back. The **SMTP password cannot be exported**: Supabase returns a protected value that cannot be used as the password in another project. Starting with 1.0.9, smoonb requests the real provider password with hidden input **before restoring any components**, including when using legacy backups. It stays in memory only and is sent to the destination Supabase project. The report distinguishes API password acceptance from readback verification (`applied_with_unverified_secrets`). Test an authentication email on the destination; API acceptance does not validate the password with the email provider.
+
+If a 1.0.8 restore stopped at `Configuration verification failed: smtp_pass` and its `report.json` confirms Database and Edge Functions, reuse the same backup and project: run `npx smoonb@1.0.9 restore`, answer **no** for Database and Edge Functions, and **yes** for the pending Auth, Storage, Database Settings and Realtime components. Enter the provider SMTP password when prompted. This specific failure does not require another backup or a database reload.
+
+Legacy Realtime captures may be stale: restoration reproduces the recorded values and date, not the source project's current settings. New backups capture Realtime directly through the API. Legacy function backups without the JWT flag default to requiring JWT; new backups preserve that flag.
+
+Reports are saved after each stage, including failures. External services cannot share the database transaction: earlier stages remain completed if a later stage fails. Do not reload the database into a populated destination. Resolve the reported stage and select only pending components, or use another empty project.
+
+Unsupported internal data (such as encrypted Vault secrets without key migration) and destination plan/version incompatibilities stop the operation. Verified status covers the selected components; validate login, email delivery and business workflows before production use.
 
 **Supported file formats:**
 - ✅ `.backup.gz` (compressed) - Automatically decompresses before restoring
@@ -503,7 +521,7 @@ restore/
    npx smoonb restore
    ```
    (Select desired backup, select components, execute restoration.)
-6. **Apply manual configurations** if necessary: Auth Settings (Dashboard → Authentication → Settings), Realtime (Dashboard → Database → Replication). Storage is restored automatically from ZIP when available.
+6. **Review the result**: inspect `backups/restore-*/report.json` and test login, email and application workflows on the destination.
 
 ## 🎨 User Experience
 
@@ -602,7 +620,7 @@ npx smoonb restore --skip-supabase-version-check
 ### .backup.gz file cannot be restored
 
 smoonb automatically supports:
-- ✅ `.backup.gz` - Decompresses via Docker before restoring
+- ✅ `.backup.gz` - Reads compressed content without changing the original archive
 - ✅ `.backup` - Restores directly
 
 If there are problems:
@@ -661,3 +679,5 @@ Contributions are welcome. [www.smoonb.com/#price](https://www.smoonb.com/#price
 **Developed by:** Goalmoon Tecnologia LTDA  
 **Website:** https://www.smoonb.com  
 **GitHub:** https://github.com/almmello/smoonb
+
+Additional restore-path test: `npm run test:restore:docker`. Uses disposable PostgreSQL, synthetic data and mocked Storage HTTP transport; covers Auth, grants, cycles, rollback, files and metadata.

package/README.pt-BR.md

@@ -296,14 +296,32 @@ npx smoonb restore --skip-supabase-version-check
    - 🔄 Realtime Settings (se disponível no backup)
 9. **Resumo detalhado** - Mostra backup selecionado, projeto destino e componentes
 10. **Confirmação final** - Confirma antes de iniciar
-11. **Aviso** - Explica que erros durante a restauração são esperados; link para [documentação de restore do Dashboard Supabase](https://supabase.com/docs/guides/platform/migrating-within-supabase/dashboard-restore); aguardar o fim do processo e testar o resultado antes de aceitar para prosseguir
+11. **Endereços do projeto** - Confirma se as URLs Supabase nos dados e arquivos devem apontar para o novo projeto
 12. **Execução da restauração:**
     - 📊 Database - Restaura via `psql` (suporta `.backup.gz` e `.backup`)
-    - ⚡ Edge Functions - Copia e faz deploy no projeto destino
-    - 🔐 Auth Settings - Exibe configurações para aplicação manual
-    - 📦 Storage - Restaura buckets e arquivos do ZIP (se disponível) ou exibe informações para migração manual
+    - ⚡ Edge Functions - Faz deploy de uma cópia temporária, preservando as fontes locais
+    - 🔐 Auth Settings - Aplica via API e verifica os valores recuperados
+    - 📦 Storage - Restaura buckets e arquivos do ZIP, preserva metadados e verifica cada download
     - 🔧 Database Settings - Restaura extensões e configurações via SQL
-    - 🔄 Realtime Settings - Exibe configurações para aplicação manual
+    - 🔄 Realtime Settings - Aplica e verifica o snapshot registrado no backup
+
+### Restauração verificada (1.0.8)
+
+Use um projeto de destino novo e vazio e Node.js 20 ou mais recente. O backup completo existente da versão 1.0.7 pode ser reutilizado, sem nova captura. A versão 1.0.8 usa o dump completo como snapshot único: recupera a estrutura da aplicação, dados de Auth, histórico de migrações, buckets e metadados. Os schemas internos e as migrações da plataforma são mantidos na versão do destino.
+
+A carga do banco usa uma transação com interrupção em erro, suspende triggers apenas nessa conexão, compara todas as colunas recuperadas e verifica chaves estrangeiras antes de confirmar. Permissões herdadas dos defaults do destino são removidas antes da reaplicação dos grants do backup. SQL com falha nunca é classificado como sucesso. O arquivo compactado e a pasta local de funções são preservados.
+
+O remapeamento opcional troca apenas o domínio Supabase do projeto em URLs, inclusive em JSON e arquivos de texto. Não troca IDs isolados nem nomes de arquivos. URLs históricas também podem ser afetadas; escolha preservar quando isso for necessário. URLs assinadas, domínios personalizados, integrações externas e chaves de API da aplicação precisam de validação específica. As chaves de plataforma do destino não são substituídas.
+
+As configurações legíveis de Auth e Realtime são aplicadas pela Management API e conferidas por nova leitura. A **senha SMTP não é exportável**: o Supabase devolve um valor protegido, que não pode ser usado como senha em outro projeto. A partir da versão 1.0.9, o smoonb solicita a senha real do provedor em campo oculto **antes de restaurar os componentes**, inclusive ao usar backups antigos. Ela permanece somente na memória e é enviada ao Supabase de destino. O relatório distingue senha aceita pela API de configurações verificadas por leitura (`applied_with_unverified_secrets`). Teste o envio de e-mail de autenticação no destino; aceitar uma senha pela API não comprova sua validade junto ao provedor.
+
+Se uma restauração 1.0.8 parou em `Configuration verification failed: smtp_pass` e o `report.json` confirmou Database e Edge Functions, use o mesmo backup e projeto: execute `npx smoonb@1.0.9 restore`, responda **não** para Database e Edge Functions e **sim** para Auth, Storage, Database Settings e Realtime que ficaram pendentes. Informe a senha SMTP do provedor quando solicitada. Não é necessário refazer o backup nem recarregar o banco nesse caso.
+
+A captura antiga de Realtime pode conter valores desatualizados: a restauração reproduz os valores e a data registrados, não o estado atual do projeto original. Novos backups capturam Realtime diretamente pela API. Em backups antigos sem o sinalizador de JWT de Functions, o padrão seguro é exigir JWT; os novos backups guardam esse sinalizador.
+
+O relatório é salvo durante cada etapa, inclusive em falhas. Serviços externos não participam da transação do banco: se uma etapa posterior falhar, as anteriores permanecem registradas como concluídas. Não repita a carga do banco em um destino já preenchido. Resolva a etapa indicada e selecione apenas os componentes pendentes, ou use outro projeto vazio.
+
+Dados internos não suportados (por exemplo, Vault com segredos criptografados sem migração da chave) e configurações incompatíveis com o plano/versão do destino interrompem o processo. O status verificado cobre os componentes selecionados; ainda é necessário validar login, envio de e-mail e fluxos de negócio antes de usar o destino em produção.
 
 **Formato de arquivos suportados:**
 - ✅ `.backup.gz` (compactado) - Descompacta automaticamente antes de restaurar
@@ -503,7 +521,7 @@ restore/
    npx smoonb restore
    ```
    (Seleciona backup desejado, componentes a restaurar, executa restauração.)
-6. **Aplicar configurações manuais** se necessário: Auth Settings (Dashboard → Authentication → Settings), Realtime (Dashboard → Database → Replication). O Storage é restaurado automaticamente do ZIP quando disponível.
+6. **Conferir o resultado**: leia `backups/restore-*/report.json` e teste login, e-mail e os fluxos da aplicação no destino.
 
 ## 🎨 Experiência do Usuário
 
@@ -602,7 +620,7 @@ npx smoonb restore --skip-supabase-version-check
 ### Arquivo .backup.gz não pode ser restaurado
 
 O smoonb suporta automaticamente:
-- ✅ `.backup.gz` - Descompacta via Docker antes de restaurar
+- ✅ `.backup.gz` - Lê o conteúdo compactado sem modificar o arquivo original
 - ✅ `.backup` - Restaura diretamente
 
 Se houver problemas:
@@ -661,3 +679,5 @@ Contribuições são bem-vindas. [www.smoonb.com/#price](https://www.smoonb.com/
 **Desenvolvido por:** Goalmoon Tecnologia LTDA  
 **Website:** https://www.smoonb.com  
 **GitHub:** https://github.com/almmello/smoonb
+
+Teste adicional do caminho real de restore: `npm run test:restore:docker`. Usa PostgreSQL descartável, dados fictícios e transporte HTTP simulado para Storage; cobre Auth, permissões, ciclos, rollback, arquivos e metadados.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smoonb",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "description": "Complete Supabase backup and migration tool. https://www.smoonb.com/#price",
   "preferGlobal": false,
   "preventGlobalInstall": true,
@@ -18,7 +18,8 @@
     "build": "node scripts/build.js",
     "build:check": "node scripts/build.js",
     "prepublishOnly": "npm test && npm run lint && npm run build",
-    "test:docker": "node tests/integration/circular-restore.js"
+    "test:docker": "node tests/integration/circular-restore.js",
+    "test:restore:docker": "node tests/integration/verified-restore.js"
   },
   "keywords": [
     "supabase",
@@ -33,7 +34,7 @@
   "author": "Goalmoon Tecnologia LTDA <https://www.smoonb.com>",
   "license": "SEE LICENSE IN LICENSE.md",
   "engines": {
-    "node": ">=16.0.0"
+    "node": ">=20.0.0"
   },
   "dependencies": {
     "@supabase/supabase-js": "^2.93.0",

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

@@ -2,6 +2,7 @@ const chalk = require('chalk');
 const path = require('path');
 const { writeJson } = require('../../../utils/fsx');
 const { t } = require('../../../i18n');
+const { authSnapshot } = require('../../../utils/auth-secrets');
 
 /**
  * Etapa 4: Backup Auth Settings via Management API
@@ -26,15 +27,18 @@ module.exports = async ({ projectId, accessToken, backupDir }) => {
 
     const authSettings = await authResponse.json();
     
-    // Salvar configurações de Auth
+    const snapshot = authSnapshot(authSettings);
+    // Never store the opaque SMTP readback as a recoverable password.
     const authSettingsPath = path.join(backupDir, 'auth-settings.json');
     await writeJson(authSettingsPath, {
       project_id: projectId,
       timestamp: new Date().toISOString(),
-      settings: authSettings
+      ...snapshot
     });
 
     console.log(chalk.green(`✅ Auth Settings exportadas: ${path.basename(authSettingsPath)}`));
+    if (snapshot.secrets.smtp_pass.requires_input)
+      console.log(chalk.yellow(getT('backup.smtp.passwordNotExported')));
     return { success: true };
 
   } catch (error) {

package/src/commands/backup/steps/06-realtime-settings.js

@@ -1,33 +1,19 @@
-const chalk = require('chalk');
-const path = require('path');
-const fs = require('fs').promises;
-const { captureRealtimeSettings } = require('../../../utils/realtime-settings');
-const { t } = require('../../../i18n');
-
-/**
- * Etapa 5: Backup Realtime Settings via Captura Interativa
- */
-module.exports = async ({ projectId, backupDir, options }) => {
-  try {
-    const getT = global.smoonbI18n?.t || t;
-    console.log(chalk.white(`   - ${getT('backup.steps.realtime.capturing')}`));
-    
-    const result = await captureRealtimeSettings(projectId, backupDir, options?.skipRealtime);
-
-    const settings = result.settings !== undefined ? result.settings : result;
-    const source = result.source || 'interactive';
-    const reusedFrom = result.reusedFrom || null;
-
-    const stats = await fs.stat(path.join(backupDir, 'realtime-settings.json'));
-    const sizeKB = (stats.size / 1024).toFixed(1);
-
-    console.log(chalk.green(`     ✅ Realtime Settings capturadas: ${sizeKB} KB`));
-
-    return { success: true, settings, source, reusedFrom };
-  } catch (error) {
-    const getT = global.smoonbI18n?.t || t;
-    console.log(chalk.yellow(`     ⚠️ ${getT('backup.steps.realtime.error', { message: error.message })}`));
-    return { success: false };
-  }
-};
-
+const path = require('path');
+const fs = require('fs').promises;
+const { management } = require('../../restore/management');
+module.exports = async ({ projectId, accessToken, backupDir }) => {
+  try {
+    const settings = await management(
+      { targetProjectId: projectId, targetAccessToken: accessToken },
+      'config/realtime',
+    );
+    const captured_at = new Date().toISOString();
+    await fs.writeFile(
+      path.join(backupDir, 'realtime-settings.json'),
+      JSON.stringify({ project_id: projectId, captured_at, settings }, null, 2),
+    );
+    return { success: true, settings, source: 'management-api', captured_at };
+  } catch {
+    return { success: false, reason: 'realtime_api_capture_failed' };
+  }
+};

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

@@ -106,18 +106,13 @@ module.exports = async ({ projectId, accessToken, backupDir, supabaseUrl, supaba
       try {
         console.log(chalk.white(`   - ${getT('backup.steps.storage.processing', { bucketName: bucket.name })}`));
 
-        const objectsResponse = await fetch(`https://api.supabase.com/v1/projects/${projectId}/storage/buckets/${bucket.name}/objects`, {
-          headers: {
-            'Authorization': `Bearer ${accessToken}`,
-            'Content-Type': 'application/json'
-          }
-        });
-
-        let objects = [];
-        if (objectsResponse.ok) {
-          objects = await objectsResponse.json();
-        }
-
+        const { readDump, records } = require('../../restore/dump');
+        const dumpFile = (await fs.readdir(backupDir)).find(f => /\.backup(?:\.gz)?$/.test(f));
+        if (!dumpFile) throw new Error('Database inventory required for Storage metadata');
+        const dump = readDump(path.join(backupDir, dumpFile));
+        const objects = records(dump.tables.find(t => t.schema === 'storage' && t.name === 'objects'))
+          .filter(o => o.bucket_id === bucket.id).map(o => ({ ...o, metadata: JSON.parse(o.metadata || '{}') }));
+
         const bucketInfo = {
           id: bucket.id,
           name: bucket.name,

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

@@ -1,202 +1,76 @@
-const chalk = require('chalk');
-const path = require('path');
-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)
- */
-module.exports = async (context) => {
-  const { projectId, accessToken, databaseUrl, backupDir } = context;
-  try {
-    const functionsDir = path.join(backupDir, 'edge-functions');
-    await ensureDir(functionsDir);
-
-    // Reset de link ao projeto de ORIGEM
-    const dbPassword = extractPasswordFromDbUrl(databaseUrl);
-    await ensureCleanLink(projectId, accessToken, dbPassword);
-
-    // Preparar diretório supabase/functions (criar se não existir, mas não limpar ainda)
-    const supabaseFunctionsDir = path.join(process.cwd(), 'supabase', 'functions');
-    
-    // Verificar flag de limpeza antes do backup
-    const shouldCleanAfter = context?.cleanupFlags?.cleanFunctions || false;
-    
-    // Registrar funções que já existiam ANTES do processo (para preservar se necessário)
-    let existingFunctionsBefore = [];
-    try {
-      const existingItems = await fs.readdir(supabaseFunctionsDir);
-      for (const item of existingItems) {
-        const itemPath = path.join(supabaseFunctionsDir, item);
-        const stats = await fs.stat(itemPath);
-        if (stats.isDirectory()) {
-          existingFunctionsBefore.push(item);
-        }
-      }
-    } catch {
-      // Diretório não existe, tudo bem
-      existingFunctionsBefore = [];
-    }
-    
-    // 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(`   - ${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(`   - ${getT('backup.steps.functions.preserving', { count: existingFunctionsBefore.length })}`));
-      } else {
-        console.log(chalk.white(`   - ${getT('backup.steps.functions.prepared')}`));
-      }
-    }
-
-    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`, {
-      headers: { 
-        'Authorization': `Bearer ${accessToken}`,
-        'Content-Type': 'application/json'
-      }
-    });
-    
-    if (!functionsResponse.ok) {
-      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(`   - ${getT('backup.steps.functions.noneFound')}`));
-      await writeJson(path.join(functionsDir, 'README.md'), {
-        message: getT('backup.steps.functions.noFunctionsMessage')
-      });
-      return { success: true, reason: 'no_functions', functions: [] };
-    }
-
-    console.log(chalk.white(`   - Encontradas ${functions.length} Edge Function(s)`));
-    
-    const downloadedFunctions = [];
-    let successCount = 0;
-    let errorCount = 0;
-    const totalFuncs = functions.length;
-    const stepStart = Date.now();
-
-    // Baixar cada Edge Function via Supabase CLI
-    // Nota: O CLI ignora o cwd e sempre baixa para supabase/functions
-    for (let idx = 0; idx < functions.length; idx++) {
-      const func = functions[idx];
-      const current = idx + 1;
-      const elapsed = Math.floor((Date.now() - stepStart) / 1000);
-      try {
-        console.log(chalk.white(`   - Baixando ${current}/${totalFuncs}: ${func.name}... (${elapsed}s)`));
-        
-        // Criar diretório da função NO BACKUP
-        const functionTargetDir = path.join(functionsDir, func.name);
-        await ensureDir(functionTargetDir);
-        
-        // Diretório temporário onde o supabase CLI irá baixar (supabase/functions)
-        const tempDownloadDir = path.join(process.cwd(), 'supabase', 'functions', func.name);
-        
-        // Baixar Edge Function via Supabase CLI (sempre vai para supabase/functions)
-        const { execSync } = require('child_process');
-        
-        execSync(`supabase functions download ${func.name}`, {
-          timeout: 60000,
-          stdio: 'pipe'
-        });
-        
-        // COPIAR arquivos de supabase/functions para o backup
-        try {
-          const stat = await fs.stat(tempDownloadDir);
-          if (stat.isDirectory()) {
-            const files = await fs.readdir(tempDownloadDir);
-            for (const file of files) {
-              const srcPath = path.join(tempDownloadDir, file);
-              const dstPath = path.join(functionTargetDir, file);
-              
-              const fileStats = await fs.stat(srcPath);
-              if (fileStats.isDirectory()) {
-                // Copiar diretórios recursivamente
-                await fs.cp(srcPath, dstPath, { recursive: true });
-              } else {
-                // Copiar arquivos
-                await fs.copyFile(srcPath, dstPath);
-              }
-            }
-          }
-        } catch {
-          // Arquivos não foram baixados, continuar
-          console.log(chalk.yellow(`     ⚠️ Nenhum arquivo encontrado em ${tempDownloadDir}`));
-        }
-        
-        // Limpar função baixada temporariamente APENAS se o usuário escolheu limpar após
-        // Se não escolheu, preservar (pode ser que já existisse antes)
-        if (shouldCleanAfter) {
-          try {
-            await fs.rm(tempDownloadDir, { recursive: true, force: true });
-          } catch {
-            // Ignorar erro de limpeza
-          }
-        }
-        // Se shouldCleanAfter = false, manter a função baixada (e qualquer função que já existia)
-        
-        console.log(chalk.green(`     ✅ ${func.name} baixada com sucesso`));
-        successCount++;
-        
-        downloadedFunctions.push({
-          name: func.name,
-          slug: func.name,
-          version: func.version || 'unknown',
-          files: await fs.readdir(functionTargetDir).catch(() => [])
-        });
-        
-      } catch (error) {
-        console.log(chalk.yellow(`     ⚠️ ${getT('backup.steps.functions.downloadError', { funcName: func.name, message: error.message })}`));
-        errorCount++;
-      }
-    }
-    
-    console.log(chalk.green(`📊 Backup de Edge Functions concluído:`));
-    console.log(chalk.green(`   ✅ Sucessos: ${successCount}`));
-    console.log(chalk.green(`   ❌ Erros: ${errorCount}`));
-    
-    // Limpar pasta supabase/functions APÓS o backup apenas se o usuário escolheu
-    // Nota: shouldCleanAfter já foi definido acima
-    if (shouldCleanAfter) {
-      await cleanDir(supabaseFunctionsDir);
-      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(`   - ${getT('backup.steps.functions.preserved')}`));
-    }
-    
-    return { 
-      success: true, 
-      reason: 'success',
-      functions: downloadedFunctions,
-      functions_count: functions.length,
-      success_count: successCount,
-      error_count: errorCount,
-      method: 'docker'
-    };
-
-  } catch (error) {
-    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: [] };
-  }
-};
-
+const path = require('path');
+const os = require('os');
+const fs = require('fs').promises;
+const { runSupabase } = require('../../../utils/supabaseCli');
+const { management } = require('../../restore/management');
+const { copyDirectoryRecursive } = require('../../restore/utils');
+module.exports = async ({ projectId, accessToken, backupDir }) => {
+  const root = await fs.mkdtemp(
+    path.join(os.tmpdir(), 'smoonb-functions-backup-'),
+  );
+  try {
+    const functions = await management(
+      { targetProjectId: projectId, targetAccessToken: accessToken },
+      'functions',
+    );
+    await fs.mkdir(path.join(root, 'supabase'), { recursive: true });
+    await fs.writeFile(
+      path.join(root, 'supabase', 'config.toml'),
+      'project_id = "smoonb-backup"\n',
+    );
+    const downloaded = [];
+    for (const f of functions) {
+      const name = f.slug || f.name;
+      if (!/^[-a-zA-Z0-9_]+$/.test(name))
+        throw new Error('Invalid function slug');
+      runSupabase(
+        'supabase',
+        [
+          'functions',
+          'download',
+          name,
+          '--project-ref',
+          projectId,
+          '--workdir',
+          root,
+        ],
+        {
+          cwd: root,
+          env: { ...process.env, SUPABASE_ACCESS_TOKEN: accessToken },
+          stdio: 'pipe',
+          timeout: 180000,
+          windowsHide: true,
+        },
+      );
+      const destination = path.join(backupDir, 'edge-functions', name);
+      await copyDirectoryRecursive(
+        path.join(root, 'supabase', 'functions', name),
+        destination,
+      );
+      downloaded.push({
+        name,
+        slug: name,
+        version: f.version,
+        verify_jwt: f.verify_jwt,
+        files: await fs.readdir(destination),
+      });
+    }
+    return {
+      success: true,
+      reason: 'success',
+      functions: downloaded,
+      functions_count: downloaded.length,
+      success_count: downloaded.length,
+      error_count: 0,
+      method: 'cli-isolated',
+    };
+  } catch {
+    return {
+      success: false,
+      reason: 'function_download_failed',
+      functions: [],
+    };
+  } finally {
+    await fs.rm(root, { recursive: true, force: true });
+  }
+};