@neetru/cli 2.7.4 → 2.8.0

package/dist/commands/db.js

@@ -1,187 +1,758 @@
 /**
- * `neetru db` — gerência de schema/migrations/seed do produto.
+ * `neetru db` — árvore de comandos de banco de dados por produto (M1).
  *
- * Sprint 10 (CLI 1.4). Subcomandos:
- *   - `neetru db init`        Lê neetru.config.json + cria manifest local stub.
- *   - `neetru db migrate <v>` Chama API Core (`/cli/v1/db/migrate`) que internamente
- *                             dispara `runMigrations` (Sprint 8 build-hook).
- *   - `neetru db seed`        Roda `db/seed.ts` no projeto (NEETRU_ENV=dev).
+ * Esta árvore é DEVELOPER-FACING: schema, migrations e banco isolado do produto.
+ * Para o plano de controle STAFF (fleet-wide), use `neetru admin database`.
  *
- * O CLI não toca Firestore direto — toda operação passa pelo Core (audit + RBAC).
- * Para `seed` o CLI apenas executa o script local.
+ * Subcomandos:
+ *   neetru db list                      — lista bancos do produto (GET /api/cli/v1/db)
+ *   neetru db status <dbId>             — READ-ONLY: detalha banco + status (D-2)
+ *   neetru db init                      — registra banco local + scaffolda db/schema.ts
+ *   neetru db apply [--dry-run]         — pipeline de migração + envia ao Core
+ *   neetru db migrations list [--db <id>]
+ *   neetru db migrations confirm <id>   — confirma migração destrutiva (exige --mfa)
+ *
+ * Todos os comandos que chamam o Core usam `apiRequest` do `api-client` —
+ * autenticação via Bearer token resolvido automaticamente do config local.
+ *
+ * Plain PT-BR em todas as strings visíveis ao usuário.
  */
 import * as fs from 'node:fs/promises';
 import * as fsSync from 'node:fs';
 import * as path from 'node:path';
-import { spawn } from 'node:child_process';
+import inquirer from 'inquirer';
 import chalk from 'chalk';
+import ora from 'ora';
 import { log } from '../utils/logger.js';
 import { apiRequest, CliApiError, CliNetworkError } from '../lib/api-client.js';
