onveloz 0.0.0-beta.1 → 0.0.0-beta.10

package/dist/index.mjs

@@ -1,11 +1,12 @@
 #!/usr/bin/env node
 import { Command } from "@commander-js/extra-typings";
-import chalk from "chalk";
+import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { exec, execSync } from "node:child_process";
+import { dirname, join, relative, resolve } from "node:path";
+import { z } from "zod";
+import chalk from "chalk";
 import { homedir, platform, tmpdir } from "node:os";
 import { createHash } from "node:crypto";
-import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, unlinkSync, writeFileSync } from "node:fs";
-import { join, relative, resolve } from "node:path";
 import * as readline from "node:readline";
 import { createInterface } from "node:readline";
 import ora from "ora";
@@ -13,11 +14,315 @@ import { createAuthClient } from "better-auth/client";
 import { deviceAuthorizationClient } from "better-auth/client/plugins";
 import { createORPCClient } from "@orpc/client";
 import { RPCLink } from "@orpc/client/fetch";
-import { z } from "zod";
-import { mkdtemp, readdir, rm, stat } from "node:fs/promises";
+import { link, mkdir, mkdtemp, readdir, rm, stat } from "node:fs/promises";
 import ignore from "ignore";
 import tar from "tar";
 
+//#region src/lib/output.ts
+let _outputMode = null;
+function getOutputMode() {
+	if (_outputMode) return _outputMode;
+	return detectOutputMode();
+}
+function detectOutputMode() {
+	if (process.env.VELOZ_OUTPUT === "json") return "json";
+	if (process.env.VELOZ_OUTPUT === "github-actions") return "github-actions";
+	if (process.env.VELOZ_OUTPUT === "plain") return "plain";
+	if (process.env.GITHUB_ACTIONS === "true") return "github-actions";
+	if (process.env.CI === "true") return "plain";
+	if (!process.stdout.isTTY || process.env.TERM === "dumb") return "plain";
+	return "fancy";
+}
+function setOutputMode(mode) {
+	_outputMode = mode;
+}
+function isInteractive() {
+	return getOutputMode() === "fancy" && process.stdin.isTTY === true;
+}
+function isMachineReadable() {
+	return getOutputMode() === "json";
+}
+/**
+* Emit structured JSON data to stdout.
+* In JSON mode: outputs raw JSON object.
+* In other modes: no-op (callers should use regular output helpers).
+*/
+function emitData(data) {
+	if (isMachineReadable()) process.stdout.write(JSON.stringify(data) + "\n");
+}
+/**
+* Open a collapsible group (GitHub Actions) or section header.
+*/
+function startGroup(name) {
+	if (getOutputMode() === "github-actions") process.stdout.write(`::group::${name}\n`);
+}
+/**
+* Close a collapsible group (GitHub Actions).
+*/
+function endGroup() {
+	if (getOutputMode() === "github-actions") process.stdout.write("::endgroup::\n");
+}
+
+//#endregion
+//#region ../../packages/config/veloz-config.ts
+const ServiceTypeSchema = z.enum(["web", "static"]);
+const PackageManagerSchema = z.enum([
+	"npm",
+	"yarn",
+	"pnpm",
+	"bun",
+	"auto"
+]);
+const BuildConfigSchema = z.object({
+	command: z.string().nullable().optional(),
+	nodeVersion: z.string().regex(/^[0-9]+(\.[0-9]+){0,2}(\.x)?$/).default("20").optional(),
+	nixpkgsArchive: z.string().regex(/^[a-f0-9]{40}$/).optional(),
+	packageManager: PackageManagerSchema.default("auto").optional(),
+	installCommand: z.string().nullable().optional(),
+	outputDir: z.string().nullable().optional(),
+	aptPackages: z.array(z.string().regex(/^[a-z0-9][a-z0-9.+\-]+$/, "Nome de pacote inválido")).optional()
+});
+const RuntimeConfigSchema = z.object({
+	command: z.string().nullable().optional(),
+	port: z.number().min(1).max(65535).default(3e3).optional(),
+	healthCheck: z.object({
+		path: z.string().default("/").optional(),
+		interval: z.number().default(30).optional(),
+		timeout: z.number().default(10).optional()
+	}).optional()
+});
+const ResourcesSchema = z.object({
+	instances: z.number().min(1).max(10).default(1).optional(),
+	cpu: z.string().regex(/^[0-9]+(\.[0-9]+)?|[0-9]+m$/).default("500m").optional(),
+	memory: z.string().regex(/^[0-9]+(Mi|Gi)$/).default("512Mi").optional(),
+	autoscale: z.object({
+		enabled: z.boolean().default(false).optional(),
+		minInstances: z.number().min(1).default(1).optional(),
+		maxInstances: z.number().min(1).max(20).default(3).optional(),
+		targetCPU: z.number().min(10).max(90).default(70).optional()
+	}).optional()
+});
+const EnvVarDefinitionSchema = z.object({
+	description: z.string().optional(),
+	required: z.boolean().default(false).optional(),
+	example: z.string().optional()
+});
+const ServiceConfigSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	type: ServiceTypeSchema.default("web"),
+	root: z.string().default("."),
+	branch: z.string().optional(),
+	build: BuildConfigSchema.optional(),
+	runtime: RuntimeConfigSchema.optional(),
+	env: z.record(z.string().regex(/^[A-Z][A-Z0-9_]*$/), EnvVarDefinitionSchema).optional(),
+	resources: ResourcesSchema.optional()
+});
+const ProjectConfigSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	slug: z.string().regex(/^[a-z0-9-]+$/).optional()
+});
+const ServiceDefaultsSchema = z.object({
+	type: ServiceTypeSchema.optional(),
+	branch: z.string().optional(),
+	build: BuildConfigSchema.optional(),
+	runtime: RuntimeConfigSchema.optional(),
+	resources: ResourcesSchema.optional()
+});
+const EnvironmentServiceOverrideSchema = z.object({
+	id: z.string(),
+	name: z.string().optional()
+});
+const EnvironmentOverrideSchema = z.object({
+	project: ProjectConfigSchema,
+	services: z.record(z.string(), EnvironmentServiceOverrideSchema)
+});
+const VelozConfigSchema = z.object({
+	$schema: z.string().optional(),
+	version: z.literal("1.0"),
+	project: ProjectConfigSchema,
+	services: z.record(z.string(), ServiceConfigSchema),
+	defaults: ServiceDefaultsSchema.optional(),
+	environments: z.record(z.string(), EnvironmentOverrideSchema).optional(),
+	created: z.string().datetime().optional(),
+	updated: z.string().datetime().optional()
+});
+function mergeServiceWithDefaults(service, defaults) {
+	if (!defaults) return service;
+	return {
+		...service,
+		type: service.type ?? defaults.type ?? "web",
+		branch: service.branch ?? defaults.branch,
+		build: {
+			...defaults.build,
+			...service.build
+		},
+		runtime: {
+			...defaults.runtime,
+			...service.runtime
+		},
+		resources: {
+			...defaults.resources,
+			...service.resources
+		}
+	};
+}
+function parseVelozConfig(data) {
+	return VelozConfigSchema.parse(data);
+}
+function resolveConfigForEnv(config, env) {
+	const envOverride = config.environments?.[env];
+	if (!envOverride) return null;
+	const resolvedServices = {};
+	for (const [key, service] of Object.entries(config.services)) {
+		const override = envOverride.services[key];
+		if (override) resolvedServices[key] = {
+			...service,
+			id: override.id,
+			name: override.name ?? service.name
+		};
+	}
+	return {
+		...config,
+		project: envOverride.project,
+		services: resolvedServices,
+		environments: void 0
+	};
+}
+
+//#endregion
+//#region src/lib/link.ts
+const CONFIG_FILE$1 = "veloz.json";
+const LOCAL_CONFIG_FILE = "veloz.local.json";
+let _activeEnv;
+function setActiveEnv(env) {
+	_activeEnv = env;
+}
+function getActiveEnv() {
+	return _activeEnv ?? process.env.VELOZ_ENV;
+}
+/**
+* Find the root directory (git root or monorepo root)
+*/
+function findProjectRoot(startPath = process.cwd()) {
+	let currentPath = resolve(startPath);
+	const root = resolve("/");
+	while (currentPath !== root) {
+		if (existsSync(join(currentPath, ".git"))) return currentPath;
+		if (existsSync(join(currentPath, "pnpm-workspace.yaml")) || existsSync(join(currentPath, "lerna.json")) || existsSync(join(currentPath, "rush.json")) || existsSync(join(currentPath, "nx.json"))) return currentPath;
+		const pkgJsonPath = join(currentPath, "package.json");
+		if (existsSync(pkgJsonPath)) try {
+			if (JSON.parse(readFileSync(pkgJsonPath, "utf-8")).workspaces) return currentPath;
+		} catch {}
+		const parentPath = resolve(currentPath, "..");
+		if (parentPath === currentPath) break;
+		currentPath = parentPath;
+	}
+	return process.cwd();
+}
+/**
+* Get the config file name (veloz.local.json when VELOZ_API_URL is set, veloz.json otherwise)
+*/
+function getConfigFileName() {
+	return process.env.VELOZ_API_URL ? LOCAL_CONFIG_FILE : CONFIG_FILE$1;
+}
+/**
+* Get the path to veloz.json (or veloz.local.json when using custom API URL)
+*/
+function getConfigPath() {
+	return join(findProjectRoot(), getConfigFileName());
+}
+/**
+* Load the veloz.json config from project root (without environment resolution)
+*/
+function loadRawConfig() {
+	const path = getConfigPath();
+	if (!existsSync(path)) return null;
+	try {
+		const raw = readFileSync(path, "utf-8");
+		return parseVelozConfig(JSON.parse(raw));
+	} catch (error) {
+		console.error(`Error loading ${getConfigFileName()}:`, error);
+		return null;
+	}
+}
+/**
+* Load the veloz.json config, resolving environment overrides if --env is active.
+* Returns the env-resolved config when an env is active and configured,
+* or the base config when no env is active.
+* Returns null if the config file doesn't exist or the active env isn't configured.
+*/
+function loadConfig() {
+	const config = loadRawConfig();
+	if (!config) return null;
+	const env = getActiveEnv();
+	if (env) return resolveConfigForEnv(config, env);
+	return config;
+}
+/**
+* Save the veloz.json config to project root
+*/
+function saveConfig(config) {
+	const path = getConfigPath();
+	const configWithSchema = {
+		$schema: "https://onveloz.com/schemas/veloz-config.schema.json",
+		...config
+	};
+	writeFileSync(path, JSON.stringify(configWithSchema, null, 2), "utf-8");
+}
+/**
+* Require config to exist, throw if not found
+*/
+function requireConfig() {
+	const config = loadConfig();
+	if (!config) throw new Error(`No ${getConfigFileName()} found in project root. Run 'veloz init' or 'veloz deploy' to set up your project.`);
+	return config;
+}
+/**
+* Check if current directory is a git repository
+*/
+function isGitRepo() {
+	try {
+		execSync("git rev-parse --is-inside-work-tree", { stdio: "pipe" });
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Get git remote origin info
+*/
+function getGitRemote() {
+	try {
+		const url = execSync("git remote get-url origin", { stdio: "pipe" }).toString().trim();
+		const httpsMatch = url.match(/github\.com\/([^/]+)\/([^/.]+)/);
+		if (httpsMatch) return {
+			owner: httpsMatch[1],
+			repo: httpsMatch[2]
+		};
+		const sshMatch = url.match(/github\.com:([^/]+)\/([^/.]+)/);
+		if (sshMatch) return {
+			owner: sshMatch[1],
+			repo: sshMatch[2]
+		};
+		return null;
+	} catch {
+		return null;
+	}
+}
+/**
+* Get current git branch
+*/
+function getGitBranch() {
+	try {
+		return execSync("git rev-parse --abbrev-ref HEAD", { stdio: "pipe" }).toString().trim();
+	} catch {
+		return "main";
+	}
+}
+
+//#endregion
 //#region src/lib/config.ts
 const CONFIG_DIR = join(homedir(), ".veloz");
 const ENV_API_URL = process.env.VELOZ_API_URL;
@@ -26,21 +331,22 @@ function getConfigFile() {
 	if (!ENV_API_URL) return join(CONFIG_DIR, "config.json");
 	return join(CONFIG_DIR, `config.${createHash("md5").update(ENV_API_URL).digest("hex").slice(0, 8)}.json`);
 }
-const CONFIG_FILE$1 = getConfigFile();
+const CONFIG_FILE = getConfigFile();
 function ensureConfigDir() {
 	if (!existsSync(CONFIG_DIR)) mkdirSync(CONFIG_DIR, { recursive: true });
 }
 function loadConfig$1() {
-	if (!existsSync(CONFIG_FILE$1)) return {
+	if (!existsSync(CONFIG_FILE)) return {
 		apiKey: "",
 		apiUrl: DEFAULT_API_URL
 	};
 	try {
-		const raw = readFileSync(CONFIG_FILE$1, "utf-8");
+		const raw = readFileSync(CONFIG_FILE, "utf-8");
 		const parsed = JSON.parse(raw);
 		return {
 			apiKey: parsed.apiKey ?? "",
-			apiUrl: ENV_API_URL ?? parsed.apiUrl ?? DEFAULT_API_URL
+			apiUrl: ENV_API_URL ?? parsed.apiUrl ?? DEFAULT_API_URL,
+			organizationId: parsed.organizationId
 		};
 	} catch {
 		return {
@@ -54,20 +360,28 @@ function saveConfig$1(config) {
 	const existing = loadConfig$1();
 	const merged = {
 		apiKey: config.apiKey ?? existing.apiKey,
-		apiUrl: config.apiUrl ?? existing.apiUrl
+		apiUrl: config.apiUrl ?? existing.apiUrl,
+		organizationId: config.organizationId ?? existing.organizationId
 	};
-	writeFileSync(CONFIG_FILE$1, JSON.stringify(merged, null, 2), "utf-8");
+	writeFileSync(CONFIG_FILE, JSON.stringify(merged, null, 2), "utf-8");
 }
 function deleteConfig() {
-	if (existsSync(CONFIG_FILE$1)) unlinkSync(CONFIG_FILE$1);
+	if (existsSync(CONFIG_FILE)) unlinkSync(CONFIG_FILE);
 }
 function isAuthenticated() {
 	return loadConfig$1().apiKey.length > 0;
 }
 let envApiUrlLogged = false;
-async function requireAuth() {
+async function requireAuth(options) {
+	const envApiKey = process.env.VELOZ_API_KEY;
+	if (envApiKey) return {
+		apiKey: envApiKey,
+		apiUrl: ENV_API_URL ?? DEFAULT_API_URL
+	};
+	if ("VELOZ_API_KEY" in process.env) throw new Error("VELOZ_API_KEY está definida mas vazia. Verifique o valor do secret.");
 	let config = loadConfig$1();
 	if (!config.apiKey) {
+		if (options?.nonInteractive) throw new Error("Nenhuma autenticação encontrada. Defina VELOZ_API_KEY ou execute `veloz login`.");
 		await performLogin(config.apiUrl);
 		config = loadConfig$1();
 	}
@@ -87,10 +401,28 @@ function isRateLimitError(error) {
 	return null;
 }
 function handleError(error) {
+	const mode = getOutputMode();
 	if (error instanceof Error) {
 		const orpcError = error;
 		if (orpcError.code) {
-			const message = orpcError.data?.message ?? orpcError.message ?? {
+			const orpcData = orpcError.data;
+			if (orpcData?.code === "ACCESS_NOT_APPROVED") {
+				const gateMsg = "Sua conta ainda não foi aprovada para usar a Veloz.";
+				const gateHint = "Acesse app.onveloz.com para solicitar acesso.";
+				if (mode === "json") emitData({
+					type: "error",
+					code: "ACCESS_NOT_APPROVED",
+					message: gateMsg,
+					hint: gateHint
+				});
+				else if (mode === "github-actions") process.stdout.write(`::error::${gateMsg} ${gateHint}\n`);
+				else {
+					console.error(chalk.red(`\n✗ ${gateMsg}`));
+					console.error(chalk.yellow(`  ${gateHint}`));
+				}
+				process.exit(1);
+			}
+			const message = orpcData?.message ?? orpcError.message ?? {
 				NOT_FOUND: "Recurso não encontrado.",
 				FORBIDDEN: "Sem permissão para acessar este recurso.",
 				CONFLICT: "Conflito — recurso já existe.",
@@ -99,51 +431,189 @@ function handleError(error) {
 				INTERNAL_SERVER_ERROR: "Erro interno do servidor. Tente novamente.",
 				TOO_MANY_REQUESTS: "Tente novamente em alguns segundos."
 			}[orpcError.code] ?? "Erro desconhecido.";
-			console.error(chalk.red(`\n✗ Erro: ${message}`));
+			if (mode === "json") emitData({
+				type: "error",
+				code: orpcError.code,
+				message
+			});
+			else if (mode === "github-actions") process.stdout.write(`::error::${message}\n`);
+			else console.error(chalk.red(`\n✗ Erro: ${message}`));
 			process.exit(1);
 		}
 		if (error.message.includes("fetch") || error.message.includes("ECONNREFUSED")) {
-			console.error(chalk.red("\n✗ Erro de conexão: Não foi possível conectar ao servidor Veloz."));
-			console.error(chalk.yellow("  Verifique se o servidor está rodando e a URL está correta."));
+			const message = "Não foi possível conectar ao servidor Veloz.";
+			const hint = "Verifique se o servidor está rodando e a URL está correta.";
+			if (mode === "json") emitData({
+				type: "error",
+				code: "CONNECTION_ERROR",
+				message,
+				hint
+			});
+			else if (mode === "github-actions") process.stdout.write(`::error::${message} ${hint}\n`);
+			else {
+				console.error(chalk.red(`\n✗ Erro de conexão: ${message}`));
+				console.error(chalk.yellow(`  ${hint}`));
+			}
 			process.exit(1);
 		}
-		console.error(chalk.red(`\n✗ Erro: ${error.message}`));
+		if (mode === "json") emitData({
+			type: "error",
+			message: error.message
+		});
+		else if (mode === "github-actions") process.stdout.write(`::error::${error.message}\n`);
+		else console.error(chalk.red(`\n✗ Erro: ${error.message}`));
 		process.exit(1);
 	}
-	console.error(chalk.red("\n✗ Erro inesperado."));
+	if (mode === "json") emitData({
+		type: "error",
+		message: "Erro inesperado."
+	});
+	else if (mode === "github-actions") process.stdout.write("::error::Erro inesperado.\n");
+	else console.error(chalk.red("\n✗ Erro inesperado."));
 	process.exit(1);
 }
 function success(message) {
-	console.log(chalk.green(`\n✓ ${message}`));
+	const mode = getOutputMode();
+	if (mode === "json") emitData({
+		type: "success",
+		message
+	});
+	else if (mode === "github-actions") process.stdout.write(`✓ ${message}\n`);
+	else console.log(chalk.green(`\n✓ ${message}`));
 }
 function info(message) {
-	console.log(chalk.cyan(`ℹ ${message}`));
+	const mode = getOutputMode();
+	if (mode === "json") emitData({
+		type: "info",
+		message
+	});
+	else if (mode === "github-actions") process.stdout.write(`${message}\n`);
+	else console.log(chalk.cyan(`ℹ ${message}`));
+}
+function warn$1(message) {
+	const mode = getOutputMode();
+	if (mode === "json") emitData({
+		type: "warning",
+		message
+	});
+	else if (mode === "github-actions") process.stdout.write(`::warning::${message}\n`);
+	else console.log(chalk.yellow(`⚠ ${message}`));
 }
-function warn(message) {
-	console.log(chalk.yellow(`⚠ ${message}`));
+/**
+* Emit structured data in JSON mode, or run the display callback otherwise.
+*
+* Usage:
+*   output({ type: "user", name, email }, () => {
+*     console.log(`  Nome:  ${name}`);
+*     console.log(`  Email: ${email}`);
+*   });
+*/
+function output(data, display) {
+	if (isMachineReadable()) emitData(data);
+	else display();
 }
 function spinner(text) {
+	const mode = getOutputMode();
+	if (mode === "json" || mode === "github-actions" || mode === "plain") {
+		const noopSpinner = ora({
+			text,
+			isEnabled: false
+		});
+		const originalStop = noopSpinner.stop.bind(noopSpinner);
+		const originalFail = noopSpinner.fail.bind(noopSpinner);
+		noopSpinner.start = function(newText) {
+			if (newText) this.text = newText;
+			if (mode === "github-actions") process.stdout.write(`${this.text}\n`);
+			return this;
+		};
+		noopSpinner.stop = function() {
+			return originalStop();
+		};
+		noopSpinner.fail = function(newText) {
+			const msg = newText ?? this.text;
+			if (mode === "json") emitData({
+				type: "error",
+				message: msg
+			});
+			else if (mode === "github-actions") process.stdout.write(`::error::${msg}\n`);
+			else console.error(msg);
+			return originalFail(newText);
+		};
+		return noopSpinner;
+	}
 	return ora({
 		text,
 		color: "cyan"
 	}).start();
 }
-function printTable(headers, rows) {
+/**
+* Print a table. Pass `rawData` for structured JSON output — commands
+* build display rows with chalk as before, and raw objects for machines.
+*
+* Usage:
+*   printTable(
+*     ["Nome", "Email"],
+*     users.map(u => [chalk.bold(u.name), u.email]),
+*     users.map(u => ({ name: u.name, email: u.email })),
+*   );
+*/
+function printTable(headers, rows, rawData) {
+	const mode = getOutputMode();
+	if (mode === "json") {
+		if (rawData) emitData({
+			type: "table",
+			data: rawData
+		});
+		else emitData({
+			type: "table",
+			data: rows.map((row) => {
+				const obj = {};
+				headers.forEach((h, i) => {
+					obj[h] = stripAnsi(row[i] ?? "");
+				});
+				return obj;
+			})
+		});
+		return;
+	}
+	if (mode === "github-actions" || mode === "plain") {
+		const cleanHeaders = headers.map(stripAnsi);
+		const cleanRows = rows.map((row) => row.map(stripAnsi));
+		const colWidths$1 = cleanHeaders.map((h, i) => {
+			const maxRow = cleanRows.reduce((max, row) => Math.max(max, (row[i] ?? "").length), 0);
+			return Math.max(h.length, maxRow);
+		});
+		const headerLine$1 = cleanHeaders.map((h, i) => h.padEnd(colWidths$1[i])).join("  ");
+		const separator$1 = colWidths$1.map((w) => "-".repeat(w)).join("--");
+		process.stdout.write(`\n${headerLine$1}\n`);
+		process.stdout.write(`${separator$1}\n`);
+		for (const row of cleanRows) {
+			const line = row.map((cell, i) => cell.padEnd(colWidths$1[i])).join("  ");
+			process.stdout.write(`${line}\n`);
+		}
+		process.stdout.write("\n");
+		return;
+	}
 	const colWidths = headers.map((h, i) => {
-		const maxRow = rows.reduce((max, row) => Math.max(max, (row[i] ?? "").length), 0);
-		return Math.max(h.length, maxRow);
+		const maxRow = rows.reduce((max, row) => Math.max(max, stripAnsi(row[i] ?? "").length), 0);
+		return Math.max(stripAnsi(h).length, maxRow);
 	});
 	const headerLine = headers.map((h, i) => chalk.bold(h.padEnd(colWidths[i]))).join("  ");
 	const separator = colWidths.map((w) => "─".repeat(w)).join("──");
 	console.log(`\n${headerLine}`);
 	console.log(chalk.dim(separator));
 	for (const row of rows) {
-		const line = row.map((cell, i) => cell.padEnd(colWidths[i])).join("  ");
+		const line = row.map((cell, i) => {
+			const visible = stripAnsi(cell);
+			const padding = colWidths[i] - visible.length;
+			return cell + " ".repeat(Math.max(0, padding));
+		}).join("  ");
 		console.log(line);
 	}
 	console.log();
 }
 async function prompt(question) {
+	if (!isInteractive()) return "";
 	const rl = createInterface({
 		input: process.stdin,
 		output: process.stdout
@@ -156,11 +626,17 @@ async function prompt(question) {
 	});
 }
 async function promptConfirm(question, defaultYes = true) {
+	if (!isInteractive()) return defaultYes;
 	const answer = await prompt(`${question} ${defaultYes ? "(S/n)" : "(s/N)"}`);
 	if (answer === "") return defaultYes;
 	return answer.toLowerCase().startsWith("s") || answer.toLowerCase().startsWith("y");
 }
 async function promptSelect(question, options) {
+	if (!isInteractive()) {
+		if (options.length > 0) return options[0].value;
+		console.error(chalk.red("Nenhuma opção disponível no modo não-interativo."));
+		process.exit(1);
+	}
 	console.log(chalk.cyan(`\n${question}\n`));
 	for (let i = 0; i < options.length; i++) console.log(chalk.white(`  ${chalk.bold(`${i + 1})`)} ${options[i].label}`));
 	const answer = await prompt("\nEscolha (número):");
@@ -172,6 +648,7 @@ async function promptSelect(question, options) {
 	return options[index].value;
 }
 async function promptMultiSelect(question, options) {
+	if (!isInteractive()) return options.map((o) => o.value);
 	console.log(chalk.cyan(`\n${question}\n`));
 	for (let i = 0; i < options.length; i++) console.log(chalk.white(`  ${chalk.bold(`${i + 1})`)} ${options[i].label}`));
 	console.log(chalk.dim(`\n  * = todos`));
@@ -184,6 +661,10 @@ async function promptMultiSelect(question, options) {
 	}
 	return indices.map((i) => options[i].value);
 }
+const ANSI_REGEX = /\x1B\[[0-9;]*m/g;
+function stripAnsi(str) {
+	return str.replace(ANSI_REGEX, "");
+}
 
 //#endregion
 //#region src/commands/login.ts
@@ -206,15 +687,21 @@ async function performLogin(apiUrl) {
 		}
 		s.stop();
 		const verificationUrl = `${apiUrl.includes("localhost") ? "http://localhost:3001" : "https://app.onveloz.com"}${data.verification_uri_complete ? new URL(data.verification_uri_complete).pathname + new URL(data.verification_uri_complete).search : `/cli/auth?code=${data.user_code}`}`;
-		console.log();
-		info("Abrindo navegador para autenticação...");
-		console.log();
-		console.log(chalk.white(`  Código de verificação: ${chalk.bold.cyan(data.user_code)}`));
-		console.log();
-		console.log(chalk.dim("  Se o navegador não abrir, acesse manualmente:"));
-		console.log(chalk.dim(`  ${verificationUrl}`));
-		console.log();
-		openBrowser(verificationUrl);
+		output({
+			type: "auth_code",
+			userCode: data.user_code,
+			verificationUrl
+		}, () => {
+			console.log();
+			info("Abrindo navegador para autenticação...");
+			console.log();
+			console.log(chalk.white(`  Código de verificação: ${chalk.bold.cyan(data.user_code)}`));
+			console.log();
+			console.log(chalk.dim("  Se o navegador não abrir, acesse manualmente:"));
+			console.log(chalk.dim(`  ${verificationUrl}`));
+			console.log();
+			openBrowser(verificationUrl);
+		});
 		const pollSpinner = spinner("Aguardando autorização no navegador...");
 		const token = await pollForToken(authClient, data.device_code, data.interval || 5);
 		if (!token) {
@@ -229,18 +716,17 @@ async function performLogin(apiUrl) {
 		success("Autenticado com sucesso!");
 	} catch (err) {
 		s.stop();
-		if (err instanceof Error && (err.message.includes("fetch") || err.message.includes("ECONNREFUSED"))) {
-			console.error(chalk.red("\n✗ Erro de conexão: Não foi possível conectar ao servidor Veloz."));
-			console.error(chalk.yellow("  Verifique se o servidor está rodando e a URL está correta."));
-			process.exit(1);
-		}
-		console.error(chalk.red(`\n✗ Erro: ${err instanceof Error ? err.message : "Erro inesperado."}`));
-		process.exit(1);
+		if (err instanceof Error) handleLoginError(err);
+		throw err;
 	}
 }
+function handleLoginError(err) {
+	if (err.message.includes("fetch") || err.message.includes("ECONNREFUSED")) throw err;
+	throw err;
+}
 const loginCommand = new Command("login").description("Autenticar na plataforma Veloz").option("--api-url <url>", "URL da API Veloz").option("--api-key <key>", "Chave de API (para CI/automação)").action(async (opts) => {
 	if (isAuthenticated()) {
-		warn("Você já está autenticado.");
+		warn$1("Você já está autenticado.");
 		if ((await prompt("Deseja fazer login novamente? (s/N)")).toLowerCase() !== "s") process.exit(0);
 	}
 	const config = loadConfig$1();
@@ -278,7 +764,7 @@ async function pollForToken(authClient, deviceCode, interval) {
 }
 const logoutCommand = new Command("logout").description("Encerrar sessão na plataforma Veloz").action(() => {
 	if (!isAuthenticated()) {
-		warn("Você não está autenticado.");
+		warn$1("Você não está autenticado.");
 		return;
 	}
 	deleteConfig();
@@ -288,660 +774,329 @@ const logoutCommand = new Command("logout").description("Encerrar sessão na pla
 //#endregion
 //#region ../../packages/api/src/client.ts
 function createClient(baseUrl, headers) {
-	return createORPCClient(new RPCLink({
-		url: `${baseUrl}/rpc`,
-		headers: headers ?? (() => ({})),
-		fetch: (request, init) => {
-			return globalThis.fetch(request, {
-				...init,
-				credentials: "include"
-			});
-		}
-	}));
-}
-
-//#endregion
-//#region src/lib/client.ts
-async function getClient() {
-	const config = await requireAuth();
-	return createClient(config.apiUrl, () => ({ Authorization: `Bearer ${config.apiKey}` }));
-}
-
-//#endregion
-//#region src/commands/projects.ts
-const projectsCommand = new Command("projects").alias("projetos").description("Gerenciar projetos");
-projectsCommand.command("list").alias("listar").description("Listar todos os projetos").action(async () => {
-	const spin = spinner("Carregando projetos...");
-	try {
-		const projects = await (await getClient()).projects.list();
-		spin.stop();
-		if (projects.length === 0) {
-			info("Nenhum projeto encontrado. Crie um pelo dashboard.");
-			return;
-		}
-		printTable([
-			"ID",
-			"Nome",
-			"Slug",
-			"Repo GitHub",
-			"Criado em"
-		], projects.map((p) => [
-			p.id.slice(0, 8),
-			p.name,
-			p.slug,
-			p.githubRepoOwner && p.githubRepoName ? `${p.githubRepoOwner}/${p.githubRepoName}` : "—",
-			new Date(p.createdAt).toLocaleDateString("pt-BR")
-		]));
-	} catch (error) {
-		spin.stop();
-		handleError(error);
-	}
-});
-
-//#endregion
-//#region ../../packages/config/veloz-config.ts
-const ServiceTypeSchema = z.enum(["web", "static"]);
-const PackageManagerSchema = z.enum([
-	"npm",
-	"yarn",
-	"pnpm",
-	"bun",
-	"auto"
-]);
-const BuildConfigSchema = z.object({
-	command: z.string().nullable().optional(),
-	nodeVersion: z.string().regex(/^[0-9]+(\.x)?$/).default("20").optional(),
-	packageManager: PackageManagerSchema.default("auto").optional(),
-	installCommand: z.string().nullable().optional(),
-	outputDir: z.string().nullable().optional()
-});
-const RuntimeConfigSchema = z.object({
-	command: z.string().nullable().optional(),
-	port: z.number().min(1).max(65535).default(3e3).optional(),
-	healthCheck: z.object({
-		path: z.string().default("/").optional(),
-		interval: z.number().default(30).optional(),
-		timeout: z.number().default(10).optional()
-	}).optional()
-});
-const ResourcesSchema = z.object({
-	instances: z.number().min(1).max(10).default(1).optional(),
-	cpu: z.string().regex(/^[0-9]+(\.[0-9]+)?|[0-9]+m$/).default("500m").optional(),
-	memory: z.string().regex(/^[0-9]+(Mi|Gi)$/).default("512Mi").optional(),
-	autoscale: z.object({
-		enabled: z.boolean().default(false).optional(),
-		minInstances: z.number().min(1).default(1).optional(),
-		maxInstances: z.number().min(1).max(20).default(3).optional(),
-		targetCPU: z.number().min(10).max(90).default(70).optional()
-	}).optional()
-});
-const EnvVarDefinitionSchema = z.object({
-	description: z.string().optional(),
-	required: z.boolean().default(false).optional(),
-	example: z.string().optional()
-});
-const ServiceConfigSchema = z.object({
-	id: z.string(),
-	name: z.string(),
-	type: ServiceTypeSchema.default("web"),
-	root: z.string().default("."),
-	branch: z.string().optional(),
-	build: BuildConfigSchema.optional(),
-	runtime: RuntimeConfigSchema.optional(),
-	env: z.record(z.string().regex(/^[A-Z][A-Z0-9_]*$/), EnvVarDefinitionSchema).optional(),
-	resources: ResourcesSchema.optional()
-});
-const ProjectConfigSchema = z.object({
-	id: z.string(),
-	name: z.string(),
-	slug: z.string().regex(/^[a-z0-9-]+$/).optional()
-});
-const ServiceDefaultsSchema = z.object({
-	type: ServiceTypeSchema.optional(),
-	branch: z.string().optional(),
-	build: BuildConfigSchema.optional(),
-	runtime: RuntimeConfigSchema.optional(),
-	resources: ResourcesSchema.optional()
-});
-const VelozConfigSchema = z.object({
-	$schema: z.string().optional(),
-	version: z.literal("1.0"),
-	project: ProjectConfigSchema,
-	services: z.record(z.string(), ServiceConfigSchema),
-	defaults: ServiceDefaultsSchema.optional(),
-	created: z.string().datetime().optional(),
-	updated: z.string().datetime().optional()
-});
-function mergeServiceWithDefaults(service, defaults) {
-	if (!defaults) return service;
-	return {
-		...service,
-		type: service.type ?? defaults.type ?? "web",
-		branch: service.branch ?? defaults.branch,
-		build: {
-			...defaults.build,
-			...service.build
-		},
-		runtime: {
-			...defaults.runtime,
-			...service.runtime
-		},
-		resources: {
-			...defaults.resources,
-			...service.resources
-		}
-	};
-}
-function parseVelozConfig(data) {
-	return VelozConfigSchema.parse(data);
-}
-
-//#endregion
-//#region src/lib/link.ts
-const CONFIG_FILE = "veloz.json";
-const LOCAL_CONFIG_FILE = "veloz.local.json";
-/**
-* Find the root directory (git root or monorepo root)
-*/
-function findProjectRoot(startPath = process.cwd()) {
-	let currentPath = resolve(startPath);
-	const root = resolve("/");
-	while (currentPath !== root) {
-		if (existsSync(join(currentPath, ".git"))) return currentPath;
-		if (existsSync(join(currentPath, "pnpm-workspace.yaml")) || existsSync(join(currentPath, "lerna.json")) || existsSync(join(currentPath, "rush.json")) || existsSync(join(currentPath, "nx.json"))) return currentPath;
-		const pkgJsonPath = join(currentPath, "package.json");
-		if (existsSync(pkgJsonPath)) try {
-			if (JSON.parse(readFileSync(pkgJsonPath, "utf-8")).workspaces) return currentPath;
-		} catch {}
-		const parentPath = resolve(currentPath, "..");
-		if (parentPath === currentPath) break;
-		currentPath = parentPath;
-	}
-	return process.cwd();
-}
-/**
-* Get the config file name (veloz.local.json when VELOZ_API_URL is set, veloz.json otherwise)
-*/
-function getConfigFileName() {
-	return process.env.VELOZ_API_URL ? LOCAL_CONFIG_FILE : CONFIG_FILE;
-}
-/**
-* Get the path to veloz.json (or veloz.local.json when using custom API URL)
-*/
-function getConfigPath() {
-	return join(findProjectRoot(), getConfigFileName());
-}
-/**
-* Load the veloz.json config from project root
-*/
-function loadConfig() {
-	const path = getConfigPath();
-	if (!existsSync(path)) return null;
-	try {
-		const raw = readFileSync(path, "utf-8");
-		return parseVelozConfig(JSON.parse(raw));
-	} catch (error) {
-		console.error(`Error loading ${getConfigFileName()}:`, error);
-		return null;
-	}
-}
-/**
-* Save the veloz.json config to project root
-*/
-function saveConfig(config) {
-	const path = getConfigPath();
-	const configWithSchema = {
-		$schema: "https://veloz.app/schemas/veloz-config.schema.json",
-		...config
-	};
-	writeFileSync(path, JSON.stringify(configWithSchema, null, 2), "utf-8");
-}
-/**
-* Require config to exist, throw if not found
-*/
-function requireConfig() {
-	const config = loadConfig();
-	if (!config) throw new Error(`No ${getConfigFileName()} found in project root. Run 'veloz init' or 'veloz deploy' to set up your project.`);
-	return config;
-}
-/**
-* Check if current directory is a git repository
-*/
-function isGitRepo() {
-	try {
-		execSync("git rev-parse --is-inside-work-tree", { stdio: "pipe" });
-		return true;
-	} catch {
-		return false;
-	}
-}
-/**
-* Get git remote origin info
-*/
-function getGitRemote() {
-	try {
-		const url = execSync("git remote get-url origin", { stdio: "pipe" }).toString().trim();
-		const httpsMatch = url.match(/github\.com\/([^/]+)\/([^/.]+)/);
-		if (httpsMatch) return {
-			owner: httpsMatch[1],
-			repo: httpsMatch[2]
-		};
-		const sshMatch = url.match(/github\.com:([^/]+)\/([^/.]+)/);
-		if (sshMatch) return {
-			owner: sshMatch[1],
-			repo: sshMatch[2]
-		};
-		return null;
-	} catch {
-		return null;
-	}
+	return createORPCClient(new RPCLink({
+		url: `${baseUrl}/rpc`,
+		headers: headers ?? (() => ({})),
+		fetch: (request, init) => {
+			return globalThis.fetch(request, {
+				...init,
+				credentials: "include"
+			});
+		}
+	}));
 }
-/**
-* Get current git branch
-*/
-function getGitBranch() {
+
+//#endregion
+//#region src/lib/client.ts
+async function getClient() {
+	const authConfig = await requireAuth();
+	const projectConfig = loadConfig();
+	return createClient(authConfig.apiUrl, () => {
+		const headers = { Authorization: `Bearer ${authConfig.apiKey}` };
+		if (projectConfig?.project?.id) headers["X-Project-Id"] = projectConfig.project.id;
+		if (!projectConfig?.project?.id && authConfig.organizationId) headers["X-Organization-Id"] = authConfig.organizationId;
+		return headers;
+	});
+}
+
+//#endregion
+//#region src/commands/projects.ts
+const projectsCommand = new Command("projects").alias("projetos").description("Gerenciar projetos");
+projectsCommand.command("list").alias("listar").description("Listar todos os projetos").action(async () => {
+	const spin = spinner("Carregando projetos...");
 	try {
-		return execSync("git rev-parse --abbrev-ref HEAD", { stdio: "pipe" }).toString().trim();
-	} catch {
-		return "main";
+		const projects = await (await getClient()).projects.list();
+		spin.stop();
+		if (projects.length === 0) {
+			info("Nenhum projeto encontrado. Crie um pelo dashboard.");
+			return;
+		}
+		printTable([
+			"ID",
+			"Nome",
+			"Slug",
+			"Repo GitHub",
+			"Criado em"
+		], projects.map((p) => [
+			p.id,
+			p.name,
+			p.slug,
+			p.githubRepoOwner && p.githubRepoName ? `${p.githubRepoOwner}/${p.githubRepoName}` : "—",
+			new Date(p.createdAt).toLocaleDateString("pt-BR")
+		]), projects.map((p) => ({
+			id: p.id,
+			name: p.name,
+			slug: p.slug,
+			githubRepo: p.githubRepoOwner && p.githubRepoName ? `${p.githubRepoOwner}/${p.githubRepoName}` : null,
+			createdAt: p.createdAt
+		})));
+	} catch (error) {
+		spin.stop();
+		handleError(error);
 	}
-}
+});
 
 //#endregion
 //#region src/commands/link.ts
 const linkCommand = new Command("link").description("Verificar vínculo do projeto com Veloz").action(async () => {
 	const config = loadConfig();
 	if (!config) {
-		warn("Nenhum projeto configurado. Execute 'veloz deploy' para configurar seu projeto.");
+		warn$1("Nenhum projeto configurado. Execute 'veloz deploy' para configurar seu projeto.");
 		return;
 	}
-	console.log(chalk.bold("\n🔗 Projeto Vinculado\n"));
-	console.log(`  ${chalk.bold("Projeto:")}     ${chalk.cyan(config.project.name)}`);
-	console.log(`  ${chalk.bold("ID:")}          ${chalk.dim(config.project.id)}`);
 	const services = Object.entries(config.services);
-	if (services.length > 0) {
-		console.log(`\n  ${chalk.bold("Serviços:")}`);
-		services.forEach(([key, service]) => {
-			const type = service.type === "web" ? "Serviço Web" : "Site Estático";
-			console.log(`    • ${chalk.cyan(service.name)} (${key}) - ${type}`);
-		});
-	}
-	console.log();
-	info("Use 'veloz deploy' para fazer deploy ou atualizar serviços.");
+	output({
+		type: "link",
+		project: {
+			id: config.project.id,
+			name: config.project.name
+		},
+		services: services.map(([key, service]) => ({
+			key,
+			id: service.id,
+			name: service.name,
+			type: service.type
+		}))
+	}, () => {
+		console.log(chalk.bold("\n🔗 Projeto Vinculado\n"));
+		console.log(`  ${chalk.bold("Projeto:")}     ${chalk.cyan(config.project.name)}`);
+		console.log(`  ${chalk.bold("ID:")}          ${chalk.dim(config.project.id)}`);
+		if (services.length > 0) {
+			console.log(`\n  ${chalk.bold("Serviços:")}`);
+			services.forEach(([key, service]) => {
+				const type = service.type === "web" ? "Serviço Web" : "Site Estático";
+				console.log(`    • ${chalk.cyan(service.name)} (${key}) - ${type}`);
+			});
+		}
+		console.log();
+		info("Use 'veloz deploy' para fazer deploy ou atualizar serviços.");
+	});
 });
 
 //#endregion
 //#region ../../packages/api/src/lib/framework-detector.ts
-const FRAMEWORK_RULES = [
-	{
+function safeParsePkg(content) {
+	try {
+		return JSON.parse(content);
+	} catch {
+		return null;
+	}
+}
+function pmRun(pm, script) {
+	if (pm === "yarn") return `yarn ${script}`;
+	return `${pm} run ${script}`;
+}
+function detectFramework(pkgJsonStr, pm) {
+	const pkg = safeParsePkg(pkgJsonStr);
+	if (!pkg) return null;
+	const allDeps = {
+		...pkg.dependencies,
+		...pkg.devDependencies
+	};
+	const hasReact = !!allDeps["react"];
+	if (allDeps["next"]) return {
 		name: "nextjs",
 		label: "Next.js",
 		type: "WEB",
-		match: (deps) => "next" in deps,
-		buildCommand: "npm run build",
-		startCommand: "npm start",
+		buildCommand: pmRun(pm, "build"),
+		startCommand: pmRun(pm, "start"),
 		outputDir: ".next",
 		port: 3e3
-	},
-	{
-		name: "hono",
-		label: "Hono",
-		type: "WEB",
-		match: (deps) => "hono" in deps,
-		buildCommand: "npm run build",
-		startCommand: "npm start",
-		outputDir: "dist",
-		port: 3e3
-	},
-	{
+	};
+	if (allDeps["nuxt"] || allDeps["nuxt3"]) return {
 		name: "nuxt",
 		label: "Nuxt",
 		type: "WEB",
-		match: (deps) => "nuxt" in deps,
-		buildCommand: "npm run build",
-		startCommand: "npm start",
-		outputDir: ".nuxt",
+		buildCommand: pmRun(pm, "build"),
+		startCommand: pmRun(pm, "start"),
+		outputDir: ".output",
 		port: 3e3
-	},
-	{
+	};
+	if (allDeps["@remix-run/node"] || allDeps["@remix-run/react"]) return {
 		name: "remix",
 		label: "Remix",
 		type: "WEB",
-		match: (deps) => "@remix-run/node" in deps,
-		buildCommand: "npm run build",
-		startCommand: "npm start",
+		buildCommand: pmRun(pm, "build"),
+		startCommand: pmRun(pm, "start"),
 		outputDir: "build",
 		port: 3e3
-	},
-	{
-		name: "sveltekit",
-		label: "SvelteKit",
-		type: "WEB",
-		match: (deps) => "@sveltejs/kit" in deps,
-		buildCommand: "npm run build",
-		startCommand: "npm start",
-		outputDir: ".svelte-kit",
-		port: 3e3
-	},
-	{
+	};
+	if (allDeps["astro"]) return {
 		name: "astro",
 		label: "Astro",
 		type: "STATIC",
-		match: (deps) => "astro" in deps,
-		buildCommand: "npm run build",
+		buildCommand: pmRun(pm, "build"),
 		startCommand: null,
 		outputDir: "dist",
 		port: 3e3
-	},
-	{
+	};
+	if (allDeps["@sveltejs/kit"]) return {
+		name: "sveltekit",
+		label: "SvelteKit",
+		type: "WEB",
+		buildCommand: pmRun(pm, "build"),
+		startCommand: pmRun(pm, "preview"),
+		outputDir: "build",
+		port: 3e3
+	};
+	if (allDeps["gatsby"]) return {
 		name: "gatsby",
 		label: "Gatsby",
 		type: "STATIC",
-		match: (deps) => "gatsby" in deps,
-		buildCommand: "npm run build",
+		buildCommand: pmRun(pm, "build"),
 		startCommand: null,
 		outputDir: "public",
 		port: 3e3
-	},
-	{
-		name: "create-react-app",
-		label: "Create React App",
-		type: "STATIC",
-		match: (deps) => "react-scripts" in deps,
-		buildCommand: "npm run build",
-		startCommand: null,
-		outputDir: "build",
-		port: 3e3
-	},
-	{
-		name: "vite-react",
-		label: "Vite + React",
-		type: "STATIC",
-		match: (deps) => "vite" in deps && "react" in deps,
-		buildCommand: "npm run build",
-		startCommand: null,
-		outputDir: "dist",
-		port: 3e3
-	},
-	{
-		name: "vite-vue",
-		label: "Vite + Vue",
-		type: "STATIC",
-		match: (deps) => "vite" in deps && "vue" in deps,
-		buildCommand: "npm run build",
-		startCommand: null,
-		outputDir: "dist",
-		port: 3e3
-	},
-	{
-		name: "vite",
-		label: "Vite",
-		type: "STATIC",
-		match: (deps) => "vite" in deps,
-		buildCommand: "npm run build",
-		startCommand: null,
-		outputDir: "dist",
-		port: 3e3
-	},
-	{
+	};
+	if (allDeps["@angular/core"]) return {
 		name: "angular",
 		label: "Angular",
-		type: "STATIC",
-		match: (deps) => "@angular/core" in deps,
-		buildCommand: "npm run build",
-		startCommand: null,
+		type: "WEB",
+		buildCommand: pmRun(pm, "build"),
+		startCommand: pmRun(pm, "start"),
 		outputDir: "dist",
 		port: 4200
-	},
-	{
+	};
+	if (allDeps["hono"]) return {
+		name: "hono",
+		label: "Hono",
+		type: "WEB",
+		buildCommand: pmRun(pm, "build"),
+		startCommand: pmRun(pm, "start"),
+		outputDir: null,
+		port: 3e3
+	};
+	if (allDeps["express"]) return {
 		name: "express",
 		label: "Express",
 		type: "WEB",
-		match: (deps) => "express" in deps,
-		buildCommand: null,
-		startCommand: "node index.js",
+		buildCommand: pmRun(pm, "build"),
+		startCommand: pmRun(pm, "start"),
 		outputDir: null,
 		port: 3e3
-	},
-	{
+	};
+	if (allDeps["fastify"]) return {
 		name: "fastify",
 		label: "Fastify",
 		type: "WEB",
-		match: (deps) => "fastify" in deps,
-		buildCommand: null,
-		startCommand: "node index.js",
+		buildCommand: pmRun(pm, "build"),
+		startCommand: pmRun(pm, "start"),
 		outputDir: null,
 		port: 3e3
-	},
-	{
+	};
+	if (allDeps["@nestjs/core"]) return {
 		name: "nestjs",
 		label: "NestJS",
 		type: "WEB",
-		match: (deps) => "@nestjs/core" in deps,
-		buildCommand: "npm run build",
-		startCommand: "npm run start:prod",
+		buildCommand: pmRun(pm, "build"),
+		startCommand: pmRun(pm, "start:prod"),
 		outputDir: "dist",
 		port: 3e3
-	},
-	{
-		name: "hono",
-		label: "Hono",
+	};
+	if (allDeps["vite"]) return {
+		name: hasReact ? "vite-react" : "vite",
+		label: hasReact ? "Vite + React" : "Vite",
+		type: "STATIC",
+		buildCommand: pmRun(pm, "build"),
+		startCommand: null,
+		outputDir: "dist",
+		port: 3e3
+	};
+	if (allDeps["react-scripts"]) return {
+		name: "cra",
+		label: "Create React App",
+		type: "STATIC",
+		buildCommand: pmRun(pm, "build"),
+		startCommand: null,
+		outputDir: "build",
+		port: 3e3
+	};
+	if (pkg.scripts?.build || pkg.scripts?.start) return {
+		name: "node",
+		label: "Node.js",
 		type: "WEB",
-		match: (deps) => "hono" in deps || "@hono/node-server" in deps,
-		buildCommand: null,
-		startCommand: "node index.js",
-		outputDir: null,
+		buildCommand: pkg.scripts?.build ? pmRun(pm, "build") : "",
+		startCommand: pkg.scripts?.start ? pmRun(pm, "start") : "node index.js",
+		outputDir: "dist",
 		port: 3e3
-	}
-];
+	};
+	return null;
+}
 function detectPackageManager$1(files) {
-	if ("bun.lockb" in files || "bun.lock" in files) return "bun";
-	if ("pnpm-lock.yaml" in files || "pnpm-workspace.yaml" in files) return "pnpm";
+	if ("pnpm-lock.yaml" in files) return "pnpm";
 	if ("yarn.lock" in files) return "yarn";
+	if ("bun.lock" in files || "bun.lockb" in files) return "bun";
 	return "npm";
 }
-function runCmd(pm, script) {
-	switch (pm) {
-		case "bun": return `bun run ${script}`;
-		case "yarn": return `yarn ${script}`;
-		case "pnpm": return `pnpm run ${script}`;
-		default: return `npm run ${script}`;
-	}
-}
-function startCmd(pm) {
-	switch (pm) {
-		case "bun": return "bun run start";
-		case "yarn": return "yarn start";
-		case "pnpm": return "pnpm start";
-		default: return "npm start";
-	}
-}
-function safeParse(json) {
-	if (!json) return null;
-	try {
-		return JSON.parse(json);
-	} catch {
-		return null;
-	}
-}
-function getAllDeps(pkg) {
-	const deps = pkg.dependencies ?? {};
-	const devDeps = pkg.devDependencies ?? {};
-	return {
-		...deps,
-		...devDeps
-	};
-}
-function detectFramework(packageJsonStr, pm = "npm") {
-	const pkg = safeParse(packageJsonStr);
-	if (!pkg) return null;
-	const allDeps = getAllDeps(pkg);
-	const scripts = pkg.scripts ?? {};
-	for (const rule of FRAMEWORK_RULES) if (rule.match(allDeps)) {
-		const ruleStart = rule.startCommand === "node index.js" ? "node index.js" : rule.startCommand ? startCmd(pm) : null;
-		let buildScript = "build";
-		let startScript = "start";
-		const scriptKeys = Object.keys(scripts);
-		const buildVariants = scriptKeys.filter((k) => k.startsWith("build:") || k.startsWith("build-"));
-		const startVariants = scriptKeys.filter((k) => k.startsWith("start:") || k.startsWith("start-"));
-		if (buildVariants.length > 0 && !scripts.build) buildScript = buildVariants[0];
-		if (startVariants.length > 0 && !scripts.start) startScript = startVariants[0];
-		return {
-			name: rule.name,
-			label: rule.label,
-			type: rule.type,
-			buildCommand: scripts[buildScript] ? runCmd(pm, buildScript) : rule.buildCommand ? runCmd(pm, "build") : null,
-			startCommand: scripts[startScript] ? runCmd(pm, startScript) : ruleStart,
-			outputDir: rule.outputDir,
-			port: rule.port
-		};
-	}
-	if (scripts.build || scripts.start) {
-		let outputDir = null;
-		if (scripts.build) {
-			if (scripts.build.includes("tsc")) outputDir = "dist";
-			else if (scripts.build.includes("tsup")) outputDir = "dist";
-			else if (scripts.build.includes("esbuild")) outputDir = "dist";
-			else if (scripts.build.includes("webpack")) outputDir = "dist";
-			else if (scripts.build.includes("rollup")) outputDir = "dist";
-			else if (scripts.build.includes("parcel")) outputDir = "dist";
-		}
-		return {
-			name: "node",
-			label: "Node.js",
-			type: scripts.start ? "WEB" : "STATIC",
-			buildCommand: scripts.build ? runCmd(pm, "build") : null,
-			startCommand: scripts.start ? startCmd(pm) : null,
-			outputDir,
-			port: 3e3
-		};
-	}
-	return null;
-}
-function detectEnvVars(files) {
-	const envContent = files[".env.example"] ?? files[".env.sample"] ?? files[".env.local.example"] ?? files[".env"];
-	if (!envContent) return [];
+function extractEnvVars(files) {
 	const vars = [];
-	for (const line of envContent.split("\n")) {
-		const trimmed = line.trim();
-		if (!trimmed || trimmed.startsWith("#")) continue;
-		const eqIdx = trimmed.indexOf("=");
-		if (eqIdx === -1) continue;
-		const key = trimmed.slice(0, eqIdx).trim();
-		const value = trimmed.slice(eqIdx + 1).trim();
-		if (key) vars.push({
-			key,
-			value
-		});
-	}
-	return vars;
-}
-function resolveWorkspacePatterns(patterns, availableFiles) {
-	const dirs = /* @__PURE__ */ new Set();
-	for (const pattern of patterns) {
-		const hasGlob = /\/?\*\*?$/.test(pattern);
-		const base = pattern.replace(/\/?\*\*?$/, "");
-		if (hasGlob) {
-			for (const filePath of availableFiles) if (filePath.startsWith(base + "/") && filePath.endsWith("/package.json")) {
-				const parts = filePath.slice(base.length + 1).split("/");
-				if (parts.length === 2 && parts[1] === "package.json") dirs.add(base + "/" + parts[0]);
+	const seen = /* @__PURE__ */ new Set();
+	for (const key of [
+		".env.example",
+		".env.sample",
+		".env"
+	]) {
+		const content = files[key];
+		if (!content) continue;
+		for (const line of content.split("\n")) {
+			const trimmed = line.trim();
+			if (!trimmed || trimmed.startsWith("#")) continue;
+			const eqIdx = trimmed.indexOf("=");
+			if (eqIdx > 0) {
+				const envKey = trimmed.slice(0, eqIdx).trim();
+				if (!seen.has(envKey)) {
+					seen.add(envKey);
+					vars.push({
+						key: envKey,
+						value: trimmed.slice(eqIdx + 1)
+					});
+				}
 			}
-		} else {
-			const pkgPath = base + "/package.json";
-			if (availableFiles.includes(pkgPath)) dirs.add(base);
 		}
 	}
-	return [...dirs];
+	return vars;
 }
-function detectMonorepo(files, pm = "npm") {
-	const rootPkg = safeParse(files["package.json"]);
-	const availableFiles = Object.keys(files);
-	let workspacePatterns = [];
-	if (rootPkg?.workspaces) {
-		const ws = rootPkg.workspaces;
-		if (Array.isArray(ws)) workspacePatterns = ws;
-		else if (typeof ws === "object" && ws !== null && "packages" in ws && Array.isArray(ws.packages)) workspacePatterns = ws.packages;
-	}
-	if (workspacePatterns.length === 0 && files["pnpm-workspace.yaml"]) {
-		const lines = files["pnpm-workspace.yaml"].split("\n");
-		let inPackages = false;
-		for (const line of lines) {
-			if (line.match(/^packages\s*:/)) {
-				inPackages = true;
-				continue;
-			}
-			if (inPackages) {
-				const match = line.match(/^\s+-\s+['"]?([^'"]+)['"]?\s*$/);
-				if (match) workspacePatterns.push(match[1]);
-				else if (line.match(/^\S/)) break;
-			}
-		}
-	}
-	if (workspacePatterns.length === 0) return {
-		isMonorepo: false,
-		apps: []
-	};
-	const dirs = resolveWorkspacePatterns(workspacePatterns, availableFiles);
-	const rootScripts = rootPkg?.scripts || {};
-	const apps = [];
-	for (const dir of dirs) {
-		const pkgContent = files[`${dir}/package.json`];
-		const pkg = safeParse(pkgContent);
-		const name = pkg?.name ?? dir.split("/").pop() ?? dir;
-		let framework = detectFramework(pkgContent, pm);
-		if (framework && rootScripts) {
-			const serviceName = dir.split("/").pop() ?? name;
-			const buildKey = [
-				`build:${serviceName}`,
-				`build-${serviceName}`,
-				`${serviceName}:build`
-			].find((k) => rootScripts[k]);
-			if (buildKey) framework.buildCommand = `${pm} run ${buildKey}`;
-			const startKey = [
-				`start:${serviceName}`,
-				`start-${serviceName}`,
-				`${serviceName}:start`,
-				`dev:${serviceName}`,
-				`serve:${serviceName}`
-			].find((k) => rootScripts[k]);
-			if (startKey) framework.startCommand = `${pm} run ${startKey}`;
-			if (framework.name === "nextjs" && !startKey) framework.startCommand = `cd ${dir} && ${pm} run start`;
-			else if ([
-				"hono",
-				"express",
-				"fastify",
-				"nestjs"
-			].includes(framework.name)) {
-				if (!startKey && framework.buildCommand) {
-					const scripts = pkg?.scripts || {};
-					if (scripts.build && scripts.build.includes("tsc")) framework.startCommand = `node ${dir}/dist/index.js`;
-					else if (scripts.build && scripts.build.includes("tsup")) framework.startCommand = `node ${dir}/dist/index.js`;
-					else if (scripts.build && scripts.build.includes("esbuild")) framework.startCommand = `node ${dir}/dist/index.js`;
-				}
+function analyzeRepo(files) {
+	const packageManager = detectPackageManager$1(files);
+	const envVars = extractEnvVars(files);
+	const rootPkgContent = files["package.json"];
+	const rootPkg = rootPkgContent ? safeParsePkg(rootPkgContent) : null;
+	const isMonorepo = "pnpm-workspace.yaml" in files || !!rootPkg?.workspaces;
+	const framework = rootPkgContent ? detectFramework(rootPkgContent, packageManager) : null;
+	const monorepoApps = [];
+	if (isMonorepo) for (const [filePath, content] of Object.entries(files)) {
+		if (filePath === "package.json") continue;
+		if (!filePath.endsWith("/package.json")) continue;
+		const nested = safeParsePkg(content);
+		if (!nested) continue;
+		const appPath = filePath.replace("/package.json", "");
+		const appName = nested.name || appPath.split("/").pop() || appPath;
+		let appFramework = detectFramework(content, packageManager);
+		if (appFramework && rootPkg) {
+			if (rootPkg.scripts?.[`build:${appName}`]) appFramework = {
+				...appFramework,
+				buildCommand: pmRun(packageManager, `build:${appName}`)
+			};
+			if (nested.scripts?.start?.startsWith("node ")) {
+				const nodePath = nested.scripts.start.slice(5).trim();
+				appFramework = {
+					...appFramework,
+					startCommand: `node ${appPath}/${nodePath}`
+				};
 			}
 		}
-		apps.push({
-			name,
-			path: dir,
-			framework
+		monorepoApps.push({
+			name: appName,
+			path: appPath,
+			framework: appFramework
 		});
 	}
 	return {
-		isMonorepo: apps.length > 0,
-		apps
-	};
-}
-function analyzeRepo(files) {
-	const pm = detectPackageManager$1(files);
-	const framework = detectFramework(files["package.json"], pm);
-	const envVars = detectEnvVars(files);
-	const { isMonorepo, apps } = detectMonorepo(files, pm);
-	return {
+		packageManager,
 		framework,
-		packageManager: pm,
 		envVars,
 		isMonorepo,
-		monorepoApps: apps
+		monorepoApps
 	};
 }
 
@@ -1001,170 +1156,108 @@ async function getFilesToUpload(directory) {
 	return files;
 }
 async function createTarball(directory, extraFiles) {
-	const createdFiles = [];
+	const tempDir = await mkdtemp(join(tmpdir(), "veloz-upload-"));
+	const tarPath = join(tempDir, "source.tar.gz");
+	const injectedFiles = [];
 	if (extraFiles) for (const file of extraFiles) {
-		const filePath = join(directory, file.name);
-		if (!existsSync(filePath)) {
-			writeFileSync(filePath, file.content);
-			createdFiles.push(filePath);
-		}
+		if (existsSync(join(directory, file.name))) continue;
+		injectedFiles.push(file);
 	}
 	try {
 		const files = await getFilesToUpload(directory);
 		if (files.length === 0) throw new Error("No files to upload");
-		const tarPath = join(await mkdtemp(join(tmpdir(), "veloz-upload-")), "source.tar.gz");
 		const relativePaths = files.map((f) => relative(directory, f));
-		for (const f of createdFiles) {
-			const rel = relative(directory, f);
-			if (!relativePaths.includes(rel)) relativePaths.push(rel);
-		}
-		await tar.create({
+		if (injectedFiles.length === 0) await tar.create({
 			gzip: true,
 			file: tarPath,
 			cwd: directory
 		}, relativePaths);
+		else {
+			const stagingDir = join(tempDir, "staging");
+			await mkdir(stagingDir, { recursive: true });
+			for (const rel of relativePaths) {
+				const src = join(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 {
 			path: tarPath,
-			size: statSync(tarPath).size
+			size: statSync(tarPath).size,
+			tempDir
 		};
-	} finally {
-		for (const f of createdFiles) try {
-			unlinkSync(f);
-		} catch {}
+	} catch (err) {
+		await rm(tempDir, {
+			recursive: true,
+			force: true
+		}).catch(() => {});
+		throw err;
 	}
 }
-async function uploadSource(apiUrl, deploymentId, directory, token, extraFiles) {
-	const { path: tarPath } = await createTarball(directory, extraFiles);
+async function uploadSource(deploymentId, directory, extraFiles) {
+	const { path: tarPath, tempDir } = await createTarball(directory, extraFiles);
+	const client = await getClient();
 	try {
-		const urlResponse = await fetch(`${apiUrl}/api/deployments/${deploymentId}/upload-url`, {
-			method: "POST",
-			headers: {
-				Authorization: `Bearer ${token}`,
-				"Content-Type": "application/json"
-			}
-		});
-		if (!urlResponse.ok) {
-			const err = await urlResponse.json().catch(() => ({ error: "Unknown error" }));
-			throw new Error(`Failed to get upload URL: ${err.error || urlResponse.statusText}`);
-		}
-		const { uploadUrl, objectKey } = await urlResponse.json();
+		const { uploadUrl, objectKey } = 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(`S3 upload failed: ${putResponse.status} ${putResponse.statusText}`);
-		const buildResponse = await fetch(`${apiUrl}/api/deployments/${deploymentId}/build`, {
-			method: "POST",
-			headers: {
-				Authorization: `Bearer ${token}`,
-				"Content-Type": "application/json"
-			},
-			body: JSON.stringify({ objectKey })
+		if (!putResponse.ok) throw new Error(`Upload falhou: ${putResponse.status}`);
+		await client.deployments.startBuild({
+			deploymentId,
+			objectKey
 		});
-		if (!buildResponse.ok) {
-			const err = await buildResponse.json().catch(() => ({ error: "Unknown error" }));
-			throw new Error(`Failed to trigger build: ${err.error || buildResponse.statusText}`);
-		}
 	} finally {
-		await rm(tarPath, {
-			force: true,
-			recursive: true
+		await rm(tempDir, {
+			recursive: true,
+			force: true
 		}).catch(() => {});
 	}
 }
 async function calculateDirectorySize(directory) {
-	const files = await getFilesToUpload(directory);
-	let totalSize = 0;
-	for (const file of files) {
-		const stats = await stat(file);
-		totalSize += stats.size;
-	}
-	return totalSize;
-}
-
-//#endregion
-//#region src/lib/deploy-stream.ts
-const statusLabels$1 = {
-	QUEUED: "Na fila",
-	BUILDING: "Construindo",
-	BUILD_FAILED: "Falha na construção",
-	DEPLOYING: "Implantando",
-	LIVE: "Ativo",
-	FAILED: "Falhou",
-	CANCELLED: "Cancelado"
-};
-const TERMINAL_STATUSES$1 = new Set([
-	"LIVE",
-	"BUILD_FAILED",
-	"FAILED",
-	"CANCELLED"
-]);
-async function streamDeploymentLogs(client, deploymentId, _serviceId, serviceName) {
-	const isVerbose = process.env.VELOZ_VERBOSE === "true";
-	const logHeader = serviceName ? `📦 Build logs para ${chalk.bold(serviceName)}:` : "📦 Build logs:";
-	console.log(chalk.cyan(`\n${logHeader}`));
-	console.log(chalk.dim("─".repeat(60)));
-	if (isVerbose) console.log(chalk.dim(`[verbose] Conectando ao stream de logs para deployment ${deploymentId}...`));
-	let finalStatus = "";
-	let logsReceived = false;
-	try {
-		const stream = await client.logs.streamBuildLogs({ deploymentId });
-		for await (const event of stream) {
-			logsReceived = true;
-			if (event.type === "status") {
-				const label = statusLabels$1[event.content] ?? event.content;
-				const icon = event.content === "LIVE" ? chalk.green("●") : event.content === "BUILD_FAILED" || event.content === "FAILED" ? chalk.red("●") : chalk.yellow("●");
-				process.stdout.write(`\n${icon} ${chalk.bold(label)}\n`);
-				finalStatus = event.content;
-				if (isVerbose) console.log(chalk.dim(`[verbose] Status mudou para: ${event.content}`));
-			} else if (event.type === "log") process.stdout.write(event.content);
-		}
-		if (!logsReceived && isVerbose) console.log(chalk.yellow("[verbose] Nenhum log recebido do stream. Buscando status do deployment..."));
-	} catch (error) {
-		if (isVerbose) console.log(chalk.red(`[verbose] Erro no stream: ${error.message}`));
-		try {
-			const d = await client.deployments.get({ deploymentId });
-			finalStatus = d.status;
-			if (isVerbose) console.log(chalk.dim(`[verbose] Status do deployment: ${d.status}`));
-			try {
-				const logs = await client.logs.getBuildLogs({ deploymentId });
-				if (logs.buildLogs) {
-					console.log(chalk.dim("\n── Logs salvos ──\n"));
-					process.stdout.write(logs.buildLogs);
-				} else if (isVerbose) console.log(chalk.yellow("[verbose] Nenhum log salvo encontrado para este deployment"));
-			} catch {
-				if (isVerbose) console.log(chalk.yellow("[verbose] Não foi possível buscar logs de build"));
-			}
-		} catch (fetchError) {
-			if (isVerbose) console.log(chalk.red(`[verbose] Erro ao buscar deployment: ${fetchError.message}`));
-		}
-	}
-	console.log(chalk.dim("\n" + "─".repeat(60)));
-	if (finalStatus === "LIVE") success(serviceName ? `Deploy de ${chalk.bold(serviceName)} concluído! Serviço está ativo.` : "Deploy concluído! Serviço está ativo.");
-	else if (TERMINAL_STATUSES$1.has(finalStatus)) {
-		const errorMsg = serviceName ? `✗ Deploy de ${chalk.bold(serviceName)} finalizou com status: ${statusLabels$1[finalStatus] ?? finalStatus}` : `✗ Deploy finalizou com status: ${statusLabels$1[finalStatus] ?? finalStatus}`;
-		console.error(chalk.red(errorMsg));
-		if (!serviceName) process.exit(1);
+	const files = await getFilesToUpload(directory);
+	let totalSize = 0;
+	for (const file of files) {
+		const stats = await stat(file);
+		totalSize += stats.size;
 	}
+	return totalSize;
 }
 
 //#endregion
-//#region src/lib/deploy-parallel.ts
-async function withRetry$1(fn, maxRetries = 3) {
+//#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) {
+		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((resolve$1) => setTimeout(resolve$1, delay));
-			continue;
+			await new Promise((r) => setTimeout(r, delay));
 		}
-		throw error;
 	}
 	throw new Error("Max retries exceeded");
 }
+
+//#endregion
+//#region src/lib/deploy-constants.ts
 const statusLabels = {
 	QUEUED: "Na fila",
 	BUILDING: "Construindo",
@@ -1174,21 +1267,90 @@ const statusLabels = {
 	FAILED: "Falhou",
 	CANCELLED: "Cancelado"
 };
-const statusIcons = {
-	QUEUED: chalk.gray("○"),
-	BUILDING: chalk.yellow("●"),
-	DEPLOYING: chalk.blue("●"),
-	LIVE: chalk.green("●"),
-	BUILD_FAILED: chalk.red("●"),
-	FAILED: chalk.red("●"),
-	CANCELLED: chalk.gray("●")
-};
+function makeStatusIcons() {
+	const mode = getOutputMode();
+	if (mode === "json" || mode === "github-actions" || mode === "plain") return {
+		QUEUED: "○",
+		BUILDING: "●",
+		DEPLOYING: "●",
+		LIVE: "●",
+		BUILD_FAILED: "●",
+		FAILED: "●",
+		CANCELLED: "●"
+	};
+	return {
+		QUEUED: chalk.gray("○"),
+		BUILDING: chalk.yellow("●"),
+		DEPLOYING: chalk.blue("●"),
+		LIVE: chalk.green("●"),
+		BUILD_FAILED: chalk.red("●"),
+		FAILED: chalk.red("●"),
+		CANCELLED: chalk.gray("●")
+	};
+}
+const statusIcons = new Proxy({}, { get(_target, prop) {
+	return makeStatusIcons()[prop] ?? chalk.yellow("●");
+} });
 const TERMINAL_STATUSES = new Set([
 	"LIVE",
 	"BUILD_FAILED",
 	"FAILED",
 	"CANCELLED"
 ]);
+
+//#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);
+		const mode = getOutputMode();
+		if (mode === "json") process.stdout.write(JSON.stringify({ type: "deploy_cancelled" }) + "\n");
+		else 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 (mode !== "json") console.log(chalk.yellow("Deploy cancelado."));
+		} catch {}
+		process.exit(130);
+	});
+}
+
+//#endregion
+//#region src/lib/deploy-parallel.ts
+async function fetchDeployUrls$1(client, serviceId) {
+	try {
+		return (await client.domains.list({ serviceId })).map((d) => `https://${d.domain}`);
+	} catch {
+		return [];
+	}
+}
+function getFailureHints$1(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 renderProgress(progressMap, prevLineCount) {
 	for (let i = 0; i < prevLineCount; i++) process.stdout.write("\x1B[1A\x1B[2K");
 	let lineCount = 0;
@@ -1198,35 +1360,47 @@ function renderProgress(progressMap, prevLineCount) {
 		process.stdout.write(`${icon} ${chalk.bold(progress.serviceName)}: ${label}\n`);
 		lineCount++;
 		if (progress.status === "BUILDING" || progress.status === "BUILD_FAILED") {
-			if (progress.logLines.length > 0) {
-				const tail = progress.logLines.slice(-3);
+			const nonEmptyLines = progress.logLines.filter((l) => l.trim());
+			if (nonEmptyLines.length > 0) {
+				const tail = nonEmptyLines.slice(-3);
 				for (const line of tail) {
 					const truncated = line.substring(0, 80) + (line.length > 80 ? "..." : "");
 					process.stdout.write(`  ${chalk.dim(truncated)}\n`);
 					lineCount++;
 				}
 			} else if (progress.status === "BUILDING") {
-				process.stdout.write(`  ${chalk.dim("⏳ Aguardando logs do build...")}\n`);
+				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`);
+			process.stdout.write(`  ${chalk.dim("Na fila para construção...")}\n`);
 			lineCount++;
 		}
 	}
 	return lineCount;
 }
-async function deployServicesInParallel(client, services) {
-	console.log(chalk.cyan("\n🚀 Iniciando deploy paralelo de múltiplos serviços...\n"));
+async function deployServicesInParallel(services) {
+	const client = await getClient();
+	const mode = getOutputMode();
+	if (mode === "json") emitData({
+		type: "parallel_deploy_start",
+		services: services.map((s) => ({
+			serviceId: s.serviceId,
+			serviceName: s.serviceName
+		}))
+	});
+	else if (mode === "github-actions") process.stdout.write(`Iniciando deploy de ${services.length} serviço(s)\n`);
+	else console.log(chalk.cyan(`\nIniciando 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$1(() => client.deployments.create({ serviceId: service.serviceId }));
-			const authConfig = await requireAuth();
-			await withRetry$1(() => uploadSource(authConfig.apiUrl, deployment.id, projectRoot, authConfig.apiKey, service.extraFiles));
+			const deployment = await withRetry(() => client.deployments.create({ serviceId: service.serviceId }));
+			await withRetry(() => uploadSource(deployment.id, projectRoot, service.extraFiles));
+			trackDeployment(deployment.id);
 			progressMap.set(service.serviceId, {
 				serviceName: service.serviceName,
 				deploymentId: deployment.id,
@@ -1235,13 +1409,27 @@ async function deployServicesInParallel(client, services) {
 				completed: false,
 				success: false
 			});
-			console.log(`${chalk.green("✓")} ${chalk.bold(service.serviceName)}: Upload concluído (${sizeMB} MB)`);
+			if (mode === "json") emitData({
+				type: "upload_complete",
+				serviceId: service.serviceId,
+				serviceName: service.serviceName,
+				deploymentId: deployment.id,
+				sizeMB
+			});
+			else if (mode === "github-actions") process.stdout.write(`✓ ${service.serviceName}: Upload concluído (${sizeMB} MB)\n`);
+			else console.log(`${chalk.green("✓")} ${chalk.bold(service.serviceName)}: Upload concluído ${chalk.dim(`(${sizeMB} MB)`)}`);
 			return {
 				service,
 				deploymentId: deployment.id
 			};
 		} catch (error) {
-			console.log(`${chalk.red("✗")} ${chalk.bold(service.serviceName)}: Falha ao iniciar deploy`);
+			if (mode === "json") emitData({
+				type: "upload_failed",
+				serviceId: service.serviceId,
+				serviceName: service.serviceName
+			});
+			else if (mode === "github-actions") process.stdout.write(`::error::${service.serviceName}: Falha ao iniciar deploy\n`);
+			else console.log(`${chalk.red("✗")} ${chalk.bold(service.serviceName)}: Falha ao iniciar deploy`);
 			progressMap.set(service.serviceId, {
 				serviceName: service.serviceName,
 				deploymentId: "",
@@ -1255,18 +1443,28 @@ async function deployServicesInParallel(client, services) {
 	});
 	const activeDeployments = (await Promise.allSettled(deploymentPromises)).filter((d) => d.status === "fulfilled").map((d) => d.value);
 	if (activeDeployments.length === 0) {
-		console.error(chalk.red("\n✗ Todos os deploys falharam ao iniciar."));
-		return;
+		if (mode === "json") emitData({
+			type: "error",
+			message: "Todos os deploys falharam ao iniciar."
+		});
+		else if (mode === "github-actions") process.stdout.write("::error::Todos os deploys falharam ao iniciar.\n");
+		else console.error(chalk.red("\n✗ Todos os deploys falharam ao iniciar."));
+		process.exit(1);
+	}
+	if (mode === "json") emitData({
+		type: "monitoring_deploys",
+		count: activeDeployments.length
+	});
+	else if (mode === "github-actions") process.stdout.write(`Monitorando ${activeDeployments.length} deploy(s)\n`);
+	else {
+		console.log(chalk.cyan(`\nMonitorando progresso dos deploys:\n`));
+		console.log(chalk.dim("─".repeat(50)) + "\n");
 	}
-	console.log(chalk.cyan("\n📦 Monitorando progresso dos deploys:\n"));
-	console.log(chalk.dim("─".repeat(60)) + "\n");
 	let lineCount = 0;
-	lineCount = renderProgress(progressMap, lineCount);
-	const isVerbose = process.env.VELOZ_VERBOSE === "true";
+	if (mode === "fancy") lineCount = renderProgress(progressMap, lineCount);
 	const streamPromises = activeDeployments.map(async ({ service, deploymentId }) => {
 		try {
 			await new Promise((resolve$1) => setTimeout(resolve$1, 1e3));
-			if (isVerbose) console.log(chalk.dim(`\n[verbose] Conectando ao stream para ${service.serviceName} (${deploymentId})...`));
 			const stream = await client.logs.streamBuildLogs({ deploymentId });
 			for await (const event of stream) {
 				const progress = progressMap.get(service.serviceId);
@@ -1277,443 +1475,865 @@ async function deployServicesInParallel(client, services) {
 						progress.completed = true;
 						progress.success = event.content === "LIVE";
 					}
-					if (isVerbose) console.log(chalk.dim(`\n[verbose] ${service.serviceName}: status mudou para ${event.content}`));
+					if (mode === "json") emitData({
+						type: "deploy_status",
+						serviceId: service.serviceId,
+						serviceName: service.serviceName,
+						deploymentId,
+						status: event.content
+					});
+					else if (mode === "plain") {
+						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 (mode === "json") emitData({
+						type: "build_log",
+						serviceId: service.serviceId,
+						serviceName: service.serviceName,
+						deploymentId,
+						lines: newLines
+					});
+					else if (mode === "github-actions" || mode === "plain") for (const line of newLines) process.stdout.write(`[${service.serviceName}] ${line}\n`);
 				}
-				lineCount = renderProgress(progressMap, lineCount);
+				if (mode === "fancy") lineCount = renderProgress(progressMap, lineCount);
 			}
 		} catch (error) {
 			const progress = progressMap.get(service.serviceId);
 			if (progress && !progress.completed) {
-				if (isVerbose) console.error(`\n${chalk.red("[verbose]")} Error streaming logs for ${service.serviceName}:`, error.message);
-				else console.error(`\n${chalk.red("✗")} Error streaming logs for ${service.serviceName}`);
+				if (mode === "json") emitData({
+					type: "deploy_stream_error",
+					serviceId: service.serviceId,
+					serviceName: service.serviceName,
+					error: error instanceof Error ? error.message : "Erro desconhecido"
+				});
+				else if (mode === "github-actions") process.stdout.write(`::error::Erro no streaming de logs para ${service.serviceName}\n`);
+				else if (mode !== "fancy") console.error(`${chalk.red("✗")} Erro no streaming de logs para ${service.serviceName}`);
 				progress.status = "FAILED";
 				progress.completed = true;
-				lineCount = renderProgress(progressMap, lineCount);
+				if (mode === "fancy") lineCount = renderProgress(progressMap, lineCount);
 			}
+		} finally {
+			untrackDeployment(deploymentId);
 		}
 	});
 	await Promise.all(streamPromises);
-	renderProgress(progressMap, lineCount);
-	console.log(chalk.dim("\n" + "─".repeat(60)));
-	const successful = Array.from(progressMap.values()).filter((p) => p.success);
-	const failed = Array.from(progressMap.values()).filter((p) => !p.success);
-	if (successful.length > 0) {
-		console.log(chalk.green(`\n✅ ${successful.length} serviço(s) implantado(s) com sucesso:\n`));
-		for (const progress of successful) console.log(`  ${chalk.green("✓")} ${chalk.bold(progress.serviceName)}`);
-	}
-	if (failed.length > 0) {
-		console.log(chalk.red(`\n✗ ${failed.length} serviço(s) falhou(aram):\n`));
-		for (const progress of failed) {
-			console.log(`  ${chalk.red("✗")} ${chalk.bold(progress.serviceName)}`);
-			if (progress.logLines.length > 0) {
-				console.log(chalk.dim("─".repeat(40)));
-				const tail = progress.logLines.slice(-50);
-				for (const line of tail) console.log(`  ${chalk.dim(line)}`);
-				console.log(chalk.dim("─".repeat(40)));
+	if (mode === "fancy") 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 (mode === "json") emitData({
+		type: "parallel_deploy_complete",
+		successful: successfulEntries.map(([serviceId, p]) => ({
+			serviceName: p.serviceName,
+			deploymentId: p.deploymentId,
+			urls: urlMap.get(serviceId) ?? []
+		})),
+		failed: failedEntries.map(([, p]) => ({
+			serviceName: p.serviceName,
+			deploymentId: p.deploymentId,
+			status: p.status,
+			hints: getFailureHints$1(p.status)
+		}))
+	});
+	else {
+		if (mode === "fancy") console.log(chalk.dim("\n" + "─".repeat(50)));
+		if (successfulEntries.length > 0) if (mode === "github-actions") {
+			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 (mode === "plain") {
+			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 {
+			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)}`);
+			}
+		}
+		if (failedEntries.length > 0) if (mode === "github-actions") {
+			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 (mode === "plain") {
+			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`);
+			}
+		} else {
+			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}`));
 			}
 		}
+		if (successfulEntries.length > 0) info("\nUse 'veloz logs -f' para acompanhar os logs de execução.");
 	}
-	if (successful.length > 0) info("\nUse 'veloz logs -f' para acompanhar os logs de execução.");
+	if (failedEntries.length > 0) process.exit(1);
 }
 
 //#endregion
-//#region src/lib/dockerfile-generator.ts
-function pmSetupInstructions(pm) {
-	switch (pm) {
-		case "pnpm": return "RUN corepack enable && corepack prepare pnpm@latest --activate";
-		case "yarn": return "RUN corepack enable";
-		case "bun": return "RUN apk add --no-cache bash curl && curl -fsSL https://bun.sh/install | bash && ln -s /root/.bun/bin/bun /usr/local/bin/bun";
-		case "npm": return "";
+//#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."];
+	}
+}
+async function streamDeploymentLogs(deploymentId, serviceId, serviceName) {
+	const client = await getClient();
+	const isVerbose = process.env.VELOZ_VERBOSE === "true";
+	const mode = getOutputMode();
+	const allLogLines = [];
+	let buildSpinner = null;
+	if (mode === "json") emitData({
+		type: "deploy_stream_start",
+		deploymentId,
+		serviceName: serviceName ?? null
+	});
+	else if (mode === "github-actions") startGroup(serviceName ? `Build: ${serviceName}` : "Build");
+	else if (mode === "fancy" && !isVerbose) buildSpinner = ora({
+		text: "Aguardando início do build...",
+		color: "cyan"
+	}).start();
+	else {
+		const header = serviceName ? `Build: ${chalk.bold(serviceName)}` : "Build";
+		console.log(chalk.cyan(`\n${header}`));
+		console.log(chalk.dim("─".repeat(50)));
 	}
-}
-function installCommand(pm) {
-	switch (pm) {
-		case "bun": return "bun install --frozen-lockfile";
-		case "pnpm": return "pnpm install --frozen-lockfile";
-		case "yarn": return "yarn install --frozen-lockfile";
-		case "npm": return "npm ci";
+	let finalStatus = "";
+	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;
+			if (mode === "json") emitData({
+				type: "deploy_status",
+				deploymentId,
+				status: event.content,
+				label
+			});
+			else if (mode === "fancy" && !isVerbose) {
+				if (buildSpinner) {
+					if (event.content === "BUILDING") buildSpinner.text = "Construindo...";
+					else if (event.content === "DEPLOYING") {
+						buildSpinner.succeed("Build concluído");
+						buildSpinner = ora({
+							text: "Publicando...",
+							color: "cyan"
+						}).start();
+					} else if (event.content === "LIVE") {
+						buildSpinner.succeed("Publicado");
+						buildSpinner = null;
+					} else if (TERMINAL_STATUSES.has(event.content) && event.content !== "LIVE") {
+						buildSpinner.fail(label);
+						buildSpinner = null;
+					}
+				}
+			} else {
+				const icon = statusIcons[event.content] ?? chalk.yellow("●");
+				process.stdout.write(`\n${icon} ${chalk.bold(label)}\n`);
+			}
+		} else if (event.type === "log") {
+			const lines = event.content.split("\n");
+			allLogLines.push(...lines);
+			if (mode === "json") emitData({
+				type: "build_log",
+				deploymentId,
+				content: event.content
+			});
+			else if (mode === "fancy" && !isVerbose) for (const line of lines) {
+				const trimmed = line.trim();
+				if (trimmed) {
+					const display = trimmed.length > 60 ? trimmed.substring(0, 57) + "..." : trimmed;
+					if (buildSpinner) buildSpinner.text = display;
+				}
+			}
+			else for (const line of lines) if (line.trim()) process.stdout.write(`  ${line}\n`);
+		}
+	} catch {
+		if (buildSpinner) {
+			buildSpinner.stop();
+			buildSpinner = null;
+		}
+		try {
+			finalStatus = (await client.deployments.get({ deploymentId })).status;
+			try {
+				const logs = await client.logs.getBuildLogs({ deploymentId });
+				if (logs.buildLogs) {
+					allLogLines.push(...logs.buildLogs.split("\n"));
+					if (mode === "json") emitData({
+						type: "build_log",
+						deploymentId,
+						content: logs.buildLogs
+					});
+				}
+			} catch {}
+		} catch {}
+	}
+	if (mode === "github-actions") endGroup();
+	if (finalStatus === "LIVE") {
+		if (buildSpinner) {
+			buildSpinner.stop();
+			buildSpinner = null;
+		}
+		success(serviceName ? `Deploy de ${chalk.bold(serviceName)} concluído! Serviço ativo.` : "Deploy concluído! Serviço ativo.");
+		const urls = await fetchDeployUrls(client, serviceId);
+		if (mode === "json") emitData({
+			type: "deploy_complete",
+			deploymentId,
+			status: "LIVE",
+			serviceName: serviceName ?? null,
+			urls
+		});
+		else if (urls.length > 0) for (const url of urls) info(`${chalk.bold(url)}`);
+	} else if (TERMINAL_STATUSES.has(finalStatus)) {
+		if (buildSpinner) {
+			buildSpinner.stop();
+			buildSpinner = null;
+		}
+		const label = statusLabels[finalStatus] ?? finalStatus;
+		const hints = getFailureHints(finalStatus);
+		if (mode === "fancy" && allLogLines.length > 0) {
+			console.log();
+			console.log(chalk.red(`  ${"─".repeat(50)}`));
+			console.log(chalk.red.bold("  Logs de build:"));
+			console.log(chalk.red(`  ${"─".repeat(50)}`));
+			for (const line of allLogLines) if (line.trim()) console.log(chalk.dim(`  ${line}`));
+			console.log(chalk.red(`  ${"─".repeat(50)}`));
+		}
+		if (mode === "json") emitData({
+			type: "deploy_complete",
+			deploymentId,
+			status: finalStatus,
+			serviceName: serviceName ?? null,
+			hints
+		});
+		else if (mode === "github-actions") {
+			const msg = serviceName ? `Deploy de ${serviceName} finalizou com status: ${label}` : `Deploy finalizou com status: ${label}`;
+			process.stdout.write(`::error::${msg}\n`);
+			for (const hint of hints) process.stdout.write(`  ${hint}\n`);
+		} else {
+			const errorMsg = serviceName ? `Deploy de ${chalk.bold(serviceName)} finalizou: ${label}` : `Deploy finalizou: ${label}`;
+			console.error(chalk.red(`\n✗ ${errorMsg}`));
+			for (const hint of hints) console.error(chalk.yellow(`  → ${hint}`));
+		}
+		process.exit(1);
 	}
 }
-function lockfileNames(pm) {
-	switch (pm) {
-		case "bun": return ["bun.lockb", "bun.lock"];
-		case "pnpm": return ["pnpm-lock.yaml"];
-		case "yarn": return ["yarn.lock"];
-		case "npm": return ["package-lock.json"];
-	}
-}
-function generateWebDockerfile(opts) {
-	const { nodeVersion, pm, buildCommand, startCommand, rootDirectory, port = 3e3 } = opts;
-	const setup = pmSetupInstructions(pm);
-	const lockfiles = lockfileNames(pm);
-	const hasRoot = !!(rootDirectory && rootDirectory !== "/");
-	const cleanRoot = hasRoot ? rootDirectory.replace(/^\//, "") : "";
-	const depsCopy = hasRoot ? [
-		`# Root-level dependency files`,
-		`COPY package.json ${lockfiles.join(" ")} ./`,
-		`# Service-level dependency files`,
-		`COPY ${cleanRoot}/package.json ./${cleanRoot}/`
-	] : [`COPY package.json ${lockfiles.join(" ")} ./`];
-	const workdirPrefix = hasRoot ? `cd ${cleanRoot} && ` : "";
-	const defaultStart = pm === "bun" ? "bun start" : `${pm} run start`;
-	const finalStart = startCommand || defaultStart;
-	return `# ── Stage 1: Install & Build ────────────────────────────
-FROM node:${nodeVersion}-alpine AS builder
-
-WORKDIR /app
-${setup ? "\n" + setup + "\n" : ""}
-# Install dependencies (cached layer)
-${depsCopy.join("\n")}
-RUN ${installCommand(pm)}
-
-# Copy full source
-COPY . .
-
-# Build with env vars from BuildKit secret mount
-RUN --mount=type=secret,id=build-env \\
-    set -a && \\
-    if [ -f /run/secrets/build-env ]; then . /run/secrets/build-env; fi && \\
-    set +a && \\
-    ${workdirPrefix}${buildCommand}
-
-# ── Stage 2: Production runner ─────────────────────────
-FROM node:${nodeVersion}-alpine
-
-WORKDIR /app
-
-# Copy built app (node_modules + build output)
-COPY --from=builder /app .
-
-ENV NODE_ENV=production
-ENV PORT=${port}
-EXPOSE ${port}
-
-HEALTHCHECK --interval=30s --timeout=3s --start-period=10s --retries=3 \\
-    CMD wget --quiet --tries=1 --spider http://localhost:${port}/ || exit 1
-
-CMD ${workdirPrefix ? `["sh", "-c", "${workdirPrefix}${finalStart}"]` : JSON.stringify(finalStart.split(" "))}
-`;
-}
-function generateStaticDockerfile(opts) {
-	const { nodeVersion, pm, buildCommand, outputDir, rootDirectory } = opts;
-	const setup = pmSetupInstructions(pm);
-	const lockfiles = lockfileNames(pm);
-	const hasRoot = !!(rootDirectory && rootDirectory !== "/");
-	const cleanRoot = hasRoot ? rootDirectory.replace(/^\//, "") : "";
-	const servicePrefix = hasRoot ? cleanRoot + "/" : "";
-	const depsCopy = hasRoot ? [`COPY package.json ${lockfiles.join(" ")} ./`, `COPY ${cleanRoot}/package.json ./${cleanRoot}/`] : [`COPY package.json ${lockfiles.join(" ")} ./`];
-	const workdirPrefix = hasRoot ? `cd ${cleanRoot} && ` : "";
-	const outputDetection = outputDir ? `ENV OUTPUT_DIR="${outputDir}"` : [
-		`# Auto-detect output directory`,
-		`RUN if [ -d "${servicePrefix}dist" ]; then echo "${servicePrefix}dist" > /tmp/output-dir; \\`,
-		`    elif [ -d "${servicePrefix}build" ]; then echo "${servicePrefix}build" > /tmp/output-dir; \\`,
-		`    elif [ -d "${servicePrefix}out" ]; then echo "${servicePrefix}out" > /tmp/output-dir; \\`,
-		`    elif [ -d "${servicePrefix}.next/out" ]; then echo "${servicePrefix}.next/out" > /tmp/output-dir; \\`,
-		`    elif [ -d "${servicePrefix}public" ]; then echo "${servicePrefix}public" > /tmp/output-dir; \\`,
-		`    else echo "${servicePrefix}dist" > /tmp/output-dir; fi`
-	].join("\n");
-	const outputDirRef = outputDir ? servicePrefix + outputDir : "$(cat /tmp/output-dir)";
-	return `# ── Stage 1: Build ──────────────────────────────────────
-FROM node:${nodeVersion}-alpine AS builder
-
-WORKDIR /app
-${setup ? "\n" + setup + "\n" : ""}
-# Install dependencies (cached layer)
-${depsCopy.join("\n")}
-RUN ${installCommand(pm)}
 
-# Copy full source
-COPY . .
-
-# Build with env vars from BuildKit secret mount
-RUN --mount=type=secret,id=build-env \\
-    set -a && \\
-    if [ -f /run/secrets/build-env ]; then . /run/secrets/build-env; fi && \\
-    set +a && \\
-    ${workdirPrefix}${buildCommand}
-
-# Detect output directory
-${outputDetection}
-
-# Process _headers and _redirects into nginx config
-COPY nginx.conf /tmp/nginx-base.conf
-COPY generate-nginx-config.cjs /tmp/generate-nginx-config.cjs
-RUN node /tmp/generate-nginx-config.cjs \\
-    --base /tmp/nginx-base.conf \\
-    --output-dir /app/${outputDirRef} \\
-    --out /tmp/nginx-final.conf
-
-# Copy build output to a known location
-RUN cp -r /app/${outputDirRef} /output
-
-# ── Stage 2: Serve ─────────────────────────────────────
-FROM nginx:alpine
-
-# Remove default nginx site
-RUN rm -f /etc/nginx/conf.d/default.conf
-
-# Copy processed nginx config and static files
-COPY --from=builder /tmp/nginx-final.conf /etc/nginx/conf.d/default.conf
-COPY --from=builder /output /usr/share/nginx/html
-
-EXPOSE 80
+//#endregion
+//#region src/lib/brand.ts
+const LOGO_LINES = [
+	"╦  ╦╔═╗╦  ╔═╗╔═╗",
+	"╚╗╔╝║╣ ║  ║ ║ ╔╝",
+	" ╚╝ ╚═╝╩═╝╚═╝╚═╝"
+];
+const BRAND_COLOR = "#FF4D00";
+function getVersion() {
+	return "0.0.0-beta.10";
+}
+function printBanner(subtitle) {
+	const mode = getOutputMode();
+	const version = getVersion();
+	const env = getActiveEnv();
+	const envTag = env ? ` [${env}]` : "";
+	if (mode === "json") return;
+	if (mode === "github-actions") {
+		process.stdout.write(`Veloz ${subtitle ?? ""} v${version}${envTag}\n`);
+		return;
+	}
+	if (mode === "plain") {
+		process.stdout.write(`\nVeloz ${subtitle ?? ""} v${version}${envTag}\n\n`);
+		return;
+	}
+	const sub = subtitle ?? "";
+	const envBadge = env ? `  ${chalk.bgYellow.black(` ${env} `)}` : "";
+	console.log();
+	console.log(`  ${chalk.hex(BRAND_COLOR).bold(LOGO_LINES[0])}`);
+	console.log(`  ${chalk.hex(BRAND_COLOR).bold(LOGO_LINES[1])}  ${chalk.bold(sub)}${envBadge}`);
+	console.log(`  ${chalk.hex(BRAND_COLOR).bold(LOGO_LINES[2])}  ${chalk.dim(`v${version}`)}`);
+	console.log();
+	console.log(`  ${chalk.dim("─".repeat(40))}`);
+	console.log();
+}
 
-HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \\
-    CMD wget --quiet --tries=1 --spider http://localhost/ || exit 1
+//#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);
+		return {
+			type: merged.type,
+			buildCommand: merged.build?.command ?? void 0,
+			startCommand: merged.runtime?.command ?? void 0,
+			port: merged.runtime?.port ?? void 0,
+			rootDirectory: merged.root,
+			outputDir: merged.build?.outputDir ?? 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 ?? void 0,
+			installCommand: merged.build?.installCommand ?? void 0
+		};
+	}
+}
+async function syncServiceConfig(client, serviceId, conf) {
+	await withRetry(() => client.services.update({
+		serviceId,
+		type: conf.type?.toUpperCase(),
+		port: conf.port,
+		instanceCount: conf.instanceCount,
+		cpuLimit: conf.cpuLimit,
+		memoryLimit: conf.memoryLimit,
+		buildCommand: conf.buildCommand,
+		startCommand: conf.startCommand,
+		rootDirectory: conf.rootDirectory,
+		healthCheckPath: conf.healthCheckPath,
+		aptPackages: conf.aptPackages,
+		nodeVersion: conf.nodeVersion,
+		nixpkgsArchive: conf.nixpkgsArchive,
+		packageManager: conf.packageManager,
+		installCommand: conf.installCommand
+	}));
+}
 
-CMD ["nginx", "-g", "daemon off;"]
-`;
+//#endregion
+//#region src/lib/deploy-checks.ts
+/**
+* Platform-specific presets that won't work on Veloz (generic K8s).
+* Maps preset name to the platform it targets.
+*/
+const INCOMPATIBLE_PRESETS = {
+	vercel: "Vercel",
+	"cloudflare-pages": "Cloudflare Pages",
+	"cloudflare-workers": "Cloudflare Workers",
+	"cloudflare-module": "Cloudflare Workers",
+	netlify: "Netlify",
+	"netlify-edge": "Netlify Edge",
+	"aws-lambda": "AWS Lambda",
+	firebase: "Firebase",
+	"deno-deploy": "Deno Deploy",
+	"render-com": "Render",
+	"flight-control": "Flightcontrol",
+	stormkit: "Stormkit",
+	edgio: "Edgio",
+	lagon: "Lagon"
+};
+/**
+* Recommended preset based on package manager / runtime.
+*/
+function recommendedPreset(basePath) {
+	const pkgPath = resolve(basePath, "package.json");
+	if (!existsSync(pkgPath)) return "node-server";
+	try {
+		const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+		if ("bun" in {
+			...pkg.dependencies,
+			...pkg.devDependencies
+		} || existsSync(resolve(basePath, "bun.lockb")) || existsSync(resolve(basePath, "bun.lock"))) return "bun";
+	} catch {}
+	return "node-server";
+}
+/**
+* Check for Nitro preset misconfigurations in vite/nuxt config files.
+*/
+function checkNitroPreset(basePath) {
+	for (const file of [
+		"vite.config.ts",
+		"vite.config.js",
+		"vite.config.mjs",
+		"nuxt.config.ts",
+		"nuxt.config.js"
+	]) {
+		const filePath = resolve(basePath, file);
+		if (!existsSync(filePath)) continue;
+		let content;
+		try {
+			content = readFileSync(filePath, "utf-8");
+		} catch {
+			continue;
+		}
+		const presetMatch = content.match(/preset\s*:\s*["']([^"']+)["']/);
+		if (!presetMatch) continue;
+		const preset = presetMatch[1];
+		const platform$1 = INCOMPATIBLE_PRESETS[preset];
+		if (!platform$1) continue;
+		const recommended = recommendedPreset(basePath);
+		return {
+			message: `${file} usa preset "${preset}" (${platform$1}) — incompativel com Veloz`,
+			hint: `Altere para preset: "${recommended}" em ${file}`
+		};
+	}
+	return null;
+}
+/**
+* Check for Dockerfile COPY instructions that reference both bun.lockb and bun.lock.
+* Only one usually exists — the COPY will fail if both are listed but one is missing.
+*/
+function checkDockerfileLockFiles(basePath) {
+	const dockerfilePath = resolve(basePath, "Dockerfile");
+	if (!existsSync(dockerfilePath)) return null;
+	let content;
+	try {
+		content = readFileSync(dockerfilePath, "utf-8");
+	} catch {
+		return null;
+	}
+	const copyLines = content.split("\n").filter((l) => /^COPY\s/.test(l.trim()));
+	for (const line of copyLines) if (line.includes("bun.lockb") && line.includes("bun.lock") && !line.includes("bun.lock*")) {
+		if (!(existsSync(resolve(basePath, "bun.lockb")) && existsSync(resolve(basePath, "bun.lock")))) return {
+			message: "Dockerfile lista bun.lockb e bun.lock mas apenas um existe",
+			hint: "Use \"COPY package.json bun.lock* ./\" para copiar o que existir"
+		};
+	}
+	return null;
+}
+/**
+* Next.js needs `output: "standalone"` for Docker/K8s deploys.
+* Without it, the build produces a node_modules-dependent output
+* that's huge and doesn't run well in containers.
+*/
+function checkNextStandalone(basePath) {
+	const pkgPath = resolve(basePath, "package.json");
+	if (!existsSync(pkgPath)) return null;
+	try {
+		const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+		if (!("next" in {
+			...pkg.dependencies,
+			...pkg.devDependencies
+		})) return null;
+	} catch {
+		return null;
+	}
+	if (existsSync(resolve(basePath, "Dockerfile"))) return null;
+	for (const file of [
+		"next.config.ts",
+		"next.config.js",
+		"next.config.mjs"
+	]) {
+		const filePath = resolve(basePath, file);
+		if (!existsSync(filePath)) continue;
+		try {
+			const content = readFileSync(filePath, "utf-8");
+			if (content.includes("\"standalone\"") || content.includes("'standalone'")) return null;
+			return {
+				message: `${file} nao tem output: "standalone"`,
+				hint: "Adicione output: \"standalone\" no next.config para deploy na Veloz"
+			};
+		} catch {
+			continue;
+		}
+	}
+	return null;
+}
+/**
+* Prisma needs `prisma generate` in the build step.
+* Without it, the Prisma client won't be generated and the app will crash.
+*/
+function checkPrismaGenerate(basePath) {
+	const pkgPath = resolve(basePath, "package.json");
+	if (!existsSync(pkgPath)) return null;
+	try {
+		const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+		const allDeps = {
+			...pkg.dependencies,
+			...pkg.devDependencies
+		};
+		if (!("prisma" in allDeps) && !("@prisma/client" in allDeps)) return null;
+		const scripts = pkg.scripts || {};
+		const buildScript = scripts.build || "";
+		const postinstall = scripts.postinstall || "";
+		if (buildScript.includes("prisma generate") || postinstall.includes("prisma generate") || buildScript.includes("prisma db push")) return null;
+		return {
+			message: "Prisma detectado mas prisma generate nao esta no build/postinstall",
+			hint: "Adicione \"prisma generate\" ao script postinstall ou build no package.json"
+		};
+	} catch {
+		return null;
+	}
+}
+/**
+* Detect if the app hardcodes a port that doesn't match the configured port.
+* Common issue: app listens on 8080 but service port is 3000.
+*/
+function checkPortMismatch(basePath) {
+	const pkgPath = resolve(basePath, "package.json");
+	if (!existsSync(pkgPath)) return null;
+	try {
+		const portMatch = ((JSON.parse(readFileSync(pkgPath, "utf-8")).scripts || {}).start || "").match(/(?:--port|-p)\s+(\d+)/);
+		if (portMatch) {
+			const hardcodedPort = parseInt(portMatch[1], 10);
+			if (hardcodedPort !== 3e3) return {
+				message: `Script start usa porta ${hardcodedPort} — certifique-se de que a porta do servico esta configurada corretamente`,
+				hint: `Configure a porta do servico para ${hardcodedPort} no dashboard ou veloz.json`
+			};
+		}
+	} catch {}
+	return null;
+}
+/**
+* Check for .env files that might be accidentally uploaded.
+*/
+function checkEnvFileCommitted(basePath) {
+	if (!existsSync(resolve(basePath, ".env"))) return null;
+	const gitignorePath = resolve(basePath, ".gitignore");
+	if (existsSync(gitignorePath)) try {
+		const lines = readFileSync(gitignorePath, "utf-8").split("\n").map((l) => l.trim());
+		if (lines.includes(".env") || lines.includes(".env*") || lines.includes("*.env")) return null;
+	} catch {}
+	return {
+		message: "Arquivo .env encontrado e nao esta no .gitignore",
+		hint: "Adicione .env ao .gitignore — use variaveis de ambiente no dashboard ou CLI"
+	};
+}
+/**
+* Node.js project without a start command — nixpacks won't know how to run it.
+* Checks for: scripts.start, main field, or common entry files.
+*/
+function checkMissingStartCommand(basePath) {
+	const pkgPath = resolve(basePath, "package.json");
+	if (!existsSync(pkgPath)) return null;
+	if (existsSync(resolve(basePath, "Dockerfile"))) return null;
+	try {
+		const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+		if (pkg.scripts?.start) return null;
+		if (pkg.main) return null;
+		const allDeps = {
+			...pkg.dependencies,
+			...pkg.devDependencies
+		};
+		if ([
+			"next",
+			"nuxt",
+			"nuxt3",
+			"@sveltejs/kit",
+			"remix",
+			"astro",
+			"@angular/core",
+			"gatsby"
+		].some((f) => f in allDeps)) return null;
+		if ([
+			"index.js",
+			"index.mjs",
+			"index.ts",
+			"server.js",
+			"server.ts",
+			"app.js",
+			"app.ts",
+			"src/index.js",
+			"src/index.ts",
+			"src/server.js",
+			"src/server.ts"
+		].some((f) => existsSync(resolve(basePath, f)))) return null;
+		return {
+			message: "Nenhum script start encontrado no package.json",
+			hint: "Adicione \"start\" em scripts (ex: \"node dist/index.js\") ou um campo \"main\" no package.json"
+		};
+	} catch {
+		return null;
+	}
+}
+/**
+* packageManager field in package.json doesn't match the lockfile present.
+* e.g., packageManager: "pnpm@9.0.0" but only package-lock.json exists.
+*/
+function checkPackageManagerMismatch(basePath) {
+	const pkgPath = resolve(basePath, "package.json");
+	if (!existsSync(pkgPath)) return null;
+	try {
+		const pmField = JSON.parse(readFileSync(pkgPath, "utf-8")).packageManager;
+		if (!pmField) return null;
+		const declaredPm = pmField.split("@")[0];
+		const lockfileMap = {
+			npm: ["package-lock.json"],
+			yarn: ["yarn.lock"],
+			pnpm: ["pnpm-lock.yaml"],
+			bun: ["bun.lockb", "bun.lock"]
+		};
+		const expectedLockfiles = lockfileMap[declaredPm];
+		if (!expectedLockfiles) return null;
+		if (expectedLockfiles.some((f) => existsSync(resolve(basePath, f)))) return null;
+		const otherPms = Object.entries(lockfileMap).filter(([pm]) => pm !== declaredPm);
+		for (const [pm, files] of otherPms) if (files.some((f) => existsSync(resolve(basePath, f)))) return {
+			message: `packageManager "${pmField}" no package.json mas lockfile de ${pm} encontrado`,
+			hint: `Remova o campo packageManager ou gere o lockfile correto com ${declaredPm} install`
+		};
+	} catch {}
+	return null;
+}
+/**
+* Native modules that need system packages to build.
+* The server auto-detects and injects apt packages for known modules (sharp, canvas,
+* puppeteer, playwright-chromium). This check warns about bcrypt which has a pure-JS
+* alternative, and modules not in the auto-detect list.
+*/
+function checkNativeModules(basePath) {
+	const pkgPath = resolve(basePath, "package.json");
+	if (!existsSync(pkgPath)) return null;
+	if (existsSync(resolve(basePath, "Dockerfile"))) return null;
+	try {
+		const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+		if ("bcrypt" in {
+			...pkg.dependencies,
+			...pkg.devDependencies
+		}) return {
+			message: "bcrypt compila codigo nativo — pode falhar em alguns ambientes",
+			hint: "Considere usar bcryptjs (pure JS) para evitar falhas de build"
+		};
+	} catch {}
+	return null;
+}
+/**
+* nixpacks.toml phases that override defaults instead of extending them.
+* Missing "..." in [phases.X.cmds] replaces all default commands.
+*/
+function checkNixpacksTomlSpread(basePath) {
+	const tomlPath = resolve(basePath, "nixpacks.toml");
+	if (!existsSync(tomlPath)) return null;
+	try {
+		const content = readFileSync(tomlPath, "utf-8");
+		if (!content.match(/\[phases\.\w+\]/g)) return null;
+		const hasCmds = /cmds\s*=\s*\[/.test(content);
+		const hasSpread = content.includes("\"...\"");
+		if (hasCmds && !hasSpread) return {
+			message: "nixpacks.toml define cmds sem \"...\" — isso substitui os comandos padrao",
+			hint: "Adicione \"...\" no array cmds para manter os comandos padrao: cmds = [\"...\", \"seu-comando\"]"
+		};
+	} catch {}
+	return null;
+}
+/**
+* Django project without gunicorn — the dev server isn't suitable for production.
+*/
+function checkDjangoGunicorn(basePath) {
+	if (existsSync(resolve(basePath, "Dockerfile"))) return null;
+	const requirementsFiles = [
+		"requirements.txt",
+		"requirements/production.txt",
+		"requirements/prod.txt"
+	];
+	let hasDjango = false;
+	let hasGunicorn = false;
+	for (const file of requirementsFiles) {
+		const filePath = resolve(basePath, file);
+		if (!existsSync(filePath)) continue;
+		try {
+			const content = readFileSync(filePath, "utf-8").toLowerCase();
+			if (content.includes("django")) hasDjango = true;
+			if (content.includes("gunicorn") || content.includes("uvicorn")) hasGunicorn = true;
+		} catch {
+			continue;
+		}
+	}
+	for (const file of ["pyproject.toml", "Pipfile"]) {
+		const filePath = resolve(basePath, file);
+		if (!existsSync(filePath)) continue;
+		try {
+			const content = readFileSync(filePath, "utf-8").toLowerCase();
+			if (content.includes("django")) hasDjango = true;
+			if (content.includes("gunicorn") || content.includes("uvicorn")) hasGunicorn = true;
+		} catch {
+			continue;
+		}
+	}
+	if (hasDjango && !hasGunicorn) return {
+		message: "Django detectado sem gunicorn/uvicorn — o servidor de dev nao deve ser usado em producao",
+		hint: "Adicione gunicorn ao requirements.txt e configure o start command: \"gunicorn myproject.wsgi\""
+	};
+	return null;
 }
-function generateDockerfile(opts) {
-	if (opts.serviceType === "STATIC") return generateStaticDockerfile(opts);
-	return generateWebDockerfile(opts);
+/**
+* SvelteKit needs adapter-node for container deploys.
+* Default adapter-auto or adapter-vercel/netlify won't work.
+*/
+function checkSvelteKitAdapter(basePath) {
+	const pkgPath = resolve(basePath, "package.json");
+	if (!existsSync(pkgPath)) return null;
+	try {
+		const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+		const allDeps = {
+			...pkg.dependencies,
+			...pkg.devDependencies
+		};
+		if (!("@sveltejs/kit" in allDeps)) return null;
+		const hasNodeAdapter = "@sveltejs/adapter-node" in allDeps;
+		const hasBunAdapter = "svelte-adapter-bun" in allDeps;
+		if (hasNodeAdapter || hasBunAdapter) return null;
+		const installed = [
+			"@sveltejs/adapter-vercel",
+			"@sveltejs/adapter-netlify",
+			"@sveltejs/adapter-cloudflare",
+			"@sveltejs/adapter-cloudflare-workers"
+		].find((a) => a in allDeps);
+		if (installed) return {
+			message: `SvelteKit usa ${installed} — incompativel com Veloz`,
+			hint: "Instale @sveltejs/adapter-node e configure em svelte.config.js"
+		};
+		if ("@sveltejs/adapter-auto" in allDeps) return {
+			message: "SvelteKit usa adapter-auto — pode nao funcionar no deploy",
+			hint: "Instale @sveltejs/adapter-node para deploys na Veloz"
+		};
+	} catch {}
+	return null;
 }
-
-//#endregion
-//#region src/lib/templates.ts
 /**
-* Embedded templates for STATIC site builds.
-* These are written to the project directory temporarily before creating the tar,
-* then cleaned up immediately after.
+* Run all pre-deploy checks and return warnings.
+* Does not block — just warns the user.
 */
-const NGINX_CONF = `server {
-    listen 80;
-    server_name _;
-    root /usr/share/nginx/html;
-    index index.html;
-    
-    # SPA routing - fallback to index.html for client-side routing
-    location / {
-        try_files \\$uri \\$uri/ /index.html;
-    }
-    
-    # Gzip compression
-    gzip on;
-    gzip_vary on;
-    gzip_min_length 256;
-    gzip_types
-        text/plain
-        text/css
-        text/xml
-        text/javascript
-        application/json
-        application/javascript
-        application/xml+rss
-        application/rss+xml
-        application/atom+xml
-        image/svg+xml
-        text/x-component
-        text/x-cross-domain-policy;
-    
-    # Cache hashed assets (fingerprinted files)
-    location ~* \\\\.(js|css|png|jpg|jpeg|gif|ico|svg|woff|woff2|ttf|eot|otf|webp|avif)\\$ {
-        expires 1y;
-        add_header Cache-Control "public, immutable";
-        access_log off;
-    }
-    
-    # No cache for HTML files
-    location ~* \\\\.html\\$ {
-        expires -1;
-        add_header Cache-Control "no-cache, no-store, must-revalidate";
-        add_header Pragma "no-cache";
-    }
-    
-    # Security headers
-    add_header X-Frame-Options "SAMEORIGIN" always;
-    add_header X-Content-Type-Options "nosniff" always;
-    add_header X-XSS-Protection "1; mode=block" always;
-    
-    # Custom headers placeholder (will be replaced during build)
-    # CUSTOM_HEADERS_PLACEHOLDER
-    
-    # Custom redirects placeholder (will be replaced during build)
-    # CUSTOM_REDIRECTS_PLACEHOLDER
-}`;
-const GENERATE_NGINX_CONFIG_CJS = `#!/usr/bin/env node
-"use strict";
-
-/**
- * Generates a final nginx.conf by processing Netlify-style _headers and _redirects
- * files from the static site build output. Runs inside the Docker build stage.
- *
- * Usage: node generate-nginx-config.cjs --base <nginx.conf> --output-dir <dir> --out <dest>
- */
-
-const fs = require("fs");
-const path = require("path");
-
-// ── Parse CLI args ─────────────────────────────────────
-
-const args = process.argv.slice(2);
-let baseConfig = "";
-let outputDir = "";
-let outFile = "";
-
-for (let i = 0; i < args.length; i++) {
-  if (args[i] === "--base" && args[i + 1]) baseConfig = args[++i];
-  if (args[i] === "--output-dir" && args[i + 1]) outputDir = args[++i];
-  if (args[i] === "--out" && args[i + 1]) outFile = args[++i];
-}
-
-if (!baseConfig || !outputDir || !outFile) {
-  console.error(
-    "Usage: node generate-nginx-config.cjs --base <nginx.conf> --output-dir <dir> --out <dest>"
-  );
-  process.exit(1);
-}
-
-let nginxConfig = fs.readFileSync(baseConfig, "utf-8");
-
-// ── Parse _headers (Netlify-style) ─────────────────────
-//
-// Format:
-//   /api/*
-//     Access-Control-Allow-Origin: *
-//   /*
-//     X-Frame-Options: DENY
-
-const headersPath = path.join(outputDir, "_headers");
-if (fs.existsSync(headersPath)) {
-  const content = fs.readFileSync(headersPath, "utf-8");
-  let headerDirectives = "";
-  let currentPath = "";
-  let inLocationBlock = false;
-
-  for (const line of content.split("\\n")) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith("#")) continue;
-
-    // Path pattern (starts without whitespace)
-    if (!line.startsWith(" ") && !line.startsWith("\\t")) {
-      // Close previous location block if open
-      if (inLocationBlock) {
-        headerDirectives += "    }\\n";
-        inLocationBlock = false;
-      }
-      currentPath = trimmed;
-      // Global headers (/*) go at server level, others get location blocks
-      if (currentPath !== "/*") {
-        headerDirectives += \\\`\\n    location \\\${currentPath} {\\n\\\`;
-        inLocationBlock = true;
-      }
-    } else {
-      // Header line (indented)
-      const colonIdx = trimmed.indexOf(":");
-      if (colonIdx === -1) continue;
-      const key = trimmed.slice(0, colonIdx).trim();
-      const value = trimmed.slice(colonIdx + 1).trim();
-      if (key && value) {
-        if (currentPath === "/*") {
-          headerDirectives += \\\`    add_header \\\${key} "\\\${value}" always;\\n\\\`;
-        } else {
-          headerDirectives += \\\`        add_header \\\${key} "\\\${value}" always;\\n\\\`;
-        }
-      }
-    }
-  }
-
-  // Close final location block
-  if (inLocationBlock) {
-    headerDirectives += "    }\\n";
-  }
-
-  nginxConfig = nginxConfig.replace(
-    "# CUSTOM_HEADERS_PLACEHOLDER",
-    headerDirectives
-  );
-  console.log("Processed _headers file");
+function runPreDeployChecks(basePath = ".") {
+	const warnings = [];
+	const fullPath = resolve(process.cwd(), basePath);
+	const checks = [
+		checkNitroPreset,
+		checkDockerfileLockFiles,
+		checkNextStandalone,
+		checkPrismaGenerate,
+		checkPortMismatch,
+		checkEnvFileCommitted,
+		checkSvelteKitAdapter,
+		checkMissingStartCommand,
+		checkPackageManagerMismatch,
+		checkNativeModules,
+		checkNixpacksTomlSpread,
+		checkDjangoGunicorn
+	];
+	for (const check of checks) {
+		const result = check(fullPath);
+		if (result) warnings.push(result);
+	}
+	return warnings;
 }
-
-// ── Parse _redirects (Netlify-style) ───────────────────
-//
-// Format:
-//   /old-path /new-path 301
-//   /api/*    https://api.example.com/:splat 200
-
-const redirectsPath = path.join(outputDir, "_redirects");
-if (fs.existsSync(redirectsPath)) {
-  const content = fs.readFileSync(redirectsPath, "utf-8");
-  let redirectDirectives = "";
-
-  for (const line of content.split("\\n")) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith("#")) continue;
-
-    const parts = trimmed.split(/\\s+/);
-    if (parts.length < 2) continue;
-
-    const from = parts[0];
-    const to = parts[1];
-    const code = parts[2] || "301";
-
-    if (!from || !to) continue;
-
-    if (!from.includes("*") && !to.includes(":splat")) {
-      // Simple redirect
-      const nginxFlag = code === "301" ? "permanent" : "redirect";
-      redirectDirectives += \\\`    rewrite ^\\\${from}\\\\$ \\\${to} \\\${nginxFlag};\\n\\\`;
-    } else {
-      // Wildcard redirect
-      const fromPattern = from.replace(/\\*/g, "(.*)");
-      const toPattern = to.replace(/:splat/g, "\\$1");
-      const nginxFlag = code === "301" ? "permanent" : "redirect";
-      redirectDirectives += \\\`    rewrite ^\\\${fromPattern}\\\\$ \\\${toPattern} \\\${nginxFlag};\\n\\\`;
-    }
-  }
-
-  nginxConfig = nginxConfig.replace(
-    "# CUSTOM_REDIRECTS_PLACEHOLDER",
-    redirectDirectives
-  );
-  console.log("Processed _redirects file");
+/**
+* Print deploy warnings to the console.
+* Returns true if any warnings were found.
+*/
+function printDeployWarnings(warnings) {
+	if (warnings.length === 0) return false;
+	const mode = getOutputMode();
+	if (mode === "json") {
+		emitData({
+			type: "deploy_warnings",
+			warnings: warnings.map((w) => ({
+				message: w.message,
+				hint: w.hint
+			}))
+		});
+		return true;
+	}
+	console.log();
+	for (const w of warnings) if (mode === "github-actions") process.stdout.write(`::warning::${w.message} — ${w.hint}\n`);
+	else {
+		console.log(chalk.yellow(`  AVISO: ${w.message}`));
+		console.log(chalk.dim(`         ${w.hint}`));
+	}
+	console.log();
+	return true;
 }
 
-// ── Write final config ─────────────────────────────────
-
-fs.mkdirSync(path.dirname(outFile), { recursive: true });
-fs.writeFileSync(outFile, nginxConfig);
-console.log(\\\`Generated nginx config at \\\${outFile}\\\`);`;
-
 //#endregion
-//#region src/commands/deploy.ts
-async function withRetry(fn, maxRetries = 3) {
-	for (let attempt = 0; attempt <= maxRetries; attempt++) try {
-		return await fn();
-	} catch (error) {
-		const rateLimit = isRateLimitError(error);
-		if (rateLimit && attempt < maxRetries) {
-			const waitMs = Math.min(rateLimit.retryAfterMs, 3e4);
-			await new Promise((r) => setTimeout(r, waitMs));
-			continue;
-		}
-		throw error;
-	}
-	throw new Error("Max retries exceeded");
-}
+//#region src/lib/auto-update.ts
+const PACKAGE_NAME = "onveloz";
 function detectPackageManager() {
-	if (existsSync(resolve(process.cwd(), "bun.lockb")) || existsSync(resolve(process.cwd(), "bun.lock"))) return "bun";
-	if (existsSync(resolve(process.cwd(), "pnpm-lock.yaml"))) return "pnpm";
-	if (existsSync(resolve(process.cwd(), "yarn.lock"))) return "yarn";
+	try {
+		const binPath = realpathSync(process.argv[1]);
+		if (binPath.includes("/hostcloud/") || binPath.includes("/onveloz/src/")) return null;
+		if (binPath.includes("/.pnpm/") || binPath.includes("/pnpm/")) return "pnpm";
+		if (binPath.includes("/.bun/")) return "bun";
+		if (binPath.includes("/yarn/")) return "yarn";
+	} catch {}
 	return "npm";
 }
-function detectNodeVersion() {
+function getInstallCommand(pm, version) {
+	switch (pm) {
+		case "pnpm": return `pnpm install -g ${PACKAGE_NAME}@${version}`;
+		case "yarn": return `yarn global add ${PACKAGE_NAME}@${version}`;
+		case "bun": return `bun install -g ${PACKAGE_NAME}@${version}`;
+		case "npm": return `npm install -g ${PACKAGE_NAME}@${version}`;
+	}
+}
+async function fetchLatestVersion() {
 	try {
-		const pkgPath = resolve(process.cwd(), "package.json");
-		if (existsSync(pkgPath)) {
-			const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-			if (pkg.engines?.node) {
-				const match = pkg.engines.node.match(/(\d+)/);
-				if (match) return match[1];
-			}
-		}
-	} catch {}
-	return "20";
+		const res = await fetch(`https://registry.npmjs.org/${PACKAGE_NAME}/latest`);
+		if (!res.ok) return null;
+		return (await res.json()).version ?? null;
+	} catch {
+		return null;
+	}
+}
+async function autoUpdate() {
+	const pm = detectPackageManager();
+	if (!pm) return;
+	const currentVersion = "0.0.0-beta.10";
+	const latestVersion = await fetchLatestVersion();
+	if (!latestVersion || latestVersion === currentVersion) return;
+	const installCmd = getInstallCommand(pm, latestVersion);
+	const spin = spinner(`Atualizando CLI ${chalk.dim(currentVersion)} → ${chalk.bold(latestVersion)}...`);
+	try {
+		execSync(installCmd, { stdio: "ignore" });
+		spin.stop();
+		console.log(chalk.green(`\n✓ CLI atualizada: ${chalk.bold(latestVersion)}\n`));
+	} catch {
+		spin.stop();
+		console.log(chalk.yellow(`\n⚠ Não foi possível atualizar automaticamente. Execute manualmente:\n  ${installCmd}\n`));
+	}
 }
-function prepareExtraFiles(detection, serviceConfig) {
+
+//#endregion
+//#region src/commands/deploy.ts
+/**
+* If a Dockerfile exists in a subdirectory (rootDirectory), copy it to tar root
+* so BuildKit can find it. If no Dockerfile exists anywhere, return nothing —
+* the server will generate one with nixpacks.
+*/
+function prepareExtraFiles(_detection, serviceConfig) {
 	if (existsSync(resolve(process.cwd(), "Dockerfile"))) return [];
 	const rootDir = serviceConfig?.rootDirectory || ".";
 	const serviceDockerfilePath = resolve(process.cwd(), rootDir, "Dockerfile");
@@ -1721,89 +2341,71 @@ function prepareExtraFiles(detection, serviceConfig) {
 		name: "Dockerfile",
 		content: readFileSync(serviceDockerfilePath, "utf-8")
 	}];
-	const fw = detection.framework;
-	const pm = detectPackageManager();
-	const nodeVersion = detectNodeVersion();
-	const type = serviceConfig?.type?.toUpperCase() ?? fw?.type ?? "WEB";
-	const files = [{
-		name: "Dockerfile",
-		content: generateDockerfile({
-			serviceType: type,
-			nodeVersion,
-			pm,
-			buildCommand: serviceConfig?.buildCommand ?? fw?.buildCommand ?? `${pm} run build`,
-			startCommand: serviceConfig?.startCommand ?? fw?.startCommand ?? void 0,
-			outputDir: serviceConfig?.outputDir ?? fw?.outputDir ?? void 0,
-			rootDirectory: serviceConfig?.rootDirectory,
-			port: serviceConfig?.port ?? fw?.port ?? 3e3
-		})
-	}];
-	if (type === "STATIC") files.push({
-		name: "nginx.conf",
-		content: NGINX_CONF
-	}, {
-		name: "generate-nginx-config.cjs",
-		content: GENERATE_NGINX_CONFIG_CJS
-	});
-	return files;
+	return [];
 }
-function computeExtraFilesForServices(services) {
+async function computeExtraFilesForServices(services) {
 	const velozConfig = loadConfig();
-	return services.map((svc) => {
-		let serviceConf;
-		if (velozConfig) {
-			for (const [, conf] of Object.entries(velozConfig.services)) if (conf.id === svc.serviceId) {
-				const merged = mergeServiceWithDefaults(conf, velozConfig.defaults);
-				serviceConf = {
-					type: merged.type,
-					buildCommand: merged.build?.command ?? void 0,
-					startCommand: merged.runtime?.command ?? void 0,
-					port: merged.runtime?.port ?? void 0,
-					rootDirectory: merged.root,
-					outputDir: merged.build?.outputDir ?? void 0
-				};
-				break;
-			}
-		}
-		const detection = detectLocalRepo();
-		return {
+	const client = await getClient();
+	const results = [];
+	const allWarnings = [];
+	for (const svc of services) {
+		const warnings = runPreDeployChecks(resolveServiceConf(velozConfig, svc.serviceId)?.rootDirectory || ".");
+		if (warnings.length > 0) allWarnings.push({
+			service: svc.serviceName,
+			warnings
+		});
+	}
+	if (allWarnings.length > 0) for (const { service, warnings } of allWarnings) output({
+		type: "service_warnings",
+		service,
+		warnings: warnings.map((w) => ({
+			message: w.message,
+			hint: w.hint
+		}))
+	}, () => {
+		console.log(chalk.yellow(`\n  ${chalk.bold(service)}:`));
+		printDeployWarnings(warnings);
+	});
+	for (const svc of services) {
+		const serviceConf = resolveServiceConf(velozConfig, svc.serviceId);
+		if (serviceConf) await syncServiceConfig(client, svc.serviceId, serviceConf);
+		const detection = detectLocalRepo(serviceConf?.rootDirectory || ".");
+		results.push({
 			...svc,
 			extraFiles: prepareExtraFiles(detection, serviceConf)
-		};
-	});
+		});
+	}
+	return results;
 }
-async function triggerDeploy(serviceId, serviceName) {
+async function triggerDeploy(serviceId, serviceName, preDetection) {
 	const spinUpload = spinner(serviceName ? `Fazendo upload ${chalk.bold(serviceName)}...` : "Fazendo upload do código...");
 	try {
 		const sizeInBytes = await calculateDirectorySize(process.cwd());
 		const sizeMB = Math.round(sizeInBytes / (1024 * 1024) * 10) / 10;
 		if (sizeMB > 5) spinUpload.text = `Fazendo upload (${sizeMB} MB)...`;
 		const client = await getClient();
-		const authConfig = await requireAuth();
-		const velozConfig = loadConfig();
-		let serviceConf;
-		if (velozConfig) {
-			for (const [, svc] of Object.entries(velozConfig.services)) if (svc.id === serviceId) {
-				const merged = mergeServiceWithDefaults(svc, velozConfig.defaults);
-				serviceConf = {
-					type: merged.type,
-					buildCommand: merged.build?.command ?? void 0,
-					startCommand: merged.runtime?.command ?? void 0,
-					port: merged.runtime?.port ?? void 0,
-					rootDirectory: merged.root,
-					outputDir: merged.build?.outputDir ?? void 0
-				};
-				break;
-			}
+		const serviceConf = resolveServiceConf(loadConfig(), serviceId);
+		if (serviceConf) await syncServiceConfig(client, serviceId, serviceConf);
+		const extraFiles = prepareExtraFiles(preDetection ?? detectLocalRepo(), serviceConf);
+		const warnings = runPreDeployChecks(serviceConf?.rootDirectory || ".");
+		if (warnings.length > 0) {
+			spinUpload.stop();
+			printDeployWarnings(warnings);
+			spinUpload.start();
 		}
-		const extraFiles = prepareExtraFiles(detectLocalRepo(), serviceConf);
 		spinUpload.text = "Iniciando deploy...";
 		const deployment = await withRetry(() => client.deployments.create({ serviceId }));
 		spinUpload.text = "Fazendo upload do código...";
-		await withRetry(() => uploadSource(authConfig.apiUrl, deployment.id, process.cwd(), authConfig.apiKey, extraFiles));
+		await withRetry(() => uploadSource(deployment.id, process.cwd(), extraFiles));
 		spinUpload.stop();
-		success("Deploy iniciado com sucesso!");
-		await streamDeploymentLogs(client, deployment.id, serviceId, serviceName);
+		success(serviceName ? `Upload de ${chalk.bold(serviceName)} concluído` : "Upload concluído");
+		setupSigintHandler();
+		trackDeployment(deployment.id);
+		try {
+			await streamDeploymentLogs(deployment.id, serviceId, serviceName);
+		} finally {
+			untrackDeployment(deployment.id);
+		}
 	} catch (error) {
 		spinUpload.stop();
 		handleError(error);
@@ -1833,19 +2435,26 @@ function readLocalFile(path) {
 	}
 }
 function printSummary(settings) {
-	console.log();
-	console.log(chalk.dim("─".repeat(40)));
-	console.log(`  ${chalk.bold("Nome:")}          ${settings.name}`);
-	console.log(`  ${chalk.bold("Tipo:")}          ${settings.type === "WEB" ? "Serviço Web" : "Site Estático"}`);
-	console.log(`  ${chalk.bold("Branch:")}        ${settings.branch}`);
-	if (settings.framework) console.log(`  ${chalk.bold("Framework:")}     ${settings.framework}`);
-	if (settings.packageManager) console.log(`  ${chalk.bold("Package Mgr:")}   ${settings.packageManager}`);
-	if (settings.buildCommand) console.log(`  ${chalk.bold("Build:")}         ${settings.buildCommand}`);
-	if (settings.startCommand) console.log(`  ${chalk.bold("Start:")}         ${settings.startCommand}`);
-	if (settings.outputDir) console.log(`  ${chalk.bold("Output:")}        ${settings.outputDir}`);
-	if (settings.port) console.log(`  ${chalk.bold("Porta:")}         ${settings.port}`);
-	console.log(chalk.dim("─".repeat(40)));
-	console.log();
+	const { type: serviceType, ...rest } = settings;
+	output({
+		type: "service_summary",
+		serviceType,
+		...rest
+	}, () => {
+		console.log();
+		console.log(chalk.dim("─".repeat(40)));
+		console.log(`  ${chalk.bold("Nome:")}          ${settings.name}`);
+		console.log(`  ${chalk.bold("Tipo:")}          ${settings.type === "WEB" ? "Serviço Web" : "Site Estático"}`);
+		console.log(`  ${chalk.bold("Branch:")}        ${settings.branch}`);
+		if (settings.framework) console.log(`  ${chalk.bold("Framework:")}     ${settings.framework}`);
+		if (settings.packageManager) console.log(`  ${chalk.bold("Package Mgr:")}   ${settings.packageManager}`);
+		if (settings.buildCommand) console.log(`  ${chalk.bold("Build:")}         ${settings.buildCommand}`);
+		if (settings.startCommand) console.log(`  ${chalk.bold("Start:")}         ${settings.startCommand}`);
+		if (settings.outputDir) console.log(`  ${chalk.bold("Output:")}        ${settings.outputDir}`);
+		if (settings.port) console.log(`  ${chalk.bold("Porta:")}         ${settings.port}`);
+		console.log(chalk.dim("─".repeat(40)));
+		console.log();
+	});
 }
 function detectLocalRepo(basePath = ".") {
 	const files = {};
@@ -1914,20 +2523,21 @@ function detectLocalRepo(basePath = ".") {
 	}
 	return analyzeRepo(files);
 }
-async function promptEnvVars(client, serviceId, detectedVars) {
+async function promptEnvVars(serviceId, detectedVars) {
 	if (detectedVars.length === 0) return;
 	console.log(chalk.cyan(`\n📝 ${detectedVars.length} variável(is) de ambiente detectada(s):\n`));
-	for (const v of detectedVars) console.log(`  • ${v.key}`);
+	for (const v of detectedVars) console.log(`  • ${v}`);
 	console.log();
 	if (!await promptConfirm("Deseja preencher as variáveis agora?", false)) return;
 	const vars = {};
-	for (const v of detectedVars) {
-		const finalVal = await prompt(`  ${chalk.bold(v.key)}:${v.value ? chalk.dim(` (${v.value})`) : ""}`) || v.value;
-		if (finalVal) vars[v.key] = finalVal;
+	for (const key of detectedVars) {
+		const val = await prompt(`  ${chalk.bold(key)}:`);
+		if (val) vars[key] = val;
 	}
 	const filled = Object.keys(vars).length;
 	if (filled > 0) {
 		const spinVars = spinner("Definindo variáveis de ambiente...");
+		const client = await getClient();
 		await withRetry(() => client.envVars.setBulk({
 			serviceId,
 			vars
@@ -1936,7 +2546,8 @@ async function promptEnvVars(client, serviceId, detectedVars) {
 		success(`${filled} variável(is) definida(s).`);
 	}
 }
-async function createServiceFlow(client, projectId, projectName, repoName) {
+async function createServiceFlow(projectId, projectName, repoName, opts = {}) {
+	const client = await getClient();
 	const branch = getGitBranch();
 	const spinDetect = spinner("Detectando framework...");
 	const detection = detectLocalRepo();
@@ -1944,36 +2555,61 @@ async function createServiceFlow(client, projectId, projectName, repoName) {
 	const pm = detection.packageManager;
 	if (detection.isMonorepo && detection.monorepoApps.length > 0) {
 		info(`Monorepo detectado (${pm})`);
-		const selectedPaths = await promptMultiSelect("Quais apps deseja fazer o deploy?", detection.monorepoApps.map((app) => ({
-			label: `${app.name}${app.framework ? ` (${app.framework.label})` : ""} — ${app.path}`,
-			value: app.path
-		})));
-		const selectedApps = detection.monorepoApps.filter((a) => selectedPaths.includes(a.path));
+		const allApps = detection.monorepoApps.map((a) => ({
+			name: a.name,
+			root: a.path,
+			framework: a.framework?.name ?? null,
+			buildCommand: a.framework?.buildCommand ?? null,
+			startCommand: a.framework?.startCommand ?? null,
+			port: a.framework?.port ?? 3e3
+		}));
+		let selectedApps;
+		if (opts.yes) if (opts.app) {
+			selectedApps = allApps.filter((a) => a.root === opts.app);
+			if (selectedApps.length === 0) {
+				output({
+					type: "error",
+					message: `App '${opts.app}' não encontrado.`,
+					available: allApps.map((a) => a.root)
+				}, () => {
+					const available = allApps.map((a) => `  • ${a.root}`).join("\n");
+					console.error(chalk.red(`\n✗ App '${opts.app}' não encontrado.\n\nApps disponíveis:\n${available}`));
+				});
+				process.exit(1);
+			}
+		} else selectedApps = allApps;
+		else {
+			const selectedPaths = await promptMultiSelect("Quais apps deseja fazer o deploy?", allApps.map((app) => ({
+				label: `${app.name}${app.framework ? ` (${app.framework})` : ""} — ${app.root}`,
+				value: app.root
+			})));
+			selectedApps = allApps.filter((a) => selectedPaths.includes(a.root));
+		}
 		for (const app of selectedApps) {
-			const fw$1 = app.framework;
 			console.log(chalk.cyan(`\n── ${app.name} ──`));
 			printSummary({
 				name: app.name,
-				type: fw$1?.type ?? "WEB",
-				rootDir: app.path,
+				type: "WEB",
+				rootDir: app.root,
 				branch,
-				framework: fw$1?.label ?? null,
+				framework: app.framework,
 				packageManager: pm,
-				buildCommand: fw$1?.buildCommand ?? null,
-				startCommand: fw$1?.startCommand ?? null,
-				outputDir: fw$1?.outputDir ?? null,
-				port: fw$1?.port ?? 3e3
+				buildCommand: app.buildCommand,
+				startCommand: app.startCommand,
+				outputDir: null,
+				port: app.port ?? 3e3
 			});
 		}
-		if (!await promptConfirm("Confirmar e fazer deploy?")) for (const app of selectedApps) {
-			const fw$1 = app.framework;
-			console.log(chalk.cyan(`\n── Editar: ${app.name} ──`));
-			const newBuild = await prompt(`  Build command: ${chalk.dim(`(${fw$1?.buildCommand ?? "—"})`)}`);
-			if (newBuild && fw$1) fw$1.buildCommand = newBuild;
-			const newStart = await prompt(`  Start command: ${chalk.dim(`(${fw$1?.startCommand ?? "—"})`)}`);
-			if (newStart && fw$1) fw$1.startCommand = newStart;
-			const newPort = await prompt(`  Port: ${chalk.dim(`(${fw$1?.port ?? 3e3})`)}`);
-			if (newPort && fw$1) fw$1.port = parseInt(newPort, 10) || fw$1.port;
+		if (!opts.yes) {
+			if (!await promptConfirm("Confirmar e fazer deploy?")) for (const app of selectedApps) {
+				console.log(chalk.cyan(`\n── Editar: ${app.name} ──`));
+				const newBuild = await prompt(`  Build command: ${chalk.dim(`(${app.buildCommand ?? "—"})`)}`);
+				if (newBuild) app.buildCommand = newBuild;
+				const newStart = await prompt(`  Start command: ${chalk.dim(`(${app.startCommand ?? "—"})`)}`);
+				if (newStart) app.startCommand = newStart;
+				const newPort = await prompt(`  Port: ${chalk.dim(`(${app.port ?? 3e3})`)}`);
+				if (newPort) app.port = parseInt(newPort, 10) || app.port;
+			}
 		}
 		const config = {
 			version: "1.0",
@@ -1986,18 +2622,17 @@ async function createServiceFlow(client, projectId, projectName, repoName) {
 		};
 		const createdServices = [];
 		for (const app of selectedApps) {
-			const fw$1 = app.framework;
 			console.log(chalk.cyan(`\n── Criando serviço: ${app.name} ──\n`));
 			const spinService$1 = spinner(`Criando serviço ${chalk.bold(app.name)}...`);
 			const service$1 = await withRetry(() => client.services.create({
 				projectId,
 				name: app.name,
-				type: fw$1?.type ?? "WEB",
+				type: "WEB",
 				branch,
-				rootDirectory: app.path,
-				buildCommand: fw$1?.buildCommand ?? void 0,
-				startCommand: fw$1?.startCommand ?? void 0,
-				port: fw$1?.port ?? 3e3
+				rootDirectory: app.root,
+				buildCommand: app.buildCommand ?? void 0,
+				startCommand: app.startCommand ?? void 0,
+				port: app.port ?? 3e3
 			}));
 			spinService$1.stop();
 			success(`Serviço criado: ${chalk.bold(service$1.name)}`);
@@ -2005,40 +2640,36 @@ async function createServiceFlow(client, projectId, projectName, repoName) {
 				service: service$1,
 				app
 			});
-			config.services[app.path] = {
+			config.services[app.root] = {
 				id: service$1.id,
 				name: service$1.name,
-				type: (fw$1?.type ?? "web").toLowerCase(),
-				root: app.path,
+				type: "web",
+				root: app.root,
 				branch,
-				build: fw$1?.buildCommand || fw$1?.outputDir ? {
-					command: fw$1?.buildCommand ?? void 0,
-					outputDir: fw$1?.outputDir ?? void 0
-				} : void 0,
+				build: app.buildCommand ? { command: app.buildCommand ?? void 0 } : void 0,
 				runtime: {
-					command: fw$1?.startCommand ?? void 0,
-					port: fw$1?.port ?? 3e3
+					command: app.startCommand ?? void 0,
+					port: app.port ?? 3e3
 				}
 			};
 		}
 		saveConfig(config);
 		info(`Arquivo ${getConfigFileName()} criado na raiz do projeto.`);
-		for (const { service: service$1, app } of createdServices) {
+		if (!opts.yes) for (const { service: service$1, app } of createdServices) {
 			console.log(chalk.cyan(`\n── Configurando variáveis: ${app.name} ──\n`));
-			const serviceDetection = detectLocalRepo(app.path);
-			await promptEnvVars(client, service$1.id, serviceDetection.envVars);
+			const serviceDetection = detectLocalRepo(app.root);
+			await promptEnvVars(service$1.id, serviceDetection.envVars.map((v) => v.key));
 		}
-		await deployServicesInParallel(client, createdServices.map(({ service: service$1, app }) => ({
+		await deployServicesInParallel(createdServices.map(({ service: service$1, app }) => ({
 			serviceId: service$1.id,
 			serviceName: app.name,
-			path: resolve(process.cwd(), app.path),
-			extraFiles: prepareExtraFiles(detectLocalRepo(app.path), {
-				type: app.framework?.type,
-				buildCommand: app.framework?.buildCommand ?? void 0,
-				startCommand: app.framework?.startCommand ?? void 0,
-				port: app.framework?.port ?? void 0,
-				rootDirectory: app.path,
-				outputDir: app.framework?.outputDir ?? void 0
+			path: resolve(process.cwd(), app.root),
+			extraFiles: prepareExtraFiles(detectLocalRepo(app.root), {
+				type: "WEB",
+				buildCommand: app.buildCommand ?? void 0,
+				startCommand: app.startCommand ?? void 0,
+				port: app.port ?? void 0,
+				rootDirectory: app.root
 			})
 		})));
 		return createdServices[createdServices.length - 1]?.service.id || "";
@@ -2049,31 +2680,33 @@ async function createServiceFlow(client, projectId, projectName, repoName) {
 		type: fw?.type ?? "WEB",
 		rootDir: ".",
 		branch,
-		framework: fw?.label ?? null,
+		framework: fw?.name ?? null,
 		packageManager: pm,
 		buildCommand: fw?.buildCommand ?? null,
 		startCommand: fw?.startCommand ?? null,
 		outputDir: fw?.outputDir ?? null,
 		port: fw?.port ?? 3e3
 	};
-	if (fw) info(`Framework detectado: ${chalk.bold(fw.label)}`);
+	if (fw) info(`Framework detectado: ${chalk.bold(fw.name)}`);
 	printSummary(settings);
-	if (!await promptConfirm("Confirmar e fazer deploy?")) {
-		const newName = await prompt(`Nome do serviço: ${chalk.dim(`(${settings.name})`)}`);
-		if (newName) settings.name = newName;
-		settings.type = await promptSelect("Tipo de serviço:", [{
-			label: "Serviço Web",
-			value: "WEB"
-		}, {
-			label: "Site Estático",
-			value: "STATIC"
-		}]);
-		const newBuild = await prompt(`Build command: ${chalk.dim(`(${settings.buildCommand ?? "—"})`)}`);
-		if (newBuild) settings.buildCommand = newBuild;
-		const newStart = await prompt(`Start command: ${chalk.dim(`(${settings.startCommand ?? "—"})`)}`);
-		if (newStart) settings.startCommand = newStart;
-		const newPort = await prompt(`Port: ${chalk.dim(`(${settings.port})`)}`);
-		if (newPort) settings.port = parseInt(newPort, 10) || settings.port;
+	if (!opts.yes) {
+		if (!await promptConfirm("Confirmar e fazer deploy?")) {
+			const newName = await prompt(`Nome do serviço: ${chalk.dim(`(${settings.name})`)}`);
+			if (newName) settings.name = newName;
+			settings.type = await promptSelect("Tipo de serviço:", [{
+				label: "Serviço Web",
+				value: "WEB"
+			}, {
+				label: "Site Estático",
+				value: "STATIC"
+			}]);
+			const newBuild = await prompt(`Build command: ${chalk.dim(`(${settings.buildCommand ?? "—"})`)}`);
+			if (newBuild) settings.buildCommand = newBuild;
+			const newStart = await prompt(`Start command: ${chalk.dim(`(${settings.startCommand ?? "—"})`)}`);
+			if (newStart) settings.startCommand = newStart;
+			const newPort = await prompt(`Port: ${chalk.dim(`(${settings.port})`)}`);
+			if (newPort) settings.port = parseInt(newPort, 10) || settings.port;
+		}
 	}
 	const spinService = spinner("Criando serviço...");
 	const service = await withRetry(() => client.services.create({
@@ -2088,7 +2721,7 @@ async function createServiceFlow(client, projectId, projectName, repoName) {
 	}));
 	spinService.stop();
 	success(`Serviço criado: ${chalk.bold(service.name)}`);
-	await promptEnvVars(client, service.id, detection.envVars);
+	if (!opts.yes) await promptEnvVars(service.id, detection.envVars.map((v) => v.key));
 	saveConfig({
 		version: "1.0",
 		project: {
@@ -2115,24 +2748,129 @@ async function createServiceFlow(client, projectId, projectName, repoName) {
 	info(`Arquivo ${getConfigFileName()} criado na raiz do projeto.`);
 	return service.id;
 }
-const deployCommand = new Command("deploy").description("Fazer deploy do serviço (auto-detecta projeto pelo git)").option("-a, --all", "Deploy todos os serviços do monorepo").option("--service <service>", "Deploy de um serviço específico (chave ou nome)").option("-v, --verbose", "Mostrar logs detalhados do servidor").action(async (options) => {
+/**
+* Create a new environment by mirroring the base config's services
+* into a new project on the platform. Saves the environment mapping to veloz.json.
+*/
+async function createEnvironmentFlow(rawConfig, envName, opts) {
+	const client = await getClient();
+	const projectName = `${rawConfig.project.name}-${envName}`;
+	info(`Criando ambiente "${envName}" — projeto: ${chalk.bold(projectName)}`);
+	if (!opts.yes) {
+		if (!await promptConfirm(`Criar ambiente "${envName}" com ${Object.keys(rawConfig.services).length} serviço(s)?`)) {
+			info("Criação de ambiente cancelada.");
+			process.exit(0);
+		}
+	}
+	const remote = getGitRemote();
+	const spinProject = spinner(`Criando projeto ${chalk.bold(projectName)}...`);
+	const newProject = await withRetry(() => client.projects.create({
+		name: projectName,
+		githubRepoOwner: remote?.owner,
+		githubRepoName: remote?.repo
+	}));
+	spinProject.stop();
+	success(`Projeto criado: ${chalk.bold(newProject.name)}`);
+	const envServices = {};
+	for (const [key, serviceConfig] of Object.entries(rawConfig.services)) {
+		const serviceName = `${serviceConfig.name}-${envName}`;
+		const spinService = spinner(`Criando serviço ${chalk.bold(serviceName)}...`);
+		const service = await withRetry(() => client.services.create({
+			projectId: newProject.id,
+			name: serviceName,
+			type: serviceConfig.type?.toUpperCase() ?? "WEB",
+			branch: serviceConfig.branch ?? "main",
+			rootDirectory: serviceConfig.root,
+			buildCommand: serviceConfig.build?.command ?? void 0,
+			startCommand: serviceConfig.runtime?.command ?? void 0,
+			port: serviceConfig.runtime?.port ?? 3e3
+		}));
+		spinService.stop();
+		success(`Serviço criado: ${chalk.bold(service.name)}`);
+		envServices[key] = {
+			id: service.id,
+			name: serviceName
+		};
+	}
+	const envOverride = {
+		project: {
+			id: newProject.id,
+			name: newProject.name
+		},
+		services: envServices
+	};
+	saveConfig({
+		...rawConfig,
+		environments: {
+			...rawConfig.environments,
+			[envName]: envOverride
+		},
+		updated: (/* @__PURE__ */ new Date()).toISOString()
+	});
+	success(`Ambiente "${envName}" salvo em ${getConfigFileName()}`);
+	setActiveEnv(envName);
+	return loadConfig();
+}
+function isMultipleOrgsError(error) {
+	if (!(error instanceof Error)) return false;
+	const e = error;
+	return e.data?.code === "MULTIPLE_ORGS" && Array.isArray(e.data?.organizations);
+}
+async function resolveOrgIfNeeded(nonInteractive) {
+	if ((await requireAuth({ nonInteractive })).organizationId) return;
+	if (loadConfig()?.project?.id) return;
+	const client = await getClient();
+	try {
+		await client.projects.list();
+	} catch (error) {
+		if (!isMultipleOrgsError(error)) throw error;
+		const orgs = error.data.organizations;
+		info(`Você tem acesso a ${orgs.length} organizações.`);
+		saveConfig$1({ organizationId: await promptSelect("Selecione a organização para este deploy:", orgs.map((org) => ({
+			label: `${org.name} ${chalk.dim(`(${org.slug})`)}`,
+			value: org.id
+		}))) });
+		success("Organização salva.");
+	}
+}
+const deployCommand = new Command("deploy").description("Fazer deploy do serviço (auto-detecta projeto pelo git)").option("-a, --all", "Deploy todos os serviços do monorepo").option("--service <service>", "Deploy de um serviço específico (chave ou nome)").option("--app <path>", "App do monorepo para deploy (ex: apps/web)").option("-y, --yes", "Auto-confirmar tudo (modo não-interativo)").option("-v, --verbose", "Mostrar logs detalhados do servidor").action(async (options) => {
 	if (options.verbose) process.env.VELOZ_VERBOSE = "true";
 	try {
-		await requireAuth();
+		printBanner("Deploy");
+		await autoUpdate();
+		await requireAuth({ nonInteractive: options.yes });
+		await resolveOrgIfNeeded(options.yes);
+		const activeEnv = getActiveEnv();
+		if (activeEnv) {
+			const rawConfig = loadRawConfig();
+			if (rawConfig && !rawConfig.environments?.[activeEnv]) {
+				info(`Ambiente "${activeEnv}" não encontrado. Configurando...`);
+				await createEnvironmentFlow(rawConfig, activeEnv, { yes: options.yes });
+			}
+		}
 		const configuredServices = await findServicesFromConfig();
 		if (configuredServices.length > 0) {
 			if (options.service) {
 				const found = configuredServices.find((s) => s.key === options.service || s.serviceName.toLowerCase() === options.service.toLowerCase() || s.serviceId === options.service);
 				if (!found) {
-					const available = configuredServices.map((s) => `  • ${s.key} (${s.serviceName})`).join("\n");
-					console.error(chalk.red(`\n✗ Serviço '${options.service}' não encontrado.\n\nServiços disponíveis:\n${available}`));
+					output({
+						type: "error",
+						message: `Serviço '${options.service}' não encontrado.`,
+						available: configuredServices.map((s) => ({
+							key: s.key,
+							name: s.serviceName
+						}))
+					}, () => {
+						const available = configuredServices.map((s) => `  • ${s.key} (${s.serviceName})`).join("\n");
+						console.error(chalk.red(`\n✗ Serviço '${options.service}' não encontrado.\n\nServiços disponíveis:\n${available}`));
+					});
 					process.exit(1);
 				}
 				await triggerDeploy(found.serviceId, found.serviceName);
 				return;
 			}
-			if (options.all || configuredServices.length === 1) {
-				if (configuredServices.length > 1) {
+			if (options.all || options.yes || configuredServices.length === 1) {
+				if (configuredServices.length > 1 && !options.yes) {
 					console.log(chalk.cyan(`\n🚀 Fazendo deploy de ${configuredServices.length} serviço(s):\n`));
 					for (const service of configuredServices) {
 						const relPath = relative(process.cwd(), service.path) || ".";
@@ -2145,10 +2883,7 @@ const deployCommand = new Command("deploy").description("Fazer deploy do serviç
 					}
 				}
 				if (configuredServices.length === 1) await triggerDeploy(configuredServices[0].serviceId, configuredServices[0].serviceName);
-				else {
-					const servicesWithExtraFiles = computeExtraFilesForServices(configuredServices);
-					await deployServicesInParallel(await getClient(), servicesWithExtraFiles);
-				}
+				else await deployServicesInParallel(await computeExtraFilesForServices(configuredServices));
 				return;
 			} else {
 				console.log(chalk.bold("\n📦 Serviços disponíveis:\n"));
@@ -2165,24 +2900,21 @@ const deployCommand = new Command("deploy").description("Fazer deploy do serviç
 					return;
 				}
 				if (selectedServices.length === 1) await triggerDeploy(selectedServices[0].serviceId, selectedServices[0].serviceName);
-				else {
-					const servicesWithExtraFiles = computeExtraFilesForServices(selectedServices);
-					await deployServicesInParallel(await getClient(), servicesWithExtraFiles);
-				}
+				else await deployServicesInParallel(await computeExtraFilesForServices(selectedServices));
 				return;
 			}
 		}
-		if (!isGitRepo()) {
-			console.error(chalk.red("\n✗ Este diretório não é um repositório git. Inicialize com `git init` e adicione um remote."));
-			process.exit(1);
-		}
+		if (!isGitRepo()) handleError(/* @__PURE__ */ new Error("Este diretório não é um repositório git. Inicialize com `git init` e adicione um remote."));
 		info("Detectando repositório git...");
 		const remote = getGitRemote();
-		if (!remote) {
-			console.error(chalk.red("\n✗ Nenhum remote 'origin' encontrado. Adicione um remote git."));
-			process.exit(1);
-		}
-		console.log(chalk.white(`  ${chalk.bold("Repositório:")} ${remote.owner}/${remote.repo}`));
+		if (!remote) handleError(/* @__PURE__ */ new Error("Nenhum remote 'origin' encontrado. Adicione um remote git."));
+		output({
+			type: "git_repo",
+			owner: remote.owner,
+			repo: remote.repo
+		}, () => {
+			console.log(chalk.white(`  ${chalk.bold("Repositório:")} ${remote.owner}/${remote.repo}`));
+		});
 		const client = await getClient();
 		const spin = spinner("Buscando projeto...");
 		const project = await withRetry(() => client.projects.findByRepo({
@@ -2198,6 +2930,10 @@ const deployCommand = new Command("deploy").description("Fazer deploy do serviç
 				const svc = project.services[0];
 				serviceId = svc.id;
 				serviceName = svc.name;
+			} else if (options.yes) {
+				const svc = project.services[0];
+				serviceId = svc.id;
+				serviceName = svc.name;
 			} else {
 				serviceId = await promptSelect("Selecione o serviço:", project.services.map((s) => ({
 					label: `${s.name} (${s.type} — branch: ${s.branch})`,
@@ -2206,6 +2942,8 @@ const deployCommand = new Command("deploy").description("Fazer deploy do serviç
 				serviceName = project.services.find((s) => s.id === serviceId)?.name ?? "";
 			}
 			const selectedService = project.services.find((s) => s.id === serviceId);
+			const detection = detectLocalRepo();
+			const detectedType = selectedService?.type?.toLowerCase() ?? "web";
 			saveConfig({
 				version: "1.0",
 				project: {
@@ -2215,24 +2953,27 @@ const deployCommand = new Command("deploy").description("Fazer deploy do serviç
 				services: { main: {
 					id: serviceId,
 					name: serviceName,
-					type: selectedService?.type?.toLowerCase() ?? "web",
+					type: detectedType,
 					root: ".",
 					branch: selectedService?.branch
 				} },
 				created: (/* @__PURE__ */ new Date()).toISOString()
 			});
 			info(`Arquivo ${getConfigFileName()} criado na raiz do projeto.`);
-			await triggerDeploy(serviceId);
+			await triggerDeploy(serviceId, void 0, detection);
 			return;
 		}
 		if (project && project.services.length === 0) {
 			info(`Projeto encontrado: ${chalk.bold(project.name)}`);
 			info("Nenhum serviço configurado. Vamos criar um.");
-			await triggerDeploy(await createServiceFlow(client, project.id, project.name, remote.repo));
+			await triggerDeploy(await createServiceFlow(project.id, project.name, remote.repo, {
+				yes: options.yes,
+				app: options.app
+			}));
 			return;
 		}
 		info("Projeto não encontrado. Vamos criar um novo.");
-		const projectName = await prompt(`Nome do projeto: ${chalk.dim(`(${remote.repo})`)}`) || remote.repo;
+		const projectName = options.yes ? remote.repo : await prompt(`Nome do projeto: ${chalk.dim(`(${remote.repo})`)}`) || remote.repo;
 		const spinProject = spinner("Criando projeto...");
 		const newProject = await withRetry(() => client.projects.create({
 			name: projectName,
@@ -2241,7 +2982,10 @@ const deployCommand = new Command("deploy").description("Fazer deploy do serviç
 		}));
 		spinProject.stop();
 		success(`Projeto criado: ${chalk.bold(newProject.name)}`);
-		await triggerDeploy(await createServiceFlow(client, newProject.id, newProject.name, remote.repo));
+		await triggerDeploy(await createServiceFlow(newProject.id, newProject.name, remote.repo, {
+			yes: options.yes,
+			app: options.app
+		}));
 	} catch (error) {
 		handleError(error);
 	}
@@ -2283,10 +3027,14 @@ const TAG_COLORS = [
 	chalk.red
 ];
 function getServiceTag(name, maxLen, colorIndex) {
+	const mode = getOutputMode();
+	if (mode === "json" || mode === "github-actions" || mode === "plain") return `[${name.padEnd(maxLen)}]`;
 	const color = TAG_COLORS[colorIndex % TAG_COLORS.length];
 	return color(`[${name.padEnd(maxLen)}]`);
 }
 function getServiceHeader(name, colorIndex) {
+	const mode = getOutputMode();
+	if (mode === "json" || mode === "github-actions" || mode === "plain") return `── ${name} ──`;
 	const color = TAG_COLORS[colorIndex % TAG_COLORS.length];
 	return color(`── ${name} ──`);
 }
@@ -2385,7 +3133,8 @@ function resolveAllServices(serviceFlag) {
 function formatTime(timestamp) {
 	return chalk.dim(new Date(timestamp).toLocaleTimeString("pt-BR"));
 }
-async function streamFollow(client, services, maxNameLen, tailLines) {
+async function streamFollow(services, maxNameLen, tailLines) {
+	const client = await getClient();
 	const showTags = services.length > 1;
 	const streams = services.map(async ({ service, index }) => {
 		const tag = showTags ? `${getServiceTag(service.name, maxNameLen, index)} ` : "";
@@ -2394,14 +3143,22 @@ async function streamFollow(client, services, maxNameLen, tailLines) {
 				serviceId: service.id,
 				tailLines: Math.ceil(tailLines / services.length)
 			});
-			for await (const entry of stream) console.log(`${tag}${formatTime(entry.timestamp)} ${entry.message}`);
+			for await (const entry of stream) output({
+				type: "log_entry",
+				service: service.name,
+				timestamp: entry.timestamp,
+				message: entry.message
+			}, () => {
+				console.log(`${tag}${formatTime(entry.timestamp)} ${entry.message}`);
+			});
 		} catch {
 			console.log(`${tag}${chalk.red("Erro ao conectar ao stream de logs")}`);
 		}
 	});
 	await Promise.allSettled(streams);
 }
-async function fetchRecent(client, services, maxNameLen, tailLines) {
+async function fetchRecent(services, maxNameLen, tailLines) {
+	const client = await getClient();
 	const showTags = services.length > 1;
 	const allEntries = (await Promise.allSettled(services.map(async ({ service, index }) => {
 		return (await client.logs.getRecent({
@@ -2417,28 +3174,36 @@ async function fetchRecent(client, services, maxNameLen, tailLines) {
 		info("Nenhum log encontrado.");
 		return;
 	}
-	console.log();
-	for (const entry of allEntries) {
-		const tag = showTags ? `${getServiceTag(entry.serviceName, maxNameLen, entry.serviceIndex)} ` : "";
-		console.log(`${tag}${formatTime(entry.timestamp)} ${entry.message}`);
-	}
-	console.log();
-	info(`Mostrando ${allEntries.length} linha(s). Use ${chalk.bold("--follow")} para acompanhar em tempo real.`);
+	output({
+		type: "logs",
+		entries: allEntries.map((e) => ({
+			service: e.serviceName,
+			timestamp: e.timestamp,
+			message: e.message
+		}))
+	}, () => {
+		console.log();
+		for (const entry of allEntries) {
+			const tag = showTags ? `${getServiceTag(entry.serviceName, maxNameLen, entry.serviceIndex)} ` : "";
+			console.log(`${tag}${formatTime(entry.timestamp)} ${entry.message}`);
+		}
+		console.log();
+		info(`Mostrando ${allEntries.length} linha(s). Use ${chalk.bold("--follow")} para acompanhar em tempo real.`);
+	});
 }
 const logsCommand = new Command("logs").description("Visualizar logs dos serviços").option("-f, --follow", "Acompanhar logs em tempo real").option("-n, --tail <linhas>", "Número de linhas recentes", "50").option("--service <service>", "Filtrar por serviço (chave ou nome)").action(async (opts) => {
 	const spin = spinner("Carregando logs...");
 	try {
 		const { services, maxNameLen } = resolveAllServices(opts.service);
-		const client = await getClient();
 		const tailLines = parseInt(opts.tail, 10) || 50;
 		if (opts.follow) {
 			spin.text = services.length > 1 ? `Conectando a ${services.length} serviço(s)...` : "Conectando ao streaming de logs...";
 			spin.stop();
 			info("Streaming de logs ativo. Pressione Ctrl+C para sair.\n");
-			await streamFollow(client, services, maxNameLen, tailLines);
+			await streamFollow(services, maxNameLen, tailLines);
 		} else {
 			spin.stop();
-			await fetchRecent(client, services, maxNameLen, tailLines);
+			await fetchRecent(services, maxNameLen, tailLines);
 		}
 	} catch (error) {
 		spin.stop();
@@ -2472,7 +3237,11 @@ envCommand.command("list").alias("listar").description("Listar variáveis de amb
 				chalk.bold(v.key),
 				chalk.dim(v.maskedValue),
 				new Date(v.updatedAt).toLocaleDateString("pt-BR")
-			]));
+			]), envVars.map((v) => ({
+				key: v.key,
+				maskedValue: v.maskedValue,
+				updatedAt: v.updatedAt
+			})));
 		}
 		spin.stop();
 		if (totalVars === 0 && !showHeaders) info("Nenhuma variável de ambiente configurada.");
@@ -2490,15 +3259,13 @@ envCommand.command("set <pares...>").description("Definir variável de ambiente
 			const eqIndex = par.indexOf("=");
 			if (eqIndex === -1) {
 				spin.stop();
-				console.error(chalk.red(`\n✗ Formato inválido: "${par}". Use CHAVE=VALOR.`));
-				process.exit(1);
+				handleError(/* @__PURE__ */ new Error(`Formato inválido: "${par}". Use CHAVE=VALOR.`));
 			}
 			const key = par.slice(0, eqIndex);
 			const value = par.slice(eqIndex + 1);
 			if (!key) {
 				spin.stop();
-				console.error(chalk.red("\n✗ Chave não pode estar vazia."));
-				process.exit(1);
+				handleError(/* @__PURE__ */ new Error("Chave não pode estar vazia."));
 			}
 			await client.envVars.set({
 				serviceId,
@@ -2540,38 +3307,32 @@ envCommand.command("import [arquivo]").description("Importar variáveis de ambie
 		let envContent = "";
 		if (arquivo) {
 			const filePath = resolve(process.cwd(), arquivo);
-			if (!existsSync(filePath)) {
-				console.error(chalk.red(`\n✗ Arquivo não encontrado: ${arquivo}`));
-				process.exit(1);
-			}
+			if (!existsSync(filePath)) handleError(/* @__PURE__ */ new Error(`Arquivo não encontrado: ${arquivo}`));
 			envContent = readFileSync(filePath, "utf-8");
 			info(`Importando de ${chalk.bold(arquivo)}...`);
 		} else {
-			console.log(chalk.cyan("\n📋 Modo de colagem interativo"));
-			console.log(chalk.dim("Cole seu conteúdo .env abaixo. Pressione Ctrl+D (ou Ctrl+Z no Windows) quando terminar:\n"));
 			const rl = readline.createInterface({
 				input: process.stdin,
-				output: process.stdout
+				output: isInteractive() ? process.stdout : void 0
 			});
-			const lines$1 = [];
+			if (isInteractive()) {
+				console.log(chalk.cyan("\n📋 Modo de colagem interativo"));
+				console.log(chalk.dim("Cole seu conteúdo .env abaixo. Pressione Ctrl+D (ou Ctrl+Z no Windows) quando terminar:\n"));
+			}
+			const lines = [];
 			await new Promise((resolve$1) => {
-				rl.on("line", (line) => {
-					lines$1.push(line);
-				});
-				rl.on("close", () => {
-					resolve$1();
-				});
+				rl.on("line", (line) => lines.push(line));
+				rl.on("close", () => resolve$1());
 			});
-			envContent = lines$1.join("\n");
+			envContent = lines.join("\n");
 		}
 		const envVars = {};
-		const lines = envContent.split("\n");
-		for (const line of lines) {
+		for (const line of envContent.split("\n")) {
 			const trimmed = line.trim();
 			if (!trimmed || trimmed.startsWith("#")) continue;
 			const eqIndex = trimmed.indexOf("=");
 			if (eqIndex === -1) continue;
-			let key = trimmed.slice(0, eqIndex).trim();
+			const key = trimmed.slice(0, eqIndex).trim();
 			let value = trimmed.slice(eqIndex + 1).trim();
 			if (value.startsWith("\"") && value.endsWith("\"") || value.startsWith("'") && value.endsWith("'")) value = value.slice(1, -1);
 			value = value.replace(/\\n/g, "\n").replace(/\\r/g, "\r").replace(/\\t/g, "	").replace(/\\\\/g, "\\");
@@ -2579,7 +3340,7 @@ envCommand.command("import [arquivo]").description("Importar variáveis de ambie
 		}
 		const varsCount = Object.keys(envVars).length;
 		if (varsCount === 0) {
-			console.error(chalk.yellow("⚠ Nenhuma variável válida encontrada."));
+			warn("Nenhuma variável válida encontrada.");
 			return;
 		}
 		console.log(chalk.bold("\n📝 Variáveis a serem importadas:\n"));
@@ -2628,20 +3389,31 @@ envCommand.command("export [arquivo]").description("Exportar variáveis de ambie
 			return;
 		}
 		const envContent = envVars.map((v) => `${v.key}=${v.maskedValue}`).join("\n");
-		if (arquivo) {
-			writeFileSync(resolve(process.cwd(), arquivo), envContent + "\n", "utf-8");
-			success(`Variáveis exportadas para ${chalk.bold(arquivo)}`);
-			console.log(chalk.dim("Nota: Valores estão mascarados por segurança."));
-		} else {
-			console.log(chalk.bold("\n# Variáveis de Ambiente (valores mascarados)\n"));
-			console.log(envContent);
-			console.log();
-		}
+		output({
+			type: "env_export",
+			vars: envVars.map((v) => ({
+				key: v.key,
+				maskedValue: v.maskedValue
+			}))
+		}, () => {
+			if (arquivo) {
+				writeFileSync(resolve(process.cwd(), arquivo), envContent + "\n", "utf-8");
+				success(`Variáveis exportadas para ${chalk.bold(arquivo)}`);
+				console.log(chalk.dim("Nota: Valores estão mascarados por segurança."));
+			} else {
+				console.log(chalk.bold("\n# Variáveis de Ambiente (valores mascarados)\n"));
+				console.log(envContent);
+				console.log();
+			}
+		});
 	} catch (error) {
 		spin.stop();
 		handleError(error);
 	}
 });
+function warn(message) {
+	console.log(chalk.yellow(`⚠ ${message}`));
+}
 
 //#endregion
 //#region src/commands/domains.ts
@@ -2674,12 +3446,18 @@ domainsCommand.command("list").alias("listar").description("Listar domínios dos
 				"TLS",
 				"Tipo"
 			], domains.map((d) => [
-				d.id.slice(0, 8),
+				d.id,
 				chalk.bold(d.domain),
 				d.verified ? chalk.green("✓ Sim") : chalk.yellow("✗ Não"),
 				tlsStatusLabels[d.tlsStatus] ?? d.tlsStatus,
 				d.isAutoGenerated ? "Auto" : "Personalizado"
-			]));
+			]), domains.map((d) => ({
+				id: d.id,
+				domain: d.domain,
+				verified: d.verified,
+				tlsStatus: d.tlsStatus,
+				isAutoGenerated: d.isAutoGenerated
+			})));
 		}
 		spin.stop();
 		if (totalDomains === 0 && !showHeaders) info("Nenhum domínio configurado.");
@@ -2697,12 +3475,19 @@ domainsCommand.command("add <dominio>").alias("adicionar").description("Adiciona
 			domain: dominio
 		});
 		spin.stop();
-		success(`Domínio ${chalk.bold(dominio)} adicionado com sucesso!`);
-		console.log();
-		console.log(chalk.yellow.bold("  Instruções de DNS:"));
-		console.log(chalk.white(`  ${result.dnsInstruction}`));
-		console.log();
-		info(`Após configurar o DNS, execute: ${chalk.bold(`veloz domains verify ${result.id.slice(0, 8)}`)}`);
+		output({
+			type: "domain_added",
+			id: result.id,
+			domain: dominio,
+			dnsInstruction: result.dnsInstruction
+		}, () => {
+			success(`Domínio ${chalk.bold(dominio)} adicionado com sucesso!`);
+			console.log();
+			console.log(chalk.yellow.bold("  Instruções de DNS:"));
+			console.log(chalk.white(`  ${result.dnsInstruction}`));
+			console.log();
+			info(`Após configurar o DNS, execute: ${chalk.bold(`veloz domains verify ${result.id}`)}`);
+		});
 	} catch (error) {
 		spin.stop();
 		handleError(error);
@@ -2713,13 +3498,19 @@ domainsCommand.command("verify <domainId>").alias("verificar").description("Veri
 	try {
 		const result = await (await getClient()).domains.verify({ domainId });
 		spin.stop();
-		if (result.verified) {
-			success(`Domínio ${chalk.bold(result.domain.domain)} verificado com sucesso!`);
-			info("O certificado TLS será provisionado automaticamente.");
-		} else {
-			console.log(chalk.yellow(`\n⚠ Domínio ${chalk.bold(result.domain.domain)} ainda não verificado.`));
-			info("Verifique se o CNAME foi propagado e tente novamente.");
-		}
+		output({
+			type: "domain_verified",
+			domain: result.domain.domain,
+			verified: result.verified
+		}, () => {
+			if (result.verified) {
+				success(`Domínio ${chalk.bold(result.domain.domain)} verificado com sucesso!`);
+				info("O certificado TLS será provisionado automaticamente.");
+			} else {
+				console.log(chalk.yellow(`\n⚠ Domínio ${chalk.bold(result.domain.domain)} ainda não verificado.`));
+				info("Verifique se o CNAME foi propagado e tente novamente.");
+			}
+		});
 	} catch (error) {
 		spin.stop();
 		handleError(error);
@@ -2762,14 +3553,22 @@ configCommand.command("show").description("Mostrar configurações atuais dos se
 		const client = await getClient();
 		const showHeaders = services.length > 1;
 		const spin = spinner("Buscando configurações...");
-		for (const { service: svcConfig, index } of services) {
-			const service = await client.services.get({ serviceId: svcConfig.id });
-			if (showHeaders) console.log(`\n${getServiceHeader(svcConfig.name, index)}\n`);
-			else console.log(chalk.bold("\n📋 Configurações do Serviço\n"));
-			printServiceConfig(service);
-			console.log();
-		}
+		const configs = [];
+		for (const { service: svcConfig } of services) configs.push(await client.services.get({ serviceId: svcConfig.id }));
 		spin.stop();
+		output({
+			type: "service_configs",
+			services: configs
+		}, () => {
+			for (let i = 0; i < services.length; i++) {
+				const { service: svcConfig, index } = services[i];
+				const service = configs[i];
+				if (showHeaders) console.log(`\n${getServiceHeader(svcConfig.name, index)}\n`);
+				else console.log(chalk.bold("\n📋 Configurações do Serviço\n"));
+				printServiceConfig(service);
+				console.log();
+			}
+		});
 	} catch (error) {
 		handleError(error);
 	}
@@ -2800,13 +3599,18 @@ configCommand.command("set").description("Atualizar configurações do serviço"
 		});
 		spin.stop();
 		success("Configurações atualizadas com sucesso!");
-		console.log(chalk.dim("\nValores atualizados:"));
-		for (const [key, value] of Object.entries(updates)) {
-			const displayKey = key.replace(/([A-Z])/g, " $1").replace(/^./, (str) => str.toUpperCase()).trim();
-			console.log(`  ${chalk.bold(displayKey)}: ${formatValue(value)}`);
-		}
-		console.log();
-		info("Execute 'veloz deploy' para aplicar as mudanças.");
+		output({
+			type: "config_updated",
+			updates
+		}, () => {
+			console.log(chalk.dim("\nValores atualizados:"));
+			for (const [key, value] of Object.entries(updates)) {
+				const displayKey = key.replace(/([A-Z])/g, " $1").replace(/^./, (str) => str.toUpperCase()).trim();
+				console.log(`  ${chalk.bold(displayKey)}: ${formatValue(value)}`);
+			}
+			console.log();
+			info("Execute 'veloz deploy' para aplicar as mudanças.");
+		});
 	} catch (error) {
 		handleError(error);
 	}
@@ -2825,8 +3629,8 @@ configCommand.command("edit").description("Editar configurações interativament
 		if (name) updates.name = name;
 		const buildCmd = await prompt(`Build command ${chalk.dim(`(${service.buildCommand || "—"})`)}: `);
 		if (buildCmd) updates.buildCommand = buildCmd === "none" ? null : buildCmd;
-		const startCmd$1 = await prompt(`Start command ${chalk.dim(`(${service.startCommand || "—"})`)}: `);
-		if (startCmd$1) updates.startCommand = startCmd$1 === "none" ? null : startCmd$1;
+		const startCmd = await prompt(`Start command ${chalk.dim(`(${service.startCommand || "—"})`)}: `);
+		if (startCmd) updates.startCommand = startCmd === "none" ? null : startCmd;
 		const port = await prompt(`Porta ${chalk.dim(`(${service.port})`)}: `);
 		if (port) updates.port = parseInt(port, 10);
 		const rootDir = await prompt(`Diretório raiz ${chalk.dim(`(${service.rootDirectory || "/"})`)}: `);
@@ -2888,15 +3692,9 @@ configCommand.command("reset").description("Resetar configurações para os padr
 const useCommand = new Command("use").description("Selecionar qual serviço usar como padrão").argument("[serviço]", "Nome ou chave do serviço").action(async (servicoArg) => {
 	try {
 		const config = loadConfig();
-		if (!config) {
-			console.error(chalk.red("\n✗ Nenhum projeto configurado. Execute 'veloz deploy' primeiro."));
-			process.exit(1);
-		}
+		if (!config) handleError(/* @__PURE__ */ new Error("Nenhum projeto configurado. Execute 'veloz deploy' primeiro."));
 		const services = Object.entries(config.services);
-		if (services.length === 0) {
-			console.error(chalk.red("\n✗ Nenhum serviço encontrado na configuração."));
-			process.exit(1);
-		}
+		if (services.length === 0) handleError(/* @__PURE__ */ new Error("Nenhum serviço encontrado na configuração."));
 		if (services.length === 1) {
 			info("Apenas um serviço configurado — já é o padrão.");
 			return;
@@ -2906,13 +3704,8 @@ const useCommand = new Command("use").description("Selecionar qual serviço usar
 		if (servicoArg) {
 			const found = services.find(([key, service]) => key === servicoArg || service.name.toLowerCase() === servicoArg.toLowerCase());
 			if (!found) {
-				console.error(chalk.red(`\n✗ Serviço '${servicoArg}' não encontrado.`));
-				console.log(chalk.dim("\nServiços disponíveis:"));
-				services.forEach(([key, service], i) => {
-					const marker = key === currentDefault ? chalk.cyan(" ← padrão") : "";
-					console.log(`  ${getServiceHeader(service.name, i)}  ${chalk.dim(key)}${marker}`);
-				});
-				process.exit(1);
+				const available = services.map(([key, svc]) => `  • ${key} (${svc.name})`).join("\n");
+				handleError(/* @__PURE__ */ new Error(`Serviço '${servicoArg}' não encontrado.\n\nServiços disponíveis:\n${available}`));
 			}
 			selectedKey = found[0];
 		} else selectedKey = await promptSelect("Qual serviço usar como padrão?", services.map(([key, service]) => ({
@@ -2921,9 +3714,138 @@ const useCommand = new Command("use").description("Selecionar qual serviço usar
 		})));
 		setDefaultServiceKey(selectedKey);
 		const selectedService = config.services[selectedKey];
-		success(`Serviço padrão: ${chalk.bold(selectedService.name)} (${selectedKey})`);
-		console.log(chalk.dim(`\nComandos como ${chalk.white("logs")}, ${chalk.white("env")}, ${chalk.white("config")} vão usar este serviço automaticamente.`));
-		console.log(chalk.dim(`Use ${chalk.white("--service <nome>")} para sobrescrever pontualmente.`));
+		output({
+			type: "default_service",
+			key: selectedKey,
+			name: selectedService.name
+		}, () => {
+			success(`Serviço padrão: ${chalk.bold(selectedService.name)} (${selectedKey})`);
+			console.log(chalk.dim(`\nComandos como ${chalk.white("logs")}, ${chalk.white("env")}, ${chalk.white("config")} vão usar este serviço automaticamente.`));
+			console.log(chalk.dim(`Use ${chalk.white("--service <nome>")} para sobrescrever pontualmente.`));
+		});
+	} catch (error) {
+		handleError(error);
+	}
+});
+
+//#endregion
+//#region src/commands/apikey.ts
+async function authFetch(path, options = {}) {
+	const config = await requireAuth();
+	const url = `${config.apiUrl}/api/auth${path}`;
+	const res = await fetch(url, {
+		...options,
+		headers: {
+			"Content-Type": "application/json",
+			Authorization: `Bearer ${config.apiKey}`,
+			...options.headers
+		}
+	});
+	if (!res.ok) {
+		const body = await res.text().catch(() => "");
+		throw new Error(`Erro ${res.status}: ${body || res.statusText}`);
+	}
+	return res.json();
+}
+const apikeyCommand = new Command("apikey").description("Gerenciar chaves de API");
+apikeyCommand.command("create").description("Criar uma nova chave de API").option("--name <name>", "Nome da chave", "cli").option("--no-expire", "Chave sem expiração").action(async (opts) => {
+	try {
+		const s = spinner("Criando chave de API...");
+		const body = {
+			name: opts.name,
+			prefix: "veloz"
+		};
+		if (opts.expire === false) body.expiresIn = null;
+		const data = await authFetch("/api-key/create", {
+			method: "POST",
+			body: JSON.stringify(body)
+		});
+		s.stop();
+		output({
+			type: "apikey_created",
+			key: data.key,
+			name: data.name,
+			expiresAt: data.expiresAt
+		}, () => {
+			success("Chave de API criada!");
+			console.log();
+			console.log(chalk.bold("  Chave:"), chalk.green(data.key));
+			console.log(chalk.bold("  Nome:"), data.name);
+			if (data.expiresAt) console.log(chalk.bold("  Expira:"), new Date(data.expiresAt).toLocaleDateString("pt-BR"));
+			else console.log(chalk.bold("  Expira:"), "Nunca");
+			console.log();
+			console.log(chalk.yellow("  Guarde esta chave — ela não será exibida novamente."));
+			console.log();
+			console.log(chalk.dim("  Uso em CI:"));
+			console.log(chalk.dim(`    VELOZ_API_KEY=${data.key} veloz deploy -y --service web`));
+			console.log();
+			console.log(chalk.dim("  GitHub Actions:"));
+			console.log(chalk.dim(`    gh secret set VELOZ_API_KEY --body "${data.key}"`));
+			console.log();
+		});
+	} catch (error) {
+		handleError(error);
+	}
+});
+apikeyCommand.command("list").alias("listar").description("Listar chaves de API").action(async () => {
+	try {
+		const s = spinner("Buscando chaves...");
+		const data = await authFetch("/api-key/list", { method: "GET" });
+		s.stop();
+		const keys = Array.isArray(data) ? data : data.apiKeys ?? [];
+		if (!keys || keys.length === 0) {
+			info("Nenhuma chave de API encontrada.");
+			return;
+		}
+		printTable([
+			"Nome",
+			"ID",
+			"Criado",
+			"Expira"
+		], keys.map((k) => [
+			k.name ?? "-",
+			k.id,
+			new Date(k.createdAt).toLocaleDateString("pt-BR"),
+			k.expiresAt ? new Date(k.expiresAt).toLocaleDateString("pt-BR") : "Nunca"
+		]), keys.map((k) => ({
+			name: k.name,
+			id: k.id,
+			createdAt: k.createdAt,
+			expiresAt: k.expiresAt
+		})));
+	} catch (error) {
+		handleError(error);
+	}
+});
+apikeyCommand.command("delete <keyId>").alias("deletar").description("Deletar uma chave de API").action(async (keyId) => {
+	try {
+		const s = spinner("Deletando chave...");
+		await authFetch("/api-key/delete", {
+			method: "POST",
+			body: JSON.stringify({ keyId })
+		});
+		s.stop();
+		success("Chave deletada.");
+	} catch (error) {
+		handleError(error);
+	}
+});
+
+//#endregion
+//#region src/commands/whoami.ts
+const whoamiCommand = new Command("whoami").description("Mostrar usuário autenticado").action(async () => {
+	try {
+		const user = await (await getClient()).me();
+		output({
+			type: "user",
+			name: user.name,
+			email: user.email
+		}, () => {
+			console.log();
+			console.log(`  ${chalk.bold("Nome:")}   ${user.name}`);
+			console.log(`  ${chalk.bold("Email:")}  ${user.email}`);
+			console.log();
+		});
 	} catch (error) {
 		handleError(error);
 	}
@@ -2931,8 +3853,23 @@ const useCommand = new Command("use").description("Selecionar qual serviço usar
 
 //#endregion
 //#region src/index.ts
-const version = process.env.npm_package_version;
-const program = new Command().name("veloz").description("CLI da plataforma Veloz — deploy rápido para o Brasil").version(version ?? "0.0.0-beta.1");
+const program = new Command().name("veloz").description("CLI da plataforma Veloz — deploy rápido para o Brasil").version("0.0.0-beta.10").option("--output <format>", "Formato de saída: fancy, json, github-actions, plain").option("--env <environment>", "Ambiente alvo (ex: preview, staging)").hook("preAction", (thisCommand) => {
+	const opts = thisCommand.opts();
+	if (opts.output) {
+		const valid = [
+			"fancy",
+			"json",
+			"github-actions",
+			"plain"
+		];
+		if (!valid.includes(opts.output)) {
+			console.error(`Formato de saída inválido: "${opts.output}". Use: ${valid.join(", ")}`);
+			process.exit(1);
+		}
+		setOutputMode(opts.output);
+	}
+	if (opts.env) setActiveEnv(opts.env);
+});
 program.addCommand(loginCommand);
 program.addCommand(logoutCommand);
 program.addCommand(projectsCommand);
@@ -2943,6 +3880,8 @@ program.addCommand(envCommand);
 program.addCommand(domainsCommand);
 program.addCommand(configCommand);
 program.addCommand(useCommand);
+program.addCommand(apikeyCommand);
+program.addCommand(whoamiCommand);
 program.parse();
 
 //#endregion