smoonb 0.0.63 → 0.0.65

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smoonb",
-  "version": "0.0.63",
+  "version": "0.0.65",
   "description": "Complete Supabase backup and migration tool - EXPERIMENTAL VERSION - USE AT YOUR OWN RISK",
   "preferGlobal": false,
   "preventGlobalInstall": true,
@@ -34,6 +34,7 @@
   },
   "dependencies": {
     "@supabase/supabase-js": "^2.38.0",
+    "adm-zip": "^0.5.16",
     "chalk": "^4.1.2",
     "commander": "^11.1.0",
     "inquirer": "^8.2.7"

package/src/commands/backup/index.js

@@ -73,8 +73,16 @@ module.exports = async (options) => {
     const envPath = path.join(process.cwd(), '.env.local');
     const envBackupPath = path.join(backupDir, 'env', '.env.local');
     await ensureDir(path.dirname(envBackupPath));
-    await backupEnvFile(envPath, envBackupPath);
-    console.log(chalk.blue(`📁 Backup do .env.local: ${path.relative(process.cwd(), envBackupPath)}`));
+    
+    // Verificar se o arquivo existe antes de fazer backup
+    try {
+      await fs.access(envPath);
+      await backupEnvFile(envPath, envBackupPath);
+      console.log(chalk.blue(`📁 Backup do .env.local: ${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.'));
+    }
 
     const expectedKeys = [
       'SUPABASE_PROJECT_ID',

package/src/commands/restore/index.js

@@ -135,8 +135,16 @@ module.exports = async (options) => {
     // Backup do .env.local
     const envPath = path.join(process.cwd(), '.env.local');
     const envBackupPath = path.join(processDir, 'env', '.env.local');
-    await backupEnvFile(envPath, envBackupPath);
-    console.log(chalk.blue(`📁 Backup do .env.local: ${path.relative(process.cwd(), envBackupPath)}`));
+    
+    // Verificar se o arquivo existe antes de fazer backup
+    try {
+      await fsPromises.access(envPath);
+      await backupEnvFile(envPath, envBackupPath);
+      console.log(chalk.blue(`📁 Backup do .env.local: ${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.'));
+    }
 
     // Leitura e mapeamento interativo
     const currentEnv = await readEnvFile(envPath);
@@ -290,7 +298,8 @@ module.exports = async (options) => {
       stepNumber++;
       console.log(chalk.blue(`\n📦 ${stepNumber}/${totalSteps} - Restaurando Storage Buckets...`));
       const storageResult = await step06Storage({
-        backupPath: selectedBackup.path
+        backupPath: selectedBackup.path,
+        targetProject
       });
       restoreResults.storage = storageResult || { success: true };
     }
@@ -358,7 +367,14 @@ module.exports = async (options) => {
     
     if (restoreResults.storage) {
       const bucketCount = restoreResults.storage.buckets_count || 0;
-      console.log(chalk.green(`📦 Storage: ${bucketCount} bucket(s) encontrado(s) - migração manual necessária`));
+      const filesRestored = restoreResults.storage.files_restored;
+      const totalFiles = restoreResults.storage.total_files || 0;
+      
+      if (filesRestored) {
+        console.log(chalk.green(`📦 Storage: ${bucketCount} bucket(s) restaurado(s), ${totalFiles} arquivo(s) enviado(s)`));
+      } else {
+        console.log(chalk.green(`📦 Storage: ${bucketCount} bucket(s) encontrado(s) - apenas metadados (arquivo .storage.zip não encontrado)`));
+      }
     }
     
     if (restoreResults.databaseSettings) {

package/src/commands/restore/steps/01-components-selection.js

@@ -31,12 +31,21 @@ module.exports = async (backupPath) => {
   
   // Storage Buckets
   const storageDir = path.join(backupPath, 'storage');
+  const storageZipFiles = fs.readdirSync(backupPath).filter(f => f.endsWith('.storage.zip'));
   let restoreStorage = false;
-  if (fs.existsSync(storageDir) && fs.readdirSync(storageDir).length > 0) {
+  
+  if (storageZipFiles.length > 0 || (fs.existsSync(storageDir) && fs.readdirSync(storageDir).length > 0)) {
     console.log(chalk.cyan('\n📦 Storage:'));
-    console.log(chalk.white('   As informações dos buckets de Storage serão exibidas para migração manual.'));
-    console.log(chalk.white('   Os arquivos precisam ser migrados manualmente usando as ferramentas do Supabase.\n'));
-    restoreStorage = await confirm('Deseja ver informações de Storage Buckets', true);
+    if (storageZipFiles.length > 0) {
+      console.log(chalk.white(`   Arquivo .storage.zip encontrado: ${storageZipFiles[0]}`));
+      console.log(chalk.white('   Os buckets e arquivos serão restaurados automaticamente no projeto destino.'));
+      console.log(chalk.white('   O arquivo ZIP será extraído, buckets criados e arquivos enviados via API.\n'));
+    } else {
+      console.log(chalk.white('   Apenas metadados dos buckets encontrados (pasta storage).'));
+      console.log(chalk.white('   Para restaurar os arquivos, é necessário o arquivo .storage.zip do Dashboard.'));
+      console.log(chalk.white('   Apenas informações dos buckets serão exibidas.\n'));
+    }
+    restoreStorage = await confirm('Deseja restaurar Storage Buckets', true);
   }
   
   // Database Extensions and Settings

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

@@ -1,58 +1,378 @@
 const chalk = require('chalk');
 const path = require('path');
-const fs = require('fs');
-const inquirer = require('inquirer');
+const fs = require('fs').promises;
+const AdmZip = require('adm-zip');
+const { createClient } = require('@supabase/supabase-js');
 
 /**
- * Etapa 6: Restaurar Storage Buckets (interativo - exibir informações)
+ * Etapa 6: Restaurar Storage Buckets e arquivos
+ * Processo baseado no script oficial do Supabase Storage Migration
+ * Segue exatamente o processo descrito no notebook oficial do Supabase
  */
-module.exports = async ({ backupPath }) => {
+module.exports = async ({ backupPath, targetProject }) => {
   
   try {
+    // 1. Verificar se existe arquivo .storage.zip na pasta do backup
+    const storageZipFiles = await fs.readdir(backupPath).then(files => 
+      files.filter(f => f.endsWith('.storage.zip'))
+    );
+    
+    // 2. Carregar metadados dos buckets do backup (se existirem)
     const storageDir = path.join(backupPath, 'storage');
+    const manifestPath = path.join(backupPath, 'backup-manifest.json');
+    const bucketMetadata = {};
+    let manifest = null;
     
-    if (!fs.existsSync(storageDir)) {
-      console.log(chalk.yellow('   ⚠️  Nenhum bucket de Storage encontrado no backup'));
-      return { success: false, buckets_count: 0 };
+    try {
+      const manifestContent = await fs.readFile(manifestPath, 'utf8');
+      manifest = JSON.parse(manifestContent);
+      
+      // Carregar metadados dos buckets do manifest
+      const buckets = manifest?.components?.storage?.buckets || [];
+      for (const bucket of buckets) {
+        bucketMetadata[bucket.name] = {
+          public: bucket.public || false,
+          file_size_limit: bucket.file_size_limit || null,
+          allowed_mime_types: bucket.allowed_mime_types || null
+        };
+      }
+      
+      // Também tentar carregar dos arquivos JSON individuais (backup mais detalhado)
+      try {
+        const storageFiles = await fs.readdir(storageDir);
+        for (const file of storageFiles) {
+          if (file.endsWith('.json') && file !== 'README.md') {
+            const bucketName = file.replace('.json', '');
+            try {
+              const bucketInfoPath = path.join(storageDir, file);
+              const bucketInfoContent = await fs.readFile(bucketInfoPath, 'utf8');
+              const bucketInfo = JSON.parse(bucketInfoContent);
+              
+              // Usar metadados dos arquivos JSON se disponíveis (mais completo)
+              // Incluir objetos para preservar metadados dos arquivos (contentType, cacheControl)
+              bucketMetadata[bucketName] = {
+                public: bucketInfo.public !== undefined ? bucketInfo.public : false,
+                file_size_limit: bucketInfo.file_size_limit || null,
+                allowed_mime_types: bucketInfo.allowed_mime_types || null,
+                objects: bucketInfo.objects || [] // Metadados dos objetos para preservar contentType e cacheControl
+              };
+            } catch {
+              // Ignorar arquivos JSON inválidos
+            }
+          }
+        }
+      } catch {
+        // Pasta storage pode não existir, continuar
+      }
+    } catch {
+      // Manifest pode não existir, continuar sem metadados
     }
     
-    const manifestPath = path.join(backupPath, 'backup-manifest.json');
-    let manifest = null;
+    if (storageZipFiles.length === 0) {
+      // Verificar se existe pasta storage com metadados (backup antigo)
+      try {
+        await fs.access(storageDir);
+        const buckets = manifest?.components?.storage?.buckets || [];
+        
+        if (buckets.length === 0) {
+          console.log(chalk.yellow('   ⚠️  Nenhum bucket de Storage encontrado no backup'));
+          return { success: false, buckets_count: 0 };
+        }
+        
+        console.log(chalk.yellow('\n   ⚠️  Arquivo .storage.zip não encontrado'));
+        console.log(chalk.white('   ℹ️  Apenas metadados dos buckets foram encontrados'));
+        console.log(chalk.white('   ℹ️  Para restaurar os arquivos, é necessário o arquivo .storage.zip do Dashboard'));
+        console.log(chalk.green(`\n   ✅ ${buckets.length} bucket(s) encontrado(s) no backup (apenas metadados)`));
+        buckets.forEach(bucket => {
+          console.log(chalk.white(`   - ${bucket.name} (${bucket.public ? 'público' : 'privado'})`));
+        });
+        
+        return { success: true, buckets_count: buckets.length, files_restored: false };
+      } catch {
+        console.log(chalk.yellow('   ⚠️  Nenhum bucket de Storage encontrado no backup'));
+        return { success: false, buckets_count: 0 };
+      }
+    }
+    
+    // 3. Selecionar o primeiro arquivo .storage.zip encontrado
+    const storageZipFile = path.join(backupPath, storageZipFiles[0]);
+    console.log(chalk.white(`   - Arquivo de storage encontrado: ${storageZipFiles[0]}`));
+    
+    // 4. Validar credenciais do projeto destino
+    if (!targetProject.targetProjectId || !targetProject.targetAccessToken) {
+      throw new Error('Credenciais do projeto destino não configuradas. É necessário SUPABASE_PROJECT_ID e SUPABASE_ACCESS_TOKEN');
+    }
     
-    if (fs.existsSync(manifestPath)) {
-      manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+    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');
     }
     
-    const buckets = manifest?.components?.storage?.buckets || [];
+    // 5. Extrair arquivo ZIP
+    console.log(chalk.white('   - Extraindo arquivo .storage.zip...'));
+    const extractDir = path.join(backupPath, 'storage_extracted');
+    
+    try {
+      await fs.mkdir(extractDir, { recursive: true });
+    } catch {
+      // Diretório pode já existir
+    }
     
-    if (buckets.length === 0) {
-      console.log(chalk.white('   ℹ️  Nenhum bucket para restaurar'));
+    const zip = new AdmZip(storageZipFile);
+    zip.extractAllTo(extractDir, true);
+    console.log(chalk.green('   ✅ Arquivo extraído com sucesso'));
+    
+    // 6. Ler estrutura de diretórios extraídos
+    // O formato do .storage.zip do Supabase tem a estrutura:
+    // bucket-name/
+    //   file1.jpg
+    //   folder/
+    //     file2.png
+    const extractedContents = await fs.readdir(extractDir);
+    const bucketDirs = [];
+    
+    for (const item of extractedContents) {
+      const itemPath = path.join(extractDir, item);
+      const stats = await fs.stat(itemPath);
+      if (stats.isDirectory()) {
+        bucketDirs.push(item);
+      }
+    }
+    
+    if (bucketDirs.length === 0) {
+      console.log(chalk.yellow('   ⚠️  Nenhum bucket encontrado no arquivo .storage.zip'));
       return { success: false, buckets_count: 0 };
     }
     
-    console.log(chalk.green(`\n   ✅ ${buckets.length} bucket(s) encontrado(s) no backup`));
-    buckets.forEach(bucket => {
-      console.log(chalk.white(`   - ${bucket.name} (${bucket.public ? 'público' : 'privado'})`));
-    });
+    console.log(chalk.white(`   - Encontrados ${bucketDirs.length} bucket(s) no arquivo ZIP`));
     
-    const colabUrl = 'https://colab.research.google.com/github/PLyn/supabase-storage-migrate/blob/main/Supabase_Storage_migration.ipynb';
+    // 7. Criar cliente Supabase para o projeto destino
+    const supabase = createClient(targetProject.targetUrl, targetProject.targetServiceKey);
     
-    console.log(chalk.yellow('\n   ⚠️  Migração de objetos de Storage requer processo manual'));
-    console.log(chalk.cyan(`   ℹ️  Use o script do Google Colab: ${colabUrl}`));
-    console.log(chalk.white('\n   📋 Instruções:'));
-    console.log(chalk.white('   1. Execute o script no Google Colab'));
-    console.log(chalk.white('   2. Configure as credenciais dos projetos (origem e destino)'));
-    console.log(chalk.white('   3. Execute a migração'));
+    // 8. Processar cada bucket
+    let successCount = 0;
+    let totalFilesUploaded = 0;
     
-    await inquirer.prompt([{
-      type: 'input',
-      name: 'continue',
-      message: 'Pressione Enter para continuar'
-    }]);
+    for (const bucketName of bucketDirs) {
+      try {
+        console.log(chalk.white(`\n   - Processando bucket: ${bucketName}`));
+        
+        const bucketPath = path.join(extractDir, bucketName);
+        
+        // 8.1 Obter metadados do bucket do backup (se disponíveis)
+        const bucketMeta = bucketMetadata[bucketName] || {
+          public: false,
+          file_size_limit: null,
+          allowed_mime_types: null
+        };
+        
+        // 8.2 Verificar se bucket já existe, se não, criar com configurações corretas
+        const { data: existingBuckets, error: listError } = await supabase.storage.listBuckets();
+        
+        if (listError) {
+          throw new Error(`Erro ao listar buckets: ${listError.message}`);
+        }
+        
+        const existingBucket = existingBuckets?.find(b => b.name === bucketName);
+        const bucketExists = !!existingBucket;
+        
+        if (!bucketExists) {
+          // Criar bucket via Management API com configurações do backup
+          console.log(chalk.white(`     - Criando bucket ${bucketName}...`));
+          console.log(chalk.white(`       Configurações: ${bucketMeta.public ? 'público' : 'privado'}, limite: ${bucketMeta.file_size_limit || 'sem limite'}, tipos: ${bucketMeta.allowed_mime_types?.join(', ') || 'todos'}`));
+          
+          const createResponse = await fetch(
+            `https://api.supabase.com/v1/projects/${targetProject.targetProjectId}/storage/buckets`,
+            {
+              method: 'POST',
+              headers: {
+                'Authorization': `Bearer ${targetProject.targetAccessToken}`,
+                'Content-Type': 'application/json'
+              },
+              body: JSON.stringify({
+                name: bucketName,
+                public: bucketMeta.public,
+                file_size_limit: bucketMeta.file_size_limit,
+                allowed_mime_types: bucketMeta.allowed_mime_types
+              })
+            }
+          );
+          
+          if (!createResponse.ok) {
+            const errorText = await createResponse.text();
+            throw new Error(`Erro ao criar bucket: ${createResponse.status} ${errorText}`);
+          }
+          
+          console.log(chalk.green(`     ✅ Bucket ${bucketName} criado com configurações do backup`));
+        } else {
+          // Bucket já existe - verificar e atualizar configurações se necessário
+          console.log(chalk.white(`     - Bucket ${bucketName} já existe`));
+          
+          const needsUpdate = 
+            existingBucket.public !== bucketMeta.public ||
+            existingBucket.file_size_limit !== bucketMeta.file_size_limit ||
+            JSON.stringify(existingBucket.allowed_mime_types || []) !== JSON.stringify(bucketMeta.allowed_mime_types || []);
+          
+          if (needsUpdate) {
+            console.log(chalk.white(`     - Atualizando configurações do bucket para corresponder ao backup...`));
+            
+            const updateResponse = await fetch(
+              `https://api.supabase.com/v1/projects/${targetProject.targetProjectId}/storage/buckets/${bucketName}`,
+              {
+                method: 'PATCH',
+                headers: {
+                  'Authorization': `Bearer ${targetProject.targetAccessToken}`,
+                  'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({
+                  public: bucketMeta.public,
+                  file_size_limit: bucketMeta.file_size_limit,
+                  allowed_mime_types: bucketMeta.allowed_mime_types
+                })
+              }
+            );
+            
+            if (!updateResponse.ok) {
+              const errorText = await updateResponse.text();
+              console.log(chalk.yellow(`       ⚠️  Não foi possível atualizar configurações: ${errorText}`));
+            } else {
+              console.log(chalk.green(`       ✅ Configurações do bucket atualizadas`));
+            }
+          } else {
+            console.log(chalk.white(`     - Configurações do bucket já estão corretas`));
+          }
+        }
+        
+        // 8.3 Listar todos os arquivos do bucket recursivamente
+        async function getAllFiles(dir, basePath = '') {
+          const files = [];
+          const entries = await fs.readdir(dir, { withFileTypes: true });
+          
+          for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            const relativePath = path.join(basePath, entry.name).replace(/\\/g, '/');
+            
+            if (entry.isDirectory()) {
+              const subFiles = await getAllFiles(fullPath, relativePath);
+              files.push(...subFiles);
+            } else {
+              files.push({
+                localPath: fullPath,
+                storagePath: relativePath
+              });
+            }
+          }
+          
+          return files;
+        }
+        
+        const filesToUpload = await getAllFiles(bucketPath);
+        console.log(chalk.white(`     - Encontrados ${filesToUpload.length} arquivo(s) para upload`));
+        
+        // 8.4 Fazer upload de cada arquivo
+        // Criar mapa de metadados dos objetos do backup (se disponível)
+        // A Management API pode retornar objetos com diferentes estruturas
+        const objectsMetadata = {};
+        if (bucketMeta.objects && Array.isArray(bucketMeta.objects)) {
+          for (const obj of bucketMeta.objects) {
+            // Normalizar o caminho para comparação (remover barras iniciais e normalizar)
+            // A API pode retornar 'name' ou 'path' ou 'id'
+            const objPath = obj.name || obj.path || obj.id || '';
+            const normalizedPath = objPath.replace(/^\/+/, '').replace(/\\/g, '/');
+            if (normalizedPath) {
+              objectsMetadata[normalizedPath] = obj;
+            }
+          }
+        }
+        
+        let filesUploaded = 0;
+        for (const file of filesToUpload) {
+          try {
+            const fileContent = await fs.readFile(file.localPath);
+            const fileName = path.basename(file.localPath);
+            
+            // Usar o caminho relativo como path no storage
+            const storagePath = file.storagePath;
+            
+            // Buscar metadados do objeto no backup (se disponível)
+            // Normalizar caminho para comparação (remover barras iniciais e normalizar separadores)
+            const normalizedStoragePath = storagePath.replace(/^\/+/, '').replace(/\\/g, '/');
+            const objectMeta = objectsMetadata[normalizedStoragePath];
+            
+            // Extrair metadados do objeto (a estrutura pode variar)
+            // A Management API pode retornar metadata.mimetype, metadata.contentType, ou metadata diretamente
+            let contentType = getContentType(fileName);
+            let cacheControl = undefined;
+            
+            if (objectMeta) {
+              // Tentar diferentes estruturas possíveis de metadados
+              const metadata = objectMeta.metadata || objectMeta;
+              contentType = metadata?.mimetype || 
+                           metadata?.contentType || 
+                           metadata?.mime_type ||
+                           objectMeta.mimetype ||
+                           objectMeta.contentType ||
+                           getContentType(fileName);
+              
+              cacheControl = metadata?.cacheControl || 
+                            metadata?.cache_control ||
+                            objectMeta.cacheControl ||
+                            objectMeta.cache_control ||
+                            undefined;
+            }
+            
+            // Preparar opções de upload seguindo o script oficial do Supabase
+            // Preservar contentType e cacheControl quando disponíveis
+            const uploadOptions = {
+              upsert: true, // Sobrescrever se já existir
+              contentType: contentType
+            };
+            
+            // Adicionar cacheControl apenas se estiver definido
+            if (cacheControl) {
+              uploadOptions.cacheControl = cacheControl;
+            }
+            
+            const { error: uploadError } = await supabase.storage
+              .from(bucketName)
+              .upload(storagePath, fileContent, uploadOptions);
+            
+            if (uploadError) {
+              console.log(chalk.yellow(`       ⚠️  Erro ao fazer upload de ${storagePath}: ${uploadError.message}`));
+            } else {
+              filesUploaded++;
+              if (filesToUpload.length <= 10 || filesUploaded % Math.ceil(filesToUpload.length / 10) === 0) {
+                const metaInfo = objectMeta ? ' (metadados preservados)' : '';
+                console.log(chalk.white(`       - Upload: ${storagePath}${metaInfo}`));
+              }
+            }
+          } catch (fileError) {
+            console.log(chalk.yellow(`       ⚠️  Erro ao processar arquivo ${file.storagePath}: ${fileError.message}`));
+          }
+        }
+        
+        console.log(chalk.green(`     ✅ Bucket ${bucketName}: ${filesUploaded}/${filesToUpload.length} arquivo(s) enviado(s)`));
+        successCount++;
+        totalFilesUploaded += filesUploaded;
+        
+      } catch (bucketError) {
+        console.log(chalk.red(`     ❌ Erro ao processar bucket ${bucketName}: ${bucketError.message}`));
+      }
+    }
+    
+    // 9. Limpar diretório de extração
+    try {
+      await fs.rm(extractDir, { recursive: true, force: true });
+    } catch {
+      // Ignorar erro de limpeza
+    }
+    
+    console.log(chalk.green(`\n   ✅ Restauração de Storage concluída: ${successCount}/${bucketDirs.length} bucket(s) processado(s), ${totalFilesUploaded} arquivo(s) enviado(s)`));
     
     return {
       success: true,
-      buckets_count: buckets.length
+      buckets_count: successCount,
+      files_restored: true,
+      total_files: totalFilesUploaded
     };
     
   } catch (error) {
@@ -61,3 +381,28 @@ module.exports = async ({ backupPath }) => {
   }
 };
 
+/**
+ * Determina o content-type baseado na extensão do arquivo
+ */
+function getContentType(fileName) {
+  const ext = path.extname(fileName).toLowerCase();
+  const contentTypes = {
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.png': 'image/png',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+    '.svg': 'image/svg+xml',
+    '.pdf': 'application/pdf',
+    '.json': 'application/json',
+    '.txt': 'text/plain',
+    '.html': 'text/html',
+    '.css': 'text/css',
+    '.js': 'application/javascript',
+    '.zip': 'application/zip',
+    '.mp4': 'video/mp4',
+    '.mp3': 'audio/mpeg'
+  };
+  
+  return contentTypes[ext] || 'application/octet-stream';
+}

package/src/commands/restore/utils.js

@@ -94,7 +94,13 @@ function showRestoreSummary(backup, components, targetProject) {
   }
   
   if (components.storage) {
-    console.log('📦 Storage Buckets: Exibir informações e instruções do Google Colab');
+    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');
+    } else {
+      console.log('📦 Storage Buckets: Exibir informações (apenas metadados - arquivo .storage.zip não encontrado)');
+    }
   }
   
   if (components.databaseSettings) {

package/src/interactive/envMapper.js

@@ -38,22 +38,22 @@ async function mapEnvVariablesInteractively(env, expectedKeys) {
       'NEXT_PUBLIC_SUPABASE_URL': {
         notFound: 'Não foi encontrada uma entrada para a variável NEXT_PUBLIC_SUPABASE_URL.',
         help: currentProjectId 
-          ? `Acesse: https://supabase.com/dashboard/project/${currentProjectId}/settings/api`
-          : 'Acesse: Dashboard -> Project Settings -> API -> Project URL',
+          ? `https://supabase.com/dashboard/project/${currentProjectId}/settings/api`
+          : 'Dashboard -> Project Settings -> API -> Project URL',
         link: currentProjectId ? `https://supabase.com/dashboard/project/${currentProjectId}/settings/api` : null
       },
       'NEXT_PUBLIC_SUPABASE_ANON_KEY': {
         notFound: 'Não foi encontrada uma entrada para a variável NEXT_PUBLIC_SUPABASE_ANON_KEY.',
         help: currentProjectId
-          ? `Acesse: https://supabase.com/dashboard/project/${currentProjectId}/settings/api-keys`
-          : 'Acesse: Dashboard -> Project Settings -> API -> API Keys -> anon public',
+          ? `https://supabase.com/dashboard/project/${currentProjectId}/settings/api-keys`
+          : 'Dashboard -> Project Settings -> API -> API Keys -> anon public',
         link: currentProjectId ? `https://supabase.com/dashboard/project/${currentProjectId}/settings/api-keys` : null
       },
       'SUPABASE_SERVICE_ROLE_KEY': {
         notFound: 'Não foi encontrada uma entrada para a variável SUPABASE_SERVICE_ROLE_KEY.',
         help: currentProjectId
-          ? `Acesse: https://supabase.com/dashboard/project/${currentProjectId}/settings/api-keys`
-          : 'Acesse: Dashboard -> Project Settings -> API -> API Keys -> service_role secret',
+          ? `https://supabase.com/dashboard/project/${currentProjectId}/settings/api-keys`
+          : 'Dashboard -> Project Settings -> API -> API Keys -> service_role secret',
         link: currentProjectId ? `https://supabase.com/dashboard/project/${currentProjectId}/settings/api-keys` : null
       },
       'SUPABASE_DB_URL': {
@@ -65,7 +65,7 @@ async function mapEnvVariablesInteractively(env, expectedKeys) {
       },
       'SUPABASE_ACCESS_TOKEN': {
         notFound: 'Não foi encontrada uma entrada para a variável SUPABASE_ACCESS_TOKEN.',
-        help: 'Acesse: https://supabase.com/dashboard/account/tokens',
+        help: 'https://supabase.com/dashboard/account/tokens',
         link: 'https://supabase.com/dashboard/account/tokens'
       },
       'SMOONB_OUTPUT_DIR': {
@@ -91,8 +91,8 @@ async function mapEnvVariablesInteractively(env, expectedKeys) {
     // Se existir chave exatamente igual, pular seleção e ir direto para confirmação
     if (Object.prototype.hasOwnProperty.call(finalEnv, expected)) {
       clientKey = expected;
-    } else {
-      // Opção explícita para adicionar nova chave
+    } else if (allKeys.length > 0) {
+      // Só mostrar seleção se houver chaves disponíveis no env
       const choices = [
         ...allKeys.map((k, idx) => ({ name: `${idx + 1}. ${k}`, value: k })),
         new inquirer.Separator(),
@@ -119,19 +119,31 @@ async function mapEnvVariablesInteractively(env, expectedKeys) {
         }
         finalEnv[clientKey] = '';
       }
+    } else {
+      // Se não há chaves no env, criar nova chave diretamente
+      clientKey = expected;
+      finalEnv[clientKey] = '';
     }
 
     const currentValue = finalEnv[clientKey] ?? '';
     const currentProjectId = getProjectId();
     const instructions = getVariableInstructions(expected, currentProjectId);
 
-    // Se não tem valor, mostrar mensagem específica
+    // Se não tem valor, mostrar mensagem específica e pular confirmação
     if (!currentValue) {
       console.log(chalk.yellow(instructions.notFound));
       if (instructions.help) {
-        console.log(chalk.white(instructions.help));
-      }
-      if (instructions.link) {
+        // Se o help contém link (https://), mostrar como link
+        if (instructions.help.includes('https://')) {
+          console.log(chalk.cyan(`🔗 ${instructions.help}`));
+        } else {
+          console.log(chalk.white(instructions.help));
+          // Se há link separado e o help não contém link, mostrar link separado
+          if (instructions.link && !instructions.help.includes('https://')) {
+            console.log(chalk.cyan(`🔗 ${instructions.link}`));
+          }
+        }
+      } else if (instructions.link) {
         console.log(chalk.cyan(`🔗 ${instructions.link}`));
       }
     } else {

package/src/utils/env.js

@@ -81,10 +81,12 @@ async function writeEnvFile(filePath, entries, _options = {}) {
 async function backupEnvFile(srcPath, destPath) {
   await fsp.mkdir(path.dirname(destPath), { recursive: true });
   try {
+    // Verificar se o arquivo existe antes de fazer backup
+    await fsp.access(srcPath);
     await fsp.copyFile(srcPath, destPath);
   } catch (e) {
     if (e.code === 'ENOENT') {
-      await fsp.writeFile(destPath, '', 'utf8');
+      // Arquivo não existe, não fazer backup de arquivo vazio
       return;
     }
     throw e;