onveloz 0.0.0-beta.18 → 0.0.0-beta.19

package/dist/index.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { Cli, middleware, z } from "incur";
-import { exec, execSync } from "node:child_process";
+import { exec, execFile, execSync } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { dirname, join, relative, resolve } from "node:path";
 import { z as z$1 } from "zod";
@@ -174,8 +174,9 @@ function getDatabaseSizeOptions(engine) {
 }
 /** @deprecated Use getDatabaseSizeOptions(engine) instead. */
 const DATABASE_SIZE_OPTIONS = getDatabaseSizeOptions("postgresql");
-function resolveDatabaseSize(cpu, memory) {
-	for (const [key, tier] of Object.entries(DATABASE_SIZES)) if (tier.cpu === cpu && tier.memory === memory) return key;
+function resolveDatabaseSize(cpu, memory, engine) {
+	const sizes = engine ? DATABASE_SIZES_BY_ENGINE[engine] : DATABASE_SIZES;
+	for (const [key, tier] of Object.entries(sizes)) if (tier.cpu === cpu && tier.memory === memory) return key;
 	return null;
 }
 
@@ -278,7 +279,9 @@ const ServiceConfigSchema = z$1.object({
 	runtime: RuntimeConfigSchema.optional(),
 	env: z$1.record(z$1.string().regex(/^[A-Z][A-Z0-9_]*$/), EnvVarDefinitionSchema).optional(),
 	volumes: z$1.array(VolumeConfigSchema).optional(),
-	resources: ResourcesSchema.optional()
+	resources: ResourcesSchema.optional(),
+	ignore: z$1.string().optional(),
+	watch: z$1.array(z$1.string()).optional()
 });
 const ProjectConfigSchema = z$1.object({
 	id: z$1.string(),
@@ -603,6 +606,34 @@ async function withSpinner(opts) {
 function isInteractive() {
 	return process.stdout.isTTY === true && process.stdin.isTTY === true;
 }
+/**
+* Gate for destructive actions in non-interactive (MCP) mode.
+*
+* Forces AI agents to:
+*   1. Explain the action to the user first
+*   2. Ask the user for explicit approval
+*   3. Copy the user's approval text into --userConfirmation
+*
+* In interactive (TTY) mode this is a no-op — the normal promptConfirm
+* flow handles confirmation.
+*/
+function requireMcpConfirmation(userConfirmation, action) {
+	if (isInteractive()) return;
+	if (!userConfirmation) throw new Error(`Ação destrutiva: ${action}. ANTES de executar esta ação, você DEVE:
+1. Explicar ao usuário exatamente o que esta ação faz e quais são as consequências
+2. Aguardar o usuário confirmar explicitamente com uma mensagem de aprovação
+3. Copiar a resposta de confirmação do usuário no parâmetro --userConfirmation
+
+NÃO execute esta ação sem aprovação explícita do usuário. O parâmetro --yes NÃO substitui --userConfirmation.`);
+}
+/**
+* Whether the current non-interactive confirmation came from --userConfirmation
+* (valid) vs only --yes (not sufficient in MCP mode).
+*/
+function hasValidNonInteractiveConfirmation(userConfirmation, yes) {
+	if (isMcpMode()) return !!userConfirmation;
+	return yes || !!userConfirmation;
+}
 async function prompt(question) {
 	if (!isInteractive()) return "";
 	const rl = createInterface({
@@ -655,7 +686,7 @@ async function promptMultiSelect(question, options) {
 
 //#endregion
 //#region src/commands/login.ts
-function openBrowser(url) {
+function openBrowser$1(url) {
 	const os = platform();
 	exec(os === "darwin" ? `open "${url}"` : os === "win32" ? `start "" "${url}"` : `xdg-open "${url}"`, () => {});
 }
@@ -683,7 +714,7 @@ async function performLogin(apiUrl) {
 	console.log(chalk.dim("  Se o navegador não abrir, acesse manualmente:"));
 	console.log(chalk.dim(`  ${verificationUrl}`));
 	console.log();
-	openBrowser(verificationUrl);
+	openBrowser$1(verificationUrl);
 	const pollSpinner = spinner("Aguardando autorização no navegador...");
 	const token = await pollForToken(authClient, data.device_code, data.interval || 5);
 	if (!token) {
@@ -1117,19 +1148,26 @@ envGroup.command("set", {
 		}
 		spin.stop();
 		for (const w of allWarnings) warn(w);
-		if (pares.length === 1) {
-			const key = pares[0].slice(0, pares[0].indexOf("="));
-			success(`Variável ${chalk.bold(key)} definida com sucesso.`);
-		} else success(`${pares.length} variáveis definidas com sucesso.`);
+		const keys = pares.map((p) => p.slice(0, p.indexOf("=")));
+		if (pares.length === 1) success(`Variável ${chalk.bold(keys[0])} definida com sucesso.`);
+		else success(`${pares.length} variáveis definidas com sucesso.`);
 		info("Faça um novo deploy para aplicar as alterações.");
+		return {
+			count: pares.length,
+			keys
+		};
 	}
 });
 envGroup.command("delete", {
 	description: "Remover variável de ambiente",
 	middleware: [requireAuth],
 	args: z.object({ chave: z.string().describe("Chave da variável de ambiente") }),
-	options: z.object({ service: z.string().optional().describe("Serviço alvo (chave ou nome)") }),
+	options: z.object({
+		service: z.string().optional().describe("Serviço alvo (chave ou nome)"),
+		userConfirmation: z.string().optional()
+	}),
 	async run(c) {
+		requireMcpConfirmation(c.options.userConfirmation, `remover variável de ambiente "${c.args.chave}"`);
 		const serviceId = await resolveServiceId(c.options.service);
 		const client = await getClient();
 		await withSpinner({
@@ -1141,6 +1179,10 @@ envGroup.command("delete", {
 		});
 		success(`Variável ${chalk.bold(c.args.chave)} removida com sucesso.`);
 		info("Faça um novo deploy para aplicar as alterações.");
+		return {
+			deleted: true,
+			key: c.args.chave
+		};
 	}
 });
 envGroup.command("import", {
@@ -1149,9 +1191,11 @@ envGroup.command("import", {
 	args: z.object({ arquivo: z.string().optional().describe("Caminho do arquivo .env") }),
 	options: z.object({
 		replace: z.boolean().default(false).describe("Substituir todas as variáveis existentes"),
-		service: z.string().optional().describe("Serviço alvo (chave ou nome)")
+		service: z.string().optional().describe("Serviço alvo (chave ou nome)"),
+		userConfirmation: z.string().optional()
 	}),
 	async run(c) {
+		if (c.options.replace) requireMcpConfirmation(c.options.userConfirmation, "substituir TODAS as variáveis de ambiente existentes");
 		const serviceId = await resolveServiceId(c.options.service);
 		const client = await getClient();
 		let envContent = "";
@@ -1220,6 +1264,11 @@ envGroup.command("import", {
 		if (result.warnings) for (const w of result.warnings) warn(w);
 		success(`${varsCount} variável(is) importada(s) com sucesso!`);
 		info("Faça um novo deploy para aplicar as alterações.");
+		return {
+			imported: true,
+			count: varsCount,
+			keys: Object.keys(envVars)
+		};
 	}
 });
 envGroup.command("export", {
@@ -1337,6 +1386,11 @@ domainsGroup.command("add", {
 		console.log(chalk.white(`  ${result.dnsInstruction}`));
 		console.log();
 		info(`Após configurar o DNS, execute: ${chalk.bold(`veloz domains verify ${result.id}`)}`);
+		return {
+			id: result.id,
+			domain: c.args.dominio,
+			dnsInstruction: result.dnsInstruction
+		};
 	}
 });
 domainsGroup.command("verify", {
@@ -1354,19 +1408,30 @@ domainsGroup.command("verify", {
 			console.log(chalk.yellow(`\n⚠ Certificado TLS de ${chalk.bold(result.domain.domain)} ainda sendo provisionado.`));
 			info("Verifique se o CNAME foi configurado para cname.onveloz.com.");
 		}
+		return {
+			ready: result.ready,
+			domain: result.domain.domain,
+			tlsStatus: result.domain.tlsStatus
+		};
 	}
 });
 domainsGroup.command("delete", {
 	description: "Remover domínio",
 	middleware: [requireAuth],
 	args: z.object({ domainId: z.string().describe("ID do domínio") }),
+	options: z.object({ userConfirmation: z.string().optional() }),
 	async run(c) {
+		requireMcpConfirmation(c.options.userConfirmation, `remover domínio "${c.args.domainId}"`);
 		const client = await getClient();
 		await withSpinner({
 			text: "Removendo domínio...",
 			fn: () => client.domains.delete({ domainId: c.args.domainId })
 		});
 		success("Domínio removido com sucesso.");
+		return {
+			deleted: true,
+			domainId: c.args.domainId
+		};
 	}
 });
 
@@ -1517,6 +1582,12 @@ volumesGroup.command("create", {
 			});
 			success("Serviço reiniciando com os volumes atualizados.");
 		} else await promptAndSyncDeployment(service.id);
+		return {
+			id: volume.id,
+			name: volume.name,
+			mountPath: volume.mountPath,
+			sizeGb: volume.sizeGb
+		};
 	}
 });
 volumesGroup.command("expand", {
@@ -1545,6 +1616,11 @@ volumesGroup.command("expand", {
 			sizeGb
 		} : entry));
 		success(`Volume ${chalk.bold(volume.name)} expandido para ${sizeGb} GB.`);
+		return {
+			id: volume.id,
+			name: volume.name,
+			sizeGb
+		};
 	}
 });
 volumesGroup.command("delete", {
@@ -1554,13 +1630,15 @@ volumesGroup.command("delete", {
 	options: z.object({
 		service: z.string().optional().describe("Serviço alvo (chave ou nome)"),
 		restart: z.boolean().default(false).describe("Reiniciar o serviço imediatamente após remover"),
-		yes: z.boolean().default(false).describe("Pular confirmação")
+		yes: z.boolean().default(false).describe("Pular confirmação"),
+		userConfirmation: z.string().optional()
 	}),
 	async run(c) {
 		const { key, service } = await resolveService(c.options.service);
 		const client = await getClient();
 		const volume = await resolveRemoteVolume(service.id, c.args.volume);
-		if (!(isInteractive() ? await promptConfirm(`Remover volume ${chalk.bold(volume.name)} (${volume.mountPath}) do serviço? Os dados serão mantidos por 30 dias.`, false) : c.options.yes === true)) {
+		requireMcpConfirmation(c.options.userConfirmation, `remover volume "${volume.name}" do serviço`);
+		if (!(isInteractive() ? await promptConfirm(`Remover volume ${chalk.bold(volume.name)} (${volume.mountPath}) do serviço? Os dados serão mantidos por 30 dias.`, false) : hasValidNonInteractiveConfirmation(c.options.userConfirmation, c.options.yes))) {
 			info("Operação cancelada.");
 			return;
 		}
@@ -1578,6 +1656,10 @@ volumesGroup.command("delete", {
 			});
 			success("Serviço reiniciando sem o volume.");
 		} else await promptAndSyncDeployment(service.id);
+		return {
+			deleted: true,
+			name: volume.name
+		};
 	}
 });
 volumesGroup.command("sync", {
@@ -1592,6 +1674,10 @@ volumesGroup.command("sync", {
 			fn: () => client.volumes.syncDeployment({ serviceId: service.id })
 		});
 		success("Serviço reiniciando com os volumes atualizados.");
+		return {
+			synced: true,
+			serviceId: service.id
+		};
 	}
 });
 
@@ -1721,6 +1807,7 @@ configGroup.command("set", {
 		}
 		console.log();
 		info("Execute 'veloz deploy' para aplicar as mudanças.");
+		return { updated: updates };
 	}
 });
 configGroup.command("edit", {
@@ -1768,6 +1855,7 @@ configGroup.command("edit", {
 		});
 		success("Configurações atualizadas com sucesso!");
 		info("Execute 'veloz deploy' para aplicar as mudanças.");
+		return { updated: updates };
 	}
 });
 configGroup.command("reset", {
@@ -1778,9 +1866,11 @@ configGroup.command("reset", {
 		start: z.boolean().default(false).describe("Resetar comando de start"),
 		preStart: z.boolean().default(false).describe("Resetar comando de pre-start"),
 		all: z.boolean().default(false).describe("Resetar todas as configurações opcionais"),
-		service: z.string().optional().describe("Serviço alvo (chave ou nome)")
+		service: z.string().optional().describe("Serviço alvo (chave ou nome)"),
+		userConfirmation: z.string().optional()
 	}),
 	async run(c) {
+		requireMcpConfirmation(c.options.userConfirmation, "resetar configurações para os padrões");
 		const serviceId = await resolveServiceId(c.options.service);
 		const client = await getClient();
 		const updates = {};
@@ -1807,6 +1897,7 @@ configGroup.command("reset", {
 		});
 		success("Configurações resetadas para os padrões!");
 		info("Execute 'veloz deploy' para aplicar as mudanças.");
+		return { reset: Object.keys(updates) };
 	}
 });
 
@@ -2101,6 +2192,12 @@ dbGroup.command("create", {
 			});
 			info(`Adicionado ao ${getConfigFileName()}.`);
 		}
+		return {
+			id: db.id,
+			name: db.name,
+			engine: validEngine,
+			engineVersion: version ?? null
+		};
 	}
 });
 dbGroup.command("credentials", {
@@ -2137,10 +2234,14 @@ dbGroup.command("delete", {
 	description: "Excluir um banco de dados",
 	middleware: [requireAuth],
 	args: z.object({ name: z.string().describe("Nome ou ID do banco de dados") }),
-	options: z.object({ yes: z.boolean().default(false).describe("Pular confirmação") }),
+	options: z.object({
+		yes: z.boolean().default(false).describe("Pular confirmação"),
+		userConfirmation: z.string().optional()
+	}),
 	async run(c) {
 		const db = await resolveDatabaseByName(getProjectId$1(), c.args.name);
-		if (!c.options.yes) {
+		requireMcpConfirmation(c.options.userConfirmation, `excluir banco de dados "${db.name}"`);
+		if (!c.options.yes && !c.options.userConfirmation) {
 			if (!isInteractive()) throw new Error("Use --yes para confirmar a exclusão em modo não-interativo.");
 			warn(`Você está prestes a excluir o banco de dados "${db.name}".`);
 			console.log(chalk.red("  Esta ação é irreversível!\n"));
@@ -2174,20 +2275,31 @@ dbGroup.command("delete", {
 				info(`Removido do ${getConfigFileName()}.`);
 			}
 		}
+		return {
+			deleted: true,
+			name: db.name,
+			dependentServices: result.dependentServices.map((d) => d.name)
+		};
 	}
 });
 dbGroup.command("restart", {
 	description: "Reiniciar um banco de dados",
 	middleware: [requireAuth],
 	args: z.object({ name: z.string().describe("Nome ou ID do banco de dados") }),
+	options: z.object({ userConfirmation: z.string().optional() }),
 	async run(c) {
 		const db = await resolveDatabaseByName(getProjectId$1(), c.args.name);
+		requireMcpConfirmation(c.options.userConfirmation, `reiniciar banco de dados "${db.name}"`);
 		const client = await getClient();
 		await withSpinner({
 			text: "Reiniciando banco de dados...",
 			fn: () => client.databases.restart({ serviceId: db.id })
 		});
 		success(`Banco de dados ${chalk.bold(db.name)} reiniciado com sucesso.`);
+		return {
+			restarted: true,
+			name: db.name
+		};
 	}
 });
 dbGroup.command("update", {
@@ -2312,7 +2424,10 @@ dbGroup.command("update", {
 		}
 		if (!updated) {
 			info("Nenhuma alteração realizada.");
-			return;
+			return {
+				updated: false,
+				changes: {}
+			};
 		}
 		if (loadConfig()) {
 			patchConfig((raw) => {
@@ -2335,6 +2450,15 @@ dbGroup.command("update", {
 			});
 			info(`Atualizado no ${getConfigFileName()}.`);
 		}
+		return {
+			updated: true,
+			changes: {
+				...size ? { size } : {},
+				...storage ? { storage } : {},
+				...poolerEnabled !== void 0 ? { poolerEnabled } : {},
+				...poolMode ? { poolMode } : {}
+			}
+		};
 	}
 });
 dbGroup.command("query", {
@@ -2358,13 +2482,17 @@ dbGroup.command("query", {
 			query
 		});
 		let hasOutput = false;
+		const outputLines = [];
+		const errorLines = [];
 		for await (const event of stream) switch (event.type) {
 			case "output":
 				hasOutput = true;
 				console.log(event.content);
+				outputLines.push(event.content);
 				break;
 			case "error":
 				console.log(chalk.red(event.content));
+				errorLines.push(event.content);
 				break;
 			case "status":
 				if (event.content === "Consulta finalizada.") {
@@ -2373,6 +2501,8 @@ dbGroup.command("query", {
 				}
 				break;
 		}
+		if (errorLines.length > 0) return { error: errorLines.join("\n") };
+		return { output: outputLines.length > 0 ? outputLines.join("\n") : "Consulta executada sem retorno." };
 	}
 });
 const ENGINE_DEFAULT_PORTS = {
@@ -2521,9 +2651,11 @@ templateGroup.command("deploy", {
 	args: z.object({ slug: z.string().describe("Slug do template (ex: n8n, metabase)") }),
 	options: z.object({
 		yes: z.boolean().default(false).describe("Pular confirmação"),
-		name: z.string().optional().describe("Nome do projeto (padrão: nome do template)")
+		name: z.string().optional().describe("Nome do projeto (padrão: nome do template)"),
+		userConfirmation: z.string().optional()
 	}),
 	async run(c) {
+		requireMcpConfirmation(c.options.userConfirmation, `fazer deploy do template "${c.args.slug}"`);
 		const client = await getClient();
 		const template = await withSpinner({
 			text: "Carregando template...",
@@ -2542,7 +2674,7 @@ templateGroup.command("deploy", {
 		}
 		console.log(chalk.dim(`  Um novo projeto será criado para este template${c.options.name ? `: ${c.options.name}` : ""}.`));
 		console.log();
-		if (!c.options.yes) {
+		if (!c.options.yes && !c.options.userConfirmation) {
 			if (!await promptConfirm(`Deseja fazer deploy do template '${template.displayName}'?`, false)) {
 				info("Operação cancelada.");
 				return;
@@ -2565,6 +2697,14 @@ templateGroup.command("deploy", {
 			console.log();
 		}
 		info("O deploy está sendo processado em background. Acompanhe pelo dashboard ou execute " + chalk.bold("veloz services list") + " no diretório do projeto.");
+		return {
+			projectName: result.projectName,
+			projectSlug: result.projectSlug,
+			services: result.services.map((svc) => ({
+				name: svc.name,
+				type: svc.type
+			}))
+		};
 	}
 });
 
@@ -2609,7 +2749,10 @@ servicesGroup.command("delete", {
 	description: "Deletar um serviço",
 	middleware: [requireAuth],
 	args: z.object({ service: z.string().optional().describe("Nome ou ID do serviço") }),
-	options: z.object({ yes: z.boolean().default(false).describe("Pular confirmação") }),
+	options: z.object({
+		yes: z.boolean().default(false).describe("Pular confirmação"),
+		userConfirmation: z.string().optional()
+	}),
 	async run(c) {
 		const projectId = getProjectId();
 		const client = await getClient();
@@ -2641,7 +2784,8 @@ servicesGroup.command("delete", {
 			warn("Nenhum serviço selecionado.");
 			return;
 		}
-		if (!(isInteractive() ? await promptConfirm(`Deletar serviço ${chalk.bold(serviceToDelete.name)} (${serviceToDelete.type})? Esta ação é irreversível.`, false) : c.options.yes === true)) {
+		requireMcpConfirmation(c.options.userConfirmation, `deletar serviço "${serviceToDelete.name}"`);
+		if (!(isInteractive() ? await promptConfirm(`Deletar serviço ${chalk.bold(serviceToDelete.name)} (${serviceToDelete.type})? Esta ação é irreversível.`, false) : hasValidNonInteractiveConfirmation(c.options.userConfirmation, c.options.yes))) {
 			info("Operação cancelada.");
 			return;
 		}
@@ -2650,6 +2794,729 @@ servicesGroup.command("delete", {
 			fn: () => client.services.delete({ serviceId: serviceToDelete.id })
 		});
 		success(`Serviço "${serviceToDelete.name}" deletado com sucesso!`);
+		return {
+			deleted: true,
+			name: serviceToDelete.name,
+			type: serviceToDelete.type
+		};
+	}
+});
+
+//#endregion
+//#region src/lib/sparkline.ts
+/**
+* Unicode sparkline renderer for terminal metrics display.
+* Uses 8-level block characters: ▁▂▃▄▅▆▇█
+*/
+const BLOCKS = [
+	"▁",
+	"▂",
+	"▃",
+	"▄",
+	"▅",
+	"▆",
+	"▇",
+	"█"
+];
+/**
+* Render a series of numeric values as a Unicode sparkline string.
+* Empty or all-zero arrays return a flat line.
+*/
+function sparkline(values) {
+	if (values.length === 0) return "";
+	let min = values[0];
+	let max = values[0];
+	for (const v of values) {
+		if (v < min) min = v;
+		if (v > max) max = v;
+	}
+	const range = max - min;
+	if (range === 0) return BLOCKS[0].repeat(values.length);
+	return values.map((v) => {
+		const normalized = (v - min) / range;
+		return BLOCKS[Math.min(Math.floor(normalized * BLOCKS.length), BLOCKS.length - 1)];
+	}).join("");
+}
+/**
+* Format a number to a compact human-readable string.
+* Examples: 1234 → "1.2k", 0.0035 → "3.5ms"
+*/
+function formatCompact(value, unit) {
+	if (unit === "ms") {
+		if (value < 1) return `${(value * 1e3).toFixed(0)}µs`;
+		if (value < 1e3) return `${value.toFixed(0)}ms`;
+		return `${(value / 1e3).toFixed(1)}s`;
+	}
+	if (unit === "s") {
+		if (value < .001) return `${(value * 1e6).toFixed(0)}µs`;
+		if (value < 1) return `${(value * 1e3).toFixed(0)}ms`;
+		return `${value.toFixed(2)}s`;
+	}
+	if (unit === "bytes") {
+		if (value < 1024) return `${value.toFixed(0)}B`;
+		if (value < 1024 * 1024) return `${(value / 1024).toFixed(1)}KB`;
+		if (value < 1024 * 1024 * 1024) return `${(value / (1024 * 1024)).toFixed(1)}MB`;
+		return `${(value / (1024 * 1024 * 1024)).toFixed(1)}GB`;
+	}
+	if (value === 0) return "0";
+	if (Math.abs(value) < .01) return value.toExponential(1);
+	if (Math.abs(value) < 1) return value.toFixed(2);
+	if (Math.abs(value) < 1e3) return value.toFixed(1);
+	if (Math.abs(value) < 1e6) return `${(value / 1e3).toFixed(1)}k`;
+	return `${(value / 1e6).toFixed(1)}M`;
+}
+
+//#endregion
+//#region src/commands/metrics.ts
+function statusColor(code) {
+	if (code.startsWith("2")) return chalk.green;
+	if (code.startsWith("3")) return chalk.cyan;
+	if (code.startsWith("4")) return chalk.yellow;
+	if (code.startsWith("5")) return chalk.red;
+	return chalk.dim;
+}
+function rateColor(errorRate) {
+	if (errorRate === 0) return chalk.green;
+	if (errorRate < 1) return chalk.yellow;
+	return chalk.red;
+}
+function seriesValues(points) {
+	return points.map((p) => p.value);
+}
+function labeledValues(series) {
+	return series.data.map((p) => p.value);
+}
+function latestValue(values) {
+	return values[values.length - 1] ?? 0;
+}
+function printSparkline(label, values, suffix, width) {
+	const latest = latestValue(values);
+	console.log(`  ${label.padEnd(width)} ${sparkline(values)}  ${chalk.bold(`${formatCompact(latest)}${suffix}`)}`);
+}
+const metricsGroup = Cli.create("metrics", { description: "Visualizar métricas dos serviços" });
+metricsGroup.command("show", {
+	description: "Exibir métricas atuais do serviço",
+	middleware: [requireAuth],
+	options: z.object({ service: z.string().optional().describe("Filtrar por serviço") }),
+	output: z.object({
+		requestRate: z.number(),
+		errorRate: z.number(),
+		latencyP95: z.number(),
+		statusCodes: z.record(z.string(), z.number()),
+		grafanaDashboardUrl: z.string().nullable()
+	}),
+	async run(c) {
+		const serviceId = await resolveServiceId(c.options.service);
+		const client = await getClient();
+		const metrics = await withSpinner({
+			text: "Carregando métricas...",
+			fn: () => client.metrics.getServiceMetrics({ serviceId })
+		});
+		if (process.stdout.isTTY) {
+			console.log();
+			console.log(chalk.bold("  Métricas do Serviço"));
+			console.log();
+			console.log(`  Requisições/min   ${chalk.bold(formatCompact(metrics.requestRate))}`);
+			console.log(`  Erros/min         ${rateColor(metrics.errorRate)(formatCompact(metrics.errorRate))}`);
+			console.log(`  Latência P95      ${chalk.bold(formatCompact(metrics.latencyP95, "s"))}`);
+			const codes = Object.entries(metrics.statusCodes);
+			if (codes.length > 0) {
+				console.log();
+				console.log(chalk.dim("  Status HTTP:"));
+				for (const [code, count] of codes.sort(([a], [b]) => a.localeCompare(b))) console.log(`    ${statusColor(code)(code)}  ${formatCompact(count)}`);
+			}
+			if (metrics.grafanaDashboardUrl) {
+				console.log();
+				info(`Dashboard: ${chalk.underline(metrics.grafanaDashboardUrl)}`);
+			}
+			console.log();
+		}
+		return metrics;
+	}
+});
+metricsGroup.command("range", {
+	description: "Exibir métricas em intervalo de tempo com sparklines",
+	middleware: [requireAuth],
+	options: z.object({
+		service: z.string().optional().describe("Filtrar por serviço"),
+		range: z.enum([
+			"1h",
+			"6h",
+			"24h",
+			"7d"
+		]).default("1h").describe("Intervalo de tempo (1h, 6h, 24h, 7d)")
+	}),
+	alias: { range: "r" },
+	async run(c) {
+		const serviceId = await resolveServiceId(c.options.service);
+		const client = await getClient();
+		const data = await withSpinner({
+			text: `Carregando métricas (${c.options.range})...`,
+			fn: () => client.metrics.getServiceMetricsRange({
+				serviceId,
+				range: c.options.range
+			})
+		});
+		if (process.stdout.isTTY) {
+			const W = 20;
+			const rangeLabel = chalk.dim(`(últimas ${c.options.range})`);
+			console.log();
+			console.log(chalk.bold(`  Métricas ${rangeLabel}`));
+			console.log();
+			if (data.requestRate.length > 0) {
+				const v = seriesValues(data.requestRate);
+				console.log(`  ${"Req/min".padEnd(W)} ${sparkline(v)}  ${chalk.bold(formatCompact(latestValue(v)))}`);
+			}
+			if (data.latencyP95.length > 0) {
+				const v = seriesValues(data.latencyP95);
+				console.log(`  ${"Latência P95".padEnd(W)} ${sparkline(v)}  ${chalk.bold(formatCompact(latestValue(v), "s"))}`);
+			}
+			if (data.latencyP50.length > 0) {
+				const v = seriesValues(data.latencyP50);
+				console.log(`  ${"Latência P50".padEnd(W)} ${sparkline(v)}  ${chalk.bold(formatCompact(latestValue(v), "s"))}`);
+			}
+			for (const series of data.cpuUsage) printSparkline(`CPU (${series.label})`, labeledValues(series), "m", W);
+			for (const series of data.memoryUsage) printSparkline(`Memória (${series.label})`, labeledValues(series), "Mi", W);
+			if (data.networkIn.length > 0) printSparkline("Rede ↓", seriesValues(data.networkIn), "KB/s", W);
+			if (data.networkOut.length > 0) printSparkline("Rede ↑", seriesValues(data.networkOut), "KB/s", W);
+			console.log();
+		}
+		return data;
+	}
+});
+const METRICS_HELP_SECTIONS = [
+	{
+		title: "Métricas disponíveis",
+		content: `  metrics show                Snapshot instantâneo do serviço
+  metrics range               Séries temporais com sparklines no terminal`
+	},
+	{
+		title: "metrics show — campos retornados",
+		content: `  requestRate                Requisições por minuto (req/min)
+  errorRate                  Erros 5xx por minuto
+  latencyP95                 Latência percentil 95 (segundos)
+  statusCodes                Mapa de código HTTP → contagem (ex: {"200": 1500, "404": 12})
+  grafanaDashboardUrl        URL do dashboard Grafana (pode ser null)`
+	},
+	{
+		title: "metrics range — séries temporais retornadas",
+		content: `  Tráfego (Traefik):
+    requestRate              [{timestamp, value}]  — req/min ao longo do tempo
+    latencyP50               [{timestamp, value}]  — latência mediana
+    latencyP95               [{timestamp, value}]  — latência P95
+    latencyP99               [{timestamp, value}]  — latência P99
+    statusCodes              [{label, data}]       — série por código HTTP
+
+  Recursos (por instância):
+    cpuUsage                 [{label, data}]       — millicores por instância
+    memoryUsage              [{label, data}]       — MiB por instância
+    networkIn                [{timestamp, value}]  — KB/s entrada
+    networkOut               [{timestamp, value}]  — KB/s saída`
+	},
+	{
+		title: "Intervalos de tempo (--range)",
+		content: `  1h                         Última hora (padrão)
+  6h                         Últimas 6 horas
+  24h                        Últimas 24 horas
+  7d                         Últimos 7 dias`
+	},
+	{
+		title: "Tipos de dados",
+		content: `  TimeSeriesPoint            { timestamp: number, value: number }
+  LabeledTimeSeries          { label: string, data: TimeSeriesPoint[] }
+                             label identifica a instância (ex: "web-abc12")`
+	},
+	{
+		title: "Exemplos de uso",
+		content: `  veloz metrics show                          Métricas atuais (serviço padrão)
+  veloz metrics show --service api             Métricas da API
+  veloz metrics range                          Sparklines última hora
+  veloz metrics range --range 24h              Sparklines últimas 24h
+  veloz metrics range --range 7d --service web Sparklines 7 dias do frontend`
+	},
+	{
+		title: "Workflow para agentes IA",
+		content: `  1. veloz metrics show          → verificar saúde geral
+  2. Se errorRate > 0:
+     veloz logs search "error"   → investigar causa dos erros
+  3. veloz metrics range --range 1h → verificar tendência recente
+  4. Se latencyP95 alto:
+     veloz metrics range --range 24h → comparar com padrão do dia`
+	}
+];
+metricsGroup.command("help", {
+	description: "Referência de métricas disponíveis e seus campos",
+	output: z.object({ sections: z.array(z.object({
+		title: z.string(),
+		content: z.string()
+	})) }),
+	async run() {
+		if (process.stdout.isTTY) {
+			console.log();
+			console.log(chalk.bold("  Referência de Métricas"));
+			console.log(chalk.dim("  Dados disponíveis via metrics show e metrics range"));
+			console.log();
+			for (const section of METRICS_HELP_SECTIONS) {
+				console.log(chalk.bold.underline(`  ${section.title}`));
+				console.log();
+				console.log(section.content);
+				console.log();
+			}
+			console.log(chalk.dim("  Uso: veloz metrics show [--service NOME] | veloz metrics range [--range 1h|6h|24h|7d]"));
+			console.log();
+		}
+		return { sections: METRICS_HELP_SECTIONS };
+	}
+});
+
+//#endregion
+//#region src/commands/logs.ts
+function formatTime(timestamp) {
+	return chalk.dim(new Date(timestamp).toLocaleTimeString("pt-BR"));
+}
+async function streamFollow(services, maxNameLen, tailLines) {
+	const client = await getClient();
+	const showTags = services.length > 1;
+	const collected = [];
+	const streams = services.map(async ({ service, index }) => {
+		const tag = showTags ? `${getServiceTag(service.name, maxNameLen, index)} ` : "";
+		if (!service.id) {
+			console.error(`${tag}${chalk.red("ID do serviço ausente para")} ${service.name}`);
+			return;
+		}
+		try {
+			const stream = await client.logs.streamRuntime({
+				serviceId: service.id,
+				tailLines: Math.ceil(tailLines / services.length)
+			});
+			for await (const entry of stream) {
+				const line = `${tag}${formatTime(entry.timestamp)} ${entry.message}`;
+				console.log(line);
+				collected.push(`${tag}${entry.timestamp} ${entry.message}`);
+			}
+		} catch (err) {
+			console.error(`${tag}${chalk.red("Erro ao conectar ao stream de logs:")} ${err instanceof Error ? err.message : String(err)}`);
+		}
+	});
+	await Promise.allSettled(streams);
+	return collected;
+}
+async function fetchRecent(services, maxNameLen, tailLines) {
+	const client = await getClient();
+	const showTags = services.length > 1;
+	const allEntries = (await Promise.allSettled(services.map(async ({ service, index }) => {
+		if (!service.id) return [];
+		return (await client.logs.getRecent({
+			serviceId: service.id,
+			tailLines
+		})).map((e) => ({
+			...e,
+			serviceIndex: index,
+			serviceName: service.name
+		}));
+	}))).filter((r) => r.status === "fulfilled").flatMap((r) => r.value).sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+	if (allEntries.length === 0) {
+		info("Nenhum log encontrado.");
+		return [];
+	}
+	console.log();
+	for (const entry of allEntries) {
+		const tag = showTags ? `${getServiceTag(entry.serviceName, maxNameLen, entry.serviceIndex)} ` : "";
+		console.log(`${tag}${formatTime(entry.timestamp)} ${entry.message}`);
+	}
+	console.log();
+	info(`Mostrando ${allEntries.length} linha(s). Use ${chalk.bold("--follow")} para acompanhar em tempo real.`);
+	return allEntries.map((entry) => {
+		return `${showTags ? `[${entry.serviceName}] ` : ""}${entry.timestamp} ${entry.message}`;
+	});
+}
+const logsGroup = Cli.create("logs", { description: "Visualizar logs dos serviços" });
+logsGroup.command("show", {
+	description: "Visualizar logs recentes ou acompanhar em tempo real",
+	middleware: [requireAuth],
+	options: z.object({
+		follow: z.boolean().optional().describe("Acompanhar logs em tempo real"),
+		tail: z.number().default(50).describe("Número de linhas recentes"),
+		service: z.string().optional().describe("Filtrar por serviço")
+	}),
+	alias: {
+		follow: "f",
+		tail: "n"
+	},
+	async run(c) {
+		const spin = spinner("Carregando logs...");
+		const { services, maxNameLen } = resolveAllServices(c.options.service);
+		const tailLines = c.options.tail;
+		if (c.options.follow) {
+			spin.text = services.length > 1 ? `Conectando a ${services.length} serviço(s)...` : "Conectando ao streaming de logs...";
+			spin.stop();
+			info("Streaming de logs ativo. Pressione Ctrl+C para sair.\n");
+			const lines$1 = await streamFollow(services, maxNameLen, tailLines);
+			return lines$1.length > 0 ? lines$1.join("\n") : "Nenhum log encontrado.";
+		}
+		spin.stop();
+		const lines = await fetchRecent(services, maxNameLen, tailLines);
+		return lines.length > 0 ? lines.join("\n") : "Nenhum log encontrado.";
+	}
+});
+logsGroup.command("search", {
+	description: "Pesquisar logs com consultas LogsQL",
+	middleware: [requireAuth],
+	args: z.object({ query: z.string().default("").describe("Consulta LogsQL (ex: error, ~\"regex\", field:value)") }),
+	options: z.object({
+		service: z.string().optional().describe("Filtrar por serviço"),
+		start: z.string().optional().describe("Data/hora início (ISO 8601)"),
+		end: z.string().optional().describe("Data/hora fim (ISO 8601)"),
+		limit: z.number().default(100).describe("Número máximo de resultados"),
+		deployment: z.string().optional().describe("Filtrar por ID do deploy")
+	}),
+	alias: { limit: "l" },
+	output: z.array(z.object({
+		timestamp: z.string(),
+		pod: z.string(),
+		message: z.string()
+	})),
+	async run(c) {
+		const serviceId = await resolveServiceId(c.options.service);
+		const entries = await (await getClient()).logs.search({
+			serviceId,
+			query: c.args.query,
+			start: c.options.start,
+			end: c.options.end,
+			limit: c.options.limit,
+			deploymentId: c.options.deployment
+		});
+		if (process.stdout.isTTY) if (entries.length === 0) info("Nenhum log encontrado para essa consulta.");
+		else {
+			console.log();
+			for (const entry of entries) console.log(`${formatTime(entry.timestamp)} ${entry.message}`);
+			console.log();
+			info(`${entries.length} resultado(s) encontrado(s).`);
+		}
+		return entries;
+	}
+});
+const QUERY_HELP_SECTIONS = [
+	{
+		title: "Filtros básicos",
+		content: `  palavra           Busca por palavra em qualquer campo
+  "frase exata"     Busca por frase exata
+  exact("texto")    Match exato (sem tokenização)
+  prefix("iní")     Busca por prefixo
+  ~"regex"          Expressão regular (RE2 syntax)`
+	},
+	{
+		title: "Filtros por campo",
+		content: `  campo:valor       Match exato no campo
+  campo:~"regex"    Regex no campo
+  campo:*           Campo existe (não vazio)`
+	},
+	{
+		title: "Filtros por tempo",
+		content: `  _time:5m          Últimos 5 minutos
+  _time:1h          Última hora
+  _time:24h         Últimas 24 horas
+  _time:[início, fim]  Intervalo ISO 8601`
+	},
+	{
+		title: "Operadores lógicos",
+		content: `  termo1 termo2     AND implícito (espaço)
+  termo1 OR termo2  OR explícito
+  NOT termo          Negação
+  -termo            Negação (atalho)
+  !termo            Negação (atalho)`
+	},
+	{
+		title: "Pipes",
+		content: `  | stats count() by (campo)    Agregar por campo
+  | sort by (campo) desc        Ordenar resultados
+  | uniq by (campo)             Valores únicos
+  | top N by (campo)            Top N por campo
+  | fields campo1, campo2       Selecionar campos
+  | limit N                     Limitar resultados
+  | extract "padrão"            Extrair campos com regex
+  | unpack_json                 Expandir JSON embarcado
+  | math expr                   Calcular expressões
+  | format "template"           Formatar saída
+  | filter condição             Filtrar pós-processamento
+  | replace ("de", "para")      Substituir texto
+  | replace_regexp ("re", "sub") Substituir com regex`
+	},
+	{
+		title: "Funções de agregação (stats)",
+		content: `  count()           Contagem
+  sum(campo)        Soma
+  avg(campo)        Média
+  min(campo)        Mínimo
+  max(campo)        Máximo
+  median(campo)     Mediana
+  quantile(N, campo) Percentil
+  count_uniq(campo)  Valores únicos
+  uniq_values(campo) Lista valores únicos
+  rate(campo)       Taxa por segundo`
+	},
+	{
+		title: "Exemplos práticos",
+		content: `  error                                   Logs com "error"
+  "connection refused"                    Frase exata
+  error NOT timeout                       Erros exceto timeouts
+  ~"status=[45]\\d{2}"                     Status 4xx/5xx via regex
+  _time:1h error | stats count() by (level)  Contagem de erros por nível na última hora
+  _time:24h | top 10 by (message)         Top 10 mensagens do dia
+  error | sort by (_time) desc | limit 50 Últimos 50 erros`
+	}
+];
+logsGroup.command("query-help", {
+	description: "Referência de sintaxe LogsQL para pesquisa de logs",
+	output: z.object({ sections: z.array(z.object({
+		title: z.string(),
+		content: z.string()
+	})) }),
+	async run() {
+		if (process.stdout.isTTY) {
+			console.log();
+			console.log(chalk.bold("  Referência LogsQL"));
+			console.log(chalk.dim("  Sintaxe de consulta para pesquisa de logs"));
+			console.log();
+			for (const section of QUERY_HELP_SECTIONS) {
+				console.log(chalk.bold.underline(`  ${section.title}`));
+				console.log();
+				console.log(section.content);
+				console.log();
+			}
+			console.log(chalk.dim("  Uso: veloz logs search <consulta> [--start ISO] [--end ISO] [--limit N]"));
+			console.log();
+		}
+		return { sections: QUERY_HELP_SECTIONS };
+	}
+});
+
+//#endregion
+//#region src/commands/github.ts
+function openBrowser(url) {
+	const os = platform();
+	execFile(os === "darwin" ? "open" : os === "win32" ? "start" : "xdg-open", os === "win32" ? ["", url] : [url], (error) => {
+		if (error) warn(`Não foi possível abrir o navegador: ${error.message}`);
+	});
+}
+const githubGroup = Cli.create("github", { description: "Gerenciar integração com GitHub" });
+githubGroup.command("setup", {
+	description: "Configurar GitHub App para deploy automático via webhook",
+	middleware: [requireAuth],
+	options: z.object({ project: z.string().optional().describe("ID do projeto a conectar") }),
+	alias: { project: "p" },
+	output: z.object({
+		connected: z.boolean(),
+		installationId: z.string().nullable(),
+		projectId: z.string().nullable()
+	}),
+	async run(c) {
+		const client = await getClient();
+		const remote = getGitRemote();
+		if (!remote) {
+			warn("Não foi possível detectar o repositório GitHub. Certifique-se de estar em um repositório git com remote 'origin' apontando para o GitHub.");
+			return {
+				connected: false,
+				installationId: null,
+				projectId: null
+			};
+		}
+		info(`Repositório detectado: ${chalk.bold(`${remote.owner}/${remote.repo}`)}`);
+		let projectId = c.options.project;
+		if (!projectId) {
+			const config = loadConfig();
+			if (config?.project?.id) {
+				projectId = config.project.id;
+				info(`Projeto encontrado no veloz.json: ${chalk.bold(config.project.name)}`);
+			}
+		}
+		if (!projectId) {
+			const existingProject = await client.projects.findByRepo({
+				githubRepoOwner: remote.owner,
+				githubRepoName: remote.repo
+			});
+			if (existingProject) {
+				projectId = existingProject.id;
+				info(`Projeto encontrado: ${chalk.bold(existingProject.name)}`);
+			}
+		}
+		if (!projectId) {
+			const projects = await client.projects.list();
+			if (projects.length === 0) {
+				warn("Nenhum projeto encontrado. Crie um projeto primeiro com 'veloz deploy'.");
+				return {
+					connected: false,
+					installationId: null,
+					projectId: null
+				};
+			}
+			projectId = await promptSelect("Selecione o projeto para conectar:", projects.map((p) => ({
+				label: `${p.name} (${p.slug})`,
+				value: p.id
+			})));
+		}
+		const s = spinner("Verificando instalação do GitHub App...");
+		const installation = await client.github.getInstallation({ owner: remote.owner });
+		s.stop();
+		if (installation.error === "TOKEN_EXPIRED") {
+			warn("Token do GitHub expirado. Faça login novamente no dashboard para reconectar sua conta GitHub.");
+			return {
+				connected: false,
+				installationId: null,
+				projectId
+			};
+		}
+		if (installation.error === "RATE_LIMITED") {
+			warn("Limite de requisições do GitHub atingido. Aguarde alguns minutos e tente novamente.");
+			return {
+				connected: false,
+				installationId: null,
+				projectId
+			};
+		}
+		if (installation.installed && installation.installationId) {
+			info(`GitHub App já instalado para ${chalk.bold(remote.owner)}.`);
+			await client.projects.connectRepo({
+				projectId,
+				githubRepoOwner: remote.owner,
+				githubRepoName: remote.repo,
+				githubInstallationId: installation.installationId
+			});
+			success(`Repositório ${remote.owner}/${remote.repo} conectado! Pushes para o branch configurado vão iniciar deploys automaticamente.`);
+			return {
+				connected: true,
+				installationId: installation.installationId,
+				projectId
+			};
+		}
+		if (!installation.installUrl) {
+			warn("GitHub App não configurado no servidor. Contate o administrador da plataforma para configurar o GITHUB_APP_SLUG.");
+			return {
+				connected: false,
+				installationId: null,
+				projectId
+			};
+		}
+		console.log();
+		info(`O GitHub App precisa ser instalado na conta/organização ${chalk.bold(remote.owner)}.`);
+		console.log();
+		if (!await promptConfirm("Abrir o navegador para instalar o GitHub App?")) {
+			console.log();
+			console.log(chalk.dim(`  Instale manualmente em: ${installation.installUrl}`));
+			console.log(chalk.dim("  Depois execute 'veloz github setup' novamente."));
+			return {
+				connected: false,
+				installationId: null,
+				projectId
+			};
+		}
+		openBrowser(installation.installUrl);
+		console.log();
+		info("Aguardando instalação do GitHub App...");
+		console.log(chalk.dim("  Instale o app no navegador e volte aqui."));
+		console.log();
+		const pollSpinner = spinner("Aguardando instalação...");
+		const maxAttempts = 60;
+		const pollInterval = 5e3;
+		let installationId = null;
+		for (let i = 0; i < maxAttempts; i++) {
+			await new Promise((r) => {
+				setTimeout(r, pollInterval);
+			});
+			const check = await client.github.getInstallation({ owner: remote.owner });
+			if (check.installed && check.installationId) {
+				installationId = check.installationId;
+				break;
+			}
+			if (check.error === "TOKEN_EXPIRED") {
+				pollSpinner.fail("Token do GitHub expirou durante a espera.");
+				return {
+					connected: false,
+					installationId: null,
+					projectId
+				};
+			}
+		}
+		pollSpinner.stop();
+		if (!installationId) {
+			warn("Tempo esgotado aguardando instalação. Instale o GitHub App e execute 'veloz github setup' novamente.");
+			return {
+				connected: false,
+				installationId: null,
+				projectId
+			};
+		}
+		await client.projects.connectRepo({
+			projectId,
+			githubRepoOwner: remote.owner,
+			githubRepoName: remote.repo,
+			githubInstallationId: installationId
+		});
+		success(`GitHub App instalado e repositório ${remote.owner}/${remote.repo} conectado! Pushes para o branch configurado vão iniciar deploys automaticamente.`);
+		return {
+			connected: true,
+			installationId,
+			projectId
+		};
+	}
+});
+githubGroup.command("status", {
+	description: "Verificar status da integração GitHub do projeto",
+	middleware: [requireAuth],
+	output: z.object({
+		connected: z.boolean(),
+		owner: z.string().nullable(),
+		repo: z.string().nullable(),
+		installationId: z.string().nullable()
+	}),
+	async run() {
+		const config = loadConfig();
+		if (!config?.project?.id) {
+			warn("Nenhum projeto encontrado. Execute 'veloz link' ou 'veloz deploy' primeiro.");
+			return {
+				connected: false,
+				owner: null,
+				repo: null,
+				installationId: null
+			};
+		}
+		const project = (await (await getClient()).projects.list()).find((p) => p.id === config.project.id);
+		if (!project) {
+			warn("Projeto não encontrado na plataforma.");
+			return {
+				connected: false,
+				owner: null,
+				repo: null,
+				installationId: null
+			};
+		}
+		if (!project.githubRepoOwner || !project.githubRepoName) {
+			info("Repositório GitHub não conectado.");
+			console.log(chalk.dim("  Execute 'veloz github setup' para conectar."));
+			return {
+				connected: false,
+				owner: null,
+				repo: null,
+				installationId: null
+			};
+		}
+		const hasInstallation = !!project.githubInstallationId;
+		console.log();
+		info(`Repositório: ${chalk.bold(`${project.githubRepoOwner}/${project.githubRepoName}`)}`);
+		if (hasInstallation) {
+			console.log(chalk.green("  GitHub App: instalado"));
+			console.log(chalk.dim(`  Installation ID: ${project.githubInstallationId}`));
+			console.log(chalk.green("  Deploys automáticos: ativados"));
+		} else {
+			console.log(chalk.yellow("  GitHub App: não instalado"));
+			console.log(chalk.dim("  Execute 'veloz github setup' para ativar deploys automáticos."));
+		}
+		return {
+			connected: true,
+			owner: project.githubRepoOwner,
+			repo: project.githubRepoName,
+			installationId: project.githubInstallationId
+		};
 	}
 });
 
@@ -3702,7 +4569,7 @@ const LOGO_LINES = [
 ];
 const BRAND_COLOR = "#FF4D00";
 function getVersion() {
-	return "0.0.0-beta.18";
+	return "0.0.0-beta.19";
 }
 function printBanner(subtitle) {
 	const version = getVersion();
@@ -4672,7 +5539,7 @@ async function autoUpdate() {
 	if (process.env.VELOZ_MCP === "true") return;
 	const pm = detectPackageManager();
 	if (!pm) return;
-	const currentVersion = "0.0.0-beta.18";
+	const currentVersion = "0.0.0-beta.19";
 	const latestVersion = await fetchLatestVersion();
 	if (!latestVersion || latestVersion === currentVersion) return;
 	const installCmd = getInstallCommand(pm, latestVersion);
@@ -4799,7 +5666,7 @@ async function provisionDatabases(config, opts) {
 async function updateDatabaseResources(client, key, dbConfig, existing, serviceId, isLive) {
 	const desiredSize = dbConfig.size;
 	if (!desiredSize) return;
-	if ((existing.size ?? resolveDatabaseSize(existing.cpuLimit, existing.memoryLimit)) === desiredSize) return;
+	if ((existing.size ?? resolveDatabaseSize(existing.cpuLimit, existing.memoryLimit, existing.engine)) === desiredSize) return;
 	if (!isLive) {
 		warn(`Banco de dados "${key}" não está LIVE — não é possível alterar recursos agora.`);
 		return;
@@ -5987,83 +6854,6 @@ async function cliDeployFlow(opts) {
 	await triggerDeploy(serviceId);
 }
 
-//#endregion
-//#region src/commands/logs.ts
-function formatTime(timestamp) {
-	return chalk.dim(new Date(timestamp).toLocaleTimeString("pt-BR"));
-}
-async function streamFollow(services, maxNameLen, tailLines) {
-	const client = await getClient();
-	const showTags = services.length > 1;
-	const streams = services.map(async ({ service, index }) => {
-		const tag = showTags ? `${getServiceTag(service.name, maxNameLen, index)} ` : "";
-		try {
-			const stream = await client.logs.streamRuntime({
-				serviceId: service.id,
-				tailLines: Math.ceil(tailLines / services.length)
-			});
-			for await (const entry of stream) console.log(`${tag}${formatTime(entry.timestamp)} ${entry.message}`);
-		} catch {
-			console.log(`${tag}${chalk.red("Erro ao conectar ao stream de logs")}`);
-		}
-	});
-	await Promise.allSettled(streams);
-}
-async function fetchRecent(services, maxNameLen, tailLines) {
-	const client = await getClient();
-	const showTags = services.length > 1;
-	const allEntries = (await Promise.allSettled(services.map(async ({ service, index }) => {
-		return (await client.logs.getRecent({
-			serviceId: service.id,
-			tailLines
-		})).map((e) => ({
-			...e,
-			serviceIndex: index,
-			serviceName: service.name
-		}));
-	}))).filter((r) => r.status === "fulfilled").flatMap((r) => r.value).sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
-	if (allEntries.length === 0) {
-		info("Nenhum log encontrado.");
-		return;
-	}
-	console.log();
-	for (const entry of allEntries) {
-		const tag = showTags ? `${getServiceTag(entry.serviceName, maxNameLen, entry.serviceIndex)} ` : "";
-		console.log(`${tag}${formatTime(entry.timestamp)} ${entry.message}`);
-	}
-	console.log();
-	info(`Mostrando ${allEntries.length} linha(s). Use ${chalk.bold("--follow")} para acompanhar em tempo real.`);
-}
-function registerLogs(cli$1) {
-	cli$1.command("logs", {
-		description: "Visualizar logs dos serviços",
-		middleware: [requireAuth],
-		options: z.object({
-			follow: z.boolean().optional().describe("Acompanhar logs em tempo real"),
-			tail: z.number().default(50).describe("Número de linhas recentes"),
-			service: z.string().optional().describe("Filtrar por serviço")
-		}),
-		alias: {
-			follow: "f",
-			tail: "n"
-		},
-		async run(c) {
-			const spin = spinner("Carregando logs...");
-			const { services, maxNameLen } = resolveAllServices(c.options.service);
-			const tailLines = c.options.tail;
-			if (c.options.follow) {
-				spin.text = services.length > 1 ? `Conectando a ${services.length} serviço(s)...` : "Conectando ao streaming de logs...";
-				spin.stop();
-				info("Streaming de logs ativo. Pressione Ctrl+C para sair.\n");
-				await streamFollow(services, maxNameLen, tailLines);
-			} else {
-				spin.stop();
-				await fetchRecent(services, maxNameLen, tailLines);
-			}
-		}
-	});
-}
-
 //#endregion
 //#region src/commands/use.ts
 function registerUse(cli$1) {
@@ -6326,7 +7116,7 @@ async function pruneRemovedEntries(config, existingConfig, services, databases)
 //#region src/index.ts
 if (process.argv.includes("--mcp")) process.env.VELOZ_MCP = "true";
 const cli = Cli.create("veloz", {
-	version: "0.0.0-beta.18",
+	version: "0.0.0-beta.19",
 	description: "CLI da plataforma Veloz — deploy rápido para o Brasil",
 	env: z.object({ VELOZ_ENV: z.string().optional().describe("Ambiente alvo (ex: preview, staging)") })
 });
@@ -6390,10 +7180,12 @@ cli.command(apikeyGroup);
 cli.command(dbGroup);
 cli.command(templateGroup);
 cli.command(servicesGroup);
+cli.command(metricsGroup);
+cli.command(logsGroup);
+cli.command(githubGroup);
 registerLogin(cli);
 registerLink(cli);
 registerDeploy(cli);
-registerLogs(cli);
 registerUse(cli);
 registerWhoami(cli);
 registerPull(cli);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "onveloz",
-  "version": "0.0.0-beta.18",
+  "version": "0.0.0-beta.19",
   "description": "CLI da plataforma Veloz — deploy rápido para o Brasil",
   "keywords": [
     "brasil",
@@ -46,7 +46,7 @@
     "@veloz/config": "workspace:*",
     "bumpp": "^10.4.1",
     "tsdown": "^0.16.5",
-    "tsx": "^4.19.2",
+    "tsx": "catalog:",
     "typescript": "catalog:",
     "vitest": "catalog:"
   },