smoonb 1.0.11 → 1.0.13

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

@@ -47,13 +47,13 @@ async function estimateClusterBytes({ postgresImage, username, password, host, p
   const query = "SELECT COALESCE(sum(pg_database_size(datname)),0) FROM pg_database WHERE datistemplate = false;";
   const args = [
     'run', '--rm', '--network', 'host',
-    '-e', `PGPASSWORD=${password}`,
+    '-e', 'PGPASSWORD',
     postgresImage, 'psql',
     '-h', host, '-p', port, '-U', username, '-d', 'postgres',
     '-t', '-A', '-c', query
   ];
   return new Promise((resolve) => {
-    const proc = spawn('docker', args, { stdio: ['ignore', 'pipe', 'pipe'] });
+    const proc = spawn('docker', args, { env: { ...process.env, PGPASSWORD: password }, stdio: ['ignore', 'pipe', 'pipe'] });
     let stdout = '';
     let done = false;
     const timeout = setTimeout(() => {
@@ -163,7 +163,7 @@ module.exports = async ({ databaseUrl, backupDir, postgresMajor: contextMajor })
     const dockerArgs = [
       'run', '--rm', '--network', 'host',
       '-v', `${backupDirAbs}:/host`,
-      '-e', `PGPASSWORD=${password}`,
+      '-e', 'PGPASSWORD',
       postgresImage, 'pg_dumpall',
       '-h', host,
       '-p', port,
@@ -183,10 +183,10 @@ module.exports = async ({ databaseUrl, backupDir, postgresMajor: contextMajor })
     let lastProgressLine = '';
 
     const runDump = () => new Promise((resolve, reject) => {
-      const proc = spawn('docker', dockerArgs, { stdio: ['ignore', 'pipe', 'pipe'] });
+      const proc = spawn('docker', dockerArgs, { env: { ...process.env, PGPASSWORD: password }, stdio: ['ignore', 'pipe', 'pipe'] });
 
       proc.stderr.on('data', (chunk) => {
-        process.stderr.write(chunk);
+        void chunk;
         if (useTty && lastProgressLine) {
           readline.cursorTo(process.stdout, 0);
           process.stdout.write(lastProgressLine);
@@ -302,7 +302,7 @@ module.exports = async ({ databaseUrl, backupDir, postgresMajor: contextMajor })
     const runGzip = () => new Promise((resolve, reject) => {
       const proc = spawn('docker', gzipArgs, { stdio: ['ignore', 'pipe', 'pipe'] });
 
-      proc.stderr.on('data', (chunk) => process.stderr.write(chunk));
+      proc.stderr.on('data', (chunk) => void chunk);
 
       const pollGzip = async () => {
         if (!(await exists(gzipOutputPath))) return;

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

@@ -1,161 +1,129 @@
-const chalk = require('chalk');
-const path = require('path');
-const fs = require('fs').promises;
-const { spawn } = require('child_process');
-const { t } = require('../../../i18n');
-const { createPgDumpDiagnostics, hasReplicaRolePrologue } = require('../../../utils/pg-dump-diagnostics');
-
-function runWithElapsedTicker(command, args, env, label, collectWarnings = false) {
-  return new Promise((resolve, reject) => {
-    const start = Date.now();
-    const useTty = Boolean(process.stdout.isTTY);
-    const clearTicker = () => {
-      if (useTty) process.stdout.write('\r' + ' '.repeat(80) + '\r');
-    };
-    const diagnostics = createPgDumpDiagnostics(chunk => {
-      clearTicker();
-      process.stderr.write(chunk);
-    });
-    const ticker = useTty ? setInterval(() => {
-      const elapsed = Math.floor((Date.now() - start) / 1000);
-      process.stdout.write(`\r     ⏱ ${label} ${elapsed}s`);
-    }, 1000) : null;
-    let settled = false;
-    const finish = (error) => {
-      if (settled) return;
-      settled = true;
-      clearInterval(ticker);
-      clearTicker();
-      const result = diagnostics.end();
-      if (error) {
-        // A failed export must never hide the diagnostics already collected.
-        if (result.messages.length) process.stderr.write(result.messages.join('\n') + '\n');
-        reject(error);
-      } else resolve(result);
-    };
-    try {
-      const proc = spawn(command, args, {
-        stdio: ['ignore', 'pipe', 'pipe'],
-        shell: true,
-        env: { ...process.env, ...env }
-      });
-      // Drain stdout as well, so a verbose CLI cannot fill its pipe and hang.
-      proc.stdout.on('data', chunk => { clearTicker(); process.stdout.write(chunk); });
-      proc.stderr.on('data', chunk => {
-        if (collectWarnings) diagnostics.write(chunk);
-        else { clearTicker(); process.stderr.write(chunk); }
-      });
-      proc.on('close', code => finish(code === 0 ? null : new Error(`Exited with code ${code}`)));
-      proc.on('error', finish);
-    } catch (error) {
-      finish(error);
-    }
-  });
-}
-
-/**
- * Etapa 2: Backup Database Separado (SQL files para troubleshooting)
- */
-function createDatabaseSeparatedStep(runDump = runWithElapsedTicker) {
-  return async ({ databaseUrl, backupDir, accessToken }) => {
-    try {
-      const getT = global.smoonbI18n?.t || t;
-      console.log(chalk.white(`   - ${getT('backup.steps.database.separated.creating')}`));
-
-      const dbUrl = databaseUrl;
-      const files = [];
-      let totalSizeKB = 0;
-      const warnings = [];
-      const failedFiles = [];
-
-      // 1. Backup do Schema
-      console.log(chalk.white(`   - ${getT('backup.steps.database.separated.exportingSchema')}`));
-      const schemaFile = path.join(backupDir, 'schema.sql');
-
-      try {
-        await runDump(
-          `supabase db dump --db-url "${dbUrl}" -f "${schemaFile}"`,
-          [],
-          { SUPABASE_ACCESS_TOKEN: accessToken || '' },
-          getT('backup.steps.database.separated.exportingSchema')
-        );
-        const stats = await fs.stat(schemaFile);
-        const sizeKB = (stats.size / 1024).toFixed(1);
-        files.push({ filename: 'schema.sql', sizeKB });
-        totalSizeKB += parseFloat(sizeKB);
-        console.log(chalk.green(`     ✅ Schema: ${sizeKB} KB`));
-      } catch (error) {
-        failedFiles.push('schema.sql');
-        console.log(chalk.yellow(`     ⚠️ ${getT('backup.steps.database.separated.schemaError', { message: error.message })}`));
-      }
-
-      // 2. Backup dos Dados
-      console.log(chalk.white(`   - ${getT('backup.steps.database.separated.exportingData')}`));
-      const dataFile = path.join(backupDir, 'data.sql');
-
-      try {
-        const diagnostics = await runDump(
-          `supabase db dump --db-url "${dbUrl}" --data-only -f "${dataFile}"`,
-          [],
-          { SUPABASE_ACCESS_TOKEN: accessToken || '' },
-          getT('backup.steps.database.separated.exportingData'),
-          true
-        );
-        const stats = await fs.stat(dataFile);
-        if (diagnostics.circularForeignKeys) {
-          const replicaRolePrologue = await hasReplicaRolePrologue(dataFile);
-          warnings.push({ code: 'CIRCULAR_FOREIGN_KEYS', ...diagnostics, replicaRolePrologue });
-          console.log(chalk.cyan(`     ℹ️ ${getT('backup.steps.database.separated.circularSummary', { tables: diagnostics.tables.join(', ') })}`));
-          console.log(chalk.yellow(`     ⚠️ ${getT(replicaRolePrologue
-            ? 'backup.steps.database.separated.circularProtected'
-            : 'backup.steps.database.separated.circularUnprotected')}`));
-        }
-        const sizeKB = (stats.size / 1024).toFixed(1);
-        files.push({ filename: 'data.sql', sizeKB });
-        totalSizeKB += parseFloat(sizeKB);
-        console.log(chalk.green(`     ✅ Data: ${sizeKB} KB`));
-      } catch (error) {
-        failedFiles.push('data.sql');
-        console.log(chalk.yellow(`     ⚠️ ${getT('backup.steps.database.separated.dataError', { message: error.message })}`));
-      }
-
-      // 3. Backup dos Roles
-      console.log(chalk.white(`   - ${getT('backup.steps.database.separated.exportingRoles')}`));
-      const rolesFile = path.join(backupDir, 'roles.sql');
-
-      try {
-        await runDump(
-          `supabase db dump --db-url "${dbUrl}" --role-only -f "${rolesFile}"`,
-          [],
-          { SUPABASE_ACCESS_TOKEN: accessToken || '' },
-          getT('backup.steps.database.separated.exportingRoles')
-        );
-        const stats = await fs.stat(rolesFile);
-        const sizeKB = (stats.size / 1024).toFixed(1);
-        files.push({ filename: 'roles.sql', sizeKB });
-        totalSizeKB += parseFloat(sizeKB);
-        console.log(chalk.green(`     ✅ Roles: ${sizeKB} KB`));
-      } catch (error) {
-        failedFiles.push('roles.sql');
-        console.log(chalk.yellow(`     ⚠️ ${getT('backup.steps.database.separated.rolesError', { message: error.message })}`));
-      }
-
-      return {
-        success: files.length === 3,
-        warnings,
-        failedFiles,
-        files,
-        totalSizeKB: totalSizeKB.toFixed(1)
-      };
-
-    } catch (error) {
-      const getT = global.smoonbI18n?.t || t;
-      console.log(chalk.yellow(`     ⚠️ ${getT('backup.steps.database.separated.error', { message: error.message })}`));
-      return { success: false, files: [], warnings: [], failedFiles: ['schema.sql', 'data.sql', 'roles.sql'], totalSizeKB: '0.0' };
-    }
-  };
-}
-
-module.exports = createDatabaseSeparatedStep();
-module.exports.createDatabaseSeparatedStep = createDatabaseSeparatedStep;
-module.exports.runWithElapsedTicker = runWithElapsedTicker;
+const chalk = require('chalk');
+const path = require('path');
+const fs = require('fs').promises;
+const { t } = require('../../../i18n');
+const { createPgDumpDiagnostics, hasReplicaRolePrologue, withoutCliUpgradeNotice } = require('../../../utils/pg-dump-diagnostics');
+
+const { isolatedSupabase } = require('../../../utils/supabaseCli');
+async function runWithElapsedTicker(_command, args, env) {
+  const result = await isolatedSupabase(args, env, { capture: true });
+  let stderr = withoutCliUpgradeNotice(result.stderr || '');
+  const secrets = Object.values(env || {}).filter(Boolean);
+  const databaseUrl = args[args.indexOf('--db-url') + 1];
+  if (databaseUrl) {
+    secrets.push(databaseUrl);
+    try { secrets.push(decodeURIComponent(new URL(databaseUrl).password)); } catch { /* invalid URLs are handled by the CLI */ }
+  }
+  for (const secret of secrets.filter(Boolean).sort((a, b) => b.length - a.length)) stderr = stderr.split(secret).join('[redacted]');
+  stderr = stderr.replace(/postgres(?:ql)?:\/\/[^\s"']+/gi, '[database URL redacted]');
+  const diagnostics = createPgDumpDiagnostics(chunk => process.stderr.write(chunk));
+  diagnostics.write(stderr);
+  return diagnostics.end();
+}
+
+/**
+ * Etapa 2: Backup Database Separado (SQL files para troubleshooting)
+ */
+function createDatabaseSeparatedStep(runDump = runWithElapsedTicker) {
+  return async ({ databaseUrl, backupDir, accessToken }) => {
+    try {
+      const getT = global.smoonbI18n?.t || t;
+      console.log(chalk.white(`   - ${getT('backup.steps.database.separated.creating')}`));
+
+      const dbUrl = databaseUrl;
+      const files = [];
+      let totalSizeKB = 0;
+      const warnings = [];
+      const failedFiles = [];
+
+      // 1. Backup do Schema
+      console.log(chalk.white(`   - ${getT('backup.steps.database.separated.exportingSchema')}`));
+      const schemaFile = path.join(backupDir, 'schema.sql');
+
+      try {
+        await runDump(
+          'supabase',
+          ['db', 'dump', '--db-url', dbUrl, '-f', path.resolve(schemaFile)],
+          { SUPABASE_ACCESS_TOKEN: accessToken || '' },
+          getT('backup.steps.database.separated.exportingSchema')
+        );
+        const stats = await fs.stat(schemaFile);
+        const sizeKB = (stats.size / 1024).toFixed(1);
+        files.push({ filename: 'schema.sql', sizeKB });
+        totalSizeKB += parseFloat(sizeKB);
+        console.log(chalk.green(`     ✅ Schema: ${sizeKB} KB`));
+      } catch (error) {
+        failedFiles.push('schema.sql');
+        console.log(chalk.yellow(`     ⚠️ ${getT('backup.steps.database.separated.schemaError', { message: error.message })}`));
+      }
+
+      // 2. Backup dos Dados
+      console.log(chalk.white(`   - ${getT('backup.steps.database.separated.exportingData')}`));
+      const dataFile = path.join(backupDir, 'data.sql');
+
+      try {
+        const diagnostics = await runDump(
+          'supabase',
+          ['db', 'dump', '--db-url', dbUrl, '--data-only', '-f', path.resolve(dataFile)],
+          { SUPABASE_ACCESS_TOKEN: accessToken || '' },
+          getT('backup.steps.database.separated.exportingData'),
+          true
+        );
+        const stats = await fs.stat(dataFile);
+        if (diagnostics.circularForeignKeys) {
+          const replicaRolePrologue = await hasReplicaRolePrologue(dataFile);
+          warnings.push({ code: 'CIRCULAR_FOREIGN_KEYS', ...diagnostics, replicaRolePrologue });
+          console.log(chalk.cyan(`     ℹ️ ${getT('backup.steps.database.separated.circularSummary', { tables: diagnostics.tables.join(', ') })}`));
+          console.log(chalk.yellow(`     ⚠️ ${getT(replicaRolePrologue
+            ? 'backup.steps.database.separated.circularProtected'
+            : 'backup.steps.database.separated.circularUnprotected')}`));
+        }
+        const sizeKB = (stats.size / 1024).toFixed(1);
+        files.push({ filename: 'data.sql', sizeKB });
+        totalSizeKB += parseFloat(sizeKB);
+        console.log(chalk.green(`     ✅ Data: ${sizeKB} KB`));
+      } catch (error) {
+        failedFiles.push('data.sql');
+        console.log(chalk.yellow(`     ⚠️ ${getT('backup.steps.database.separated.dataError', { message: error.message })}`));
+      }
+
+      // 3. Backup dos Roles
+      console.log(chalk.white(`   - ${getT('backup.steps.database.separated.exportingRoles')}`));
+      const rolesFile = path.join(backupDir, 'roles.sql');
+
+      try {
+        await runDump(
+          'supabase',
+          ['db', 'dump', '--db-url', dbUrl, '--role-only', '-f', path.resolve(rolesFile)],
+          { SUPABASE_ACCESS_TOKEN: accessToken || '' },
+          getT('backup.steps.database.separated.exportingRoles')
+        );
+        const stats = await fs.stat(rolesFile);
+        const sizeKB = (stats.size / 1024).toFixed(1);
+        files.push({ filename: 'roles.sql', sizeKB });
+        totalSizeKB += parseFloat(sizeKB);
+        console.log(chalk.green(`     ✅ Roles: ${sizeKB} KB`));
+      } catch (error) {
+        failedFiles.push('roles.sql');
+        console.log(chalk.yellow(`     ⚠️ ${getT('backup.steps.database.separated.rolesError', { message: error.message })}`));
+      }
+
+      return {
+        success: files.length === 3,
+        warnings,
+        failedFiles,
+        files,
+        totalSizeKB: totalSizeKB.toFixed(1)
+      };
+
+    } catch (error) {
+      const getT = global.smoonbI18n?.t || t;
+      console.log(chalk.yellow(`     ⚠️ ${getT('backup.steps.database.separated.error', { message: error.message })}`));
+      return { success: false, files: [], warnings: [], failedFiles: ['schema.sql', 'data.sql', 'roles.sql'], totalSizeKB: '0.0' };
+    }
+  };
+}
+
+module.exports = createDatabaseSeparatedStep();
+module.exports.createDatabaseSeparatedStep = createDatabaseSeparatedStep;
+module.exports.runWithElapsedTicker = runWithElapsedTicker;

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

@@ -1,7 +1,7 @@
 const chalk = require('chalk');
 const path = require('path');
 const fs = require('fs').promises;
-const { execSync } = require('child_process');
+const { runSql } = require('../../restore/pg');
 const { t } = require('../../../i18n');
 const { parseDatabaseUrl } = require('../utils');
 
@@ -21,8 +21,8 @@ module.exports = async ({ databaseUrl, projectId, backupDir, postgresMajor }) =>
     if (!parsed) {
       throw new Error(getT('error.databaseUrlInvalidSimple'));
     }
-    const { username, password, host, port, database } = parsed;
-    
+
+
     // Gerar nome do arquivo
     const now = new Date();
     const day = String(now.getDate()).padStart(2, '0');
@@ -31,12 +31,12 @@ module.exports = async ({ databaseUrl, projectId, backupDir, postgresMajor }) =>
     const hours = String(now.getHours()).padStart(2, '0');
     const minutes = String(now.getMinutes()).padStart(2, '0');
     const seconds = String(now.getSeconds()).padStart(2, '0');
-    
+
     const fileName = `database-settings-${day}-${month}-${year}@${hours}-${minutes}-${seconds}.json`;
-    
+
     // Usar caminho absoluto igual às outras funções
-    const backupDirAbs = path.resolve(backupDir);
-    
+
+
     // Script SQL para capturar todas as configurações
     const sqlScript = `
 -- Database Extensions and Settings Backup
@@ -62,10 +62,10 @@ SELECT json_agg(
     'description', short_desc
   )
 ) as postgres_settings
-FROM pg_settings 
+FROM pg_settings
 WHERE name IN (
   'statement_timeout',
-  'idle_in_transaction_session_timeout', 
+  'idle_in_transaction_session_timeout',
   'lock_timeout',
   'shared_buffers',
   'work_mem',
@@ -75,7 +75,7 @@ WHERE name IN (
   'log_statement',
   'log_min_duration_statement',
   'timezone',
-  'log_timezone', 
+  'log_timezone',
   'default_transaction_isolation',
   'default_transaction_read_only',
   'checkpoint_completion_target',
@@ -91,7 +91,7 @@ SELECT json_agg(
     'config', rolconfig
   )
 ) as role_configurations
-FROM pg_roles 
+FROM pg_roles
 WHERE rolname IN ('anon', 'authenticated', 'authenticator', 'postgres', 'service_role')
 AND rolconfig IS NOT NULL;
 
@@ -102,10 +102,10 @@ SELECT json_agg(
     'config', rolconfig
   )
 ) as pgaudit_configurations
-FROM pg_roles 
-WHERE rolconfig IS NOT NULL 
+FROM pg_roles
+WHERE rolconfig IS NOT NULL
 AND EXISTS (
-  SELECT 1 FROM unnest(rolconfig) AS config 
+  SELECT 1 FROM unnest(rolconfig) AS config
   WHERE config LIKE '%pgaudit%'
 );
 `;
@@ -113,29 +113,14 @@ AND EXISTS (
     // Salvar script SQL temporário
     const sqlFile = path.join(backupDir, 'temp_settings.sql');
     await fs.writeFile(sqlFile, sqlScript);
-    
+
     // Executar via Docker (mesma major do step Postgres version)
-    const postgresImage = `postgres:${postgresMajor}`;
-    const dockerCmd = [
-      'docker run --rm --network host',
-      `-v "${backupDirAbs}:/host"`,
-      `-e PGPASSWORD="${password}"`,
-      `${postgresImage} psql`,
-      `-h ${host}`,
-      `-p ${port}`,
-      `-U ${username}`,
-      `-d ${database}`,
-      '-f /host/temp_settings.sql',
-      '-t', // Tuples only
-      '-A'  // Unaligned output
-    ].join(' ');
-    
-    console.log(chalk.white(`   - ${getT('backup.steps.databaseSettings.executing')}`));
-    const output = execSync(dockerCmd, { stdio: 'pipe', encoding: 'utf8' });
-    
+
+    const output = await runSql(databaseUrl, sqlScript, { postgresMajor });
+
     // Processar output e criar JSON estruturado
     const lines = output.trim().split('\n').filter(line => line.trim());
-    
+
     const result = {
       database_settings: {
         note: "Configurações específicas do database Supabase capturadas via SQL",
@@ -161,19 +146,19 @@ AND EXISTS (
         }
       }
     };
-    
+
     // Salvar arquivo JSON
     const jsonFile = path.join(backupDir, fileName);
     await fs.writeFile(jsonFile, JSON.stringify(result, null, 2));
-    
+
     // Limpar arquivo temporário
     await fs.unlink(sqlFile);
-    
+
     const stats = await fs.stat(jsonFile);
     const sizeKB = (stats.size / 1024).toFixed(1);
-    
+
     console.log(chalk.green(`     ✅ Database Settings: ${fileName} (${sizeKB} KB)`));
-    
+
     return { success: true, size: sizeKB, fileName: fileName };
   } catch (error) {
     const getT = global.smoonbI18n?.t || t;
@@ -181,4 +166,3 @@ AND EXISTS (
     return { success: false };
   }
 };
-

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

@@ -88,7 +88,7 @@ module.exports = async ({ projectId, accessToken, backupDir, supabaseUrl, supaba
 
     if (!supabaseUrl || !supabaseServiceKey) {
       console.log(chalk.yellow(`   ⚠️  ${getT('backup.steps.storage.credentialsNotAvailable')}`));
-      return await backupMetadataOnly(buckets, storageDir, projectId, accessToken);
+      return { ...await backupMetadataOnly(buckets, storageDir, projectId, accessToken), success: false, reason: 'storage_files_not_exported' };
     }
 
     const supabase = createClient(supabaseUrl, supabaseServiceKey);
@@ -106,13 +106,13 @@ module.exports = async ({ projectId, accessToken, backupDir, supabaseUrl, supaba
       try {
         console.log(chalk.white(`   - ${getT('backup.steps.storage.processing', { bucketName: bucket.name })}`));
 
-        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 { 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,
@@ -211,6 +211,7 @@ module.exports = async ({ projectId, accessToken, backupDir, supabaseUrl, supaba
           objectCount: objects?.length || 0,
           filesDownloaded,
           filesSkipped,
+          listingFailed,
           totalFiles: allFiles.length
         });
 
@@ -251,9 +252,9 @@ module.exports = async ({ projectId, accessToken, backupDir, supabaseUrl, supaba
       console.log(chalk.white(`   ℹ️  ${getT('backup.steps.storage.tempKept', { path: path.relative(process.cwd(), tempStorageDir) })}`));
     }
 
-    console.log(chalk.green(`✅ ${getT('backup.steps.storage.done', { buckets: processedBuckets.length, files: totalFilesDownloaded })}`));
+    console.log(require('../outcome').storageComplete(processedBuckets, buckets.length) ? 'Storage: exportação concluída.' : 'Storage: exportação incompleta; arquivos disponíveis preservados.');
     return {
-      success: true,
+      success: require('../outcome').storageComplete(processedBuckets, buckets.length),
       buckets: processedBuckets,
       zipFile: zipFileName,
       zipSizeMB,

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

@@ -1,60 +1,10 @@
-const chalk = require('chalk');
 const path = require('path');
 const fs = require('fs').promises;
-const { spawn } = require('child_process');
-const { t } = require('../../../i18n');
-
-function runWithElapsedTicker(command, env, label) {
-  return new Promise((resolve, reject) => {
-    const start = Date.now();
-    const ticker = setInterval(() => {
-      const elapsed = Math.floor((Date.now() - start) / 1000);
-      process.stdout.write(`\r     ⏱ ${label} ${elapsed}s`);
-    }, 1000);
-    const proc = spawn(command, [], {
-      stdio: ['ignore', 'pipe', 'pipe'],
-      shell: true,
-      env: { ...process.env, ...env }
-    });
-    proc.stderr.on('data', (chunk) => process.stderr.write(chunk));
-    proc.on('close', (code) => {
-      clearInterval(ticker);
-      process.stdout.write('\r' + ' '.repeat(60) + '\r');
-      if (code !== 0) reject(new Error(`Exited with code ${code}`));
-      else resolve();
-    });
-    proc.on('error', reject);
-  });
-}
-
-/**
- * Etapa 7: Backup Custom Roles via SQL
- */
+const { isolatedSupabase } = require('../../../utils/supabaseCli');
 module.exports = async ({ databaseUrl, backupDir, accessToken }) => {
   try {
-    const getT = global.smoonbI18n?.t || t;
-    console.log(chalk.white(`   - ${getT('backup.steps.roles.exporting')}`));
-    
-    const customRolesFile = path.join(backupDir, 'custom-roles.sql');
-    const cmd = `supabase db dump --db-url "${databaseUrl}" --role-only -f "${customRolesFile}"`;
-    
-    try {
-      await runWithElapsedTicker(cmd, { SUPABASE_ACCESS_TOKEN: accessToken || '' }, getT('backup.steps.roles.exporting'));
-      
-      const stats = await fs.stat(customRolesFile);
-      const sizeKB = (stats.size / 1024).toFixed(1);
-      
-      console.log(chalk.green(`     ✅ Custom Roles exportados via Docker: ${sizeKB} KB`));
-      
-      return { success: true, roles: [{ filename: 'custom-roles.sql', sizeKB }] };
-    } catch (error) {
-      console.log(chalk.yellow(`     ⚠️ ${getT('backup.steps.roles.exportError', { message: error.message })}`));
-      return { success: false, roles: [] };
-    }
-  } catch (error) {
-    const getT = global.smoonbI18n?.t || t;
-    console.log(chalk.yellow(`     ⚠️ ${getT('backup.steps.roles.error', { message: error.message })}`));
-    return { success: false, roles: [] };
-  }
+    const file = path.resolve(backupDir, 'custom-roles.sql');
+    await isolatedSupabase(['db', 'dump', '--db-url', databaseUrl, '--role-only', '-f', file], { SUPABASE_ACCESS_TOKEN: accessToken || '' });
+    return { success: true, roles: [{ filename: 'custom-roles.sql', sizeKB: ((await fs.stat(file)).size / 1024).toFixed(1) }] };
+  } catch { return { success: false, roles: [], reason: 'roles_export_failed' }; }
 };
-

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

@@ -1,7 +1,6 @@
 const chalk = require('chalk');
 const path = require('path');
 const { copyDirSafe } = require('../../../utils/fsExtra');
-const { cleanDir } = require('../../../utils/fsExtra');
 const { t } = require('../../../i18n');
 
 /**
@@ -24,14 +23,6 @@ module.exports = async (context) => {
       console.log(chalk.green(`   ✅ ${getT('backup.steps.temp.copied', { count: fileCount })}`));
     }
     
-    // Usar flag de limpeza do contexto (já foi perguntado no início)
-    const shouldClean = context?.cleanupFlags?.cleanTemp || false;
-    
-    if (shouldClean) {
-      await cleanDir(tempDir);
-      console.log(chalk.white(`   - ${getT('backup.steps.temp.cleaned')}`));
-    }
-    
     return {
       success: true,
       file_count: fileCount