-const CONFIG_FILENAMES = ['neetru.config.json', '.neetru.json'];
+import { renderTable, fmtTimestamp } from '../lib/render.js';
+import { readDbJson, writeDbJson, normalizeEnv, } from '../lib/db-local/index.js';
+import { runApplyPipeline, buildPipelineDeps, isPipelineError, } from '../lib/db-pipeline/index.js';
+// ---------------------------------------------------------------------------
+// Constantes e tipos locais
+// ---------------------------------------------------------------------------
+const CONFIG_FILES = ['neetru.config.json', '.neetru.json'];
+/** Caminho canônico do registro local de bancos. */
+const DB_JSON_REL = '.neetru/db.json';
+/** Caminho default do arquivo de schema DrizzleORM do produto. */
+const DEFAULT_SCHEMA_PATH = 'db/schema.ts';
+/** Engines disponíveis (espelha os 7 engines do Core). */
+const ENGINES = [
+    'firestore-instance',
+    'cloud-sql-postgres',
+    'cloud-sql-mysql',
+    'vm-postgres-single',
+    'vm-postgres-cluster',
+    'vm-mysql-single',
+    'vm-mysql-cluster',
+];
+/** Labels amigáveis por engine pra exibição no prompt. */
+const ENGINE_LABELS = {
+    'firestore-instance': 'Firestore (instância isolada)',
+    'cloud-sql-postgres': 'Cloud SQL — PostgreSQL gerenciado',
+    'cloud-sql-mysql': 'Cloud SQL — MySQL gerenciado',
+    'vm-postgres-single': 'VM — PostgreSQL (nó único)',
+    'vm-postgres-cluster': 'VM — PostgreSQL (cluster HA)',
+    'vm-mysql-single': 'VM — MySQL (nó único)',
+    'vm-mysql-cluster': 'VM — MySQL (cluster HA)',
+};
+// ---------------------------------------------------------------------------
+// Helpers internos
+// ---------------------------------------------------------------------------
 async function loadProductConfig() {
-    for (const name of CONFIG_FILENAMES) {
+    for (const name of CONFIG_FILES) {
         const filePath = path.resolve(process.cwd(), name);
-        if (fsSync.existsSync(filePath)) {
-            try {
-                const raw = await fs.readFile(filePath, 'utf8');
-                const parsed = JSON.parse(raw);
-                if (typeof parsed.slug !== 'string' || !parsed.slug)
-                    return null;
-                return parsed;
-            }
-            catch {
+        if (!fsSync.existsSync(filePath))
+            continue;
+        try {
+            const raw = await fs.readFile(filePath, 'utf8');
+            const parsed = JSON.parse(raw);
+            if (typeof parsed.slug !== 'string' || !parsed.slug)
                 return null;
-            }
+            return parsed;
+        }
+        catch {
+            return null;
         }
     }
     return null;
 }
-const DEFAULT_MANIFEST_PATH = 'db/schema.manifest.json';
-const STARTER_MANIFEST = (slug) => ({
-    productId: slug,
-    schemaVersion: 1,
-    collections: [
-        {
-            name: 'profiles',
-            fields: { email: 'string', createdAt: 'timestamp' },
-            indexes: [],
-        },
-    ],
-});
-export async function runDbInit(opts = {}) {
+function handleApiError(err) {
+    if (err instanceof CliApiError) {
+        if (err.status === 401) {
+            log.error('Token inválido ou expirado. Execute: neetru login');
+            process.exit(2);
+        }
+        if (err.status === 403) {
+            log.error(`Permissão negada: ${err.message}`);
+            process.exit(3);
+        }
+        log.error(`Erro do servidor (${err.status}): ${err.message}`);
+        process.exit(4);
+    }
+    if (err instanceof CliNetworkError) {
+        log.error(`Falha de rede: ${err.message}`);
+        process.exit(4);
+    }
+    log.error(err.message ?? String(err));
+    process.exit(4);
+}
+function statusColor(status) {
+    switch (status) {
+        case 'ativo':
+        case 'active': return chalk.green(status);
+        case 'falha':
+        case 'failed': return chalk.red(status);
+        case 'provisionando':
+        case 'provisioning': return chalk.yellow(status);
+        case 'arquivado':
+        case 'archived': return chalk.dim(status);
+        default: return chalk.dim(status);
+    }
+}
+function severityColor(severity) {
+    if (!severity)
+        return '—';
+    if (severity === 'destrutiva')
+        return chalk.red(severity);
+    return chalk.green(severity);
+}
+export async function runDbList(opts = {}) {
     log.banner();
-    log.heading('neetru db init');
-    const cfg = await loadProductConfig();
-    if (!cfg) {
-        log.error('neetru.config.json não encontrado ou inválido. Rode `neetru init` primeiro.');
+    const spinner = ora({ text: 'Buscando bancos…', color: 'blue' }).start();
+    const params = new URLSearchParams();
+    if (opts.productId)
+        params.set('productId', opts.productId);
+    if (opts.engine)
+        params.set('engine', opts.engine);
+    if (opts.status)
+        params.set('status', opts.status);
+    const qs = params.toString() ? `?${params.toString()}` : '';
+    let resp;
+    try {
+        resp = await apiRequest(`/api/cli/v1/db${qs}`);
+        spinner.stop();
+    }
+    catch (err) {
+        spinner.fail('Falha ao buscar bancos.');
+        handleApiError(err);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify(resp, null, 2));
+        return;
+    }
+    log.heading(`Bancos (${resp.count})`);
+    renderTable([
+        { header: 'ID', value: (r) => r.id, maxWidth: 28 },
+        { header: 'Produto', value: (r) => r.productId, maxWidth: 20 },
+        { header: 'Label', value: (r) => r.label ?? '—', maxWidth: 24 },
+        { header: 'Engine', value: (r) => r.engine, maxWidth: 22 },
+        { header: 'Env', value: (r) => r.env, maxWidth: 12 },
+        { header: 'Status', value: (r) => statusColor(r.status), maxWidth: 16 },
+        { header: 'Criado', value: (r) => fmtTimestamp(r.createdAt), maxWidth: 18 },
+    ], resp.databases);
+}
+export async function runDbStatus(dbId, opts = {}) {
+    log.banner();
+    if (!dbId) {
+        log.error('<dbId> é obrigatório.');
         process.exit(1);
         return;
     }
-    const outRel = opts.out ?? DEFAULT_MANIFEST_PATH;
-    const outAbs = path.resolve(process.cwd(), outRel);
-    if (fsSync.existsSync(outAbs) && !opts.force) {
-        log.warn(`Manifest já existe em ${chalk.bold(outRel)}. Use --force para sobrescrever.`);
-        process.exit(2);
+    const spinner = ora({ text: `Buscando banco ${dbId}…`, color: 'blue' }).start();
+    let resp;
+    try {
+        // BL-9 fix: `/status` é POST-only (atualização de status). O endpoint de
+        // leitura de detalhe é `/get` (GET).
+        resp = await apiRequest(`/api/cli/v1/db/${encodeURIComponent(dbId)}/get`);
+        spinner.stop();
+    }
+    catch (err) {
+        spinner.fail('Falha ao buscar status do banco.');
+        handleApiError(err);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify(resp, null, 2));
         return;
     }
-    await fs.mkdir(path.dirname(outAbs), { recursive: true });
-    const manifest = STARTER_MANIFEST(cfg.slug);
-    await fs.writeFile(outAbs, JSON.stringify(manifest, null, 2) + '\n', 'utf8');
-    log.success(`Manifest criado em ${chalk.bold(outRel)}`);
-    log.dim('  Edite os campos e adicione collections conforme necessário.');
-    log.dim('  Após editar, rode: neetru db migrate <toVersion>');
+    const db = resp.database;
+    log.heading(`Banco: ${chalk.bold(db.label ?? db.id)}`);
+    log.dim(`  ID:       ${db.id}`);
+    log.dim(`  Produto:  ${db.productId}`);
+    log.dim(`  Engine:   ${db.engine}`);
+    log.dim(`  Env:      ${db.env}`);
+    log.dim(`  Status:   ${statusColor(db.status)}`);
+    if (db.region)
+        log.dim(`  Região:   ${db.region}`);
+    if (db.serverId)
+        log.dim(`  VM:       ${db.serverId}`);
+    if (db.healthy !== null && db.healthy !== undefined) {
+        log.dim(`  Saúde:    ${db.healthy ? chalk.green('ok') : chalk.red('falha')}`);
+    }
+    if (db.healthLastCheckedAt) {
+        log.dim(`  Verificado: ${fmtTimestamp(db.healthLastCheckedAt)}`);
+    }
+    if (db.provisioningError) {
+        log.warn(`  Erro de provisionamento: ${db.provisioningError}`);
+    }
+    log.dim(`  Criado:   ${fmtTimestamp(db.createdAt)}`);
+    log.dim(`  Atualizado: ${fmtTimestamp(db.updatedAt)}`);
 }
-export async function runDbMigrate(opts) {
+/** Conteúdo do `db/schema.ts` gerado durante o init. */
+const SCHEMA_STARTER = (productId, engine) => `/**
+ * Schema do banco "${productId}" — ${ENGINE_LABELS[engine] ?? engine}.
+ *
+ * Gerado por \`neetru db init\`.
+ * Edite este arquivo e rode \`neetru db apply\` pra enviar a migração ao Core.
+ */
+
+// Exemplo com DrizzleORM (PostgreSQL):
+// import { pgTable, serial, text, timestamp } from 'drizzle-orm/pg-core';
+//
+// export const usuarios = pgTable('usuarios', {
+//   id: serial('id').primaryKey(),
+//   email: text('email').notNull().unique(),
+//   criadoEm: timestamp('criado_em').defaultNow(),
+// });
+
+// Remova o comentário acima e adapte ao seu schema.
+export {};
+`;
+export async function runDbInit(opts = {}) {
     log.banner();
-    log.heading('neetru db migrate');
+    log.heading('neetru db init');
+    // ── D-3: opções legadas removidas (Sprint 10 — schema.manifest.json) ────
+    // `--out` e `--force` eram usados para gerar schema.manifest.json.
+    // O branch legado foi cortado. Passar essas flags agora é um erro.
+    if (opts.out !== undefined || opts.force !== undefined) {
+        log.error('As opções --out e --force foram removidas (D-3).\n' +
+            'O `neetru db init` agora faz UMA coisa: registra o banco no Core + ' +
+            'grava .neetru/db.json + scaffolda db/schema.ts.\n' +
+            'Para inicializar o banco, use:\n' +
+            '  neetru db init --name <nome> --engine <engine> --env dev-local');
+        process.exit(1);
+        return;
+    }
     const cfg = await loadProductConfig();
     if (!cfg) {
-        log.error('neetru.config.json não encontrado.');
+        log.error('neetru.config.json não encontrado. Rode `neetru init` primeiro.');
         process.exit(1);
         return;
     }
-    const toVersion = Number(opts.toVersion);
-    if (!Number.isFinite(toVersion) || toVersion < 1) {
-        log.error('toVersion inválido. Use um inteiro positivo.');
-        process.exit(2);
-        return;
+    const productId = opts.productId ?? cfg.slug;
+    const cwd = process.cwd();
+    const dbJsonPath = path.resolve(cwd, DB_JSON_REL);
+    const dbJson = readDbJson(dbJsonPath);
+    // ── nome do banco ────────────────────────────────────────────────────────
+    let dbName = opts.name;
+    if (!dbName && !opts.yes) {
+        const existing = dbJson.databases.map((d) => d.name);
+        const { n } = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'n',
+                message: 'Nome do banco (ex: principal, analytics):',
+                default: existing.length === 0 ? 'principal' : `db${existing.length + 1}`,
+                validate: (v) => {
+                    if (!v.trim())
+                        return 'Nome obrigatório.';
+                    if (dbJson.databases.some((d) => d.name === v.trim())) {
+                        return `Banco "${v.trim()}" já registrado em .neetru/db.json.`;
+                    }
+                    return true;
+                },
+            },
+        ]);
+        dbName = n.trim();
+    }
+    else if (!dbName) {
+        dbName = dbJson.databases.length === 0 ? 'principal' : `db${dbJson.databases.length + 1}`;
     }
-    const fromVersion = opts.fromVersion !== undefined
-        ? Number(opts.fromVersion)
-        : (cfg.schemaVersion ?? 1);
-    if (!Number.isFinite(fromVersion) || fromVersion < 0) {
-        log.error('fromVersion inválido.');
+    if (dbJson.databases.some((d) => d.name === dbName)) {
+        log.error(`Banco "${dbName}" já registrado. Use outro nome ou edite .neetru/db.json.`);
         process.exit(2);
         return;
     }
-    if (toVersion <= fromVersion) {
-        log.error(`toVersion (${toVersion}) deve ser maior que fromVersion (${fromVersion}).`);
-        process.exit(2);
+    // ── engine ───────────────────────────────────────────────────────────────
+    let engine;
+    if (opts.engine && ENGINES.includes(opts.engine)) {
+        engine = opts.engine;
+    }
+    else if (opts.yes) {
+        engine = 'cloud-sql-postgres';
+    }
+    else {
+        const { e } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'e',
+                message: 'Engine do banco:',
+                default: 'cloud-sql-postgres',
+                choices: ENGINES.map((eng) => ({
+                    name: `${ENGINE_LABELS[eng]} ${chalk.dim('(' + eng + ')')}`,
+                    value: eng,
+                })),
+            },
+        ]);
+        engine = e;
+    }
+    // ── ambiente (D-4: dev-local é o valor canônico) ─────────────────────────
+    let env;
+    try {
+        env = opts.env ? normalizeEnv(opts.env) : 'dev-local';
+    }
+    catch {
+        log.error(`Ambiente inválido: "${opts.env}". Use dev-local, staging ou production.`);
+        process.exit(1);
         return;
     }
-    log.info(`Migrating ${chalk.bold(cfg.slug)} v${fromVersion} → v${toVersion} ...`);
+    // ── grava .neetru/db.json (stub inicial — ids preenchidos depois do register)
+    const stubEntry = { name: dbName, productId, engine, ids: {} };
+    const withStub = {
+        ...dbJson,
+        databases: [...dbJson.databases, stubEntry],
+    };
+    writeDbJson(dbJsonPath, withStub);
+    log.success(`Banco "${dbName}" registrado localmente em ${chalk.bold(DB_JSON_REL)}`);
+    // ── BL-6 fix: registra o banco no Core e persiste os IDs por ambiente ────
+    const registerSpinner = ora({ text: 'Registrando banco no Core…', color: 'blue' }).start();
+    let registerResp;
     try {
-        const r = await apiRequest('/cli/v1/db/migrate', {
+        registerResp = await apiRequest('/api/cli/v1/db/register', {
             method: 'POST',
-            body: { productId: cfg.slug, fromVersion, toVersion },
+            body: {
+                productId,
+                label: dbName,
+                engine,
+                provisioning: { type: engine.startsWith('vm-') ? 'vm' : 'managed' },
+            },
         });
-        log.success(`Migration aplicada: ${r.migrationsApplied} step(s).`);
-        log.dim(`  v${r.fromVersion} → v${r.toVersion}`);
+        registerSpinner.succeed('Banco registrado no Core.');
     }
     catch (err) {
-        if (err instanceof CliApiError) {
-            log.error(`API ${err.status}: ${err.message}`);
-            process.exit(3);
-            return;
-        }
-        if (err instanceof CliNetworkError) {
-            log.error(`Conexão falhou: ${err.message}`);
-            process.exit(4);
-            return;
-        }
-        log.error(err instanceof Error ? err.message : String(err));
-        process.exit(5);
+        registerSpinner.fail('Falha ao registrar banco no Core.');
+        handleApiError(err);
+    }
+    // Persiste os IDs retornados pelo Core em `.neetru/db.json`.
+    const ids = {
+        'dev-local': registerResp.ids.devLocal,
+        staging: registerResp.ids.staging,
+        production: registerResp.ids.production,
+    };
+    const finalEntry = { name: dbName, productId, engine, ids };
+    const withIds = {
+        version: 2,
+        databases: [...withStub.databases.slice(0, -1), finalEntry],
+    };
+    writeDbJson(dbJsonPath, withIds);
+    log.success(`IDs de ambiente gravados em ${chalk.bold(DB_JSON_REL)}`);
+    // ── scaffolda db/schema.ts se não existir ─────────────────────────────────
+    const schemaPath = path.resolve(cwd, DEFAULT_SCHEMA_PATH);
+    if (!fsSync.existsSync(schemaPath)) {
+        await fs.mkdir(path.dirname(schemaPath), { recursive: true });
+        await fs.writeFile(schemaPath, SCHEMA_STARTER(productId, engine), 'utf8');
+        log.success(`Schema gerado em ${chalk.bold(DEFAULT_SCHEMA_PATH)}`);
+    }
+    else {
+        log.dim(`  Schema existente em ${DEFAULT_SCHEMA_PATH} — não sobrescrito.`);
     }
+    log.dim('');
+    log.dim('Próximos passos:');
+    log.dim(`  1. Edite ${DEFAULT_SCHEMA_PATH} com as tabelas do seu produto.`);
+    log.dim(`  2. Execute \`neetru db apply\` pra enviar a migração ao Core.`);
+    log.dim(`  3. O Core irá provisionar o banco ${chalk.bold(engine)} em ${chalk.bold(env)}.`);
 }
-const DEFAULT_SEED_PATHS = ['db/seed.ts', 'db/seed.js', 'scripts/seed.ts', 'scripts/seed.js'];
-export async function runDbSeed(opts = {}) {
+export async function runDbApply(opts = {}) {
     log.banner();
-    log.heading('neetru db seed');
+    log.heading('neetru db apply');
     const cfg = await loadProductConfig();
     if (!cfg) {
-        log.error('neetru.config.json não encontrado.');
+        log.error('neetru.config.json não encontrado. Rode `neetru init` primeiro.');
         process.exit(1);
         return;
     }
-    // Resolve path do seed script.
-    let scriptPath = null;
-    if (opts.script) {
-        const abs = path.resolve(process.cwd(), opts.script);
-        if (!fsSync.existsSync(abs)) {
-            log.error(`Script não encontrado: ${opts.script}`);
-            process.exit(2);
+    const cwd = process.cwd();
+    const dbJsonPath = path.resolve(cwd, DB_JSON_REL);
+    const dbJson = readDbJson(dbJsonPath);
+    if (dbJson.databases.length === 0) {
+        log.error('Nenhum banco registrado em .neetru/db.json. Rode `neetru db init` primeiro.');
+        process.exit(1);
+        return;
+    }
+    // Resolve o banco alvo.
+    let dbEntry = dbJson.databases[0];
+    if (opts.dbName) {
+        const found = dbJson.databases.find((d) => d.name === opts.dbName);
+        if (!found) {
+            log.error(`Banco "${opts.dbName}" não encontrado em .neetru/db.json.`);
+            log.dim(`  Bancos disponíveis: ${dbJson.databases.map((d) => d.name).join(', ')}`);
+            process.exit(1);
             return;
         }
-        scriptPath = abs;
+        dbEntry = found;
     }
-    else {
-        for (const candidate of DEFAULT_SEED_PATHS) {
-            const abs = path.resolve(process.cwd(), candidate);
-            if (fsSync.existsSync(abs)) {
-                scriptPath = abs;
-                break;
-            }
+    else if (dbJson.databases.length > 1 && !opts.yes) {
+        const { chosen } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'chosen',
+                message: 'Qual banco aplicar a migração?',
+                choices: dbJson.databases.map((d) => ({
+                    name: `${d.name} ${chalk.dim('(' + d.engine + ')')}`,
+                    value: d.name,
+                })),
+            },
+        ]);
+        const found = dbJson.databases.find((d) => d.name === chosen);
+        if (!found) {
+            log.error('Banco não encontrado.');
+            process.exit(1);
+            return;
         }
+        dbEntry = found;
     }
-    if (!scriptPath) {
-        log.error('Nenhum seed script encontrado. Tente: db/seed.ts ou passe --script <path>.');
-        process.exit(2);
+    // Resolve ambiente (D-4: default canônico é dev-local, nunca dev).
+    let env;
+    try {
+        env = normalizeEnv(opts.env ?? 'dev-local');
+    }
+    catch {
+        log.error(`Ambiente inválido: "${opts.env}". Use dev-local, staging ou production.`);
+        process.exit(1);
         return;
     }
-    log.info(`Executando ${chalk.bold(path.relative(process.cwd(), scriptPath))} (NEETRU_ENV=dev)`);
-    const isTs = scriptPath.endsWith('.ts');
-    const cmd = isTs ? 'npx' : 'node';
-    const args = isTs ? ['tsx', scriptPath] : [scriptPath];
-    await new Promise((resolve) => {
-        const child = spawn(cmd, args, {
-            stdio: 'inherit',
-            env: { ...process.env, NEETRU_ENV: 'dev' },
-            shell: process.platform === 'win32',
+    // Resolve schema path.
+    const schemaFile = opts.schemaPath ?? DEFAULT_SCHEMA_PATH;
+    const schemaAbs = path.resolve(cwd, schemaFile);
+    if (!fsSync.existsSync(schemaAbs)) {
+        log.error(`Schema não encontrado em ${schemaFile}. Rode \`neetru db init\` pra criar.`);
+        process.exit(1);
+        return;
+    }
+    // BL-5 fix: resolve o dbId do env alvo. O ID deve estar em `.neetru/db.json`
+    // (preenchido pelo `runDbInit` via `POST /api/cli/v1/db/register`).
+    const canonicalEnv = env;
+    const dbId = dbEntry.ids[canonicalEnv];
+    if (!dbId) {
+        log.error(`Banco "${dbEntry.name}" não tem ID registrado para o ambiente "${env}". ` +
+            `Execute \`neetru db init\` novamente ou verifique .neetru/db.json.`);
+        process.exit(1);
+        return;
+    }
+    log.dim(`  Banco:   ${dbEntry.name} (${dbEntry.engine})`);
+    log.dim(`  Schema:  ${schemaFile}`);
+    log.dim(`  Env:     ${env}`);
+    log.dim(`  DB ID:   ${dbId}`);
+    if (opts.dryRun)
+        log.warn('  Modo --dry-run: nenhuma alteração será enviada ao Core.');
+    // Executa o pipeline.
+    const phaseLabels = {
+        fingerprint: 'Calculando fingerprint…',
+        generate: 'Gerando SQL (drizzle-kit)…',
+        rehearse: 'Ensaiando em Postgres efêmero…',
+        classify: 'Classificando migração…',
+        push: 'Enviando ao Core…',
+    };
+    let spinner = ora({ text: 'Iniciando pipeline…', color: 'blue' }).start();
+    let result;
+    try {
+        const deps = buildPipelineDeps({
+            onPhase: (phase) => {
+                spinner.text = phaseLabels[phase] ?? phase;
+            },
+            ...(opts.dryRun
+                ? {
+                    pushToCore: async () => {
+                        return { migrationId: '(dry-run)', status: 'dry_run' };
+                    },
+                }
+                : {}),
         });
-        child.on('exit', (code) => {
-            if (code === 0) {
-                log.success('Seed completo.');
-                resolve();
-            }
-            else {
-                log.error(`Seed falhou (exit ${code ?? '?'}).`);
-                process.exit(6);
-            }
+        // BL-5 fix: passa `dbId` resolvido para o pipeline.
+        result = await runApplyPipeline({
+            schemaPath: schemaAbs,
+            env: canonicalEnv,
+            dbId,
+        }, deps);
+        spinner.stop();
+    }
+    catch (err) {
+        spinner.fail('Pipeline falhou.');
+        if (isPipelineError(err)) {
+            const pe = err;
+            log.error(`Fase "${pe.phase}": ${pe.message}`);
+            process.exit(5);
+            return;
+        }
+        log.error(err.message ?? String(err));
+        process.exit(5);
+        return;
+    }
+    if (result.status === 'no_changes') {
+        log.success('Schema sem alterações — nenhuma migração necessária.');
+        return;
+    }
+    // H-7 fix: persiste o fingerprint após push bem-sucedido (não dry-run) para
+    // que o gate de deploy (`checkSchemaGate` em deploy.ts) consiga detectar drift.
+    if (!opts.dryRun && result.fingerprint) {
+        const dbJsonAfter = readDbJson(dbJsonPath);
+        const updatedDatabases = dbJsonAfter.databases.map((d) => d.name === dbEntry.name
+            ? { ...d, lastAppliedFingerprint: result.fingerprint }
+            : d);
+        writeDbJson(dbJsonPath, { ...dbJsonAfter, databases: updatedDatabases });
+        log.dim(`  Fingerprint gravado em ${chalk.bold(DB_JSON_REL)}`);
+    }
+    log.dim('');
+    log.dim(`  Severidade:   ${severityColor(result.severity)}`);
+    log.dim(`  Migração ID:  ${result.migrationId}`);
+    log.dim(`  Status:       ${result.status}`);
+    if (result.severity === 'destrutiva' && !opts.dryRun) {
+        log.warn('Esta migração é destrutiva e requer confirmação antes de ser aplicada.');
+        log.dim(`  Execute: neetru db migrations confirm ${result.migrationId} --mfa <token>`);
+    }
+    else if (!opts.dryRun) {
+        log.success(`Migração ${chalk.bold(result.migrationId)} enviada ao Core (${result.status}).`);
+    }
+}
+export async function runDbMigrationsList(opts = {}) {
+    log.banner();
+    const qs = opts.dbId ? `?dbId=${encodeURIComponent(opts.dbId)}` : '';
+    const spinner = ora({ text: 'Buscando migrações…', color: 'blue' }).start();
+    let resp;
+    try {
+        resp = await apiRequest(`/api/cli/v1/db/migrations${qs}`);
+        spinner.stop();
+    }
+    catch (err) {
+        spinner.fail('Falha ao buscar migrações.');
+        handleApiError(err);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify(resp, null, 2));
+        return;
+    }
+    log.heading(`Migrações (${resp.count})`);
+    renderTable([
+        { header: 'ID', value: (r) => r.id, maxWidth: 28 },
+        { header: 'Banco', value: (r) => r.dbId ?? '—', maxWidth: 20 },
+        { header: 'Status', value: (r) => r.status, maxWidth: 20 },
+        { header: 'Severidade', value: (r) => severityColor(r.severity), maxWidth: 14 },
+        { header: 'Aplicado', value: (r) => fmtTimestamp(r.appliedAt ?? r.createdAt), maxWidth: 18 },
+    ], resp.migrations);
+}
+export async function runDbMigrationsConfirm(migrationId, opts) {
+    log.banner();
+    if (!migrationId) {
+        log.error('<migrationId> é obrigatório.');
+        process.exit(1);
+        return;
+    }
+    if (!opts.mfa) {
+        log.error('--mfa <token> é obrigatório para confirmar migrações destrutivas.');
+        process.exit(1);
+        return;
+    }
+    const spinner = ora({ text: `Confirmando migração ${migrationId}…`, color: 'yellow' }).start();
+    let resp;
+    try {
+        resp = await apiRequest(`/api/cli/v1/db/migrations/${encodeURIComponent(migrationId)}/confirm`, {
+            method: 'POST',
+            headers: { 'X-Neetru-MFA-Token': opts.mfa },
+            body: { migrationId },
         });
-        child.on('error', (err) => {
-            log.error(`Falha ao executar: ${err.message}`);
-            process.exit(7);
+        spinner.succeed(`Migração ${chalk.bold(resp.migrationId)} confirmada — status: ${resp.status}`);
+    }
+    catch (err) {
+        spinner.fail('Falha ao confirmar migração.');
+        handleApiError(err);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify(resp, null, 2));
+    }
+}
+/**
+ * Lista os backups disponíveis de um banco específico.
+ *
+ * Endpoint: GET /api/cli/v1/db/[id]/backups
+ * Rota implementada em `src/app/api/cli/v1/db/[id]/backups/route.ts`.
+ */
+export async function runDbBackups(dbId, opts = {}) {
+    log.banner();
+    if (!dbId) {
+        log.error('<dbId> é obrigatório.');
+        process.exit(1);
+        return;
+    }
+    const spinner = ora({ text: `Buscando backups do banco ${dbId}…`, color: 'blue' }).start();
+    let resp;
+    try {
+        resp = await apiRequest(`/api/cli/v1/db/${encodeURIComponent(dbId)}/backups`);
+        spinner.stop();
+    }
+    catch (err) {
+        spinner.fail('Falha ao buscar backups.');
+        handleApiError(err);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify(resp, null, 2));
+        return;
+    }
+    log.heading(`Backups do banco ${chalk.bold(dbId)} (${resp.count})`);
+    renderTable([
+        { header: 'ID', value: (r) => r.id, maxWidth: 28 },
+        { header: 'Status', value: (r) => statusColor(r.status), maxWidth: 16 },
+        { header: 'Data/Hora', value: (r) => fmtTimestamp(r.timestamp), maxWidth: 22 },
+        { header: 'Tamanho (MB)', value: (r) => r.sizeMb != null ? String(r.sizeMb) : '—', maxWidth: 14 },
+        { header: 'GCS Path', value: (r) => r.gcsPath ?? '—', maxWidth: 60 },
+    ], resp.backups);
+}
+/**
+ * Dispara um restore de banco a partir de um backup selecionado interativamente.
+ *
+ * Fluxo:
+ *   1. Lista backups disponíveis via GET /api/cli/v1/db/[id]/backups
+ *   2. Operador escolhe qual backup restaurar
+ *   3. Exige confirmação textual "RESTAURAR" (operação destrutiva)
+ *   4. POST /api/cli/v1/db/[id]/restore com MFA step-up
+ *
+ * Endpoints implementados em:
+ *   GET  src/app/api/cli/v1/db/[id]/backups/route.ts
+ *   POST src/app/api/cli/v1/db/[id]/restore/route.ts
+ */
+export async function runDbRestore(dbId, opts) {
+    log.banner();
+    if (!dbId) {
+        log.error('<dbId> é obrigatório.');
+        process.exit(1);
+        return;
+    }
+    if (!opts.mfa) {
+        log.error('--mfa <token> é obrigatório para restaurar banco (operação destrutiva).');
+        process.exit(1);
+        return;
+    }
+    // 1. Lista backups disponíveis
+    const spinnerList = ora({ text: `Buscando backups do banco ${dbId}…`, color: 'blue' }).start();
+    let backupsResp;
+    try {
+        backupsResp = await apiRequest(`/api/cli/v1/db/${encodeURIComponent(dbId)}/backups`);
+        spinnerList.stop();
+    }
+    catch (err) {
+        spinnerList.fail('Falha ao buscar backups.');
+        handleApiError(err);
+    }
+    if (backupsResp.count === 0 || backupsResp.backups.length === 0) {
+        log.warn('Nenhum backup disponível para este banco.');
+        process.exit(0);
+        return;
+    }
+    // 2. Operador escolhe backup
+    const { backupId } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'backupId',
+            message: 'Escolha o backup para restaurar:',
+            choices: backupsResp.backups.map((b) => ({
+                name: `${b.id}  ${fmtTimestamp(b.timestamp)}  ${b.sizeMb != null ? b.sizeMb + ' MB' : ''}  ${statusColor(b.status)}`,
+                value: b.id,
+            })),
+        },
+    ]);
+    const chosen = backupsResp.backups.find((b) => b.id === backupId);
+    log.warn('');
+    log.warn(`ATENÇÃO: Restore de banco é destrutivo — o banco ${chalk.bold(dbId)} será sobrescrito`);
+    log.warn(`pelo backup ${chalk.bold(backupId)} (${fmtTimestamp(chosen?.timestamp)}).`);
+    log.warn('Esta operação NÃO pode ser desfeita.');
+    log.warn('');
+    // 3. Confirmação textual obrigatória
+    const { confirmText } = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'confirmText',
+            message: `Digite ${chalk.bold('RESTAURAR')} para confirmar:`,
+        },
+    ]);
+    if (confirmText !== 'RESTAURAR') {
+        log.dim('Operação cancelada.');
+        return;
+    }
+    // 4. POST restore com MFA step-up
+    const spinnerRestore = ora({ text: 'Disparando restore…', color: 'yellow' }).start();
+    let resp;
+    try {
+        resp = await apiRequest(`/api/cli/v1/db/${encodeURIComponent(dbId)}/restore`, {
+            method: 'POST',
+            headers: { 'X-Neetru-MFA-Token': opts.mfa },
+            body: { backupId, dbId },
         });
-    });
+        spinnerRestore.succeed(`Restore iniciado — job ${chalk.bold(resp.jobId ?? '—')} · status: ${resp.status}`);
+    }
+    catch (err) {
+        spinnerRestore.fail('Falha ao iniciar restore.');
+        handleApiError(err);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify(resp, null, 2));
+    }
+}
+function dbDensityLabel(databases) {
+    if (!databases || databases.length === 0)
+        return chalk.dim('(vazio)');
+    const names = databases.map((d) => d.label ?? d.id).join(', ');
+    const label = `${databases.length} banco${databases.length > 1 ? 's' : ''}`;
+    return `${chalk.bold(String(databases.length))} — ${chalk.dim(names.slice(0, 50))}${names.length > 50 ? '…' : ''}`;
+}
+function ramLabel(total, available) {
+    if (total == null)
+        return '—';
+    if (available == null)
+        return `${total} MB`;
+    return `${available}/${total} MB livre`;
+}
+/**
+ * Lista as VMs host e quantos bancos de produto cada uma hospeda.
+ *
+ * Usa o endpoint de servers com `?capacity=true&db=true` para incluir
+ * o inventário de bancos por servidor. O Core agrega o campo `databases`
+ * quando `db=true` é passado.
+ *
+ * Endpoint: GET /api/cli/v1/servers?capacity=true&db=true
+ *
+ * NOTA: O parâmetro `db=true` (que instrui o Core a enriquecer cada server
+ * com o array `databases`) não está implementado ainda no endpoint de servers
+ * do Core (GAP: parâmetro db=true em /api/cli/v1/servers ausente). O comando
+ * funciona com a resposta atual — apenas o campo `databases` por server
+ * ficará ausente/vazio até o Core implementar o enriquecimento.
+ */
+export async function runDbHosts(opts = {}) {
+    log.banner();
+    const spinner = ora({ text: 'Buscando VM hosts e densidade de bancos…', color: 'blue' }).start();
+    let resp;
+    try {
+        resp = await apiRequest('/api/cli/v1/servers?capacity=true&db=true');
+        spinner.stop();
+    }
+    catch (err) {
+        spinner.fail('Falha ao buscar hosts.');
+        handleApiError(err);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify(resp, null, 2));
+        return;
+    }
+    log.heading(`VM Hosts de Banco (${resp.count})`);
+    renderTable([
+        { header: 'ID', value: (r) => r.id, maxWidth: 20 },
+        { header: 'Nome', value: (r) => r.name ?? '—', maxWidth: 22 },
+        { header: 'Região', value: (r) => r.region ?? '—', maxWidth: 14 },
+        { header: 'Status', value: (r) => statusColor(r.status ?? '—'), maxWidth: 14 },
+        { header: 'RAM (livre/total)', value: (r) => ramLabel(r.totalRamMb, r.availableRamMb), maxWidth: 22 },
+        { header: 'Bancos', value: (r) => dbDensityLabel(r.databases), maxWidth: 50 },
+    ], resp.servers);
 }
+// ── D-3: runDbMigrate e runDbSeed removidos (legado Sprint 10) ──────────────
+// Esses comandos operavam via schema.manifest.json (Sprint 10) e foram cortados
+// junto com o branch legado do `db init`. O fluxo canônico é:
+//   neetru db init → neetru db apply → neetru db migrations confirm (se destrutiva)
 //# sourceMappingURL=db.js.map