@neetru/cli 2.28.7 → 2.28.8

package/dist/commands/db-move.js

@@ -0,0 +1,890 @@
+/**
+ * `neetru db move` — relocação ATÔMICA de um banco de produto entre VMs.
+ *
+ * Fase 2 do PR #423 (design em docs/_review/AUDITORIA_DESIGN_MIGRACAO_ENTRE_VMS).
+ * Este arquivo é a superfície CLI do relocate: dá o kickoff da máquina de estados
+ * no Core (Server Action `relocateProductDatabase`) e ACOMPANHA o progresso,
+ * reportando SUCESSO só quando o Core confirma o cutover VERIFICADO (state `done`).
+ *
+ * INVARIANTE que o CLI honra (espelha as invariantes do Core):
+ *   - Nunca declara "movido" antes de o Core reportar `done`. Estados de rollback
+ *     (`rolled_back`/`failed`) são reportados EXPLICITAMENTE como "o produto
+ *     seguiu na origem" (fail-closed pro estado atual) e saem com exit != 0.
+ *   - `move` é destrutivo sobre banco de produção → confirmação interativa
+ *     (pulável com --yes) + step-up MFA (resolveStepUp: sessão 1h → --mfa-token
+ *     → prompt). `--dry-run` roda só o preflight (sem MFA, sem confirmação).
+ *
+ * SEGURANÇA por construção (iteração 2 — abort/decommission NÃO podem apagar dado
+ * vivo, e o CLI NÃO pode MENTIR sobre isso):
+ *   - `abort` agora exige MFA, faz GET do estado ANTES (mensagem pré vs pós-cutover)
+ *     e ACOMPANHA o rollback até um estado terminal. Só afirma "nada perdido"
+ *     quando o Core confirma o terminal + o ledger (`live.serverId`) aponta pra um
+ *     servidor com os dados. `needs_attention` é HALT fail-closed (nada destruído,
+ *     mas NÃO é all-clear). A iteração 1 imprimia o all-clear INCONDICIONALMENTE
+ *     logo após o POST — a mentira que este arquivo corta.
+ *   - `decommission` é o ÚNICO caminho que dropa a ORIGEM (comando SEPARADO, MFA),
+ *     recusado client-side se o ledger ainda não aponta pro destino — espelho da
+ *     INV-DESTROY do Core (nunca dropar quem o ledger diz ser o vivo).
+ *
+ * Endpoints (contrato com o Core — construídos pelo componente irmão):
+ *   POST /api/cli/v1/db/{id}/relocate                        — kickoff (MFA)
+ *   GET  /api/cli/v1/db/relocate/{migrationId}               — status (poll)
+ *   POST /api/cli/v1/db/relocate/{migrationId}/confirm       — cutover manual (MFA)
+ *   POST /api/cli/v1/db/relocate/{migrationId}/abort         — rollback seguro (MFA)
+ *   POST /api/cli/v1/db/relocate/{migrationId}/decommission  — drop da origem (MFA)
+ *
+ * Plain PT-BR em toda string visível ao usuário.
+ */
+import chalk from 'chalk';
+import ora from 'ora';
+import { apiRequest, CliNetworkError } from '../lib/api-client.js';
+import { handleApiError } from '../lib/api-error.js';
+import { requireToken } from '../lib/cli-read.js';
+import { confirmDestructive, resolveStepUp } from '../lib/cli-write.js';
+import { renderTable } from '../lib/render.js';
+import { log } from '../utils/logger.js';
+import { safeExit, setSafeExitCode } from '../utils/safe-exit.js';
+/** Ordem "pra frente" do caminho feliz — usada só pra exibir progresso. */
+export const FORWARD_STATES = [
+    'planning',
+    'provisioning_target',
+    'replicating',
+    'verifying_target',
+    'quiescing_source',
+    'final_sync',
+    'cutover',
+    'observing',
+    'draining_source',
+    'done',
+];
+/** Estados terminais de SUCESSO (o único ponto onde "movido" pode ser dito). */
+export const TERMINAL_SUCCESS = new Set(['done']);
+/** Estados terminais de FALHA/rollback (produto seguiu/voltou pra origem). */
+export const TERMINAL_FAILURE = new Set([
+    'rolled_back',
+    'failed',
+]);
+/**
+ * Estado terminal de HALT fail-closed (iteração 2). O Core PARA a máquina aqui
+ * quando detecta drift de ledger ou um destroy recusado por INV-DESTROY. NÃO é
+ * sucesso nem "voltou pra origem" — é "parou e precisa de gente", e o dado NÃO
+ * foi destruído (fail-closed). Poll NUNCA pode tratar isto como `running` (senão
+ * ficaria pendurado até o timeout).
+ */
+export const TERMINAL_ATTENTION = new Set([
+    'needs_attention',
+]);
+/**
+ * Estados em que o cutover PODE já ter trocado o ledger pro destino (o "vivo"
+ * pode estar no destino). `cutover` entra aqui por ser AMBÍGUO — durante ele a
+ * troca do ledger pode ou não ter acontecido; tratamos como pós por segurança
+ * (mensagem cuidadosa, nunca afirmar "ledger intocado"). Usado pelo `abort`
+ * pra escolher a mensagem correta (pré vs pós-cutover).
+ */
+export const POST_CUTOVER_STATES = new Set([
+    'cutover',
+    'observing',
+    'draining_source',
+    'done',
+    'rolling_back_post',
+]);
+/** True se o estado já pode ter o ledger apontando pro destino (pós-cutover). */
+export function isPostCutoverState(s) {
+    return POST_CUTOVER_STATES.has(s);
+}
+/** Rótulos PT-BR de cada estado da máquina (progresso ostensivo). */
+export const STATE_LABELS = {
+    planning: 'planejando (preflight)',
+    provisioning_target: 'provisionando destino',
+    replicating: 'replicando dados (bulk)',
+    verifying_target: 'verificando destino (prova de dados + health-gate)',
+    quiescing_source: 'congelando origem (quiesce)',
+    final_sync: 'sincronizando delta final',
+    cutover: 'cutover (flip do ledger)',
+    observing: 'observando destino pós-cutover',
+    draining_source: 'drenando origem',
+    done: 'concluído — cutover verificado',
+    resume_source: 'retomando origem',
+    rolling_back: 'revertendo (rollback)',
+    rolling_back_post: 'revertendo pós-cutover (o vivo volta pra origem íntegra)',
+    rolled_back: 'revertido — produto seguiu na origem',
+    needs_attention: 'PAROU — precisa de atenção (drift de ledger ou destroy recusado; nada destruído)',
+    failed: 'falhou',
+};
+/**
+ * Classifica o estado de uma migração numa das FASES que o CLI trata.
+ * `await_confirm`: manual-cutover pausado em `verifying_target` com o health-gate
+ * já verde — o Core está esperando `db move confirm`.
+ * `attention`: HALT fail-closed (`needs_attention`) — parou, precisa de gente,
+ * nada destruído. É TERMINAL para o poll (não pode ser confundido com `running`).
+ *
+ * Função pura — não toca rede/relógio. É o coração testável do driver de watch.
+ */
+export function classifyRelocation(m) {
+    if (TERMINAL_SUCCESS.has(m.state)) {
+        return { phase: 'success', label: STATE_LABELS[m.state] };
+    }
+    if (TERMINAL_ATTENTION.has(m.state)) {
+        return { phase: 'attention', label: STATE_LABELS[m.state] };
+    }
+    if (TERMINAL_FAILURE.has(m.state)) {
+        return { phase: 'failure', label: STATE_LABELS[m.state] };
+    }
+    if (m.manualCutover === true &&
+        m.state === 'verifying_target' &&
+        !!m.healthGatePassedAt) {
+        return { phase: 'await_confirm', label: STATE_LABELS[m.state] };
+    }
+    return { phase: 'running', label: STATE_LABELS[m.state] ?? m.state };
+}
+/** Linhas humanas do verifyReport (contagem por tabela origem vs destino). */
+export function formatVerifyReportLines(report) {
+    if (!report)
+        return [];
+    const lines = [];
+    for (const t of report.tables ?? []) {
+        const mark = t.ok ? chalk.green('✓') : chalk.red('✗');
+        lines.push(`    ${mark} ${t.name}: origem=${t.srcRows} destino=${t.dstRows}`);
+    }
+    if (typeof report.checksumOk === 'boolean') {
+        lines.push(`    checksum: ${report.checksumOk ? chalk.green('ok') : chalk.red('divergente')}`);
+    }
+    return lines;
+}
+/** Valida o teto duro de quiesce (guardrail INV-1). Retorna erro ou null. */
+export function validateMaxQuiesceMs(raw) {
+    const DEFAULT = 15_000;
+    const CAP = 60_000;
+    if (raw === undefined || raw === null || raw === '')
+        return { value: DEFAULT };
+    const n = typeof raw === 'number' ? raw : Number(raw);
+    if (!Number.isFinite(n) || n <= 0) {
+        return { value: DEFAULT, error: '--max-quiesce-ms deve ser um número positivo' };
+    }
+    if (n > CAP) {
+        return {
+            value: CAP,
+            error: `--max-quiesce-ms acima do teto de segurança (${CAP}ms); recuse ou reduza`,
+        };
+    }
+    return { value: Math.floor(n) };
+}
+const VALID_STRATEGIES = ['snapshot_quiesce', 'logical_stream'];
+function colorState(s) {
+    if (TERMINAL_SUCCESS.has(s))
+        return chalk.green(s);
+    if (TERMINAL_ATTENTION.has(s))
+        return chalk.yellow(s);
+    if (TERMINAL_FAILURE.has(s))
+        return chalk.red(s);
+    if (s === 'cutover')
+        return chalk.magenta(s);
+    return chalk.cyan(s);
+}
+/**
+ * Classifica o desfecho TERMINAL de um abort a partir do doc de migração.
+ *
+ * REGRA DE SEGURANÇA (iteração 2): o CLI só pode afirmar "nenhum dado perdido"
+ * quando o Core CONFIRMA um estado terminal + o ledger aponta pra um servidor
+ * que tem os dados. Nunca infere segurança do `state` sozinho, nunca antes do
+ * terminal. Um abort que para em `needs_attention` NÃO é "tudo certo" — é HALT
+ * (nada destruído, mas precisa de gente); afirmar all-clear ali seria mentir.
+ *
+ * Função pura — é o núcleo testável do relatório de abort.
+ */
+export function classifyAbortTerminal(m) {
+    const liveServerId = m.live?.serverId ?? undefined;
+    if (m.state === 'rolled_back') {
+        // Ledger de volta na origem (íntegra). Único estado onde o all-clear é honesto.
+        return { outcome: 'reverted_safe', dataSafe: true, liveServerId };
+    }
+    if (m.state === 'needs_attention') {
+        // HALT fail-closed: nada foi destruído, mas NÃO afirmamos "seguiu/voltou".
+        return { outcome: 'needs_attention', dataSafe: false, liveServerId };
+    }
+    if (m.state === 'failed') {
+        return { outcome: 'failed', dataSafe: false, liveServerId };
+    }
+    // Ainda em trânsito (rolling_back / rolling_back_post / etc.) — sem afirmação.
+    return { outcome: 'pending', dataSafe: false, liveServerId };
+}
+/**
+ * Resolve o banco alvo a partir de `--db <id>` (explícito) OU `--product <slug>`
+ * (+ opcional `--env`). Fail-closed em ambiguidade — nunca "escolhe na dúvida".
+ */
+async function resolveTargetDb(opts) {
+    if (opts.db) {
+        // Explícito: busca o detalhe só pra exibir a origem no plano.
+        try {
+            const res = await apiRequest(`/api/cli/v1/db/${encodeURIComponent(opts.db)}/get`);
+            return { dbId: res.database.id, source: res.database };
+        }
+        catch {
+            // Se o /get falhar (rede/permissão), segue com o dbId cru — o Core valida.
+            return { dbId: opts.db };
+        }
+    }
+    if (!opts.product) {
+        if (opts.json) {
+            console.log(JSON.stringify({ ok: false, error: 'input', message: 'informe --product <slug> ou --db <dbId>' }));
+        }
+        else {
+            log.error('Informe --product <slug> ou --db <dbId>.');
+        }
+        safeExit(1);
+    }
+    const qs = `?productId=${encodeURIComponent(opts.product)}`;
+    let list;
+    try {
+        list = await apiRequest(`/api/cli/v1/db${qs}`);
+    }
+    catch (err) {
+        handleApiError(err, opts.json);
+    }
+    let dbs = (list.databases ?? []).filter((d) => d.status !== 'archived');
+    if (opts.env) {
+        dbs = dbs.filter((d) => (d.environment ?? d.env) === opts.env);
+    }
+    if (dbs.length === 0) {
+        const msg = `Nenhum banco ativo encontrado para o produto "${opts.product}"${opts.env ? ` no ambiente "${opts.env}"` : ''}.`;
+        if (opts.json)
+            console.log(JSON.stringify({ ok: false, error: 'not_found', message: msg }));
+        else
+            log.error(msg);
+        safeExit(1);
+    }
+    if (dbs.length > 1) {
+        const msg = `O produto "${opts.product}" tem ${dbs.length} bancos ativos — ` +
+            'desambigue com --db <dbId> ou --env <ambiente>.';
+        if (opts.json) {
+            console.log(JSON.stringify({ ok: false, error: 'ambiguous', message: msg, databases: dbs }));
+        }
+        else {
+            log.error(msg);
+            for (const d of dbs) {
+                log.dim(`  · ${d.id}  env=${d.environment ?? d.env ?? '—'}  engine=${d.engine ?? '—'}  vm=${d.serverId ?? '—'}`);
+            }
+        }
+        safeExit(1);
+    }
+    return { dbId: dbs[0].id, source: dbs[0] };
+}
+export async function runDbMoveStart(opts) {
+    if (!opts.json)
+        log.banner();
+    // ── Validação de entrada (fail-closed cedo, antes de tocar o Core) ──────────
+    if (!opts.to) {
+        if (opts.json)
+            console.log(JSON.stringify({ ok: false, error: 'input', message: '--to <serverId> é obrigatório' }));
+        else
+            log.error('--to <serverId> (VM destino) é obrigatório.');
+        safeExit(1);
+    }
+    const strategy = (opts.strategy ?? 'snapshot_quiesce');
+    if (!VALID_STRATEGIES.includes(strategy)) {
+        const msg = `--strategy inválida: "${opts.strategy}" (use ${VALID_STRATEGIES.join(' | ')})`;
+        if (opts.json)
+            console.log(JSON.stringify({ ok: false, error: 'input', message: msg }));
+        else
+            log.error(msg);
+        safeExit(1);
+    }
+    const quiesce = validateMaxQuiesceMs(opts.maxQuiesceMs);
+    if (quiesce.error) {
+        if (opts.json)
+            console.log(JSON.stringify({ ok: false, error: 'input', message: quiesce.error }));
+        else
+            log.error(quiesce.error);
+        safeExit(1);
+    }
+    if (!opts.dryRun && !opts.reason) {
+        const msg = '--reason "<texto>" é obrigatório (vai pro audit).';
+        if (opts.json)
+            console.log(JSON.stringify({ ok: false, error: 'input', message: msg }));
+        else
+            log.error(msg);
+        safeExit(1);
+    }
+    await requireToken(opts.json);
+    // ── Resolve o banco alvo ────────────────────────────────────────────────────
+    const { dbId, source } = await resolveTargetDb(opts);
+    const sourceServerId = source?.serverId ?? undefined;
+    // Guardrail cliente: destino == origem não faz sentido (o Core também recusa).
+    if (sourceServerId && sourceServerId === opts.to) {
+        const msg = `A VM destino (${opts.to}) é a mesma da origem — nada a mover.`;
+        if (opts.json)
+            console.log(JSON.stringify({ ok: false, error: 'same_server', message: msg }));
+        else
+            log.error(msg);
+        safeExit(1);
+    }
+    // ── Plano + confirmação interativa (pulável com --yes) ──────────────────────
+    if (!opts.json) {
+        log.heading(opts.dryRun ? 'Relocação de banco (DRY-RUN)' : 'Relocação de banco');
+        log.info(`Banco:      ${chalk.cyan(dbId)}${source?.label ? ` (${source.label})` : ''}`);
+        log.info(`Origem:     ${sourceServerId ? chalk.bold(sourceServerId) : chalk.dim('(o Core resolve)')}`);
+        log.info(`Destino:    ${chalk.bold(String(opts.to))}`);
+        if (source?.engine)
+            log.info(`Engine:     ${source.engine}`);
+        log.info(`Estratégia: ${strategy}`);
+        if (opts.manualCutover)
+            log.info('Cutover:    MANUAL (pausa em verifying_target aguardando confirm)');
+    }
+    if (!opts.dryRun) {
+        await confirmDestructive(`Mover o banco ${dbId} de ${sourceServerId ?? '(origem atual)'} para ${opts.to}? ` +
+            'A origem serve read-write até o cutover; há rollback até o descomissionamento manual.', { yes: opts.yes, json: opts.json });
+    }
+    // ── MFA (step-up). Em dry-run só o header X-Neetru-Dry-Run. ──────────────────
+    const { headers } = await resolveStepUp({
+        mfaToken: opts.mfaToken,
+        json: opts.json,
+        dryRun: opts.dryRun,
+        yes: opts.yes,
+    });
+    const body = {
+        targetServerId: opts.to,
+        reason: opts.reason,
+        replicationStrategy: strategy,
+        manualCutover: !!opts.manualCutover,
+        maxQuiesceMs: quiesce.value,
+        dryRun: !!opts.dryRun,
+    };
+    const spinner = opts.json ? null : ora({ text: 'Iniciando relocação…', color: 'blue' }).start();
+    let start;
+    try {
+        start = await apiRequest(`/api/cli/v1/db/${encodeURIComponent(dbId)}/relocate`, { method: 'POST', body, headers, timeoutMs: 60_000 });
+        spinner?.stop();
+    }
+    catch (err) {
+        spinner?.fail('Falha ao iniciar relocação.');
+        handleApiError(err, opts.json);
+    }
+    // ── Dry-run: só o preflight. Nada foi provisionado. ─────────────────────────
+    if (opts.dryRun) {
+        if (opts.json) {
+            console.log(JSON.stringify({ ...start, dryRun: true, ok: start.preflight.ok }));
+            if (!start.preflight.ok)
+                setSafeExitCode(1);
+            return;
+        }
+        log.heading('Preflight');
+        for (const c of start.preflight.checks) {
+            const mark = c.ok ? chalk.green('✓') : chalk.red('✗');
+            log.dim(`  ${mark} ${c.name}${c.detail ? ` — ${c.detail}` : ''}`);
+        }
+        if (start.preflight.ok) {
+            log.success('Preflight OK. Nada foi provisionado (dry-run). Rode sem --dry-run para executar.');
+        }
+        else {
+            log.error('Preflight REPROVADO — a relocação seria abortada. Nada foi tocado.');
+            setSafeExitCode(1);
+        }
+        return;
+    }
+    if (!opts.json) {
+        log.success(`Relocação iniciada: ${chalk.cyan(start.migrationId)} (estado: ${colorState(start.state)})`);
+    }
+    // Sem --watch: só reporta que iniciou (NÃO afirma sucesso — INV do CLI).
+    const watch = opts.watch !== false;
+    if (!watch) {
+        if (opts.json) {
+            console.log(JSON.stringify({ ...start, started: true, ok: true }));
+        }
+        else {
+            log.info(`Acompanhe com: ${chalk.cyan(`neetru db move status ${start.migrationId}`)}`);
+        }
+        return;
+    }
+    await pollRelocation(start.migrationId, opts);
+}
+// ---------------------------------------------------------------------------
+// Poll da máquina de estados
+// ---------------------------------------------------------------------------
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+/**
+ * Acompanha a máquina de estados até um estado terminal (done/rolled_back/failed)
+ * ou até a pausa de manual-cutover. Reporta SUCESSO só em `done`.
+ * Usado por `runDbMoveStart` (com --watch) e por `runDbMoveConfirm`.
+ */
+export async function pollRelocation(migrationId, opts) {
+    const intervalMs = opts.pollIntervalMs ?? 4000;
+    const timeoutMs = opts.pollTimeoutMs ?? 30 * 60 * 1000;
+    const start = Date.now();
+    let lastState = '';
+    const spinner = opts.json ? null : ora({ text: 'Acompanhando relocação…', color: 'blue' }).start();
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        if (Date.now() - start >= timeoutMs) {
+            spinner?.fail('Timeout acompanhando a relocação.');
+            if (opts.json)
+                console.log(JSON.stringify({ ok: false, error: 'watch_timeout', migrationId }));
+            else
+                log.warn(`Timeout. Consulte: neetru db move status ${migrationId}`);
+            setSafeExitCode(1);
+            return;
+        }
+        let resp;
+        try {
+            resp = await apiRequest(`/api/cli/v1/db/relocate/${encodeURIComponent(migrationId)}`);
+        }
+        catch (err) {
+            // Erro transitório de rede → segue tentando (o Core/relocate é resumível).
+            if (err instanceof CliNetworkError) {
+                await sleep(Math.min(intervalMs, 3000));
+                continue;
+            }
+            spinner?.fail('Falha ao consultar o estado da relocação.');
+            handleApiError(err, opts.json);
+        }
+        const m = resp.migration;
+        const { phase, label } = classifyRelocation(m);
+        if (m.state !== lastState) {
+            lastState = m.state;
+            if (spinner)
+                spinner.text = `${chalk.bold(m.state)} — ${label}`;
+        }
+        if (phase === 'success') {
+            spinner?.succeed(`Cutover VERIFICADO. Banco ${m.dbId} agora vive em ${chalk.bold(m.targetServerId)}.`);
+            if (opts.json) {
+                console.log(JSON.stringify({ ok: true, ...m }));
+            }
+            else {
+                for (const line of formatVerifyReportLines(m.verifyReport))
+                    console.log(line);
+                log.success('Relocação concluída com sucesso.');
+                log.dim(`A origem (${m.sourceServerId}) NÃO foi destruída — descomissione depois com ` +
+                    `neetru db move status ${m.id} (janela de segurança de rollback).`);
+            }
+            return;
+        }
+        if (phase === 'attention') {
+            // HALT fail-closed (iteração 2): drift de ledger ou destroy recusado por
+            // INV-DESTROY. NÃO é "voltou pra origem" nem "movido" — é "parou, precisa
+            // de gente, e nada foi destruído". Reportar como tal, com exit != 0.
+            const code = m.lastError?.code ?? 'RELOCATE_NEEDS_ATTENTION';
+            spinner?.fail(`Relocação PAROU e precisa de atenção (${m.state}).`);
+            if (opts.json) {
+                console.log(JSON.stringify({ ok: false, error: code, needsAttention: true, ...m }));
+            }
+            else {
+                if (m.lastError)
+                    log.error(`${m.lastError.code}: ${m.lastError.message}`);
+                log.warn('A relocação foi PARADA de propósito (fail-closed): o Core detectou ' +
+                    'drift de ledger ou recusou um destroy que atingiria o banco vivo. ' +
+                    'NENHUM dado foi destruído. Investigue e resolva manualmente: ' +
+                    `neetru db move status ${m.id}`);
+            }
+            setSafeExitCode(1);
+            return;
+        }
+        if (phase === 'failure') {
+            const code = m.lastError?.code ?? m.state;
+            spinner?.fail(`Relocação NÃO concluída (${m.state}).`);
+            if (opts.json) {
+                console.log(JSON.stringify({ ok: false, error: code, ...m }));
+            }
+            else {
+                if (m.lastError)
+                    log.error(`${m.lastError.code}: ${m.lastError.message}`);
+                // INV-2 explícito pro operador: o produto seguiu/voltou pra origem.
+                log.warn(`O produto NÃO foi movido — seguiu na origem (${m.sourceServerId}). ` +
+                    'Nenhum dado foi perdido (fail-closed pro estado atual).');
+            }
+            setSafeExitCode(1);
+            return;
+        }
+        if (phase === 'await_confirm') {
+            spinner?.stop();
+            if (opts.json) {
+                console.log(JSON.stringify({ ok: true, awaitingConfirm: true, ...m }));
+            }
+            else {
+                log.warn('Destino provado saudável. Cutover MANUAL aguardando confirmação.');
+                for (const line of formatVerifyReportLines(m.verifyReport))
+                    console.log(line);
+                log.info(`Confirme com: ${chalk.cyan(`neetru db move confirm ${m.id} --mfa <código TOTP>`)}`);
+            }
+            return;
+        }
+        await sleep(intervalMs);
+    }
+}
+// ---------------------------------------------------------------------------
+// neetru db move status <migrationId>
+// ---------------------------------------------------------------------------
+export async function runDbMoveStatus(migrationId, opts = {}) {
+    await requireToken(opts.json);
+    let resp;
+    try {
+        resp = await apiRequest(`/api/cli/v1/db/relocate/${encodeURIComponent(migrationId)}`);
+    }
+    catch (err) {
+        handleApiError(err, opts.json);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify(resp));
+        return;
+    }
+    const m = resp.migration;
+    log.heading(`Relocação ${m.id}`);
+    log.info(`Estado:   ${colorState(m.state)} — ${STATE_LABELS[m.state] ?? m.state}`);
+    log.info(`Banco:    ${m.dbId}${m.engine ? ` (${m.engine})` : ''}`);
+    log.info(`Origem:   ${m.sourceServerId}`);
+    log.info(`Destino:  ${m.targetServerId}`);
+    if (m.manualCutover)
+        log.dim('  cutover: MANUAL');
+    if (m.healthGatePassedAt)
+        log.dim(`  health-gate OK em: ${m.healthGatePassedAt}`);
+    const verifyLines = formatVerifyReportLines(m.verifyReport);
+    if (verifyLines.length) {
+        log.heading('Verificação de dados (origem vs destino)');
+        for (const line of verifyLines)
+            console.log(line);
+    }
+    if (m.live?.serverId)
+        log.dim(`  vivo agora em (ledger): ${m.live.serverId}`);
+    if (m.lastError) {
+        log.warn(`Último erro: ${m.lastError.code} — ${m.lastError.message}`);
+    }
+    if (TERMINAL_ATTENTION.has(m.state)) {
+        log.warn('PAROU (fail-closed): drift de ledger ou destroy recusado por INV-DESTROY. ' +
+            'NENHUM dado foi destruído — a máquina espera intervenção manual.');
+    }
+    else if (TERMINAL_FAILURE.has(m.state)) {
+        log.warn(`O produto seguiu na origem (${m.sourceServerId}). Nenhum dado perdido.`);
+    }
+}
+// ---------------------------------------------------------------------------
+// neetru db move confirm <migrationId>  (cutover manual — MFA)
+// ---------------------------------------------------------------------------
+export async function runDbMoveConfirm(migrationId, opts = {}) {
+    if (!opts.json)
+        log.banner();
+    await requireToken(opts.json);
+    const { headers } = await resolveStepUp({ mfaToken: opts.mfa, json: opts.json });
+    const spinner = opts.json ? null : ora({ text: 'Confirmando cutover…', color: 'blue' }).start();
+    let resp;
+    try {
+        resp = await apiRequest(`/api/cli/v1/db/relocate/${encodeURIComponent(migrationId)}/confirm`, { method: 'POST', body: {}, headers });
+        spinner?.stop();
+    }
+    catch (err) {
+        spinner?.fail('Falha ao confirmar o cutover.');
+        handleApiError(err, opts.json);
+    }
+    if (!opts.json)
+        log.success(`Cutover liberado (estado: ${colorState(resp.state)}).`);
+    const watch = opts.watch !== false;
+    if (watch) {
+        await pollRelocation(migrationId, opts);
+    }
+    else if (opts.json) {
+        console.log(JSON.stringify({ ...resp, ok: true }));
+    }
+}
+// ---------------------------------------------------------------------------
+// neetru db move abort <migrationId>  (rollback do estado atual)
+// ---------------------------------------------------------------------------
+export async function runDbMoveAbort(migrationId, opts = {}) {
+    if (!opts.json)
+        log.banner();
+    if (!opts.reason) {
+        const msg = '--reason "<texto>" é obrigatório para abortar (vai pro audit).';
+        if (opts.json)
+            console.log(JSON.stringify({ ok: false, error: 'input', message: msg }));
+        else
+            log.error(msg);
+        safeExit(1);
+    }
+    await requireToken(opts.json);
+    // ── GET estado ANTES (iteração 2): a mensagem/confirmação DEPENDE de onde a
+    //    migração está. Pré-cutover o ledger nunca foi tocado; pós-cutover o
+    //    abort re-aponta o vivo de volta pra ORIGEM íntegra. Nunca confiar no CLI:
+    //    é o Core+ledger que dizem a posição. GET transitório que falha não bloqueia
+    //    o abort (o Core valida de novo), mas então NÃO afirmamos posição. ────────
+    let before = null;
+    try {
+        const s = await apiRequest(`/api/cli/v1/db/relocate/${encodeURIComponent(migrationId)}`);
+        before = s.migration;
+    }
+    catch (err) {
+        // 404/403 etc. são reais — reporta e sai. Rede transitória segue com before=null
+        // (o Core re-valida no POST; só não afirmamos posição pré-abort).
+        if (!(err instanceof CliNetworkError))
+            handleApiError(err, opts.json);
+    }
+    const postCutover = before ? isPostCutoverState(before.state) : false;
+    const srcLabel = before?.sourceServerId ?? 'a origem';
+    const confirmMsg = postCutover
+        ? `Abortar a relocação ${migrationId}? Ela JÁ passou (ou pode ter passado) do ` +
+            `cutover — o rollback re-aponta o ledger de volta pra ORIGEM (${srcLabel}), ` +
+            'que segue íntegra. NENHUMA cópia com dado vivo é destruída pelo abort.'
+        : `Abortar a relocação ${migrationId}? PRÉ-cutover: o ledger nunca foi tocado; ` +
+            'o rollback só remove os recursos-shadow do destino (provados-não-vivos). ' +
+            `A origem (${srcLabel}) serve read-write o tempo todo.`;
+    await confirmDestructive(confirmMsg, { yes: opts.yes, json: opts.json });
+    // ── Step-up MFA (igual start/confirm) — abort dispara ação destrutiva no Core
+    //    (drop de shadow); exige step-up. Fail-closed em não-interativo sem token. ──
+    const { headers } = await resolveStepUp({
+        mfaToken: opts.mfaToken,
+        json: opts.json,
+        yes: opts.yes,
+    });
+    const spinner = opts.json ? null : ora({ text: 'Abortando relocação…', color: 'blue' }).start();
+    let resp;
+    try {
+        resp = await apiRequest(`/api/cli/v1/db/relocate/${encodeURIComponent(migrationId)}/abort`, { method: 'POST', body: { reason: opts.reason }, headers });
+        spinner?.stop();
+    }
+    catch (err) {
+        spinner?.fail('Falha ao abortar a relocação.');
+        handleApiError(err, opts.json);
+    }
+    if (!opts.json) {
+        log.success(`Rollback disparado (estado: ${colorState(resp.state)}).`);
+        if (postCutover) {
+            log.info('Revertendo PÓS-cutover: o ledger volta pra origem íntegra. ' +
+                'O antigo destino só é limpo depois, guardado por INV-DESTROY.');
+        }
+    }
+    // ── Poll até um estado TERMINAL. SÓ afirmamos "nada perdido" quando o Core
+    //    confirma o terminal + o ledger aponta pra um servidor com os dados. Isto
+    //    mata a mentira da iteração 1 (all-clear incondicional logo após o POST). ──
+    const watch = opts.watch !== false;
+    if (!watch) {
+        if (opts.json)
+            console.log(JSON.stringify({ ...resp, ok: true }));
+        else
+            log.info(`Acompanhe com: ${chalk.cyan(`neetru db move status ${migrationId}`)}`);
+        return;
+    }
+    await pollAbort(migrationId, opts);
+}
+/**
+ * Acompanha o rollback disparado por um abort até um estado terminal e reporta
+ * a segurança dos dados SÓ com base no ledger (`live.serverId`) + estado terminal
+ * confirmado pelo Core. Nunca afirma "nada perdido" antes do terminal, nem em
+ * `needs_attention` (HALT). Reusa o mesmo mecanismo de poll do caminho forward.
+ */
+async function pollAbort(migrationId, opts) {
+    const intervalMs = opts.pollIntervalMs ?? 4000;
+    const timeoutMs = opts.pollTimeoutMs ?? 30 * 60 * 1000;
+    const startedAt = Date.now();
+    let lastState = '';
+    const spinner = opts.json ? null : ora({ text: 'Acompanhando o rollback…', color: 'blue' }).start();
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        if (Date.now() - startedAt >= timeoutMs) {
+            spinner?.fail('Timeout acompanhando o rollback.');
+            if (opts.json)
+                console.log(JSON.stringify({ ok: false, error: 'watch_timeout', migrationId }));
+            else
+                log.warn(`Timeout. Consulte: neetru db move status ${migrationId}`);
+            setSafeExitCode(1);
+            return;
+        }
+        let resp;
+        try {
+            resp = await apiRequest(`/api/cli/v1/db/relocate/${encodeURIComponent(migrationId)}`);
+        }
+        catch (err) {
+            if (err instanceof CliNetworkError) {
+                await sleep(Math.min(intervalMs, 3000));
+                continue;
+            }
+            spinner?.fail('Falha ao consultar o estado do rollback.');
+            handleApiError(err, opts.json);
+        }
+        const m = resp.migration;
+        if (m.state !== lastState) {
+            lastState = m.state;
+            if (spinner)
+                spinner.text = `${chalk.bold(m.state)} — ${STATE_LABELS[m.state] ?? m.state}`;
+        }
+        // Terminal? (rolled_back / failed / needs_attention). `done` não deveria
+        // acontecer num abort, mas se acontecer não é "seguiu na origem" — trata como
+        // não-terminal-de-abort e deixa o loop achar o estado real ou o timeout pegar.
+        const terminalForAbort = TERMINAL_FAILURE.has(m.state) || TERMINAL_ATTENTION.has(m.state);
+        if (!terminalForAbort) {
+            await sleep(intervalMs);
+            continue;
+        }
+        const outcome = classifyAbortTerminal(m);
+        if (opts.json) {
+            console.log(JSON.stringify({
+                ok: outcome.outcome === 'reverted_safe',
+                outcome: outcome.outcome,
+                dataSafe: outcome.dataSafe,
+                liveServerId: outcome.liveServerId,
+                ...m,
+            }));
+            if (outcome.outcome !== 'reverted_safe')
+                setSafeExitCode(1);
+            return;
+        }
+        if (outcome.outcome === 'reverted_safe') {
+            const where = outcome.liveServerId ?? m.sourceServerId;
+            spinner?.succeed(`Rollback concluído — o produto vive em ${chalk.bold(where)}.`);
+            log.success(`Revertido. O ledger aponta pra origem (${where}), íntegra. ` +
+                'Nenhum dado foi perdido.');
+            return;
+        }
+        if (outcome.outcome === 'needs_attention') {
+            spinner?.fail('Rollback PAROU e precisa de atenção.');
+            if (m.lastError)
+                log.error(`${m.lastError.code}: ${m.lastError.message}`);
+            log.warn('O abort foi PARADO de propósito (fail-closed): drift de ledger ou destroy ' +
+                'recusado por INV-DESTROY. NENHUM dado foi destruído. NÃO está "tudo certo" — ' +
+                `resolva manualmente e cheque: neetru db move status ${m.id}`);
+            setSafeExitCode(1);
+            return;
+        }
+        // failed
+        spinner?.fail(`Rollback NÃO concluído (${m.state}).`);
+        if (m.lastError)
+            log.error(`${m.lastError.code}: ${m.lastError.message}`);
+        log.warn(`O rollback falhou. NÃO afirmo segurança automaticamente — cheque o ledger: ` +
+            `neetru db move status ${m.id}.`);
+        setSafeExitCode(1);
+        return;
+    }
+}
+// ---------------------------------------------------------------------------
+// neetru db move decommission <migrationId>  (drop da ORIGEM — comando à parte)
+// ---------------------------------------------------------------------------
+/**
+ * Descomissiona (dropa) a ORIGEM de uma relocação JÁ concluída. É o ÚNICO caminho
+ * que destrói a origem, e por design é SEPARADO, explícito, gated por MFA e —
+ * client-side — recusado se o ledger ainda NÃO aponta pro destino (i.e., o move
+ * não terminou / foi revertido). Isto é o espelho-CLI da INV-DESTROY: nunca pedir
+ * o drop de um servidor que o ledger diz ser o vivo. O Core é a autoridade final
+ * (re-checa live==target + grace + INV-DESTROY), mas falhamos cedo e claro.
+ */
+export async function runDbMoveDecommission(migrationId, opts = {}) {
+    if (!opts.json)
+        log.banner();
+    if (!opts.reason) {
+        const msg = '--reason "<texto>" é obrigatório para descomissionar (vai pro audit).';
+        if (opts.json)
+            console.log(JSON.stringify({ ok: false, error: 'input', message: msg }));
+        else
+            log.error(msg);
+        safeExit(1);
+    }
+    await requireToken(opts.json);
+    // ── GET estado ANTES + guarda-cliente INV-DESTROY. Só a origem de um move
+    //    CONFIRMADO pode ser dropada. Se o ledger ainda aponta pra origem (move
+    //    não terminou ou foi revertido), RECUSAR — dropar aqui apagaria o vivo. ──
+    let m;
+    try {
+        const s = await apiRequest(`/api/cli/v1/db/relocate/${encodeURIComponent(migrationId)}`);
+        m = s.migration;
+    }
+    catch (err) {
+        handleApiError(err, opts.json);
+    }
+    const liveServerId = m.live?.serverId ?? undefined;
+    const movedConfirmed = m.state === 'done' &&
+        // Se o Core expõe o ledger, exigir live==target. Se não expõe, o `done`
+        // já é a confirmação de cutover verificado (o Core re-checa mesmo assim).
+        (liveServerId === undefined || liveServerId === m.targetServerId);
+    if (!movedConfirmed) {
+        const msg = `RECUSADO: a relocação ${migrationId} não está com o cutover confirmado no ` +
+            `destino (estado=${m.state}` +
+            (liveServerId ? `, vivo=${liveServerId}` : '') +
+            `). Descomissionar a origem (${m.sourceServerId}) agora poderia apagar o ` +
+            'banco VIVO. Conclua/relocação ou reverta primeiro.';
+        if (opts.json)
+            console.log(JSON.stringify({ ok: false, error: 'not_decommissionable', message: msg, state: m.state }));
+        else
+            log.error(msg);
+        safeExit(1);
+    }
+    await confirmDestructive(`Descomissionar (DROPAR) a ORIGEM ${m.sourceServerId} do banco ${m.dbId}? ` +
+        `O vivo já está no destino (${m.targetServerId}). Isto é IRREVERSÍVEL e ` +
+        'FECHA a janela de rollback.', { yes: opts.yes, json: opts.json });
+    const { headers } = await resolveStepUp({
+        mfaToken: opts.mfaToken,
+        json: opts.json,
+        yes: opts.yes,
+    });
+    const spinner = opts.json ? null : ora({ text: 'Descomissionando a origem…', color: 'blue' }).start();
+    let resp;
+    try {
+        resp = await apiRequest(`/api/cli/v1/db/relocate/${encodeURIComponent(migrationId)}/decommission`, { method: 'POST', body: { reason: opts.reason }, headers });
+        spinner?.stop();
+    }
+    catch (err) {
+        spinner?.fail('Falha ao descomissionar a origem.');
+        handleApiError(err, opts.json);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ ...resp, ok: true }));
+        return;
+    }
+    log.success(`Origem ${resp.dropped?.serverId ?? m.sourceServerId} descomissionada. ` +
+        `A janela de rollback foi fechada; o banco vive só em ${m.targetServerId}.`);
+}
+// ---------------------------------------------------------------------------
+// neetru db where  (onde o banco vive) — por --product <slug> ou --db <dbId>
+// ---------------------------------------------------------------------------
+export async function runDbWhere(opts = {}) {
+    if (!opts.json)
+        log.banner();
+    await requireToken(opts.json);
+    if (opts.db) {
+        let resp;
+        try {
+            resp = await apiRequest(`/api/cli/v1/db/${encodeURIComponent(opts.db)}/get`);
+        }
+        catch (err) {
+            handleApiError(err, opts.json);
+        }
+        if (opts.json) {
+            console.log(JSON.stringify(resp));
+            return;
+        }
+        const d = resp.database;
+        log.heading(`Banco ${d.id}`);
+        log.info(`Produto:  ${d.productId ?? '—'}`);
+        log.info(`Engine:   ${d.engine ?? '—'}`);
+        log.info(`Ambiente: ${d.environment ?? d.env ?? '—'}`);
+        log.info(`Status:   ${d.status ?? '—'}`);
+        log.info(`VM:       ${d.serverId ? chalk.bold(d.serverId) : chalk.dim('(sem VM — engine gerenciado)')}`);
+        if (d.endpoint)
+            log.info(`Endpoint: ${d.endpoint}`);
+        return;
+    }
+    if (!opts.product) {
+        const msg = 'Informe --product <slug> ou --db <dbId>.';
+        if (opts.json)
+            console.log(JSON.stringify({ ok: false, error: 'input', message: msg }));
+        else
+            log.error(msg);
+        safeExit(1);
+    }
+    const qs = `?productId=${encodeURIComponent(opts.product)}`;
+    let list;
+    try {
+        list = await apiRequest(`/api/cli/v1/db${qs}`);
+    }
+    catch (err) {
+        handleApiError(err, opts.json);
+    }
+    let dbs = list.databases ?? [];
+    if (opts.env)
+        dbs = dbs.filter((d) => (d.environment ?? d.env) === opts.env);
+    if (opts.json) {
+        console.log(JSON.stringify({ ok: true, count: dbs.length, databases: dbs }));
+        return;
+    }
+    log.heading(`Bancos do produto "${opts.product}" (${dbs.length})`);
+    renderTable([
+        { header: 'ID', value: (r) => r.id, maxWidth: 24 },
+        { header: 'ENGINE', value: (r) => r.engine ?? '—', maxWidth: 20 },
+        { header: 'ENV', value: (r) => r.environment ?? r.env ?? '—', maxWidth: 12 },
+        { header: 'STATUS', value: (r) => r.status ?? '—', maxWidth: 14 },
+        { header: 'VM (onde vive)', value: (r) => r.serverId ?? '—', maxWidth: 20 },
+    ], dbs);
+}
+//# sourceMappingURL=db-move.js.map