onveloz 0.0.0-beta.16 → 0.0.0-beta.18

package/dist/index.mjs

@@ -14,6 +14,8 @@ import { createInterface } from "node:readline";
 import ora from "ora";
 import { createAuthClient } from "better-auth/client";
 import { deviceAuthorizationClient } from "better-auth/client/plugins";
+import net from "node:net";
+import WebSocket from "ws";
 import { link, mkdir, mkdtemp, readdir, rm, stat } from "node:fs/promises";
 import ignore from "ignore";
 import tar from "tar";
@@ -51,6 +53,131 @@ const DATABASE_ENGINE_DEFAULTS = {
 		defaultVersion: "7"
 	}
 };
+/** Default size tiers for disk-based engines (PostgreSQL, MySQL). */
+const DISK_ENGINE_SIZES = {
+	basico: {
+		label: "Básico",
+		cpu: "250m",
+		memory: "256Mi",
+		cpuLabel: "0.25 vCPU",
+		memoryLabel: "256 MB"
+	},
+	essencial: {
+		label: "Essencial",
+		cpu: "500m",
+		memory: "512Mi",
+		cpuLabel: "0.5 vCPU",
+		memoryLabel: "512 MB"
+	},
+	turbo: {
+		label: "Turbo",
+		cpu: "1",
+		memory: "1Gi",
+		cpuLabel: "1 vCPU",
+		memoryLabel: "1 GB"
+	},
+	"turbo-plus": {
+		label: "Turbo Plus",
+		cpu: "1500m",
+		memory: "2Gi",
+		cpuLabel: "1.5 vCPU",
+		memoryLabel: "2 GB"
+	},
+	nitro: {
+		label: "Nitro",
+		cpu: "2",
+		memory: "4Gi",
+		cpuLabel: "2 vCPU",
+		memoryLabel: "4 GB"
+	},
+	"nitro-plus": {
+		label: "Nitro Plus",
+		cpu: "4",
+		memory: "8Gi",
+		cpuLabel: "4 vCPU",
+		memoryLabel: "8 GB"
+	}
+};
+/** Redis size tiers — memory-heavy since Redis is purely in-memory, CPU stays minimal. */
+const REDIS_SIZES = {
+	basico: {
+		label: "Básico",
+		cpu: "150m",
+		memory: "128Mi",
+		cpuLabel: "0.15 vCPU",
+		memoryLabel: "128 MB"
+	},
+	essencial: {
+		label: "Essencial",
+		cpu: "250m",
+		memory: "256Mi",
+		cpuLabel: "0.25 vCPU",
+		memoryLabel: "256 MB"
+	},
+	turbo: {
+		label: "Turbo",
+		cpu: "250m",
+		memory: "512Mi",
+		cpuLabel: "0.25 vCPU",
+		memoryLabel: "512 MB"
+	},
+	"turbo-plus": {
+		label: "Turbo Plus",
+		cpu: "500m",
+		memory: "1Gi",
+		cpuLabel: "0.5 vCPU",
+		memoryLabel: "1 GB"
+	},
+	nitro: {
+		label: "Nitro",
+		cpu: "500m",
+		memory: "2Gi",
+		cpuLabel: "0.5 vCPU",
+		memoryLabel: "2 GB"
+	},
+	"nitro-plus": {
+		label: "Nitro Plus",
+		cpu: "1",
+		memory: "4Gi",
+		cpuLabel: "1 vCPU",
+		memoryLabel: "4 GB"
+	}
+};
+/** Per-engine size tier maps. */
+const DATABASE_SIZES_BY_ENGINE = {
+	postgresql: DISK_ENGINE_SIZES,
+	mysql: DISK_ENGINE_SIZES,
+	redis: REDIS_SIZES
+};
+/**
+* Flat union of all size keys across engines.
+* Kept for backward compatibility (Zod schemas, Prisma column).
+*/
+const DATABASE_SIZES = {
+	...DISK_ENGINE_SIZES,
+	...REDIS_SIZES
+};
+/** All unique size keys across all engines (for Zod validation). */
+const DATABASE_SIZE_KEYS = [...new Set([...Object.keys(DISK_ENGINE_SIZES), ...Object.keys(REDIS_SIZES)])];
+/** Get size tiers for a specific engine. */
+function getDatabaseSizes(engine) {
+	return DATABASE_SIZES_BY_ENGINE[engine];
+}
+/** Get size option list for a specific engine (for UI selectors). */
+function getDatabaseSizeOptions(engine) {
+	const sizes = getDatabaseSizes(engine);
+	return Object.entries(sizes).map(([key, tier]) => ({
+		value: key,
+		label: tier.label,
+		description: `${tier.cpuLabel} · ${tier.memoryLabel}`
+	}));
+}
+/** @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;
+	return null;
+}
 
 //#endregion
 //#region ../../packages/config/veloz-config.ts
@@ -63,17 +190,22 @@ const PackageManagerSchema = z$1.enum([
 	"bun",
 	"auto"
 ]);
+const BuildMethodSchema = z$1.enum(["nixpacks", "dockerfile"]);
 const BuildConfigSchema = z$1.object({
+	method: BuildMethodSchema.default("nixpacks").optional(),
 	command: z$1.string().nullable().optional(),
 	nodeVersion: z$1.string().regex(/^[0-9]+(\.[0-9]+){0,2}(\.x)?$/).default("20").optional(),
 	nixpkgsArchive: z$1.string().regex(/^[a-f0-9]{40}$/).optional(),
 	packageManager: PackageManagerSchema.default("auto").optional(),
 	installCommand: z$1.string().nullable().optional(),
 	outputDir: z$1.string().nullable().optional(),
-	aptPackages: z$1.array(z$1.string().regex(/^[a-z0-9][a-z0-9.+-]+$/, "Nome de pacote inválido")).optional()
+	aptPackages: z$1.array(z$1.string().regex(/^[a-z0-9][a-z0-9.+-]+$/, "Nome de pacote inválido")).optional(),
+	dockerfile: z$1.string().optional(),
+	context: z$1.string().optional()
 });
 const RuntimeConfigSchema = z$1.object({
 	command: z$1.string().nullable().optional(),
+	preStartCommand: z$1.string().nullable().optional(),
 	port: z$1.number().min(1).max(65535).default(3e3).optional(),
 	fsGroup: z$1.number().int().min(0).max(65534).default(1001).optional(),
 	healthCheck: z$1.object({
@@ -109,10 +241,6 @@ const VolumeConfigSchema = z$1.object({
 	].some((p) => value === p || value.startsWith(p + "/")), "Caminho de montagem não permitido por segurança"),
 	sizeGb: z$1.number().int().min(10).max(100).optional().default(10)
 });
-const DatabaseResourcesSchema = z$1.object({
-	cpu: z$1.string().regex(/^[0-9]+(\.[0-9]+)?|[0-9]+m$/).default("500m").optional(),
-	memory: z$1.string().regex(/^[0-9]+(Mi|Gi)$/).default("512Mi").optional()
-});
 const PoolerConfigSchema = z$1.object({
 	enabled: z$1.boolean().default(false),
 	poolMode: z$1.enum([
@@ -123,6 +251,8 @@ const PoolerConfigSchema = z$1.object({
 	defaultPoolSize: z$1.number().int().min(1).max(200).default(20).optional(),
 	maxClientConn: z$1.number().int().min(1).max(1e4).default(100).optional()
 });
+const LOWERCASE_SIZE_KEYS = DATABASE_SIZE_KEYS.map((k) => k);
+const DatabaseSizeSchema = z$1.enum(LOWERCASE_SIZE_KEYS);
 const DatabaseConfigSchema = z$1.object({
 	id: z$1.string().optional(),
 	name: z$1.string().optional(),
@@ -132,13 +262,13 @@ const DatabaseConfigSchema = z$1.object({
 		"redis"
 	]),
 	version: z$1.string().optional(),
-	storage: z$1.string().regex(/^[0-9]+(Gi)$/).default("10Gi").optional(),
-	resources: DatabaseResourcesSchema.optional(),
+	storage: z$1.string().regex(/^[0-9]+(Gi)$/).refine((val) => Number.parseInt(val, 10) >= 10, "Tamanho mínimo de storage é 10Gi").optional(),
+	size: DatabaseSizeSchema.optional(),
 	pooler: PoolerConfigSchema.optional(),
 	fromTemplate: z$1.string().optional()
 });
 const ServiceConfigSchema = z$1.object({
-	id: z$1.string(),
+	id: z$1.string().optional(),
 	name: z$1.string(),
 	type: ServiceTypeSchema.default("web"),
 	root: z$1.string().default(".").optional(),
@@ -294,7 +424,10 @@ function loadConfig() {
 	return config;
 }
 /**
-* Save the veloz.json config to project root
+* Save the veloz.json config to project root.
+*
+* When possible, prefer `patchConfig` to avoid overwriting user-authored
+* fields with Zod-applied defaults.
 */
 function saveConfig(config) {
 	const path = getConfigPath();
@@ -305,6 +438,18 @@ function saveConfig(config) {
 	writeFileSync(path, JSON.stringify(configWithSchema, null, 2), "utf-8");
 }
 /**
+* Apply targeted patches to veloz.json without running Zod parse.
+* Reads the raw JSON as VelozConfig (type-only cast, no transforms/defaults),
+* applies the patch function, and writes back — preserving user-authored values.
+*/
+function patchConfig(patchFn) {
+	const path = getConfigPath();
+	if (!existsSync(path)) throw new Error(`${getConfigFileName()} not found`);
+	const raw = JSON.parse(readFileSync(path, "utf-8"));
+	patchFn(raw);
+	writeFileSync(path, JSON.stringify(raw, null, 2), "utf-8");
+}
+/**
 * Require config to exist, throw if not found
 */
 function requireConfig() {
@@ -811,6 +956,10 @@ function throwNotFound(flag, entries) {
 *  3. Default from `veloz use`   → remembered choice
 *  4. Interactive prompt          → last resort
 */
+function requireServiceId(service) {
+	if (!service.id) throw new Error(`Serviço "${service.name}" não possui ID. Execute 'veloz deploy' para vincular o serviço.`);
+	return service;
+}
 async function resolveService(serviceFlag) {
 	const config = requireConfig();
 	const entries = Object.entries(config.services);
@@ -821,7 +970,7 @@ async function resolveService(serviceFlag) {
 		const [key, service] = found;
 		return {
 			key,
-			service: mergeServiceWithDefaults(service, config.defaults),
+			service: requireServiceId(mergeServiceWithDefaults(service, config.defaults)),
 			config
 		};
 	}
@@ -829,7 +978,7 @@ async function resolveService(serviceFlag) {
 		const [key, service] = entries[0];
 		return {
 			key,
-			service: mergeServiceWithDefaults(service, config.defaults),
+			service: requireServiceId(mergeServiceWithDefaults(service, config.defaults)),
 			config
 		};
 	}
@@ -838,7 +987,7 @@ async function resolveService(serviceFlag) {
 		const service = config.services[defaultKey];
 		return {
 			key: defaultKey,
-			service: mergeServiceWithDefaults(service, config.defaults),
+			service: requireServiceId(mergeServiceWithDefaults(service, config.defaults)),
 			config
 		};
 	}
@@ -848,13 +997,12 @@ async function resolveService(serviceFlag) {
 	})));
 	return {
 		key: selectedKey,
-		service: mergeServiceWithDefaults(config.services[selectedKey], config.defaults),
+		service: requireServiceId(mergeServiceWithDefaults(config.services[selectedKey], config.defaults)),
 		config
 	};
 }
 async function resolveServiceId(serviceFlag) {
 	const { service } = await resolveService(serviceFlag);
-	if (!service.id) throw new Error(`Serviço "${service.name}" não possui ID. Execute 'veloz deploy' para vincular o serviço.`);
 	return service.id;
 }
 function resolveAllServices(serviceFlag) {
@@ -947,6 +1095,7 @@ envGroup.command("set", {
 		const serviceId = await resolveServiceId(c.options.service);
 		const client = await getClient();
 		const pares = c.args.pares.split(/\s+/);
+		const allWarnings = [];
 		for (const par of pares) {
 			const eqIndex = par.indexOf("=");
 			if (eqIndex === -1) {
@@ -959,13 +1108,15 @@ envGroup.command("set", {
 				spin.stop();
 				throw new Error("Chave não pode estar vazia.");
 			}
-			await client.envVars.set({
+			const result = await client.envVars.set({
 				serviceId,
 				key,
 				value
 			});
+			if (result.warnings) allWarnings.push(...result.warnings);
 		}
 		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.`);
@@ -1061,11 +1212,12 @@ envGroup.command("import", {
 				key: envVar.key
 			});
 		}
-		await client.envVars.setBulk({
+		const result = await client.envVars.setBulk({
 			serviceId,
 			vars: envVars
 		});
 		spin.stop();
+		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.");
 	}
@@ -1225,9 +1377,11 @@ function updateServiceVolumesInConfig(serviceKey, updater) {
 	if (!config) return false;
 	const currentService = config.services[serviceKey];
 	if (!currentService) return false;
-	currentService.volumes = updater([...currentService.volumes ?? []]);
-	config.updated = (/* @__PURE__ */ new Date()).toISOString();
-	saveConfig(config);
+	const updatedVolumes = updater([...currentService.volumes ?? []]);
+	patchConfig((raw) => {
+		if (raw.services[serviceKey]) raw.services[serviceKey].volumes = updatedVolumes;
+		raw.updated = (/* @__PURE__ */ new Date()).toISOString();
+	});
 	return true;
 }
 
@@ -1454,6 +1608,7 @@ function printServiceConfig(service) {
 	console.log(`  ${chalk.bold("Root Dir:")}       ${formatValue(service.rootDirectory || "/")}`);
 	console.log(`  ${chalk.bold("Build Command:")}  ${formatValue(service.buildCommand)}`);
 	console.log(`  ${chalk.bold("Start Command:")}  ${formatValue(service.startCommand)}`);
+	console.log(`  ${chalk.bold("Pre-Start Cmd:")}  ${formatValue(service.preStartCommand)}`);
 	console.log(`  ${chalk.bold("Porta:")}          ${formatValue(service.port)}`);
 	console.log(`  ${chalk.bold("Instâncias:")}     ${formatValue(service.instanceCount)}`);
 	console.log(`  ${chalk.bold("CPU Limit:")}      ${formatValue(service.cpuLimit)}`);
@@ -1471,6 +1626,7 @@ configGroup.command("show", {
 		rootDirectory: z.string().nullable(),
 		buildCommand: z.string().nullable(),
 		startCommand: z.string().nullable(),
+		preStartCommand: z.string().nullable(),
 		port: z.number().nullable(),
 		instanceCount: z.number().nullable(),
 		cpuLimit: z.string().nullable(),
@@ -1499,6 +1655,7 @@ configGroup.command("show", {
 			rootDirectory: svc.rootDirectory ?? null,
 			buildCommand: svc.buildCommand ?? null,
 			startCommand: svc.startCommand ?? null,
+			preStartCommand: svc.preStartCommand ?? null,
 			port: svc.port ?? null,
 			instanceCount: svc.instanceCount ?? null,
 			cpuLimit: svc.cpuLimit ?? null,
@@ -1513,6 +1670,7 @@ configGroup.command("set", {
 		name: z.string().optional().describe("Nome do serviço"),
 		build: z.string().optional().describe("Comando de build"),
 		start: z.string().optional().describe("Comando de start"),
+		preStart: z.string().optional().describe("Comando executado antes de iniciar o serviço (ex: migrations)"),
 		port: z.string().optional().describe("Porta do serviço"),
 		root: z.string().optional().describe("Diretório raiz"),
 		instances: z.string().optional().describe("Número de instâncias"),
@@ -1536,6 +1694,7 @@ configGroup.command("set", {
 		if (c.options.name) updates.name = c.options.name;
 		if (c.options.build !== void 0) updates.buildCommand = c.options.build === "none" ? null : c.options.build;
 		if (c.options.start !== void 0) updates.startCommand = c.options.start === "none" ? null : c.options.start;
+		if (c.options.preStart !== void 0) updates.preStartCommand = c.options.preStart === "none" ? null : c.options.preStart;
 		if (c.options.port) updates.port = parseInt(c.options.port, 10);
 		if (c.options.root !== void 0) updates.rootDirectory = c.options.root === "/" ? null : c.options.root;
 		if (c.options.instances) updates.instanceCount = parseInt(c.options.instances, 10);
@@ -1584,6 +1743,8 @@ configGroup.command("edit", {
 		if (buildCmd) updates.buildCommand = buildCmd === "none" ? null : buildCmd;
 		const startCmd = await prompt(`Start command ${chalk.dim(`(${svc.startCommand || "—"})`)}: `);
 		if (startCmd) updates.startCommand = startCmd === "none" ? null : startCmd;
+		const preStartCmd = await prompt(`Pre-start command ${chalk.dim(`(${svc.preStartCommand || "—"})`)}: `);
+		if (preStartCmd) updates.preStartCommand = preStartCmd === "none" ? null : preStartCmd;
 		const port = await prompt(`Porta ${chalk.dim(`(${svc.port})`)}: `);
 		if (port) updates.port = parseInt(port, 10);
 		const rootDir = await prompt(`Diretório raiz ${chalk.dim(`(${svc.rootDirectory || "/"})`)}: `);
@@ -1615,6 +1776,7 @@ configGroup.command("reset", {
 	options: z.object({
 		build: z.boolean().default(false).describe("Resetar comando de build"),
 		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)")
 	}),
@@ -1625,13 +1787,15 @@ configGroup.command("reset", {
 		if (c.options.all) {
 			updates.buildCommand = null;
 			updates.startCommand = null;
+			updates.preStartCommand = null;
 			updates.rootDirectory = null;
 		} else {
 			if (c.options.build) updates.buildCommand = null;
 			if (c.options.start) updates.startCommand = null;
+			if (c.options.preStart) updates.preStartCommand = null;
 		}
 		if (Object.keys(updates).length === 0) {
-			warn("Especifique o que resetar: --build, --start, ou --all");
+			warn("Especifique o que resetar: --build, --start, --pre-start, ou --all");
 			return;
 		}
 		await withSpinner({
@@ -1865,8 +2029,7 @@ dbGroup.command("create", {
 		engine: z.string().optional().describe("Engine (postgresql, mysql, redis)"),
 		engineVersion: z.string().optional().describe("Versão do engine"),
 		storage: z.string().optional().describe("Armazenamento (ex: 10Gi, 20Gi)"),
-		cpu: z.string().optional().describe("Limite de CPU (ex: 500m, 1)"),
-		memory: z.string().optional().describe("Limite de memória (ex: 512Mi, 1Gi)"),
+		size: z.string().optional().describe("Tier de recursos (basico, essencial, turbo, turbo-plus, nitro, nitro-plus)"),
 		pooler: z.boolean().optional().describe("Habilitar PgBouncer (apenas PostgreSQL)")
 	}),
 	async run(c) {
@@ -1917,30 +2080,25 @@ dbGroup.command("create", {
 				engine: validEngine,
 				engineVersion: version,
 				storage,
-				cpuLimit: c.options.cpu,
-				memoryLimit: c.options.memory,
+				size: c.options.size,
 				poolerEnabled: c.options.pooler
 			})
 		});
 		success(`Banco de dados ${chalk.bold(db.name)} criado! Provisionando...`);
 		info("Use 'veloz db credentials " + db.name + "' para ver as credenciais quando estiver pronto.");
-		const config = loadConfig();
-		if (config) {
-			const updatedDatabases = { ...config.databases };
-			updatedDatabases[name] = {
-				id: db.id,
-				engine: validEngine,
-				version: version ?? void 0,
-				storage: storage ?? void 0,
-				...c.options.cpu || c.options.memory ? { resources: {
-					...c.options.cpu && { cpu: c.options.cpu },
-					...c.options.memory && { memory: c.options.memory }
-				} } : {},
-				...c.options.pooler ? { pooler: { enabled: true } } : {}
-			};
-			config.databases = updatedDatabases;
-			config.updated = (/* @__PURE__ */ new Date()).toISOString();
-			saveConfig(config);
+		if (loadConfig()) {
+			patchConfig((raw) => {
+				raw.databases ??= {};
+				raw.databases[name] = {
+					id: db.id,
+					engine: validEngine,
+					...version ? { version } : {},
+					...storage ? { storage } : {},
+					...c.options.size ? { size: c.options.size } : {},
+					...c.options.pooler ? { pooler: { enabled: true } } : {}
+				};
+				raw.updated = (/* @__PURE__ */ new Date()).toISOString();
+			});
 			info(`Adicionado ao ${getConfigFileName()}.`);
 		}
 	}
@@ -2006,10 +2164,13 @@ dbGroup.command("delete", {
 		if (config?.databases) {
 			const key = Object.entries(config.databases).find(([k, d]) => d.id === db.id || k === db.name)?.[0];
 			if (key) {
-				const { [key]: _, ...rest } = config.databases;
-				config.databases = Object.keys(rest).length > 0 ? rest : void 0;
-				config.updated = (/* @__PURE__ */ new Date()).toISOString();
-				saveConfig(config);
+				patchConfig((raw) => {
+					if (raw.databases) {
+						delete raw.databases[key];
+						if (Object.keys(raw.databases).length === 0) raw.databases = void 0;
+					}
+					raw.updated = (/* @__PURE__ */ new Date()).toISOString();
+				});
 				info(`Removido do ${getConfigFileName()}.`);
 			}
 		}
@@ -2029,6 +2190,291 @@ dbGroup.command("restart", {
 		success(`Banco de dados ${chalk.bold(db.name)} reiniciado com sucesso.`);
 	}
 });
+dbGroup.command("update", {
+	description: "Atualizar configurações de um banco de dados",
+	middleware: [requireAuth],
+	args: z.object({ name: z.string().describe("Nome ou ID do banco de dados") }),
+	options: z.object({
+		size: z.string().optional().describe("Tier de recursos (basico, essencial, turbo, turbo-plus, nitro, nitro-plus)"),
+		storage: z.string().optional().describe("Armazenamento (ex: 20Gi, 50Gi)"),
+		pooler: z.boolean().optional().describe("Habilitar/desabilitar PgBouncer"),
+		poolMode: z.string().optional().describe("Modo do pooler (transaction, session, statement)"),
+		poolSize: z.number().optional().describe("Pool size padrão (1-200)"),
+		maxConnections: z.number().optional().describe("Máximo de conexões do cliente (1-10000)")
+	}),
+	async run(c) {
+		const db = await resolveDatabaseByName(getProjectId$1(), c.args.name);
+		const client = await getClient();
+		const hasFlags = c.options.size !== void 0 || c.options.storage !== void 0 || c.options.pooler !== void 0 || c.options.poolMode !== void 0 || c.options.poolSize !== void 0 || c.options.maxConnections !== void 0;
+		let size = c.options.size;
+		let storage = c.options.storage;
+		let poolerEnabled = c.options.pooler;
+		let poolMode = c.options.poolMode;
+		let poolSize = c.options.poolSize;
+		let maxConnections = c.options.maxConnections;
+		if (!hasFlags && isInteractive()) {
+			const engineSizes = getDatabaseSizes(db.engine ?? "postgresql");
+			const engineSizeKeys = Object.keys(engineSizes);
+			const currentSizeLabel = db.size ? engineSizes[db.size]?.label ?? db.size : "—";
+			console.log(`\n  ${chalk.dim("Tier atual:")} ${currentSizeLabel}`);
+			if (await promptConfirm("Alterar tier de recursos?", false)) size = await promptSelect("Novo tier:", engineSizeKeys.map((k) => {
+				const s = engineSizes[k];
+				const current = k === db.size ? " (atual)" : "";
+				return {
+					label: `${s.label} — ${s.cpuLabel}, ${s.memoryLabel}${current}`,
+					value: k
+				};
+			}));
+			const currentStorageGb = db.storageGb;
+			console.log(`  ${chalk.dim("Storage atual:")} ${currentStorageGb} GB`);
+			if (await promptConfirm("Alterar armazenamento?", false)) {
+				const storageOptions = STORAGE_OPTIONS.filter((s) => parseInt(s.replace("Gi", ""), 10) > currentStorageGb);
+				if (storageOptions.length === 0) info("Já está no armazenamento máximo disponível.");
+				else storage = await promptSelect("Novo armazenamento:", storageOptions.map((s) => ({
+					label: formatStorageLabel(s),
+					value: s
+				})));
+			}
+			if (db.engine === "postgresql") {
+				const poolerStatus = db.poolerEnabled ? "ativado" : "desativado";
+				console.log(`  ${chalk.dim("Pooler:")} ${poolerStatus}`);
+				if (await promptConfirm("Alterar configuração do pooler?", false)) {
+					poolerEnabled = await promptConfirm("Habilitar PgBouncer?", db.poolerEnabled);
+					if (poolerEnabled) poolMode = await promptSelect("Modo do pool:", [
+						{
+							label: "Transaction (padrão)",
+							value: "transaction"
+						},
+						{
+							label: "Session",
+							value: "session"
+						},
+						{
+							label: "Statement",
+							value: "statement"
+						}
+					]);
+				}
+			}
+		}
+		const validEngineSizes = getDatabaseSizes(db.engine ?? "postgresql");
+		const validSizeKeys = Object.keys(validEngineSizes);
+		if (size && !validSizeKeys.includes(size)) throw new Error(`Tier inválido: ${size}. Opções para ${db.engine}: ${validSizeKeys.join(", ")}`);
+		let updated = false;
+		if (size && size !== db.size) if (db.databaseStatus !== "LIVE") warn(`Banco de dados não está LIVE — não é possível alterar recursos agora.`);
+		else {
+			const sizeConfig = validEngineSizes[size];
+			await withSpinner({
+				text: `Atualizando tier para ${sizeConfig.label} (${sizeConfig.cpuLabel}, ${sizeConfig.memoryLabel})...`,
+				fn: () => client.databases.updateResources({
+					serviceId: db.id,
+					size
+				})
+			});
+			success(`Tier atualizado para ${sizeConfig.label}.`);
+			updated = true;
+		}
+		if (storage) {
+			const desiredGb = parseInt(storage.replace("Gi", ""), 10);
+			if (isNaN(desiredGb) || desiredGb <= 0) throw new Error(`Storage inválido: ${storage}. Use formato como "20Gi".`);
+			if (desiredGb <= db.storageGb) warn(`Storage solicitado (${desiredGb} GB) não é maior que o atual (${db.storageGb} GB). Redução não é suportada.`);
+			else {
+				const dataVolume = (await client.volumes.list({ serviceId: db.id })).find((v) => v.name === "data");
+				if (!dataVolume) warn("Volume de dados não encontrado. O banco pode ainda estar sendo provisionado.");
+				else {
+					await withSpinner({
+						text: `Redimensionando armazenamento de ${db.storageGb} GB para ${desiredGb} GB...`,
+						fn: () => client.volumes.update({
+							volumeId: dataVolume.id,
+							sizeGb: desiredGb
+						})
+					});
+					success(`Armazenamento atualizado para ${desiredGb} GB.`);
+					updated = true;
+				}
+			}
+		}
+		if (poolerEnabled !== void 0 || poolMode || poolSize || maxConnections) if (db.engine !== "postgresql") warn(`Connection pooler só é suportado para PostgreSQL.`);
+		else if (db.databaseStatus !== "LIVE") warn(`Banco de dados não está LIVE — não é possível alterar o pooler agora.`);
+		else {
+			await withSpinner({
+				text: "Atualizando configuração do pooler...",
+				fn: () => client.databases.updatePooler({
+					serviceId: db.id,
+					enabled: poolerEnabled ?? db.poolerEnabled,
+					poolMode,
+					defaultPoolSize: poolSize,
+					maxClientConn: maxConnections
+				})
+			});
+			success(`Pooler ${poolerEnabled ?? db.poolerEnabled ? "ativado" : "desativado"}.`);
+			updated = true;
+		}
+		if (!updated) {
+			info("Nenhuma alteração realizada.");
+			return;
+		}
+		if (loadConfig()) {
+			patchConfig((raw) => {
+				raw.databases ??= {};
+				const configKey = Object.entries(raw.databases).find(([k, d]) => d?.id === db.id || k === db.name)?.[0] ?? db.name;
+				raw.databases[configKey] ??= { engine: db.engine };
+				if (size) raw.databases[configKey].size = size;
+				if (storage) raw.databases[configKey].storage = storage;
+				if (poolerEnabled !== void 0 || poolMode || poolSize || maxConnections) {
+					const existing = raw.databases[configKey].pooler ?? { enabled: false };
+					raw.databases[configKey].pooler = {
+						...existing,
+						...poolerEnabled !== void 0 ? { enabled: poolerEnabled } : {},
+						...poolMode ? { poolMode } : {},
+						...poolSize ? { defaultPoolSize: poolSize } : {},
+						...maxConnections ? { maxClientConn: maxConnections } : {}
+					};
+				}
+				raw.updated = (/* @__PURE__ */ new Date()).toISOString();
+			});
+			info(`Atualizado no ${getConfigFileName()}.`);
+		}
+	}
+});
+dbGroup.command("query", {
+	description: "Executar uma consulta no banco de dados",
+	middleware: [requireAuth],
+	args: z.object({ name: z.string().describe("Nome ou ID do banco de dados") }),
+	options: z.object({ query: z.string().optional().describe("Consulta SQL ou comando Redis") }),
+	alias: { query: "q" },
+	async run(c) {
+		const db = await resolveDatabaseByName(getProjectId$1(), c.args.name);
+		let query = c.options.query;
+		if (!query) {
+			if (!isInteractive()) throw new Error("Use --query ou -q para fornecer a consulta em modo não-interativo.");
+			query = await prompt(`Consulta ${ENGINE_DISPLAY[db.engine] ?? db.engine} (ex: ${db.engine === "redis" ? "GET chave" : "SELECT * FROM tabela LIMIT 10"}):`);
+			if (!query) throw new Error("Consulta é obrigatória.");
+		}
+		const client = await getClient();
+		console.log(chalk.dim(`\n  Executando consulta em ${chalk.bold(db.name)}...\n`));
+		const stream = await client.databases.executeQuery({
+			serviceId: db.id,
+			query
+		});
+		let hasOutput = false;
+		for await (const event of stream) switch (event.type) {
+			case "output":
+				hasOutput = true;
+				console.log(event.content);
+				break;
+			case "error":
+				console.log(chalk.red(event.content));
+				break;
+			case "status":
+				if (event.content === "Consulta finalizada.") {
+					if (!hasOutput) info("Consulta executada sem retorno.");
+					console.log();
+				}
+				break;
+		}
+	}
+});
+const ENGINE_DEFAULT_PORTS = {
+	postgresql: 5432,
+	mysql: 3306,
+	redis: 6379
+};
+const ENGINE_CONNECT_HINTS = {
+	postgresql: (p) => `psql -h localhost -p ${p}`,
+	mysql: (p) => `mysql -h 127.0.0.1 -P ${p}`,
+	redis: (p) => `redis-cli -p ${p}`
+};
+dbGroup.command("tunnel", {
+	description: "Criar túnel local para um banco de dados",
+	middleware: [requireAuth],
+	args: z.object({ name: z.string().describe("Nome ou ID do banco de dados") }),
+	options: z.object({ port: z.number().optional().describe("Porta local (padrão: porta do engine)") }),
+	alias: { port: "p" },
+	async run(c) {
+		const db = await resolveDatabaseByName(getProjectId$1(), c.args.name);
+		const client = await getClient();
+		const localPort = c.options.port ?? ENGINE_DEFAULT_PORTS[db.engine] ?? 5432;
+		const engineLabel = ENGINE_DISPLAY[db.engine] ?? db.engine;
+		const creds = await withSpinner({
+			text: "Carregando credenciais...",
+			fn: () => client.databases.getCredentials({ serviceId: db.id })
+		});
+		let localUrl;
+		if (db.engine === "redis") localUrl = creds.password ? `redis://:${creds.password}@127.0.0.1:${localPort}` : `redis://127.0.0.1:${localPort}`;
+		else localUrl = `${db.engine === "mysql" ? "mysql" : "postgresql"}://${creds.username}:${creds.password}@127.0.0.1:${localPort}/${creds.database}`;
+		const server = net.createServer(async (socket) => {
+			let session;
+			try {
+				session = await client.databases.createTunnelSession({ serviceId: db.id });
+			} catch (err) {
+				const message = err instanceof Error ? err.message : "Erro desconhecido";
+				console.log(chalk.red(`  Falha ao criar sessão de túnel: ${message}`));
+				socket.destroy();
+				return;
+			}
+			const ws = new WebSocket(`${session.proxyUrl}/connect?token=${session.token}`);
+			ws.binaryType = "nodebuffer";
+			let wsReady = false;
+			const pendingData = [];
+			ws.on("open", () => {
+				wsReady = true;
+				for (const chunk of pendingData) ws.send(chunk);
+				pendingData.length = 0;
+			});
+			ws.on("message", (data) => {
+				if (!socket.destroyed) socket.write(data);
+			});
+			ws.on("close", () => {
+				if (!socket.destroyed) socket.destroy();
+			});
+			ws.on("error", (err) => {
+				console.log(chalk.red(`  Erro no túnel: ${err.message}`));
+				if (!socket.destroyed) socket.destroy();
+			});
+			socket.on("data", (data) => {
+				if (wsReady) ws.send(data);
+				else pendingData.push(data);
+			});
+			socket.on("close", () => {
+				if (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING) ws.close();
+			});
+			socket.on("error", () => {
+				if (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING) ws.close();
+			});
+		});
+		server.on("error", (err) => {
+			if (err.code === "EADDRINUSE") console.log(chalk.red(`\n  Porta ${localPort} já está em uso. Use --port para escolher outra.\n`));
+			else console.log(chalk.red(`\n  Erro ao iniciar servidor local: ${err.message}\n`));
+			process.exit(1);
+		});
+		server.listen(localPort, "127.0.0.1", () => {
+			console.log();
+			success(`Túnel ${engineLabel} ativo para ${chalk.bold(db.name)}`);
+			console.log();
+			console.log(`  ${chalk.dim("Endereço local:")}  ${chalk.bold(`127.0.0.1:${localPort}`)}`);
+			console.log(`  ${chalk.dim("URL de conexão:")} ${chalk.cyan(localUrl)}`);
+			const hint = ENGINE_CONNECT_HINTS[db.engine];
+			if (hint) console.log(`  ${chalk.dim("Conectar com:")}    ${chalk.cyan(hint(localPort))}`);
+			console.log();
+			console.log(chalk.dim("  Pressione Ctrl+C para encerrar o túnel."));
+			console.log();
+		});
+		await new Promise((resolve$1) => {
+			const shutdown = () => {
+				console.log(chalk.dim("\n  Encerrando túnel..."));
+				server.close(() => {
+					resolve$1();
+				});
+				setTimeout(() => {
+					resolve$1();
+				}, 3e3);
+			};
+			process.on("SIGINT", shutdown);
+			process.on("SIGTERM", shutdown);
+		});
+	}
+});
 
 //#endregion
 //#region src/commands/template.ts
@@ -2109,7 +2555,7 @@ templateGroup.command("deploy", {
 				projectName: c.options.name
 			})
 		});
-		success(`Template '${template.displayName}' implantado com sucesso!`);
+		success(`Template '${template.displayName}' — deploy concluído com sucesso!`);
 		console.log(chalk.bold(`\n  Projeto: ${result.projectName}`));
 		console.log(chalk.dim(`  Slug: ${result.projectSlug}`));
 		console.log();
@@ -2247,7 +2693,7 @@ function registerLink(cli$1) {
 				},
 				services: services.map(([key, service]) => ({
 					key,
-					id: service.id,
+					id: service.id ?? "",
 					name: service.name,
 					type: service.type
 				}))
@@ -2284,13 +2730,16 @@ function detectFramework(pkgJsonStr, pm) {
 		...pkg.dependencies,
 		...pkg.devDependencies
 	};
+	const scripts = pkg.scripts ?? {};
 	const hasReact = !!allDeps["react"];
+	const buildCmd = scripts.build ? pmRun(pm, "build") : null;
+	const startCmd = scripts.start ? pmRun(pm, "start") : null;
 	if (allDeps["next"]) return {
 		name: "nextjs",
 		label: "Next.js",
 		type: "WEB",
-		buildCommand: pmRun(pm, "build"),
-		startCommand: pmRun(pm, "start"),
+		buildCommand: buildCmd ?? pmRun(pm, "build"),
+		startCommand: startCmd ?? pmRun(pm, "start"),
 		outputDir: ".next",
 		port: 3e3
 	};
@@ -2298,8 +2747,8 @@ function detectFramework(pkgJsonStr, pm) {
 		name: "nuxt",
 		label: "Nuxt",
 		type: "WEB",
-		buildCommand: pmRun(pm, "build"),
-		startCommand: pmRun(pm, "start"),
+		buildCommand: buildCmd ?? pmRun(pm, "build"),
+		startCommand: startCmd ?? pmRun(pm, "start"),
 		outputDir: ".output",
 		port: 3e3
 	};
@@ -2307,8 +2756,8 @@ function detectFramework(pkgJsonStr, pm) {
 		name: "remix",
 		label: "Remix",
 		type: "WEB",
-		buildCommand: pmRun(pm, "build"),
-		startCommand: pmRun(pm, "start"),
+		buildCommand: buildCmd ?? pmRun(pm, "build"),
+		startCommand: startCmd ?? pmRun(pm, "start"),
 		outputDir: "build",
 		port: 3e3
 	};
@@ -2316,7 +2765,7 @@ function detectFramework(pkgJsonStr, pm) {
 		name: "astro",
 		label: "Astro",
 		type: "STATIC",
-		buildCommand: pmRun(pm, "build"),
+		buildCommand: buildCmd ?? pmRun(pm, "build"),
 		startCommand: null,
 		outputDir: "dist",
 		port: 3e3
@@ -2325,8 +2774,8 @@ function detectFramework(pkgJsonStr, pm) {
 		name: "sveltekit",
 		label: "SvelteKit",
 		type: "WEB",
-		buildCommand: pmRun(pm, "build"),
-		startCommand: pmRun(pm, "preview"),
+		buildCommand: buildCmd ?? pmRun(pm, "build"),
+		startCommand: scripts.preview ? pmRun(pm, "preview") : startCmd ?? pmRun(pm, "start"),
 		outputDir: "build",
 		port: 3e3
 	};
@@ -2334,7 +2783,7 @@ function detectFramework(pkgJsonStr, pm) {
 		name: "gatsby",
 		label: "Gatsby",
 		type: "STATIC",
-		buildCommand: pmRun(pm, "build"),
+		buildCommand: buildCmd ?? pmRun(pm, "build"),
 		startCommand: null,
 		outputDir: "public",
 		port: 3e3
@@ -2343,8 +2792,8 @@ function detectFramework(pkgJsonStr, pm) {
 		name: "angular",
 		label: "Angular",
 		type: "WEB",
-		buildCommand: pmRun(pm, "build"),
-		startCommand: pmRun(pm, "start"),
+		buildCommand: buildCmd ?? pmRun(pm, "build"),
+		startCommand: startCmd ?? pmRun(pm, "start"),
 		outputDir: "dist",
 		port: 4200
 	};
@@ -2352,8 +2801,8 @@ function detectFramework(pkgJsonStr, pm) {
 		name: "hono",
 		label: "Hono",
 		type: "WEB",
-		buildCommand: pmRun(pm, "build"),
-		startCommand: pmRun(pm, "start"),
+		buildCommand: buildCmd,
+		startCommand: startCmd,
 		outputDir: null,
 		port: 3e3
 	};
@@ -2361,8 +2810,8 @@ function detectFramework(pkgJsonStr, pm) {
 		name: "express",
 		label: "Express",
 		type: "WEB",
-		buildCommand: pmRun(pm, "build"),
-		startCommand: pmRun(pm, "start"),
+		buildCommand: buildCmd,
+		startCommand: startCmd,
 		outputDir: null,
 		port: 3e3
 	};
@@ -2370,8 +2819,8 @@ function detectFramework(pkgJsonStr, pm) {
 		name: "fastify",
 		label: "Fastify",
 		type: "WEB",
-		buildCommand: pmRun(pm, "build"),
-		startCommand: pmRun(pm, "start"),
+		buildCommand: buildCmd,
+		startCommand: startCmd,
 		outputDir: null,
 		port: 3e3
 	};
@@ -2379,8 +2828,8 @@ function detectFramework(pkgJsonStr, pm) {
 		name: "nestjs",
 		label: "NestJS",
 		type: "WEB",
-		buildCommand: pmRun(pm, "build"),
-		startCommand: pmRun(pm, "start:prod"),
+		buildCommand: buildCmd ?? pmRun(pm, "build"),
+		startCommand: scripts["start:prod"] ? pmRun(pm, "start:prod") : startCmd ?? pmRun(pm, "start:prod"),
 		outputDir: "dist",
 		port: 3e3
 	};
@@ -2388,7 +2837,7 @@ function detectFramework(pkgJsonStr, pm) {
 		name: hasReact ? "vite-react" : "vite",
 		label: hasReact ? "Vite + React" : "Vite",
 		type: "STATIC",
-		buildCommand: pmRun(pm, "build"),
+		buildCommand: buildCmd ?? pmRun(pm, "build"),
 		startCommand: null,
 		outputDir: "dist",
 		port: 3e3
@@ -2397,17 +2846,17 @@ function detectFramework(pkgJsonStr, pm) {
 		name: "cra",
 		label: "Create React App",
 		type: "STATIC",
-		buildCommand: pmRun(pm, "build"),
+		buildCommand: buildCmd ?? pmRun(pm, "build"),
 		startCommand: null,
 		outputDir: "build",
 		port: 3e3
 	};
-	if (pkg.scripts?.build || pkg.scripts?.start) return {
+	if (buildCmd || startCmd) return {
 		name: "node",
 		label: "Node.js",
 		type: "WEB",
-		buildCommand: pkg.scripts?.build ? pmRun(pm, "build") : "",
-		startCommand: pkg.scripts?.start ? pmRun(pm, "start") : "node index.js",
+		buildCommand: buildCmd ?? "",
+		startCommand: startCmd,
 		outputDir: "dist",
 		port: 3e3
 	};
@@ -2549,6 +2998,104 @@ async function getFilesToUpload(directory) {
 	await walk(directory);
 	return files;
 }
+/**
+* Create a base tarball from the project directory (no extra files).
+* This is the expensive operation (file walk + gzip) that should happen once.
+*/
+async function createBaseTarball(directory) {
+	const tempDir = await mkdtemp(join(tmpdir(), "veloz-base-"));
+	const tarPath = join(tempDir, "source.tar.gz");
+	try {
+		const files = await getFilesToUpload(directory);
+		if (files.length === 0) throw new Error("No files to upload");
+		const relativePaths = files.map((f) => relative(directory, f));
+		await tar.create({
+			gzip: true,
+			file: tarPath,
+			cwd: directory
+		}, relativePaths);
+		return {
+			tarPath,
+			tempDir,
+			relativePaths,
+			directory
+		};
+	} catch (err) {
+		await rm(tempDir, {
+			recursive: true,
+			force: true
+		}).catch(() => {});
+		throw err;
+	}
+}
+/**
+* Create a service-specific tarball. If extraFiles need injection, creates
+* an overlay tarball using hardlinks from the base. Otherwise, returns the
+* base tarball path directly.
+*/
+async function createServiceTarball(base, extraFiles) {
+	const injectedFiles = [];
+	if (extraFiles) for (const file of extraFiles) {
+		if (existsSync(join(base.directory, file.name))) continue;
+		injectedFiles.push(file);
+	}
+	if (injectedFiles.length === 0) return {
+		tarPath: base.tarPath,
+		tempDir: null
+	};
+	const tempDir = await mkdtemp(join(tmpdir(), "veloz-overlay-"));
+	const tarPath = join(tempDir, "source.tar.gz");
+	const stagingDir = join(tempDir, "staging");
+	await mkdir(stagingDir, { recursive: true });
+	try {
+		const relativePaths = [...base.relativePaths];
+		for (const rel of relativePaths) {
+			const src = join(base.directory, rel);
+			const dest = join(stagingDir, rel);
+			await mkdir(dirname(dest), { recursive: true });
+			await link(src, dest);
+		}
+		for (const file of injectedFiles) {
+			writeFileSync(join(stagingDir, file.name), file.content);
+			if (!relativePaths.includes(file.name)) relativePaths.push(file.name);
+		}
+		await tar.create({
+			gzip: true,
+			file: tarPath,
+			cwd: stagingDir
+		}, relativePaths);
+		return {
+			tarPath,
+			tempDir
+		};
+	} catch (err) {
+		await rm(tempDir, {
+			recursive: true,
+			force: true
+		}).catch(() => {});
+		throw err;
+	}
+}
+/** Upload a pre-built tarball for a deployment. */
+async function uploadTarball(deploymentId, tarPath) {
+	const client = await getClient();
+	const { uploadUrl } = await client.deployments.getUploadUrl({ deploymentId });
+	const fileBuffer = readFileSync(tarPath);
+	const putResponse = await fetch(uploadUrl, {
+		method: "PUT",
+		headers: { "Content-Type": "application/gzip" },
+		body: fileBuffer
+	});
+	if (!putResponse.ok) throw new Error(`Upload falhou: ${putResponse.status}`);
+	await client.deployments.startBuild({ deploymentId });
+}
+/** Clean up shared tarball temp directory. */
+async function cleanupTarball(base) {
+	await rm(base.tempDir, {
+		recursive: true,
+		force: true
+	}).catch(() => {});
+}
 async function createTarball(directory, extraFiles) {
 	const tempDir = await mkdtemp(join(tmpdir(), "veloz-upload-"));
 	const tarPath = join(tempDir, "source.tar.gz");
@@ -2628,36 +3175,13 @@ async function calculateDirectorySize(directory) {
 	return totalSize;
 }
 
-//#endregion
-//#region src/lib/retry.ts
-async function withRetry(fn, maxRetries = 3) {
-	for (let attempt = 0; attempt <= maxRetries; attempt++) try {
-		return await fn();
-	} catch (error) {
-		if (attempt >= maxRetries) throw error;
-		const rateLimit = isRateLimitError(error);
-		if (rateLimit) {
-			const waitMs = Math.min(rateLimit.retryAfterMs, 3e4);
-			await new Promise((r) => {
-				setTimeout(r, waitMs);
-			});
-		} else {
-			const delay = Math.min(1e3 * Math.pow(2, attempt), 1e4);
-			await new Promise((r) => {
-				setTimeout(r, delay);
-			});
-		}
-	}
-	throw new Error("Max retries exceeded");
-}
-
 //#endregion
 //#region src/lib/deploy-constants.ts
 const statusLabels = {
 	QUEUED: "Na fila",
 	BUILDING: "Compilando",
-	BUILD_FAILED: "Falha na construção",
-	DEPLOYING: "Implantando",
+	BUILD_FAILED: "Falha na compilação",
+	DEPLOYING: "Realizando deploy",
 	LIVE: "Ativo",
 	FAILED: "Falhou",
 	CANCELLED: "Cancelado"
@@ -2693,33 +3217,7 @@ const TERMINAL_STATUSES = new Set([
 ]);
 
 //#endregion
-//#region src/lib/deploy-cancel.ts
-const activeDeploymentIds = /* @__PURE__ */ new Set();
-let sigintHandlerRegistered = false;
-function trackDeployment(deploymentId) {
-	activeDeploymentIds.add(deploymentId);
-}
-function untrackDeployment(deploymentId) {
-	activeDeploymentIds.delete(deploymentId);
-}
-function setupSigintHandler() {
-	if (sigintHandlerRegistered) return;
-	sigintHandlerRegistered = true;
-	process.on("SIGINT", async () => {
-		if (activeDeploymentIds.size === 0) process.exit(130);
-		if (process.stdout.isTTY) console.log(chalk.yellow("\n\nCancelando deploy(s)..."));
-		try {
-			const client = await getClient();
-			const cancelPromises = Array.from(activeDeploymentIds).map((deploymentId) => client.deployments.cancel({ deploymentId }).catch(() => {}));
-			await Promise.all(cancelPromises);
-			if (process.stdout.isTTY) console.log(chalk.yellow("Deploy cancelado."));
-		} catch {}
-		process.exit(130);
-	});
-}
-
-//#endregion
-//#region src/lib/deploy-parallel.ts
+//#region src/lib/deploy-stream.ts
 async function fetchDeployUrls$1(client, serviceId) {
 	try {
 		return (await client.domains.list({ serviceId })).map((d) => `https://${d.domain}`);
@@ -2743,256 +3241,6 @@ function getFailureHints$1(status) {
 		default: return ["Execute 'veloz logs -f' para mais detalhes."];
 	}
 }
-function renderProgress(progressMap, prevLineCount) {
-	for (let i = 0; i < prevLineCount; i++) process.stdout.write("\x1B[1A\x1B[2K");
-	let lineCount = 0;
-	for (const [, progress] of progressMap) {
-		const icon = statusIcons[progress.status] || chalk.gray("○");
-		const label = statusLabels[progress.status] || progress.status;
-		process.stdout.write(`${icon} ${chalk.bold(progress.serviceName)}: ${label}\n`);
-		lineCount++;
-		if (progress.status === "BUILDING" || progress.status === "BUILD_FAILED") {
-			const nonEmptyLines = progress.logLines.filter((l) => l.trim());
-			if (nonEmptyLines.length > 0) {
-				const tail = nonEmptyLines.slice(-3);
-				for (const line of tail) {
-					process.stdout.write(`  ${chalk.dim(line)}\n`);
-					lineCount++;
-				}
-			} else if (progress.status === "BUILDING") {
-				process.stdout.write(`  ${chalk.dim("Aguardando logs do build...")}\n`);
-				lineCount++;
-			}
-		} else if (progress.status === "QUEUED") {
-			process.stdout.write(`  ${chalk.dim("Na fila para construção...")}\n`);
-			lineCount++;
-		}
-	}
-	return lineCount;
-}
-async function deployServicesInParallel(services) {
-	const client = await getClient();
-	const mcp = isMcpMode();
-	const isTTY = !mcp && process.stdout.isTTY;
-	const isGHA = !mcp && process.env.GITHUB_ACTIONS === "true";
-	if (mcp) log(`[deploy] Iniciando deploy de ${services.length} serviço(s)`);
-	else if (isGHA) process.stdout.write(`Iniciando deploy de ${services.length} serviço(s)\n`);
-	else if (isTTY) console.log(chalk.cyan(`\nIniciando deploy de ${services.length} serviço(s)...\n`));
-	else process.stdout.write(`Iniciando deploy de ${services.length} serviço(s)\n`);
-	setupSigintHandler();
-	const progressMap = /* @__PURE__ */ new Map();
-	const projectRoot = process.cwd();
-	const sizeInBytes = await calculateDirectorySize(projectRoot);
-	const sizeMB = Math.round(sizeInBytes / (1024 * 1024) * 10) / 10;
-	const deploymentPromises = services.map(async (service) => {
-		try {
-			const deployment = await withRetry(() => client.deployments.create({
-				serviceId: service.serviceId,
-				serviceConfig: service.serviceConfig
-			}));
-			await withRetry(() => uploadSource(deployment.id, projectRoot, service.extraFiles));
-			trackDeployment(deployment.id);
-			progressMap.set(service.serviceId, {
-				serviceName: service.serviceName,
-				deploymentId: deployment.id,
-				status: "QUEUED",
-				logLines: [],
-				completed: false,
-				success: false
-			});
-			if (mcp) log(`[deploy] ✓ ${service.serviceName}: Upload concluído (${sizeMB} MB)`);
-			else if (isGHA) process.stdout.write(`✓ ${service.serviceName}: Upload concluído (${sizeMB} MB)\n`);
-			else if (isTTY) console.log(`${chalk.green("✓")} ${chalk.bold(service.serviceName)}: Upload concluído ${chalk.dim(`(${sizeMB} MB)`)}`);
-			else process.stdout.write(`✓ ${service.serviceName}: Upload concluído (${sizeMB} MB)\n`);
-			return {
-				service,
-				deploymentId: deployment.id
-			};
-		} catch (error) {
-			if (mcp) log(`[deploy] ✗ ${service.serviceName}: Falha ao iniciar deploy`);
-			else if (isGHA) process.stdout.write(`::error::${service.serviceName}: Falha ao iniciar deploy\n`);
-			else if (isTTY) console.log(`${chalk.red("✗")} ${chalk.bold(service.serviceName)}: Falha ao iniciar deploy`);
-			else process.stdout.write(`✗ ${service.serviceName}: Falha ao iniciar deploy\n`);
-			progressMap.set(service.serviceId, {
-				serviceName: service.serviceName,
-				deploymentId: "",
-				status: "FAILED",
-				logLines: [],
-				completed: true,
-				success: false
-			});
-			throw error;
-		}
-	});
-	const activeDeployments = (await Promise.allSettled(deploymentPromises)).filter((d) => d.status === "fulfilled").map((d) => d.value);
-	if (activeDeployments.length === 0) {
-		if (mcp) throw new Error("Todos os deploys falharam ao iniciar.");
-		else if (isGHA) process.stdout.write("::error::Todos os deploys falharam ao iniciar.\n");
-		else if (isTTY) console.error(chalk.red("\n✗ Todos os deploys falharam ao iniciar."));
-		else process.stdout.write("✗ Todos os deploys falharam ao iniciar.\n");
-		process.exit(1);
-	}
-	if (mcp) log(`[deploy] Monitorando ${activeDeployments.length} deploy(s)`);
-	else if (isGHA) process.stdout.write(`Monitorando ${activeDeployments.length} deploy(s)\n`);
-	else if (isTTY) {
-		console.log(chalk.cyan(`\nMonitorando progresso dos deploys:\n`));
-		console.log(chalk.dim("─".repeat(50)) + "\n");
-	} else process.stdout.write(`Monitorando ${activeDeployments.length} deploy(s)\n`);
-	let lineCount = 0;
-	if (isTTY) lineCount = renderProgress(progressMap, lineCount);
-	const streamPromises = activeDeployments.map(async ({ service, deploymentId }) => {
-		try {
-			await new Promise((resolve$1) => {
-				setTimeout(resolve$1, 1e3);
-			});
-			const stream = await client.logs.streamBuildLogs({ deploymentId });
-			for await (const event of stream) {
-				const progress = progressMap.get(service.serviceId);
-				if (!progress) continue;
-				if (event.type === "status") {
-					progress.status = event.content;
-					if (TERMINAL_STATUSES.has(event.content)) {
-						progress.completed = true;
-						progress.success = event.content === "LIVE";
-					}
-					if (mcp) {
-						const label = statusLabels[event.content] || event.content;
-						log(`[deploy] [${service.serviceName}] ${label}`);
-					} else if (!isTTY) {
-						const label = statusLabels[event.content] || event.content;
-						process.stdout.write(`[${service.serviceName}] ${label}\n`);
-					}
-				} else if (event.type === "log") {
-					const newLines = event.content.split("\n").filter((l) => l.trim());
-					progress.logLines.push(...newLines);
-					if (mcp) for (const line of newLines) log(`[build] [${service.serviceName}] ${line}`);
-					else if (!isTTY) for (const line of newLines) process.stdout.write(`[${service.serviceName}] ${line}\n`);
-				}
-				if (isTTY) lineCount = renderProgress(progressMap, lineCount);
-			}
-		} catch (error) {
-			const errorMessage = error instanceof Error ? error.message : String(error);
-			const progress = progressMap.get(service.serviceId);
-			if (progress && !progress.completed) {
-				if (mcp) log(`[deploy] ✗ Erro no streaming de logs para ${service.serviceName}: ${errorMessage}`);
-				else if (isGHA) process.stdout.write(`::error::Erro no streaming de logs para ${service.serviceName}: ${errorMessage}\n`);
-				else if (!isTTY) process.stdout.write(`✗ Erro no streaming de logs para ${service.serviceName}: ${errorMessage}\n`);
-				progress.status = "FAILED";
-				progress.completed = true;
-				if (isTTY) lineCount = renderProgress(progressMap, lineCount);
-			}
-		} finally {
-			untrackDeployment(deploymentId);
-		}
-	});
-	await Promise.all(streamPromises);
-	if (isTTY) renderProgress(progressMap, lineCount);
-	const successfulEntries = Array.from(progressMap.entries()).filter(([, p]) => p.success);
-	const failedEntries = Array.from(progressMap.entries()).filter(([, p]) => !p.success);
-	const urlMap = /* @__PURE__ */ new Map();
-	await Promise.all(successfulEntries.map(async ([serviceId]) => {
-		const urls = await fetchDeployUrls$1(client, serviceId);
-		if (urls.length > 0) urlMap.set(serviceId, urls);
-	}));
-	if (isTTY) console.log(chalk.dim("\n" + "─".repeat(50)));
-	if (successfulEntries.length > 0) if (mcp) {
-		log(`[deploy] ✓ ${successfulEntries.length} serviço(s) implantado(s) com sucesso`);
-		for (const [serviceId, progress] of successfulEntries) {
-			log(`[deploy]   ✓ ${progress.serviceName}`);
-			for (const url of urlMap.get(serviceId) ?? []) log(`[deploy]     ${url}`);
-		}
-	} else if (isGHA) {
-		process.stdout.write(`\n✓ ${successfulEntries.length} serviço(s) implantado(s) com sucesso\n`);
-		for (const [serviceId, progress] of successfulEntries) {
-			process.stdout.write(`  ✓ ${progress.serviceName}\n`);
-			for (const url of urlMap.get(serviceId) ?? []) process.stdout.write(`    ${url}\n`);
-		}
-	} else if (isTTY) {
-		console.log(chalk.green(`\n✓ ${successfulEntries.length} serviço(s) implantado(s) com sucesso:\n`));
-		for (const [serviceId, progress] of successfulEntries) {
-			console.log(`  ${chalk.green("✓")} ${chalk.bold(progress.serviceName)}`);
-			for (const url of urlMap.get(serviceId) ?? []) console.log(`    ${chalk.cyan(url)}`);
-		}
-	} else {
-		process.stdout.write(`\n${successfulEntries.length} serviço(s) implantado(s) com sucesso:\n`);
-		for (const [serviceId, progress] of successfulEntries) {
-			process.stdout.write(`  ✓ ${progress.serviceName}\n`);
-			for (const url of urlMap.get(serviceId) ?? []) process.stdout.write(`    ${url}\n`);
-		}
-	}
-	if (failedEntries.length > 0) if (mcp) {
-		log(`[deploy] ✗ ${failedEntries.length} serviço(s) falhou(aram)`);
-		for (const [, progress] of failedEntries) {
-			log(`[deploy]   ✗ ${progress.serviceName} (${progress.status})`);
-			const hints = getFailureHints$1(progress.status);
-			for (const hint of hints) log(`[deploy]     → ${hint}`);
-		}
-	} else if (isGHA) {
-		process.stdout.write(`\n✗ ${failedEntries.length} serviço(s) falhou(aram)\n`);
-		for (const [, progress] of failedEntries) {
-			process.stdout.write(`::error::${progress.serviceName} falhou (${progress.status})\n`);
-			const hints = getFailureHints$1(progress.status);
-			for (const hint of hints) process.stdout.write(`  ${hint}\n`);
-		}
-	} else if (isTTY) {
-		console.log(chalk.red(`\n✗ ${failedEntries.length} serviço(s) falhou(aram):\n`));
-		for (const [, progress] of failedEntries) {
-			console.log(`  ${chalk.red("✗")} ${chalk.bold(progress.serviceName)} ${chalk.dim(`(${progress.status})`)}`);
-			if (progress.logLines.length > 0) {
-				console.log(chalk.red(`  ${"─".repeat(50)}`));
-				console.log(chalk.red.bold("  Logs de build:"));
-				console.log(chalk.red(`  ${"─".repeat(50)}`));
-				for (const line of progress.logLines) if (line.trim()) console.log(`  ${chalk.dim(line)}`);
-				console.log(chalk.red(`  ${"─".repeat(50)}`));
-			}
-			const hints = getFailureHints$1(progress.status);
-			for (const hint of hints) console.log(chalk.yellow(`  → ${hint}`));
-		}
-	} else {
-		process.stdout.write(`\n${failedEntries.length} serviço(s) falhou(aram):\n`);
-		for (const [, progress] of failedEntries) {
-			process.stdout.write(`\n  ✗ ${progress.serviceName} (${progress.status})\n`);
-			const hints = getFailureHints$1(progress.status);
-			for (const hint of hints) process.stdout.write(`    → ${hint}\n`);
-		}
-	}
-	if (successfulEntries.length > 0) info("\nUse 'veloz logs -f' para acompanhar os logs de execução.");
-	const results = [];
-	for (const [serviceId, progress] of progressMap) results.push({
-		status: progress.status,
-		logs: progress.logLines.filter((l) => l.trim()),
-		urls: urlMap.get(serviceId) ?? [],
-		serviceName: progress.serviceName
-	});
-	if (failedEntries.length > 0 && !mcp) process.exit(1);
-	return results;
-}
-
-//#endregion
-//#region src/lib/deploy-stream.ts
-async function fetchDeployUrls(client, serviceId) {
-	try {
-		return (await client.domains.list({ serviceId })).map((d) => `https://${d.domain}`);
-	} catch {
-		return [];
-	}
-}
-function getFailureHints(status) {
-	switch (status) {
-		case "BUILD_FAILED": return [
-			"Verifique os logs de build acima para erros de compilação",
-			"Teste o build localmente: rode o comando de build do seu projeto",
-			"Use 'veloz config show' para verificar as configurações"
-		];
-		case "DEPLOY_FAILED": return [
-			"O build passou mas o serviço falhou ao iniciar",
-			"Verifique se a porta configurada está correta: 'veloz config show'",
-			"Veja os logs de runtime: 'veloz logs -f'"
-		];
-		case "CANCELLED": return ["Deploy cancelado. Execute 'veloz deploy' para tentar novamente."];
-		default: return ["Execute 'veloz logs -f' para mais detalhes."];
-	}
-}
 /** Raw BuildKit line: `#N content` */
 const BUILDKIT_PREFIX_RE = /^#(\d+)\s+(.*)/;
 /** Docker build step: `[stage step/total] COMMAND` */
@@ -3374,7 +3622,7 @@ async function streamDeploymentLogs(deploymentId, serviceId, serviceName) {
 	}
 	if (isGHA) endGroup();
 	if (renderer) renderer.stopSpinner();
-	const urls = finalStatus === "LIVE" ? await fetchDeployUrls(client, serviceId) : [];
+	const urls = finalStatus === "LIVE" ? await fetchDeployUrls$1(client, serviceId) : [];
 	if (finalStatus === "LIVE") {
 		if (buildSpinner) {
 			buildSpinner.stop();
@@ -3388,7 +3636,7 @@ async function streamDeploymentLogs(deploymentId, serviceId, serviceName) {
 			buildSpinner = null;
 		}
 		const label = statusLabels[finalStatus] ?? finalStatus;
-		const hints = getFailureHints(finalStatus);
+		const hints = getFailureHints$1(finalStatus);
 		if (mcp) {
 			log(`✗ Deploy finalizou: ${label}`);
 			for (const hint of hints) log(`  → ${hint}`);
@@ -3418,63 +3666,31 @@ async function streamDeploymentLogs(deploymentId, serviceId, serviceName) {
 		serviceName
 	};
 }
-/**
-* MCP streaming variant — yields progress events as an async generator.
-* Each yield becomes an MCP `notifications/progress` message if the client
-* provides a progressToken.
-*/
-async function* streamDeploymentLogsMcp(deploymentId, serviceId, serviceName) {
-	const client = await getClient();
-	const allLogLines = [];
-	let finalStatus = "";
-	yield {
-		type: "status",
-		message: serviceName ? `Build: ${serviceName}` : "Build iniciando..."
-	};
-	try {
-		const stream = await client.logs.streamBuildLogs({ deploymentId });
-		for await (const event of stream) if (event.type === "status") {
-			const label = statusLabels[event.content] ?? event.content;
-			finalStatus = event.content;
-			yield {
-				type: "status",
-				message: label
-			};
-		} else if (event.type === "log") {
-			const lines = event.content.split("\n").filter((l) => l.trim());
-			allLogLines.push(...lines);
-			for (const line of lines) yield {
-				type: "log",
-				message: line
-			};
-		}
-	} catch {
+
+//#endregion
+//#region src/lib/deploy-cancel.ts
+const activeDeploymentIds = /* @__PURE__ */ new Set();
+let sigintHandlerRegistered = false;
+function trackDeployment(deploymentId) {
+	activeDeploymentIds.add(deploymentId);
+}
+function untrackDeployment(deploymentId) {
+	activeDeploymentIds.delete(deploymentId);
+}
+function setupSigintHandler() {
+	if (sigintHandlerRegistered) return;
+	sigintHandlerRegistered = true;
+	process.on("SIGINT", async () => {
+		if (activeDeploymentIds.size === 0) process.exit(130);
+		if (process.stdout.isTTY) console.log(chalk.yellow("\n\nCancelando deploy(s)..."));
 		try {
-			finalStatus = (await client.deployments.get({ deploymentId })).status;
-			try {
-				const logs = await client.logs.getBuildLogs({ deploymentId });
-				if (logs.buildLogs) {
-					const lines = logs.buildLogs.split("\n").filter((l) => l.trim());
-					allLogLines.push(...lines);
-					for (const line of lines) yield {
-						type: "log",
-						message: line
-					};
-				}
-			} catch {}
+			const client = await getClient();
+			const cancelPromises = Array.from(activeDeploymentIds).map((deploymentId) => client.deployments.cancel({ deploymentId }).catch(() => {}));
+			await Promise.all(cancelPromises);
+			if (process.stdout.isTTY) console.log(chalk.yellow("Deploy cancelado."));
 		} catch {}
-	}
-	const urls = finalStatus === "LIVE" ? await fetchDeployUrls(client, serviceId) : [];
-	yield {
-		type: "result",
-		message: finalStatus === "LIVE" ? "Deploy concluído" : `Deploy finalizou: ${finalStatus}`,
-		data: {
-			status: finalStatus,
-			logs: allLogLines,
-			urls,
-			serviceName
-		}
-	};
+		process.exit(130);
+	});
 }
 
 //#endregion
@@ -3486,7 +3702,7 @@ const LOGO_LINES = [
 ];
 const BRAND_COLOR = "#FF4D00";
 function getVersion() {
-	return "0.0.0-beta.16";
+	return "0.0.0-beta.18";
 }
 function printBanner(subtitle) {
 	const version = getVersion();
@@ -3508,29 +3724,527 @@ function printBanner(subtitle) {
 	console.log();
 }
 
+//#endregion
+//#region src/lib/retry.ts
+async function withRetry(fn, maxRetries = 3) {
+	for (let attempt = 0; attempt <= maxRetries; attempt++) try {
+		return await fn();
+	} catch (error) {
+		if (attempt >= maxRetries) throw error;
+		const rateLimit = isRateLimitError(error);
+		if (rateLimit) {
+			const waitMs = Math.min(rateLimit.retryAfterMs, 3e4);
+			await new Promise((r) => {
+				setTimeout(r, waitMs);
+			});
+		} else {
+			const delay = Math.min(1e3 * Math.pow(2, attempt), 1e4);
+			await new Promise((r) => {
+				setTimeout(r, delay);
+			});
+		}
+	}
+	throw new Error("Max retries exceeded");
+}
+
+//#endregion
+//#region src/lib/deploy-core.ts
+async function fetchDeployUrls(client, serviceId) {
+	try {
+		return (await client.domains.list({ serviceId })).map((d) => `https://${d.domain}`);
+	} catch {
+		return [];
+	}
+}
+/**
+* Deploy a single service using the full streamDeploymentLogs experience
+* (BuildProgressRenderer with progress bars, spinner, runtime logs).
+*/
+async function deploySingleService(service, options) {
+	const { projectRoot } = options;
+	const client = await getClient();
+	const sizeInBytes = await calculateDirectorySize(projectRoot);
+	const sizeMB = Math.round(sizeInBytes / (1024 * 1024) * 10) / 10;
+	const baseTarball = await createBaseTarball(projectRoot);
+	const deployment = await withRetry(() => client.deployments.create({
+		serviceId: service.serviceId,
+		serviceConfig: service.serviceConfig
+	}));
+	const { tarPath, tempDir: overlayTempDir } = await createServiceTarball(baseTarball, service.extraFiles);
+	try {
+		await withRetry(() => uploadTarball(deployment.id, tarPath));
+	} finally {
+		if (overlayTempDir) await rm(overlayTempDir, {
+			recursive: true,
+			force: true
+		}).catch(() => {});
+		await cleanupTarball(baseTarball);
+	}
+	if (sizeMB > 5) info(`Upload concluído (${sizeMB} MB)`);
+	else success(`Upload concluído`);
+	setupSigintHandler();
+	trackDeployment(deployment.id);
+	try {
+		return [await streamDeploymentLogs(deployment.id, service.serviceId, service.serviceName)];
+	} finally {
+		untrackDeployment(deployment.id);
+	}
+}
+/**
+* Deploy multiple services in parallel with progress tracking.
+*/
+async function deployMultipleServices(services, options) {
+	const { projectRoot, output } = options;
+	const client = await getClient();
+	const isTTY = process.stdout.isTTY && !process.env.GITHUB_ACTIONS;
+	setupSigintHandler();
+	const sizeInBytes = await calculateDirectorySize(projectRoot);
+	const sizeMB = Math.round(sizeInBytes / (1024 * 1024) * 10) / 10;
+	const baseTarball = await createBaseTarball(projectRoot);
+	const progressMap = /* @__PURE__ */ new Map();
+	const deploymentPromises = services.map(async (service) => {
+		try {
+			const deployment = await withRetry(() => client.deployments.create({
+				serviceId: service.serviceId,
+				serviceConfig: service.serviceConfig
+			}));
+			const { tarPath, tempDir: overlayTempDir } = await createServiceTarball(baseTarball, service.extraFiles);
+			try {
+				await withRetry(() => uploadTarball(deployment.id, tarPath));
+			} finally {
+				if (overlayTempDir) await rm(overlayTempDir, {
+					recursive: true,
+					force: true
+				}).catch(() => {});
+			}
+			trackDeployment(deployment.id);
+			progressMap.set(service.serviceId, {
+				serviceName: service.serviceName,
+				status: "QUEUED",
+				logLines: [],
+				completed: false,
+				success: false
+			});
+			output.uploadComplete(service.serviceName, sizeMB);
+			return {
+				service,
+				deploymentId: deployment.id
+			};
+		} catch (error) {
+			output.uploadFailed(service.serviceName);
+			progressMap.set(service.serviceId, {
+				serviceName: service.serviceName,
+				status: "FAILED",
+				logLines: [],
+				completed: true,
+				success: false
+			});
+			throw error;
+		}
+	});
+	const deployments = await Promise.allSettled(deploymentPromises);
+	await cleanupTarball(baseTarball);
+	const activeDeployments = deployments.filter((d) => d.status === "fulfilled").map((d) => d.value);
+	if (activeDeployments.length === 0) {
+		output.allUploadsFailed();
+		process.exit(1);
+	}
+	output.monitoringStart(activeDeployments.length);
+	if (isTTY) output.initProgress(progressMap);
+	const streamPromises = activeDeployments.map(async ({ service, deploymentId }) => {
+		try {
+			await new Promise((resolve$1) => {
+				setTimeout(resolve$1, 1e3);
+			});
+			const stream = await client.logs.streamBuildLogs({ deploymentId });
+			for await (const event of stream) {
+				const progress = progressMap.get(service.serviceId);
+				if (!progress) continue;
+				if (event.type === "status") {
+					progress.status = event.content;
+					if (TERMINAL_STATUSES.has(event.content)) {
+						progress.completed = true;
+						progress.success = event.content === "LIVE";
+					}
+					if (!isTTY) output.statusUpdate(service.serviceName, event.content);
+				} else if (event.type === "log") {
+					const newLines = event.content.split("\n").filter((l) => l.trim());
+					progress.logLines.push(...newLines);
+					if (!isTTY) for (const line of newLines) output.logLine(service.serviceName, line);
+				}
+				if (isTTY) output.renderProgress(progressMap);
+			}
+		} catch (error) {
+			const errorMessage = error instanceof Error ? error.message : String(error);
+			const progress = progressMap.get(service.serviceId);
+			if (progress && !progress.completed) {
+				output.streamError(service.serviceName, errorMessage);
+				progress.status = "FAILED";
+				progress.completed = true;
+				if (isTTY) output.renderProgress(progressMap);
+			}
+		} finally {
+			untrackDeployment(deploymentId);
+		}
+	});
+	await Promise.all(streamPromises);
+	if (isTTY) output.renderProgress(progressMap);
+	const successfulEntries = Array.from(progressMap.entries()).filter(([, p]) => p.success);
+	const failedEntries = Array.from(progressMap.entries()).filter(([, p]) => !p.success);
+	const urlMap = /* @__PURE__ */ new Map();
+	await Promise.all(successfulEntries.map(async ([serviceId]) => {
+		const urls = await fetchDeployUrls(client, serviceId);
+		if (urls.length > 0) urlMap.set(serviceId, urls);
+	}));
+	const successful = successfulEntries.map(([serviceId, p]) => ({
+		serviceId,
+		serviceName: p.serviceName,
+		status: p.status,
+		logLines: p.logLines.filter((l) => l.trim()),
+		urls: urlMap.get(serviceId) ?? []
+	}));
+	const failed = failedEntries.map(([serviceId, p]) => ({
+		serviceId,
+		serviceName: p.serviceName,
+		status: p.status,
+		logLines: p.logLines.filter((l) => l.trim()),
+		urls: []
+	}));
+	output.printSummary(successful, failed);
+	if (successful.length > 0) output.printFollowUp();
+	const results = [];
+	for (const [serviceId, progress] of progressMap) results.push({
+		status: progress.status,
+		logs: progress.logLines.filter((l) => l.trim()),
+		urls: urlMap.get(serviceId) ?? [],
+		serviceName: progress.serviceName
+	});
+	if (failed.length > 0 && !process.env.VELOZ_MCP) process.exit(1);
+	return results;
+}
+/**
+* Unified deploy function for 1-to-N services.
+*
+* - Single service: uses the full streamDeploymentLogs experience
+*   (BuildProgressRenderer with progress bars, spinner, runtime logs)
+* - Multiple services: parallel deploy with compact progress tracking
+*/
+async function deployServices(services, options) {
+	if (services.length === 1) return deploySingleService(services[0], options);
+	return deployMultipleServices(services, options);
+}
+
+//#endregion
+//#region src/lib/deploy-output-tty.ts
+var TtyOutput = class {
+	prevLineCount = 0;
+	startDeploy(serviceCount) {
+		console.log(chalk.cyan(`\nIniciando deploy de ${serviceCount} serviço(s)...\n`));
+	}
+	uploadComplete(serviceName, sizeMB) {
+		console.log(`${chalk.green("✓")} ${chalk.bold(serviceName)}: Upload concluído ${chalk.dim(`(${sizeMB} MB)`)}`);
+	}
+	uploadFailed(serviceName) {
+		console.log(`${chalk.red("✗")} ${chalk.bold(serviceName)}: Falha ao iniciar deploy`);
+	}
+	allUploadsFailed() {
+		console.error(chalk.red("\n✗ Todos os deploys falharam ao iniciar."));
+	}
+	monitoringStart(_activeCount) {
+		console.log(chalk.cyan(`\nMonitorando progresso dos deploys:\n`));
+		console.log(chalk.dim("─".repeat(50)) + "\n");
+	}
+	statusUpdate(_serviceName, _status) {}
+	logLine(_serviceName, _line) {}
+	streamError(_serviceName, _error) {}
+	initProgress(entries) {
+		this.prevLineCount = this.doRenderProgress(entries, 0);
+	}
+	renderProgress(entries) {
+		this.prevLineCount = this.doRenderProgress(entries, this.prevLineCount);
+	}
+	doRenderProgress(progressMap, prevLineCount) {
+		for (let i = 0; i < prevLineCount; i++) process.stdout.write("\x1B[1A\x1B[2K");
+		let lineCount = 0;
+		for (const [, progress] of progressMap) {
+			const icon = statusIcons[progress.status] || chalk.gray("○");
+			const label = statusLabels[progress.status] || progress.status;
+			process.stdout.write(`${icon} ${chalk.bold(progress.serviceName)}: ${label}\n`);
+			lineCount++;
+			if (progress.status === "BUILDING" || progress.status === "BUILD_FAILED") {
+				const nonEmptyLines = progress.logLines.filter((l) => l.trim());
+				if (nonEmptyLines.length > 0) {
+					const tail = nonEmptyLines.slice(-3);
+					for (const line of tail) {
+						process.stdout.write(`  ${chalk.dim(line)}\n`);
+						lineCount++;
+					}
+				} else if (progress.status === "BUILDING") {
+					process.stdout.write(`  ${chalk.dim("Aguardando logs do build...")}\n`);
+					lineCount++;
+				}
+			} else if (progress.status === "QUEUED") {
+				process.stdout.write(`  ${chalk.dim("Na fila para compilação...")}\n`);
+				lineCount++;
+			}
+		}
+		return lineCount;
+	}
+	buildStart(_serviceName) {}
+	buildEnd() {}
+	printSummary(successful, failed) {
+		console.log(chalk.dim("\n" + "─".repeat(50)));
+		if (successful.length > 0) {
+			console.log(chalk.green(`\n✓ ${successful.length} serviço(s) com deploy concluído:\n`));
+			for (const entry of successful) {
+				console.log(`  ${chalk.green("✓")} ${chalk.bold(entry.serviceName)}`);
+				for (const url of entry.urls) console.log(`    ${chalk.cyan(url)}`);
+			}
+		}
+		if (failed.length > 0) {
+			console.log(chalk.red(`\n✗ ${failed.length} serviço(s) falhou(aram):\n`));
+			for (const entry of failed) {
+				console.log(`  ${chalk.red("✗")} ${chalk.bold(entry.serviceName)} ${chalk.dim(`(${entry.status})`)}`);
+				if (entry.logLines.length > 0) {
+					console.log(chalk.red(`  ${"─".repeat(50)}`));
+					console.log(chalk.red.bold("  Logs de build:"));
+					console.log(chalk.red(`  ${"─".repeat(50)}`));
+					for (const line of entry.logLines) if (line.trim()) console.log(`  ${chalk.dim(line)}`);
+					console.log(chalk.red(`  ${"─".repeat(50)}`));
+				}
+				const hints = getFailureHints(entry.status);
+				for (const hint of hints) console.log(chalk.yellow(`  → ${hint}`));
+			}
+		}
+	}
+	printFollowUp() {
+		console.log(chalk.cyan("\nℹ Use 'veloz logs -f' para acompanhar os logs de execução."));
+	}
+};
+
+//#endregion
+//#region src/lib/deploy-output-plain.ts
+var PlainOutput = class {
+	startDeploy(serviceCount) {
+		process.stdout.write(`Iniciando deploy de ${serviceCount} serviço(s)\n`);
+	}
+	uploadComplete(serviceName, sizeMB) {
+		process.stdout.write(`✓ ${serviceName}: Upload concluído (${sizeMB} MB)\n`);
+	}
+	uploadFailed(serviceName) {
+		process.stdout.write(`✗ ${serviceName}: Falha ao iniciar deploy\n`);
+	}
+	allUploadsFailed() {
+		process.stdout.write("✗ Todos os deploys falharam ao iniciar.\n");
+	}
+	monitoringStart(activeCount) {
+		process.stdout.write(`Monitorando ${activeCount} deploy(s)\n`);
+	}
+	statusUpdate(serviceName, status) {
+		const label = statusLabels[status] || status;
+		process.stdout.write(`[${serviceName}] ${label}\n`);
+	}
+	logLine(serviceName, line) {
+		process.stdout.write(`[${serviceName}] ${line}\n`);
+	}
+	streamError(serviceName, error) {
+		process.stdout.write(`✗ Erro no streaming de logs para ${serviceName}: ${error}\n`);
+	}
+	initProgress(_entries) {}
+	renderProgress(_entries) {}
+	buildStart(_serviceName) {}
+	buildEnd() {}
+	printSummary(successful, failed) {
+		if (successful.length > 0) {
+			process.stdout.write(`\n${successful.length} serviço(s) com deploy concluído:\n`);
+			for (const entry of successful) {
+				process.stdout.write(`  ✓ ${entry.serviceName}\n`);
+				for (const url of entry.urls) process.stdout.write(`    ${url}\n`);
+			}
+		}
+		if (failed.length > 0) {
+			process.stdout.write(`\n${failed.length} serviço(s) falhou(aram):\n`);
+			for (const entry of failed) {
+				process.stdout.write(`\n  ✗ ${entry.serviceName} (${entry.status})\n`);
+				const hints = getFailureHints(entry.status);
+				for (const hint of hints) process.stdout.write(`    → ${hint}\n`);
+			}
+		}
+	}
+	printFollowUp() {
+		process.stdout.write("Use 'veloz logs -f' para acompanhar os logs de execução.\n");
+	}
+};
+
+//#endregion
+//#region src/lib/deploy-output-gha.ts
+var GhaOutput = class {
+	startDeploy(serviceCount) {
+		process.stdout.write(`Iniciando deploy de ${serviceCount} serviço(s)\n`);
+	}
+	uploadComplete(serviceName, sizeMB) {
+		process.stdout.write(`✓ ${serviceName}: Upload concluído (${sizeMB} MB)\n`);
+	}
+	uploadFailed(serviceName) {
+		process.stdout.write(`::error::${serviceName}: Falha ao iniciar deploy\n`);
+	}
+	allUploadsFailed() {
+		process.stdout.write("::error::Todos os deploys falharam ao iniciar.\n");
+	}
+	monitoringStart(activeCount) {
+		process.stdout.write(`Monitorando ${activeCount} deploy(s)\n`);
+	}
+	statusUpdate(serviceName, status) {
+		const label = statusLabels[status] || status;
+		process.stdout.write(`[${serviceName}] ${label}\n`);
+	}
+	logLine(serviceName, line) {
+		process.stdout.write(`[${serviceName}] ${line}\n`);
+	}
+	streamError(serviceName, error) {
+		process.stdout.write(`::error::Erro no streaming de logs para ${serviceName}: ${error}\n`);
+	}
+	initProgress(_entries) {}
+	renderProgress(_entries) {}
+	buildStart(serviceName) {
+		startGroup(serviceName ? `Build: ${serviceName}` : "Build");
+	}
+	buildEnd() {
+		endGroup();
+	}
+	printSummary(successful, failed) {
+		if (successful.length > 0) {
+			process.stdout.write(`\n✓ ${successful.length} serviço(s) com deploy concluído\n`);
+			for (const entry of successful) {
+				process.stdout.write(`  ✓ ${entry.serviceName}\n`);
+				for (const url of entry.urls) process.stdout.write(`    ${url}\n`);
+			}
+		}
+		if (failed.length > 0) {
+			process.stdout.write(`\n✗ ${failed.length} serviço(s) falhou(aram)\n`);
+			for (const entry of failed) {
+				process.stdout.write(`::error::${entry.serviceName} falhou (${entry.status})\n`);
+				const hints = getFailureHints(entry.status);
+				for (const hint of hints) process.stdout.write(`  ${hint}\n`);
+			}
+		}
+	}
+	printFollowUp() {
+		process.stdout.write("Use 'veloz logs -f' para acompanhar os logs de execução.\n");
+	}
+};
+
+//#endregion
+//#region src/lib/deploy-output-mcp.ts
+var McpOutput = class {
+	startDeploy(serviceCount) {
+		log(`[deploy] Iniciando deploy de ${serviceCount} serviço(s)`);
+	}
+	uploadComplete(serviceName, sizeMB) {
+		log(`[deploy] ✓ ${serviceName}: Upload concluído (${sizeMB} MB)`);
+	}
+	uploadFailed(serviceName) {
+		log(`[deploy] ✗ ${serviceName}: Falha ao iniciar deploy`);
+	}
+	allUploadsFailed() {
+		throw new Error("Todos os deploys falharam ao iniciar.");
+	}
+	monitoringStart(activeCount) {
+		log(`[deploy] Monitorando ${activeCount} deploy(s)`);
+	}
+	statusUpdate(serviceName, status) {
+		log(`[deploy] [${serviceName}] ${statusLabels[status] || status}`);
+	}
+	logLine(serviceName, line) {
+		log(`[build] [${serviceName}] ${line}`);
+	}
+	streamError(serviceName, error) {
+		log(`[deploy] ✗ Erro no streaming de logs para ${serviceName}: ${error}`);
+	}
+	initProgress(_entries) {}
+	renderProgress(_entries) {}
+	buildStart(_serviceName) {}
+	buildEnd() {}
+	printSummary(successful, failed) {
+		if (successful.length > 0) {
+			log(`[deploy] ✓ ${successful.length} serviço(s) com deploy concluído`);
+			for (const entry of successful) {
+				log(`[deploy]   ✓ ${entry.serviceName}`);
+				for (const url of entry.urls) log(`[deploy]     ${url}`);
+			}
+		}
+		if (failed.length > 0) {
+			log(`[deploy] ✗ ${failed.length} serviço(s) falhou(aram)`);
+			for (const entry of failed) {
+				log(`[deploy]   ✗ ${entry.serviceName} (${entry.status})`);
+				const hints = getFailureHints(entry.status);
+				for (const hint of hints) log(`[deploy]     → ${hint}`);
+			}
+		}
+	}
+	printFollowUp() {
+		log("[deploy] Use 'veloz logs -f' para acompanhar os logs de execução.");
+	}
+};
+
+//#endregion
+//#region src/lib/deploy-output.ts
+function getFailureHints(status) {
+	switch (status) {
+		case "BUILD_FAILED": return [
+			"Verifique os logs de build acima para erros de compilação",
+			"Teste o build localmente: rode o comando de build do seu projeto",
+			"Use 'veloz config show' para verificar as configurações"
+		];
+		case "DEPLOY_FAILED": return [
+			"O build passou mas o serviço falhou ao iniciar",
+			"Verifique se a porta configurada está correta: 'veloz config show'",
+			"Veja os logs de runtime: 'veloz logs -f'"
+		];
+		case "CANCELLED": return ["Deploy cancelado. Execute 'veloz deploy' para tentar novamente."];
+		default: return ["Execute 'veloz logs -f' para mais detalhes."];
+	}
+}
+function createDeployOutput() {
+	if (isMcpMode()) return new McpOutput();
+	if (process.env.GITHUB_ACTIONS === "true") return new GhaOutput();
+	if (process.stdout.isTTY) return new TtyOutput();
+	return new PlainOutput();
+}
+
 //#endregion
 //#region src/lib/deploy-config.ts
 function resolveServiceConf(velozConfig, serviceId) {
 	if (!velozConfig) return void 0;
 	for (const [, conf] of Object.entries(velozConfig.services)) if (conf.id === serviceId) {
 		const merged = mergeServiceWithDefaults(conf, velozConfig.defaults);
+		const build = merged.build;
+		const isDockerfile = build?.method === "dockerfile";
 		return {
 			type: merged.type?.toUpperCase(),
 			branch: merged.branch,
-			buildCommand: merged.build?.command ?? void 0,
+			buildCommand: build?.command ?? void 0,
 			startCommand: merged.runtime?.command ?? void 0,
+			preStartCommand: merged.runtime?.preStartCommand ?? void 0,
 			port: merged.runtime?.port ?? void 0,
 			rootDirectory: merged.root,
+			docker: isDockerfile ? {
+				dockerfile: build.dockerfile ?? "Dockerfile",
+				context: build.context ?? merged.root ?? "."
+			} : void 0,
 			instanceCount: merged.resources?.instances ?? void 0,
 			cpuLimit: merged.resources?.cpu ?? void 0,
 			memoryLimit: merged.resources?.memory ?? void 0,
 			healthCheckPath: merged.runtime?.healthCheck?.path ?? null,
-			aptPackages: merged.build?.aptPackages ?? void 0,
-			nodeVersion: merged.build?.nodeVersion ?? void 0,
-			nixpkgsArchive: merged.build?.nixpkgsArchive ?? void 0,
-			packageManager: merged.build?.packageManager,
-			installCommand: merged.build?.installCommand ?? void 0,
-			volumes: merged.volumes ?? void 0
+			aptPackages: build?.aptPackages ?? void 0,
+			nodeVersion: build?.nodeVersion ?? void 0,
+			nixpkgsArchive: build?.nixpkgsArchive ?? void 0,
+			packageManager: build?.packageManager,
+			installCommand: build?.installCommand ?? void 0,
+			volumes: merged.volumes?.map((v) => ({
+				...v,
+				sizeGb: v.sizeGb ?? 10
+			})) ?? void 0
 		};
 	}
 }
@@ -3958,7 +4672,7 @@ async function autoUpdate() {
 	if (process.env.VELOZ_MCP === "true") return;
 	const pm = detectPackageManager();
 	if (!pm) return;
-	const currentVersion = "0.0.0-beta.16";
+	const currentVersion = "0.0.0-beta.18";
 	const latestVersion = await fetchLatestVersion();
 	if (!latestVersion || latestVersion === currentVersion) return;
 	const installCmd = getInstallCommand(pm, latestVersion);
@@ -3990,26 +4704,27 @@ async function provisionDatabases(config, opts) {
 		text: "Verificando bancos de dados...",
 		fn: () => client.databases.list({ projectId })
 	});
-	let updatedConfig = { ...config };
+	const idUpdates = {};
 	for (const [key, dbConfig] of entries) {
 		const existing = serverDatabases.find((d) => dbConfig.id && d.id === dbConfig.id || d.name === key);
 		if (existing) {
-			if (!dbConfig.id || dbConfig.id !== existing.id) updatedConfig = {
-				...updatedConfig,
-				databases: {
-					...updatedConfig.databases,
-					[key]: {
-						...dbConfig,
-						id: existing.id
-					}
-				}
-			};
+			if (!dbConfig.id || dbConfig.id !== existing.id) idUpdates[key] = existing.id;
 			if (existing.databaseStatus === "FAILED") {
 				warn(`Banco de dados "${key}" está com status FAILED no servidor.`);
 				console.log(chalk.dim(`  Use 'veloz db restart ${key}' para tentar reiniciar.`));
 				console.log();
-			} else if (existing.databaseStatus === "PENDING" || existing.databaseStatus === "PROVISIONING" || existing.databaseStatus === "WAITING_ON_PROVIDER") info(`Banco de dados "${key}" ainda está sendo provisionado (${existing.databaseStatus === "WAITING_ON_PROVIDER" ? "levando mais tempo" : existing.databaseStatus}).`);
-			else info(`Banco de dados "${key}" encontrado no servidor (${chalk.green("LIVE")}).`);
+				continue;
+			}
+			if (existing.databaseStatus === "PENDING" || existing.databaseStatus === "PROVISIONING" || existing.databaseStatus === "WAITING_ON_PROVIDER") {
+				info(`Banco de dados "${key}" ainda está sendo provisionado (${existing.databaseStatus === "WAITING_ON_PROVIDER" ? "levando mais tempo" : existing.databaseStatus}).`);
+				continue;
+			}
+			const serviceId = existing.id;
+			const isLive = existing.databaseStatus === "LIVE";
+			await updateDatabaseResources(client, key, dbConfig, existing, serviceId, isLive);
+			await updateDatabasePooler(client, key, dbConfig, existing, serviceId, isLive);
+			await updateDatabaseStorage(client, key, dbConfig, serviceId);
+			info(`Banco de dados "${key}" encontrado no servidor (${chalk.green(existing.databaseStatus ?? "LIVE")}).`);
 			continue;
 		}
 		console.log();
@@ -4035,8 +4750,7 @@ async function provisionDatabases(config, opts) {
 					engine: dbConfig.engine,
 					engineVersion: dbConfig.version,
 					storage: dbConfig.storage,
-					cpuLimit: dbConfig.resources?.cpu,
-					memoryLimit: dbConfig.resources?.memory,
+					size: dbConfig.size ?? "essencial",
 					poolerEnabled: dbConfig.pooler?.enabled,
 					poolerPoolMode: dbConfig.pooler?.poolMode,
 					poolerDefaultPoolSize: dbConfig.pooler?.defaultPoolSize,
@@ -4044,29 +4758,128 @@ async function provisionDatabases(config, opts) {
 				})
 			});
 			success(`Banco de dados "${key}" criado (provisionando...).`);
-			updatedConfig = {
-				...updatedConfig,
-				databases: {
-					...updatedConfig.databases,
-					[key]: {
-						...dbConfig,
-						id: db.id
-					}
-				}
-			};
+			idUpdates[key] = db.id;
 		} catch (error) {
 			warn(`Falha ao criar banco de dados "${key}": ${error instanceof Error ? error.message : String(error)}`);
 			console.log(chalk.dim(`  Continuando com o deploy dos serviços...`));
 			console.log();
 		}
 	}
-	if (JSON.stringify(updatedConfig.databases) !== JSON.stringify(config.databases)) try {
-		saveConfig(updatedConfig);
+	if (Object.keys(idUpdates).length > 0) try {
+		patchConfig((raw) => {
+			raw.databases ??= {};
+			for (const [key, id] of Object.entries(idUpdates)) if (raw.databases[key]) raw.databases[key].id = id;
+			else {
+				const dbConfig = entries.find(([k]) => k === key)?.[1];
+				if (dbConfig) raw.databases[key] = {
+					engine: dbConfig.engine,
+					id
+				};
+			}
+			raw.updated = (/* @__PURE__ */ new Date()).toISOString();
+		});
 		info(`Arquivo veloz.json atualizado com IDs dos bancos de dados.`);
 	} catch (error) {
 		warn(`Não foi possível atualizar veloz.json: ${error instanceof Error ? error.message : String(error)}`);
 	}
-	return updatedConfig;
+	const updatedDatabases = { ...databases };
+	for (const [key, id] of Object.entries(idUpdates)) if (updatedDatabases[key]) updatedDatabases[key] = {
+		...updatedDatabases[key],
+		id
+	};
+	return {
+		...config,
+		databases: updatedDatabases
+	};
+}
+/**
+* Compare desired size tier from config against the server state and call
+* updateResources if they differ.
+*/
+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 (!isLive) {
+		warn(`Banco de dados "${key}" não está LIVE — não é possível alterar recursos agora.`);
+		return;
+	}
+	const sizeConfig = DATABASE_SIZES[desiredSize];
+	if (!sizeConfig) {
+		warn(`Tamanho "${desiredSize}" inválido para banco de dados "${key}".`);
+		return;
+	}
+	try {
+		await withSpinner({
+			text: `Atualizando recursos de "${key}" para ${sizeConfig.label} (${sizeConfig.cpuLabel}, ${sizeConfig.memoryLabel})...`,
+			fn: () => client.databases.updateResources({
+				serviceId,
+				size: desiredSize
+			})
+		});
+		success(`Recursos de "${key}" atualizados para ${sizeConfig.label}.`);
+	} catch (error) {
+		warn(`Falha ao atualizar recursos de "${key}": ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
+/**
+* Compare desired pooler settings from config against the server state and call
+* updatePooler if they differ.
+*/
+async function updateDatabasePooler(client, key, dbConfig, existing, serviceId, isLive) {
+	const desiredPooler = dbConfig.pooler;
+	if (!desiredPooler) return;
+	const enabledChanged = desiredPooler.enabled !== existing.poolerEnabled;
+	const poolModeChanged = desiredPooler.poolMode !== void 0 && desiredPooler.poolMode !== existing.poolerPoolMode;
+	if (!enabledChanged && !poolModeChanged) return;
+	if (!isLive) {
+		warn(`Banco de dados "${key}" não está LIVE — não é possível alterar o pooler agora.`);
+		return;
+	}
+	if (existing.engine !== "postgresql") {
+		warn(`Connection pooler só é suportado para PostgreSQL (banco "${key}" usa ${existing.engine}).`);
+		return;
+	}
+	try {
+		await withSpinner({
+			text: `Atualizando pooler de "${key}"...`,
+			fn: () => client.databases.updatePooler({
+				serviceId,
+				enabled: desiredPooler.enabled,
+				poolMode: desiredPooler.poolMode,
+				defaultPoolSize: desiredPooler.defaultPoolSize,
+				maxClientConn: desiredPooler.maxClientConn
+			})
+		});
+		success(`Pooler de "${key}" ${desiredPooler.enabled ? "ativado" : "desativado"}.`);
+	} catch (error) {
+		warn(`Falha ao atualizar pooler de "${key}": ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
+/**
+* Compare desired storage size from config against the server's volume and call
+* volumes.update to resize if the config requests a larger volume.
+*/
+async function updateDatabaseStorage(client, key, dbConfig, serviceId) {
+	const desiredStorage = dbConfig.storage;
+	if (!desiredStorage) return;
+	const desiredSizeGb = parseInt(desiredStorage.replace("Gi", ""), 10);
+	if (isNaN(desiredSizeGb) || desiredSizeGb <= 0) return;
+	const dataVolume = (await client.volumes.list({ serviceId })).find((v) => v.name === "data");
+	if (!dataVolume) return;
+	if (desiredSizeGb <= dataVolume.sizeGb) return;
+	try {
+		await withSpinner({
+			text: `Redimensionando armazenamento de "${key}" de ${dataVolume.sizeGb} GB para ${desiredSizeGb} GB...`,
+			fn: () => client.volumes.update({
+				volumeId: dataVolume.id,
+				sizeGb: desiredSizeGb
+			})
+		});
+		success(`Armazenamento de "${key}" atualizado para ${desiredSizeGb} GB.`);
+	} catch (error) {
+		warn(`Falha ao redimensionar armazenamento de "${key}": ${error instanceof Error ? error.message : String(error)}`);
+	}
 }
 /**
 * Get hint messages about auto-injected DATABASE_URLs for display during env var prompts.
@@ -4098,6 +4911,14 @@ const SERVICE_TYPE_LABELS = {
 * the server will generate one with nixpacks.
 */
 function prepareExtraFiles(_detection, serviceConfig) {
+	if (serviceConfig?.docker) {
+		const dockerfilePath = resolve(process.cwd(), serviceConfig.docker.dockerfile);
+		if (!existsSync(dockerfilePath)) throw new Error(`Dockerfile não encontrado: ${serviceConfig.docker.dockerfile}`);
+		return [{
+			name: "Dockerfile",
+			content: readFileSync(dockerfilePath, "utf-8")
+		}];
+	}
 	if (existsSync(resolve(process.cwd(), "Dockerfile"))) return [];
 	const rootDir = serviceConfig?.rootDirectory || ".";
 	const serviceDockerfilePath = resolve(process.cwd(), rootDir, "Dockerfile");
@@ -4169,39 +4990,6 @@ async function triggerDeploy(serviceId, serviceName, preDetection) {
 		untrackDeployment(deployment.id);
 	}
 }
-/**
-* MCP variant of triggerDeploy — yields progress events as async generator.
-* Upload phase is awaited, then build log streaming is delegated to the
-* streaming generator.
-*/
-async function* triggerDeployMcp(serviceId, serviceName) {
-	const client = await getClient();
-	const serviceConf = resolveServiceConf(loadConfig(), serviceId);
-	const extraFiles = prepareExtraFiles(detectLocalRepo(), serviceConf);
-	yield {
-		type: "status",
-		message: "Iniciando deploy..."
-	};
-	const deployment = await withRetry(() => client.deployments.create({
-		serviceId,
-		serviceConfig: serviceConf
-	}));
-	yield {
-		type: "status",
-		message: "Fazendo upload do código..."
-	};
-	await withRetry(() => uploadSource(deployment.id, process.cwd(), extraFiles));
-	yield {
-		type: "status",
-		message: "Upload concluído. Aguardando build..."
-	};
-	trackDeployment(deployment.id);
-	try {
-		yield* streamDeploymentLogsMcp(deployment.id, serviceId, serviceName);
-	} finally {
-		untrackDeployment(deployment.id);
-	}
-}
 function warnIfEphemeralFsDetected(detection, serviceConf, serviceLabel) {
 	if (!detection.usesNodeFs || (serviceConf?.volumes?.length ?? 0) > 0) return;
 	warn(`Uso de fs/node:fs detectado${serviceLabel ? ` no serviço ${chalk.bold(serviceLabel)}` : ""}. O filesystem do container é efêmero; configure um volume em veloz.json ou use 'veloz volumes create'.`);
@@ -4212,7 +5000,7 @@ async function maybeConfigurePersistentVolume(serviceConfig, detection, opts, se
 	if (!await promptConfirm(`Deseja adicionar um volume persistente para ${serviceLabel}?`, true)) return;
 	const name = await prompt(`Nome do volume ${chalk.dim("(data)")}:`) || "data";
 	const mountPath = await prompt(`Mount path ${chalk.dim("(/data)")}:`) || "/data";
-	const sizeInput = await prompt(`Tamanho em GB ${chalk.dim("(1)")}:`);
+	const sizeInput = await prompt(`Tamanho em GB ${chalk.dim("(10)")}:`);
 	const parsedSize = Number.parseInt(sizeInput || "10", 10);
 	serviceConfig.volumes = [{
 		name,
@@ -4258,7 +5046,12 @@ async function findServicesFromConfig() {
 			}
 		}
 		if (configUpdated) {
-			saveConfig(config);
+			const serviceIdMap = {};
+			for (const [key, svc] of Object.entries(config.services)) if (svc.id) serviceIdMap[key] = svc.id;
+			patchConfig((raw) => {
+				for (const [key, id] of Object.entries(serviceIdMap)) if (raw.services[key]) raw.services[key].id = id;
+				raw.updated = (/* @__PURE__ */ new Date()).toISOString();
+			});
 			info(`Arquivo ${getConfigFileName()} atualizado com IDs dos serviços.`);
 		}
 	}
@@ -4452,6 +5245,7 @@ async function createServiceFlow(projectId, projectName, repoName, opts = {}) {
 		const allApps = detection.monorepoApps.map((a) => ({
 			name: a.name,
 			root: a.path,
+			type: a.framework?.type ?? "WEB",
 			framework: a.framework?.name ?? null,
 			buildCommand: a.framework?.buildCommand ?? null,
 			startCommand: a.framework?.startCommand ?? null,
@@ -4517,7 +5311,7 @@ async function createServiceFlow(projectId, projectName, repoName, opts = {}) {
 				fn: () => withRetry(() => client.services.create({
 					projectId,
 					name: app.name,
-					type: "WEB",
+					type: app.type,
 					branch,
 					rootDirectory: app.root,
 					buildCommand: app.buildCommand ?? void 0,
@@ -4552,13 +5346,15 @@ async function createServiceFlow(projectId, projectName, repoName, opts = {}) {
 			await promptEnvVars(service$1.id, serviceDetection.envVars.map((v) => v.key), config$1);
 		}
 		config$1 = await provisionDatabases(config$1, { yes: opts.yes ?? false });
-		await deployServicesInParallel(createdServices.map(({ service: service$1, app }) => ({
+		await deployServices(createdServices.map(({ service: service$1, app }) => ({
 			serviceId: service$1.id,
 			serviceName: app.name,
-			path: resolve(process.cwd(), app.root),
 			serviceConfig: resolveServiceConf(config$1, service$1.id),
 			extraFiles: prepareExtraFiles(detectLocalRepo(app.root), { rootDirectory: app.root })
-		})));
+		})), {
+			projectRoot: process.cwd(),
+			output: createDeployOutput()
+		});
 		return createdServices[createdServices.length - 1]?.service.id || "";
 	}
 	const fw = detection.framework;
@@ -4698,13 +5494,10 @@ async function createEnvironmentFlow(rawConfig, envName, opts) {
 		},
 		services: envServices
 	};
-	saveConfig({
-		...rawConfig,
-		environments: {
-			...rawConfig.environments,
-			[envName]: envOverride
-		},
-		updated: (/* @__PURE__ */ new Date()).toISOString()
+	patchConfig((raw) => {
+		raw.environments ??= {};
+		raw.environments[envName] = envOverride;
+		raw.updated = (/* @__PURE__ */ new Date()).toISOString();
 	});
 	success(`Ambiente "${envName}" salvo em ${getConfigFileName()}`);
 	setActiveEnv(envName);
@@ -4730,6 +5523,7 @@ async function addServiceFlow(existingConfig, opts) {
 		const availableApps = detection.monorepoApps.map((a) => ({
 			name: a.name,
 			root: a.path,
+			type: a.framework?.type ?? "WEB",
 			framework: a.framework?.name ?? null,
 			buildCommand: a.framework?.buildCommand ?? null,
 			startCommand: a.framework?.startCommand ?? null,
@@ -4797,7 +5591,7 @@ async function addServiceFlow(existingConfig, opts) {
 				fn: () => withRetry(() => client.services.create({
 					projectId,
 					name: app.name,
-					type: "WEB",
+					type: app.type,
 					branch,
 					rootDirectory: app.root,
 					buildCommand: app.buildCommand ?? void 0,
@@ -4824,8 +5618,11 @@ async function addServiceFlow(existingConfig, opts) {
 			};
 			await maybeConfigurePersistentVolume(updatedConfig$1.services[app.root], detectLocalRepo(app.root), opts, app.name);
 		}
-		updatedConfig$1.updated = (/* @__PURE__ */ new Date()).toISOString();
-		saveConfig(updatedConfig$1);
+		const newServices = Object.fromEntries(createdServices.map(({ app }) => [app.root, updatedConfig$1.services[app.root]]));
+		patchConfig((raw) => {
+			for (const [key, value] of Object.entries(newServices)) if (value) raw.services[key] = value;
+			raw.updated = (/* @__PURE__ */ new Date()).toISOString();
+		});
 		info(`Arquivo ${getConfigFileName()} atualizado com ${createdServices.length} novo(s) serviço(s).`);
 		if (!opts.yes) for (const { service: service$1, app } of createdServices) {
 			console.log(chalk.cyan(`\n── Configurando variáveis: ${app.name} ──\n`));
@@ -4833,13 +5630,15 @@ async function addServiceFlow(existingConfig, opts) {
 			await promptEnvVars(service$1.id, serviceDetection.envVars.map((v) => v.key), updatedConfig$1);
 		}
 		await provisionDatabases(updatedConfig$1, { yes: opts.yes ?? false });
-		await deployServicesInParallel(createdServices.map(({ service: service$1, app }) => ({
+		await deployServices(createdServices.map(({ service: service$1, app }) => ({
 			serviceId: service$1.id,
 			serviceName: app.name,
-			path: resolve(process.cwd(), app.root),
 			serviceConfig: resolveServiceConf(updatedConfig$1, service$1.id),
 			extraFiles: prepareExtraFiles(detectLocalRepo(app.root), { rootDirectory: app.root })
-		})));
+		})), {
+			projectRoot: process.cwd(),
+			output: createDeployOutput()
+		});
 		return;
 	}
 	const fw = detection.framework;
@@ -4926,7 +5725,11 @@ async function addServiceFlow(existingConfig, opts) {
 		updated: (/* @__PURE__ */ new Date()).toISOString()
 	};
 	await maybeConfigurePersistentVolume(updatedConfig.services[serviceKey], detection, opts, service.name);
-	saveConfig(updatedConfig);
+	const newServiceEntry = updatedConfig.services[serviceKey];
+	patchConfig((raw) => {
+		raw.services[serviceKey] = newServiceEntry;
+		raw.updated = (/* @__PURE__ */ new Date()).toISOString();
+	});
 	info(`Arquivo ${getConfigFileName()} atualizado.`);
 	await provisionDatabases(updatedConfig, { yes: opts.yes ?? false });
 	await triggerDeploy(service.id, service.name);
@@ -4981,17 +5784,32 @@ function registerDeploy(cli$1) {
 async function* mcpDeployFlow(opts) {
 	const configuredServices = await findServicesFromConfig();
 	if (configuredServices.length === 0) throw new Error("Nenhum serviço configurado. Execute 'veloz deploy' no terminal para configurar o projeto primeiro.");
+	const currentConfig = loadConfig();
+	if (currentConfig) await provisionDatabases(currentConfig, { yes: true });
+	let servicesToProcess = configuredServices;
 	if (opts.service) {
 		const found = configuredServices.find((s) => s.key === opts.service || s.serviceName.toLowerCase() === opts.service.toLowerCase() || s.serviceId === opts.service);
 		if (!found) {
+			if ((currentConfig?.databases ? Object.keys(currentConfig.databases).find((k) => k === opts.service || k.toLowerCase() === opts.service.toLowerCase()) : void 0) && currentConfig) {
+				await provisionDatabases(currentConfig, { yes: true });
+				return;
+			}
 			const available = configuredServices.map((s) => `${s.key} (${s.serviceName})`).join(", ");
-			throw new Error(`Serviço '${opts.service}' não encontrado. Disponíveis: ${available}`);
+			const dbNames = currentConfig?.databases ? Object.keys(currentConfig.databases) : [];
+			const hint = dbNames.length > 0 ? `\nBancos de dados: ${dbNames.join(", ")} (use 'veloz db update' para gerenciar)` : "";
+			throw new Error(`Serviço '${opts.service}' não encontrado. Disponíveis: ${available}${hint}`);
 		}
-		yield* triggerDeployMcp(found.serviceId, found.serviceName);
-		return;
+		servicesToProcess = [found];
 	}
-	if (configuredServices.length === 1) yield* triggerDeployMcp(configuredServices[0].serviceId, configuredServices[0].serviceName);
-	else for (const svc of configuredServices) yield* triggerDeployMcp(svc.serviceId, svc.serviceName);
+	const results = await deployServices(await computeExtraFilesForServices(servicesToProcess), {
+		projectRoot: process.cwd(),
+		output: createDeployOutput()
+	});
+	for (const result of results) yield {
+		type: "result",
+		message: result.status === "LIVE" ? "Deploy concluído" : `Deploy finalizou: ${result.status}`,
+		data: result
+	};
 }
 async function cliDeployFlow(opts) {
 	if (opts.verbose) process.env.VELOZ_VERBOSE = "true";
@@ -5026,10 +5844,21 @@ async function cliDeployFlow(opts) {
 		if (opts.service) {
 			const found = configuredServices.find((s) => s.key === opts.service || s.serviceName.toLowerCase() === opts.service.toLowerCase() || s.serviceId === opts.service);
 			if (!found) {
+				const dbMatch = currentConfig?.databases ? Object.keys(currentConfig.databases).find((k) => k === opts.service || k.toLowerCase() === opts.service.toLowerCase()) : void 0;
+				if (dbMatch && currentConfig) {
+					info(`"${dbMatch}" é um banco de dados. Aplicando alterações de configuração...`);
+					await provisionDatabases(currentConfig, { yes: opts.yes ?? false });
+					return;
+				}
 				const available = configuredServices.map((s) => `  • ${s.key} (${s.serviceName})`).join("\n");
-				throw new Error(`Serviço '${opts.service}' não encontrado.\n\nServiços disponíveis:\n${available}`);
+				const dbNames = currentConfig?.databases ? Object.keys(currentConfig.databases) : [];
+				const dbHint = dbNames.length > 0 ? `\n\nBancos de dados:\n${dbNames.map((n) => `  • ${n} (banco de dados)`).join("\n")}` : "";
+				throw new Error(`Serviço '${opts.service}' não encontrado.\n\nServiços disponíveis:\n${available}${dbHint}`);
 			}
-			await triggerDeploy(found.serviceId, found.serviceName);
+			await deployServices(await computeExtraFilesForServices([found]), {
+				projectRoot: process.cwd(),
+				output: createDeployOutput()
+			});
 			return;
 		}
 		if (opts.all || opts.yes || configuredServices.length === 1) {
@@ -5045,8 +5874,10 @@ async function cliDeployFlow(opts) {
 					return;
 				}
 			}
-			if (configuredServices.length === 1) await triggerDeploy(configuredServices[0].serviceId, configuredServices[0].serviceName);
-			else await deployServicesInParallel(await computeExtraFilesForServices(configuredServices));
+			await deployServices(await computeExtraFilesForServices(configuredServices), {
+				projectRoot: process.cwd(),
+				output: createDeployOutput()
+			});
 			return;
 		}
 		console.log(chalk.bold("\nServiços disponíveis:\n"));
@@ -5062,8 +5893,11 @@ async function cliDeployFlow(opts) {
 			info("Nenhum serviço selecionado.");
 			return;
 		}
-		if (selectedServices.length === 1) await triggerDeploy(selectedServices[0].serviceId, selectedServices[0].serviceName);
-		else await deployServicesInParallel(await computeExtraFilesForServices(selectedServices));
+		await deployServices(await computeExtraFilesForServices(selectedServices), {
+			projectRoot: process.cwd(),
+			output: createDeployOutput()
+		});
+		return;
 	}
 	if (!isGitRepo()) throw new Error("Este diretório não é um repositório git. Inicialize com `git init` e adicione um remote.");
 	info("Detectando repositório git...");
@@ -5364,7 +6198,35 @@ function registerPull(cli$1) {
 			else config = buildFreshConfig(project, services, databases);
 			if (existingConfig && !c.options.force && isInteractive()) config = await pruneRemovedEntries(config, existingConfig, services, databases);
 			config.updated = (/* @__PURE__ */ new Date()).toISOString();
-			saveConfig(config);
+			if (existingConfig && !c.options.force) patchConfig((raw) => {
+				raw.project = config.project;
+				for (const [key, svc] of Object.entries(config.services)) if (raw.services[key]) {
+					raw.services[key].id = svc.id;
+					raw.services[key].name = svc.name;
+				} else raw.services[key] = svc;
+				for (const key of Object.keys(raw.services)) if (!config.services[key]) delete raw.services[key];
+				const mergedDatabases = config.databases ?? {};
+				if (Object.keys(mergedDatabases).length > 0) {
+					raw.databases ??= {};
+					for (const [key, db] of Object.entries(mergedDatabases)) if (raw.databases[key]) {
+						raw.databases[key].id = db.id;
+						raw.databases[key].name = db.name;
+						raw.databases[key].engine = db.engine;
+						if (db.version) raw.databases[key].version = db.version;
+					} else {
+						raw.databases[key] = {
+							id: db.id,
+							name: db.name,
+							engine: db.engine
+						};
+						if (db.version) raw.databases[key].version = db.version;
+					}
+					for (const key of Object.keys(raw.databases)) if (!mergedDatabases[key]) delete raw.databases[key];
+					if (Object.keys(raw.databases).length === 0) raw.databases = void 0;
+				}
+				raw.updated = config.updated;
+			});
+			else saveConfig(config);
 			success(`${getConfigFileName()} atualizado com sucesso.`);
 			const svcCount = Object.keys(config.services).length;
 			const dbCount = Object.keys(config.databases ?? {}).length;
@@ -5464,7 +6326,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.16",
+	version: "0.0.0-beta.18",
 	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)") })
 });