onveloz 0.0.0-beta.1

package/dist/index.mjs

@@ -0,0 +1,2949 @@
+#!/usr/bin/env node
+import { Command } from "@commander-js/extra-typings";
+import chalk from "chalk";
+import { exec, execSync } from "node:child_process";
+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";
+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 ignore from "ignore";
+import tar from "tar";
+
+//#region src/lib/config.ts
+const CONFIG_DIR = join(homedir(), ".veloz");
+const ENV_API_URL = process.env.VELOZ_API_URL;
+const DEFAULT_API_URL = ENV_API_URL ?? "https://platform.onveloz.com";
+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();
+function ensureConfigDir() {
+	if (!existsSync(CONFIG_DIR)) mkdirSync(CONFIG_DIR, { recursive: true });
+}
+function loadConfig$1() {
+	if (!existsSync(CONFIG_FILE$1)) return {
+		apiKey: "",
+		apiUrl: DEFAULT_API_URL
+	};
+	try {
+		const raw = readFileSync(CONFIG_FILE$1, "utf-8");
+		const parsed = JSON.parse(raw);
+		return {
+			apiKey: parsed.apiKey ?? "",
+			apiUrl: ENV_API_URL ?? parsed.apiUrl ?? DEFAULT_API_URL
+		};
+	} catch {
+		return {
+			apiKey: "",
+			apiUrl: DEFAULT_API_URL
+		};
+	}
+}
+function saveConfig$1(config) {
+	ensureConfigDir();
+	const existing = loadConfig$1();
+	const merged = {
+		apiKey: config.apiKey ?? existing.apiKey,
+		apiUrl: config.apiUrl ?? existing.apiUrl
+	};
+	writeFileSync(CONFIG_FILE$1, JSON.stringify(merged, null, 2), "utf-8");
+}
+function deleteConfig() {
+	if (existsSync(CONFIG_FILE$1)) unlinkSync(CONFIG_FILE$1);
+}
+function isAuthenticated() {
+	return loadConfig$1().apiKey.length > 0;
+}
+let envApiUrlLogged = false;
+async function requireAuth() {
+	let config = loadConfig$1();
+	if (!config.apiKey) {
+		await performLogin(config.apiUrl);
+		config = loadConfig$1();
+	}
+	if (ENV_API_URL && !envApiUrlLogged) {
+		envApiUrlLogged = true;
+		console.log(`\n🔧 Usando API: ${ENV_API_URL}\n`);
+	}
+	return config;
+}
+
+//#endregion
+//#region src/lib/utils.ts
+function isRateLimitError(error) {
+	if (!(error instanceof Error)) return null;
+	const orpcError = error;
+	if (orpcError.code === "TOO_MANY_REQUESTS" && orpcError.data?.retryAfterMs) return { retryAfterMs: orpcError.data.retryAfterMs };
+	return null;
+}
+function handleError(error) {
+	if (error instanceof Error) {
+		const orpcError = error;
+		if (orpcError.code) {
+			const message = orpcError.data?.message ?? orpcError.message ?? {
+				NOT_FOUND: "Recurso não encontrado.",
+				FORBIDDEN: "Sem permissão para acessar este recurso.",
+				CONFLICT: "Conflito — recurso já existe.",
+				BAD_REQUEST: "Requisição inválida.",
+				UNAUTHORIZED: "Não autorizado. Execute `veloz login` para autenticar.",
+				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}`));
+			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."));
+			process.exit(1);
+		}
+		console.error(chalk.red(`\n✗ Erro: ${error.message}`));
+		process.exit(1);
+	}
+	console.error(chalk.red("\n✗ Erro inesperado."));
+	process.exit(1);
+}
+function success(message) {
+	console.log(chalk.green(`\n✓ ${message}`));
+}
+function info(message) {
+	console.log(chalk.cyan(`ℹ ${message}`));
+}
+function warn(message) {
+	console.log(chalk.yellow(`⚠ ${message}`));
+}
+function spinner(text) {
+	return ora({
+		text,
+		color: "cyan"
+	}).start();
+}
+function printTable(headers, rows) {
+	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 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("  ");
+		console.log(line);
+	}
+	console.log();
+}
+async function prompt(question) {
+	const rl = createInterface({
+		input: process.stdin,
+		output: process.stdout
+	});
+	return new Promise((resolve$1) => {
+		rl.question(chalk.cyan(`${question} `), (answer) => {
+			rl.close();
+			resolve$1(answer.trim());
+		});
+	});
+}
+async function promptConfirm(question, defaultYes = true) {
+	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) {
+	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):");
+	const index = parseInt(answer, 10) - 1;
+	if (isNaN(index) || index < 0 || index >= options.length) {
+		console.error(chalk.red("Opção inválida."));
+		process.exit(1);
+	}
+	return options[index].value;
+}
+async function promptMultiSelect(question, options) {
+	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`));
+	const answer = await prompt("\nEscolha (números separados por vírgula, ou *):");
+	if (answer.trim() === "*") return options.map((o) => o.value);
+	const indices = answer.split(",").map((s) => parseInt(s.trim(), 10) - 1).filter((i) => !isNaN(i) && i >= 0 && i < options.length);
+	if (indices.length === 0) {
+		console.error(chalk.red("Nenhuma opção válida selecionada."));
+		process.exit(1);
+	}
+	return indices.map((i) => options[i].value);
+}
+
+//#endregion
+//#region src/commands/login.ts
+function openBrowser(url) {
+	const os = platform();
+	exec(os === "darwin" ? `open "${url}"` : os === "win32" ? `start "" "${url}"` : `xdg-open "${url}"`, () => {});
+}
+const CLIENT_ID = "veloz-cli";
+async function performLogin(apiUrl) {
+	const authClient = createAuthClient({
+		baseURL: apiUrl,
+		plugins: [deviceAuthorizationClient()]
+	});
+	const s = spinner("Iniciando autenticação...");
+	try {
+		const { data, error } = await authClient.device.code({ client_id: CLIENT_ID });
+		if (error || !data) {
+			s.fail("Erro ao iniciar autenticação.");
+			process.exit(1);
+		}
+		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);
+		const pollSpinner = spinner("Aguardando autorização no navegador...");
+		const token = await pollForToken(authClient, data.device_code, data.interval || 5);
+		if (!token) {
+			pollSpinner.fail("Tempo esgotado. Execute `veloz login` para tentar novamente.");
+			process.exit(1);
+		}
+		pollSpinner.stop();
+		saveConfig$1({
+			apiKey: token,
+			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);
+	}
+}
+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.");
+		if ((await prompt("Deseja fazer login novamente? (s/N)")).toLowerCase() !== "s") process.exit(0);
+	}
+	const config = loadConfig$1();
+	const apiUrl = opts.apiUrl ?? config.apiUrl;
+	if (opts.apiKey) {
+		saveConfig$1({
+			apiKey: opts.apiKey,
+			apiUrl
+		});
+		success("Autenticado com sucesso!");
+		info("Configuração salva em ~/.veloz/config.json");
+		return;
+	}
+	await performLogin(apiUrl);
+});
+async function pollForToken(authClient, deviceCode, interval) {
+	let pollingInterval = interval;
+	const maxAttempts = Math.ceil(300 / pollingInterval);
+	for (let i = 0; i < maxAttempts; i++) {
+		await new Promise((r) => setTimeout(r, pollingInterval * 1e3));
+		try {
+			const { data, error } = await authClient.device.token({
+				grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+				device_code: deviceCode,
+				client_id: CLIENT_ID
+			});
+			if (data?.access_token) return data.access_token;
+			if (error?.error === "slow_down") pollingInterval += 5;
+			if (error?.error === "expired_token") return null;
+		} catch {
+			continue;
+		}
+	}
+	return null;
+}
+const logoutCommand = new Command("logout").description("Encerrar sessão na plataforma Veloz").action(() => {
+	if (!isAuthenticated()) {
+		warn("Você não está autenticado.");
+		return;
+	}
+	deleteConfig();
+	success("Sessão encerrada com sucesso.");
+});
+
+//#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;
+	}
+}
+/**
+* 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/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.");
+		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.");
+});
+
+//#endregion
+//#region ../../packages/api/src/lib/framework-detector.ts
+const FRAMEWORK_RULES = [
+	{
+		name: "nextjs",
+		label: "Next.js",
+		type: "WEB",
+		match: (deps) => "next" in deps,
+		buildCommand: "npm run build",
+		startCommand: "npm 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
+	},
+	{
+		name: "nuxt",
+		label: "Nuxt",
+		type: "WEB",
+		match: (deps) => "nuxt" in deps,
+		buildCommand: "npm run build",
+		startCommand: "npm start",
+		outputDir: ".nuxt",
+		port: 3e3
+	},
+	{
+		name: "remix",
+		label: "Remix",
+		type: "WEB",
+		match: (deps) => "@remix-run/node" in deps,
+		buildCommand: "npm run build",
+		startCommand: "npm 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
+	},
+	{
+		name: "astro",
+		label: "Astro",
+		type: "STATIC",
+		match: (deps) => "astro" in deps,
+		buildCommand: "npm run build",
+		startCommand: null,
+		outputDir: "dist",
+		port: 3e3
+	},
+	{
+		name: "gatsby",
+		label: "Gatsby",
+		type: "STATIC",
+		match: (deps) => "gatsby" in deps,
+		buildCommand: "npm run 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
+	},
+	{
+		name: "angular",
+		label: "Angular",
+		type: "STATIC",
+		match: (deps) => "@angular/core" in deps,
+		buildCommand: "npm run build",
+		startCommand: null,
+		outputDir: "dist",
+		port: 4200
+	},
+	{
+		name: "express",
+		label: "Express",
+		type: "WEB",
+		match: (deps) => "express" in deps,
+		buildCommand: null,
+		startCommand: "node index.js",
+		outputDir: null,
+		port: 3e3
+	},
+	{
+		name: "fastify",
+		label: "Fastify",
+		type: "WEB",
+		match: (deps) => "fastify" in deps,
+		buildCommand: null,
+		startCommand: "node index.js",
+		outputDir: null,
+		port: 3e3
+	},
+	{
+		name: "nestjs",
+		label: "NestJS",
+		type: "WEB",
+		match: (deps) => "@nestjs/core" in deps,
+		buildCommand: "npm run build",
+		startCommand: "npm run start:prod",
+		outputDir: "dist",
+		port: 3e3
+	},
+	{
+		name: "hono",
+		label: "Hono",
+		type: "WEB",
+		match: (deps) => "hono" in deps || "@hono/node-server" in deps,
+		buildCommand: null,
+		startCommand: "node index.js",
+		outputDir: null,
+		port: 3e3
+	}
+];
+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 ("yarn.lock" in files) return "yarn";
+	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 [];
+	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]);
+			}
+		} else {
+			const pkgPath = base + "/package.json";
+			if (availableFiles.includes(pkgPath)) dirs.add(base);
+		}
+	}
+	return [...dirs];
+}
+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`;
+				}
+			}
+		}
+		apps.push({
+			name,
+			path: dir,
+			framework
+		});
+	}
+	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 {
+		framework,
+		packageManager: pm,
+		envVars,
+		isMonorepo,
+		monorepoApps: apps
+	};
+}
+
+//#endregion
+//#region src/lib/upload.ts
+const DEFAULT_IGNORE = [
+	".git",
+	"node_modules",
+	".env",
+	".env.local",
+	".env.*.local",
+	"dist",
+	"build",
+	".next",
+	".nuxt",
+	".output",
+	"*.log",
+	".DS_Store",
+	"Thumbs.db",
+	".idea",
+	".vscode",
+	".claude",
+	".cursor",
+	".sisyphus",
+	".playwright-mcp",
+	"*.swp",
+	"*.swo"
+];
+async function getIgnorePatterns(directory) {
+	const patterns = [...DEFAULT_IGNORE];
+	try {
+		const gitignoreContent = readFileSync(join(directory, ".gitignore"), "utf-8");
+		patterns.push(...gitignoreContent.split("\n").filter((line) => line.trim() && !line.startsWith("#")));
+	} catch {}
+	try {
+		const velozignoreContent = readFileSync(join(directory, ".velozignore"), "utf-8");
+		patterns.push(...velozignoreContent.split("\n").filter((line) => line.trim() && !line.startsWith("#")));
+	} catch {}
+	return patterns;
+}
+async function getFilesToUpload(directory) {
+	const ignorePatterns = await getIgnorePatterns(directory);
+	const ig = ignore().add(ignorePatterns);
+	const files = [];
+	async function walk(dir) {
+		const entries = await readdir(dir, { withFileTypes: true });
+		for (const entry of entries) {
+			const fullPath = join(dir, entry.name);
+			const relativePath = relative(directory, fullPath);
+			if (ig.ignores(relativePath)) continue;
+			if (entry.name === "node_modules" || entry.name === ".git") continue;
+			if (entry.isDirectory()) await walk(fullPath);
+			else if (entry.isFile()) files.push(fullPath);
+		}
+	}
+	await walk(directory);
+	return files;
+}
+async function createTarball(directory, extraFiles) {
+	const createdFiles = [];
+	if (extraFiles) for (const file of extraFiles) {
+		const filePath = join(directory, file.name);
+		if (!existsSync(filePath)) {
+			writeFileSync(filePath, file.content);
+			createdFiles.push(filePath);
+		}
+	}
+	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({
+			gzip: true,
+			file: tarPath,
+			cwd: directory
+		}, relativePaths);
+		return {
+			path: tarPath,
+			size: statSync(tarPath).size
+		};
+	} finally {
+		for (const f of createdFiles) try {
+			unlinkSync(f);
+		} catch {}
+	}
+}
+async function uploadSource(apiUrl, deploymentId, directory, token, extraFiles) {
+	const { path: tarPath } = await createTarball(directory, extraFiles);
+	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 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 (!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
+		}).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);
+	}
+}
+
+//#endregion
+//#region src/lib/deploy-parallel.ts
+async function withRetry$1(fn, maxRetries = 3) {
+	for (let attempt = 0; attempt <= maxRetries; attempt++) try {
+		return await fn();
+	} catch (error) {
+		if (attempt < maxRetries) {
+			const delay = Math.min(1e3 * Math.pow(2, attempt), 1e4);
+			await new Promise((resolve$1) => setTimeout(resolve$1, delay));
+			continue;
+		}
+		throw error;
+	}
+	throw new Error("Max retries exceeded");
+}
+const statusLabels = {
+	QUEUED: "Na fila",
+	BUILDING: "Construindo",
+	BUILD_FAILED: "Falha na construção",
+	DEPLOYING: "Implantando",
+	LIVE: "Ativo",
+	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("●")
+};
+const TERMINAL_STATUSES = new Set([
+	"LIVE",
+	"BUILD_FAILED",
+	"FAILED",
+	"CANCELLED"
+]);
+function renderProgress(progressMap, prevLineCount) {
+	for (let i = 0; i < prevLineCount; i++) process.stdout.write("\x1B[1A\x1B[2K");
+	let lineCount = 0;
+	for (const [, progress] of progressMap) {
+		const icon = statusIcons[progress.status] || chalk.gray("○");
+		const label = statusLabels[progress.status] || progress.status;
+		process.stdout.write(`${icon} ${chalk.bold(progress.serviceName)}: ${label}\n`);
+		lineCount++;
+		if (progress.status === "BUILDING" || progress.status === "BUILD_FAILED") {
+			if (progress.logLines.length > 0) {
+				const tail = progress.logLines.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`);
+				lineCount++;
+			}
+		} else if (progress.status === "QUEUED") {
+			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"));
+	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));
+			progressMap.set(service.serviceId, {
+				serviceName: service.serviceName,
+				deploymentId: deployment.id,
+				status: "QUEUED",
+				logLines: [],
+				completed: false,
+				success: false
+			});
+			console.log(`${chalk.green("✓")} ${chalk.bold(service.serviceName)}: Upload concluído (${sizeMB} MB)`);
+			return {
+				service,
+				deploymentId: deployment.id
+			};
+		} catch (error) {
+			console.log(`${chalk.red("✗")} ${chalk.bold(service.serviceName)}: Falha ao iniciar deploy`);
+			progressMap.set(service.serviceId, {
+				serviceName: service.serviceName,
+				deploymentId: "",
+				status: "FAILED",
+				logLines: [],
+				completed: true,
+				success: false
+			});
+			throw error;
+		}
+	});
+	const activeDeployments = (await Promise.allSettled(deploymentPromises)).filter((d) => d.status === "fulfilled").map((d) => d.value);
+	if (activeDeployments.length === 0) {
+		console.error(chalk.red("\n✗ Todos os deploys falharam ao iniciar."));
+		return;
+	}
+	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";
+	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);
+				if (!progress) continue;
+				if (event.type === "status") {
+					progress.status = event.content;
+					if (TERMINAL_STATUSES.has(event.content)) {
+						progress.completed = true;
+						progress.success = event.content === "LIVE";
+					}
+					if (isVerbose) console.log(chalk.dim(`\n[verbose] ${service.serviceName}: status mudou para ${event.content}`));
+				} else if (event.type === "log") {
+					const newLines = event.content.split("\n").filter((l) => l.trim());
+					progress.logLines.push(...newLines);
+				}
+				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}`);
+				progress.status = "FAILED";
+				progress.completed = true;
+				lineCount = renderProgress(progressMap, lineCount);
+			}
+		}
+	});
+	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 (successful.length > 0) info("\nUse 'veloz logs -f' para acompanhar os logs de execução.");
+}
+
+//#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 "";
+	}
+}
+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";
+	}
+}
+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
+
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \\
+    CMD wget --quiet --tries=1 --spider http://localhost/ || exit 1
+
+CMD ["nginx", "-g", "daemon off;"]
+`;
+}
+function generateDockerfile(opts) {
+	if (opts.serviceType === "STATIC") return generateStaticDockerfile(opts);
+	return generateWebDockerfile(opts);
+}
+
+//#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.
+*/
+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");
+}
+
+// ── 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");
+}
+
+// ── 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");
+}
+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";
+	return "npm";
+}
+function detectNodeVersion() {
+	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";
+}
+function prepareExtraFiles(detection, serviceConfig) {
+	if (existsSync(resolve(process.cwd(), "Dockerfile"))) return [];
+	const rootDir = serviceConfig?.rootDirectory || ".";
+	const serviceDockerfilePath = resolve(process.cwd(), rootDir, "Dockerfile");
+	if (rootDir !== "." && existsSync(serviceDockerfilePath)) return [{
+		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;
+}
+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 {
+			...svc,
+			extraFiles: prepareExtraFiles(detection, serviceConf)
+		};
+	});
+}
+async function triggerDeploy(serviceId, serviceName) {
+	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 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));
+		spinUpload.stop();
+		success("Deploy iniciado com sucesso!");
+		await streamDeploymentLogs(client, deployment.id, serviceId, serviceName);
+	} catch (error) {
+		spinUpload.stop();
+		handleError(error);
+	}
+}
+async function findServicesFromConfig() {
+	const config = loadConfig();
+	if (!config) return [];
+	const services = [];
+	for (const [key, serviceConfig] of Object.entries(config.services)) services.push({
+		path: resolve(process.cwd(), serviceConfig.root),
+		serviceId: serviceConfig.id,
+		projectId: config.project.id,
+		serviceName: serviceConfig.name,
+		projectName: config.project.name,
+		key
+	});
+	return services;
+}
+function readLocalFile(path) {
+	const fullPath = resolve(process.cwd(), path);
+	if (!existsSync(fullPath)) return null;
+	try {
+		return readFileSync(fullPath, "utf-8");
+	} catch {
+		return null;
+	}
+}
+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();
+}
+function detectLocalRepo(basePath = ".") {
+	const files = {};
+	const pkgJson = readLocalFile(join(basePath, "package.json"));
+	if (pkgJson) files["package.json"] = pkgJson;
+	const envExample = readLocalFile(join(basePath, ".env.example"));
+	if (envExample) files[".env.example"] = envExample;
+	else {
+		const envSample = readLocalFile(join(basePath, ".env.sample"));
+		if (envSample) files[".env.sample"] = envSample;
+		else {
+			const envFile = readLocalFile(join(basePath, ".env"));
+			if (envFile) files[".env"] = envFile;
+		}
+	}
+	const pnpmWs = readLocalFile(join(basePath, "pnpm-workspace.yaml"));
+	if (pnpmWs) files["pnpm-workspace.yaml"] = pnpmWs;
+	for (const lf of [
+		"pnpm-lock.yaml",
+		"yarn.lock",
+		"bun.lock",
+		"bun.lockb",
+		"package-lock.json"
+	]) if (existsSync(resolve(process.cwd(), basePath, lf))) files[lf] = "";
+	const workspacePatterns = [];
+	if (pkgJson) try {
+		const pkg = JSON.parse(pkgJson);
+		if (pkg.workspaces) {
+			const ws = pkg.workspaces;
+			if (Array.isArray(ws)) workspacePatterns.push(...ws);
+			else if (typeof ws === "object" && ws !== null && "packages" in ws && Array.isArray(ws.packages)) workspacePatterns.push(...ws.packages);
+		}
+	} catch {}
+	if (pnpmWs) {
+		const lines = pnpmWs.split("\n");
+		let inPackages = false;
+		for (const line of lines) {
+			if (line.match(/^packages\s*:/)) {
+				inPackages = true;
+				continue;
+			}
+			if (inPackages) {
+				const m = line.match(/^\s+-\s+['"]?([^'"]+)['"]?\s*$/);
+				if (m) workspacePatterns.push(m[1]);
+				else if (line.match(/^\S/)) break;
+			}
+		}
+	}
+	for (const pattern of workspacePatterns) {
+		const hasGlob = /\/?\*\*?$/.test(pattern);
+		const base = pattern.replace(/\/?\*\*?$/, "");
+		if (hasGlob) {
+			const dirPath = resolve(process.cwd(), base);
+			if (!existsSync(dirPath)) continue;
+			try {
+				const entries = readdirSync(dirPath, { withFileTypes: true });
+				for (const entry of entries) if (entry.isDirectory()) {
+					const nestedPkg = readLocalFile(join(basePath, base, entry.name, "package.json"));
+					if (nestedPkg) files[`${base}/${entry.name}/package.json`] = nestedPkg;
+				}
+			} catch {}
+		} else {
+			const nestedPkg = readLocalFile(join(basePath, base, "package.json"));
+			if (nestedPkg) files[`${base}/package.json`] = nestedPkg;
+		}
+	}
+	return analyzeRepo(files);
+}
+async function promptEnvVars(client, 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}`);
+	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;
+	}
+	const filled = Object.keys(vars).length;
+	if (filled > 0) {
+		const spinVars = spinner("Definindo variáveis de ambiente...");
+		await withRetry(() => client.envVars.setBulk({
+			serviceId,
+			vars
+		}));
+		spinVars.stop();
+		success(`${filled} variável(is) definida(s).`);
+	}
+}
+async function createServiceFlow(client, projectId, projectName, repoName) {
+	const branch = getGitBranch();
+	const spinDetect = spinner("Detectando framework...");
+	const detection = detectLocalRepo();
+	spinDetect.stop();
+	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));
+		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,
+				branch,
+				framework: fw$1?.label ?? null,
+				packageManager: pm,
+				buildCommand: fw$1?.buildCommand ?? null,
+				startCommand: fw$1?.startCommand ?? null,
+				outputDir: fw$1?.outputDir ?? null,
+				port: fw$1?.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;
+		}
+		const config = {
+			version: "1.0",
+			project: {
+				id: projectId,
+				name: projectName
+			},
+			services: {},
+			created: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		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",
+				branch,
+				rootDirectory: app.path,
+				buildCommand: fw$1?.buildCommand ?? void 0,
+				startCommand: fw$1?.startCommand ?? void 0,
+				port: fw$1?.port ?? 3e3
+			}));
+			spinService$1.stop();
+			success(`Serviço criado: ${chalk.bold(service$1.name)}`);
+			createdServices.push({
+				service: service$1,
+				app
+			});
+			config.services[app.path] = {
+				id: service$1.id,
+				name: service$1.name,
+				type: (fw$1?.type ?? "web").toLowerCase(),
+				root: app.path,
+				branch,
+				build: fw$1?.buildCommand || fw$1?.outputDir ? {
+					command: fw$1?.buildCommand ?? void 0,
+					outputDir: fw$1?.outputDir ?? void 0
+				} : void 0,
+				runtime: {
+					command: fw$1?.startCommand ?? void 0,
+					port: fw$1?.port ?? 3e3
+				}
+			};
+		}
+		saveConfig(config);
+		info(`Arquivo ${getConfigFileName()} criado na raiz do projeto.`);
+		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);
+		}
+		await deployServicesInParallel(client, 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
+			})
+		})));
+		return createdServices[createdServices.length - 1]?.service.id || "";
+	}
+	const fw = detection.framework;
+	const settings = {
+		name: repoName,
+		type: fw?.type ?? "WEB",
+		rootDir: ".",
+		branch,
+		framework: fw?.label ?? 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)}`);
+	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;
+	}
+	const spinService = spinner("Criando serviço...");
+	const service = await withRetry(() => client.services.create({
+		projectId,
+		name: settings.name,
+		type: settings.type,
+		branch,
+		rootDirectory: settings.rootDir,
+		buildCommand: settings.buildCommand ?? void 0,
+		startCommand: settings.startCommand ?? void 0,
+		port: settings.port
+	}));
+	spinService.stop();
+	success(`Serviço criado: ${chalk.bold(service.name)}`);
+	await promptEnvVars(client, service.id, detection.envVars);
+	saveConfig({
+		version: "1.0",
+		project: {
+			id: projectId,
+			name: projectName
+		},
+		services: { main: {
+			id: service.id,
+			name: service.name,
+			type: settings.type.toLowerCase(),
+			root: settings.rootDir,
+			branch,
+			build: settings.buildCommand || settings.outputDir ? {
+				command: settings.buildCommand ?? void 0,
+				outputDir: settings.outputDir ?? void 0
+			} : void 0,
+			runtime: {
+				command: settings.startCommand ?? void 0,
+				port: settings.port
+			}
+		} },
+		created: (/* @__PURE__ */ new Date()).toISOString()
+	});
+	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) => {
+	if (options.verbose) process.env.VELOZ_VERBOSE = "true";
+	try {
+		await requireAuth();
+		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}`));
+					process.exit(1);
+				}
+				await triggerDeploy(found.serviceId, found.serviceName);
+				return;
+			}
+			if (options.all || configuredServices.length === 1) {
+				if (configuredServices.length > 1) {
+					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) || ".";
+						console.log(`  • ${chalk.bold(service.serviceName)} ${chalk.dim(`(${relPath})`)}`);
+					}
+					console.log();
+					if (!await promptConfirm("Confirmar deploy de todos os serviços?")) {
+						info("Deploy cancelado.");
+						return;
+					}
+				}
+				if (configuredServices.length === 1) await triggerDeploy(configuredServices[0].serviceId, configuredServices[0].serviceName);
+				else {
+					const servicesWithExtraFiles = computeExtraFilesForServices(configuredServices);
+					await deployServicesInParallel(await getClient(), servicesWithExtraFiles);
+				}
+				return;
+			} else {
+				console.log(chalk.bold("\n📦 Serviços disponíveis:\n"));
+				const selectedServiceIds = await promptMultiSelect("Quais serviços deseja fazer deploy?", configuredServices.map((s) => {
+					const relPath = relative(process.cwd(), s.path) || ".";
+					return {
+						label: `${s.serviceName} ${chalk.dim(`(${relPath})`)}`,
+						value: s.serviceId
+					};
+				}));
+				const selectedServices = configuredServices.filter((s) => selectedServiceIds.includes(s.serviceId));
+				if (selectedServices.length === 0) {
+					info("Nenhum serviço selecionado.");
+					return;
+				}
+				if (selectedServices.length === 1) await triggerDeploy(selectedServices[0].serviceId, selectedServices[0].serviceName);
+				else {
+					const servicesWithExtraFiles = computeExtraFilesForServices(selectedServices);
+					await deployServicesInParallel(await getClient(), servicesWithExtraFiles);
+				}
+				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);
+		}
+		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}`));
+		const client = await getClient();
+		const spin = spinner("Buscando projeto...");
+		const project = await withRetry(() => client.projects.findByRepo({
+			githubRepoOwner: remote.owner,
+			githubRepoName: remote.repo
+		}));
+		spin.stop();
+		if (project && project.services.length > 0) {
+			info(`Projeto encontrado: ${chalk.bold(project.name)}`);
+			let serviceId;
+			let serviceName;
+			if (project.services.length === 1) {
+				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})`,
+					value: s.id
+				})));
+				serviceName = project.services.find((s) => s.id === serviceId)?.name ?? "";
+			}
+			const selectedService = project.services.find((s) => s.id === serviceId);
+			saveConfig({
+				version: "1.0",
+				project: {
+					id: project.id,
+					name: project.name
+				},
+				services: { main: {
+					id: serviceId,
+					name: serviceName,
+					type: selectedService?.type?.toLowerCase() ?? "web",
+					root: ".",
+					branch: selectedService?.branch
+				} },
+				created: (/* @__PURE__ */ new Date()).toISOString()
+			});
+			info(`Arquivo ${getConfigFileName()} criado na raiz do projeto.`);
+			await triggerDeploy(serviceId);
+			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));
+			return;
+		}
+		info("Projeto não encontrado. Vamos criar um novo.");
+		const projectName = 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,
+			githubRepoOwner: remote.owner,
+			githubRepoName: remote.repo
+		}));
+		spinProject.stop();
+		success(`Projeto criado: ${chalk.bold(newProject.name)}`);
+		await triggerDeploy(await createServiceFlow(client, newProject.id, newProject.name, remote.repo));
+	} catch (error) {
+		handleError(error);
+	}
+});
+
+//#endregion
+//#region src/lib/service-resolver.ts
+const STATE_FILE = join(homedir(), ".veloz", "state.json");
+function loadState() {
+	if (!existsSync(STATE_FILE)) return { projectDefaults: {} };
+	try {
+		return JSON.parse(readFileSync(STATE_FILE, "utf-8"));
+	} catch {
+		return { projectDefaults: {} };
+	}
+}
+function saveState(state) {
+	const dir = join(homedir(), ".veloz");
+	if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+	writeFileSync(STATE_FILE, JSON.stringify(state, null, 2), "utf-8");
+}
+function getDefaultServiceKey() {
+	const config = loadConfig();
+	if (!config) return null;
+	return loadState().projectDefaults[config.project.id]?.currentService ?? null;
+}
+function setDefaultServiceKey(serviceKey) {
+	const config = requireConfig();
+	const state = loadState();
+	state.projectDefaults[config.project.id] = { currentService: serviceKey };
+	saveState(state);
+}
+const TAG_COLORS = [
+	chalk.cyan,
+	chalk.magenta,
+	chalk.yellow,
+	chalk.green,
+	chalk.blue,
+	chalk.red
+];
+function getServiceTag(name, maxLen, colorIndex) {
+	const color = TAG_COLORS[colorIndex % TAG_COLORS.length];
+	return color(`[${name.padEnd(maxLen)}]`);
+}
+function getServiceHeader(name, colorIndex) {
+	const color = TAG_COLORS[colorIndex % TAG_COLORS.length];
+	return color(`── ${name} ──`);
+}
+function findByFlag(entries, flag) {
+	return entries.find(([key, svc]) => key === flag || svc.name.toLowerCase() === flag.toLowerCase() || svc.id === flag);
+}
+function throwNotFound(flag, entries) {
+	const available = entries.map(([key, svc]) => `  • ${key} (${svc.name})`).join("\n");
+	throw new Error(`Serviço '${flag}' não encontrado.\n\nServiços disponíveis:\n${available}`);
+}
+/**
+* Resolution order:
+*  1. Explicit `--service` flag  → match by key, name, or id
+*  2. Single service in config   → auto-select (zero friction)
+*  3. Default from `veloz use`   → remembered choice
+*  4. Interactive prompt          → last resort
+*/
+async function resolveService(serviceFlag) {
+	const config = requireConfig();
+	const entries = Object.entries(config.services);
+	if (entries.length === 0) throw new Error("Nenhum serviço encontrado na configuração. Execute 'veloz deploy' para criar um.");
+	if (serviceFlag) {
+		const found = findByFlag(entries, serviceFlag);
+		if (!found) throwNotFound(serviceFlag, entries);
+		const [key, service] = found;
+		return {
+			key,
+			service: mergeServiceWithDefaults(service, config.defaults),
+			config
+		};
+	}
+	if (entries.length === 1) {
+		const [key, service] = entries[0];
+		return {
+			key,
+			service: mergeServiceWithDefaults(service, config.defaults),
+			config
+		};
+	}
+	const defaultKey = getDefaultServiceKey();
+	if (defaultKey && config.services[defaultKey]) {
+		const service = config.services[defaultKey];
+		return {
+			key: defaultKey,
+			service: mergeServiceWithDefaults(service, config.defaults),
+			config
+		};
+	}
+	const selectedKey = await promptSelect("Qual serviço?", entries.map(([key, svc]) => ({
+		label: `${svc.name} (${key})`,
+		value: key
+	})));
+	return {
+		key: selectedKey,
+		service: mergeServiceWithDefaults(config.services[selectedKey], config.defaults),
+		config
+	};
+}
+async function resolveServiceId(serviceFlag) {
+	const { service } = await resolveService(serviceFlag);
+	return service.id;
+}
+function resolveAllServices(serviceFlag) {
+	const config = requireConfig();
+	const entries = Object.entries(config.services);
+	if (entries.length === 0) throw new Error("Nenhum serviço encontrado na configuração. Execute 'veloz deploy' para criar um.");
+	if (serviceFlag) {
+		const found = findByFlag(entries, serviceFlag);
+		if (!found) throwNotFound(serviceFlag, entries);
+		const [key, raw] = found;
+		const service = mergeServiceWithDefaults(raw, config.defaults);
+		return {
+			services: [{
+				key,
+				service,
+				index: 0
+			}],
+			config,
+			maxNameLen: service.name.length
+		};
+	}
+	const services = entries.map(([key, raw], index) => ({
+		key,
+		service: mergeServiceWithDefaults(raw, config.defaults),
+		index
+	}));
+	return {
+		services,
+		config,
+		maxNameLen: Math.max(...services.map((s) => s.service.name.length))
+	};
+}
+
+//#endregion
+//#region src/commands/logs.ts
+function formatTime(timestamp) {
+	return chalk.dim(new Date(timestamp).toLocaleTimeString("pt-BR"));
+}
+async function streamFollow(client, services, maxNameLen, tailLines) {
+	const showTags = services.length > 1;
+	const streams = services.map(async ({ service, index }) => {
+		const tag = showTags ? `${getServiceTag(service.name, maxNameLen, index)} ` : "";
+		try {
+			const stream = await client.logs.streamRuntime({
+				serviceId: service.id,
+				tailLines: Math.ceil(tailLines / services.length)
+			});
+			for await (const entry of stream) console.log(`${tag}${formatTime(entry.timestamp)} ${entry.message}`);
+		} catch {
+			console.log(`${tag}${chalk.red("Erro ao conectar ao stream de logs")}`);
+		}
+	});
+	await Promise.allSettled(streams);
+}
+async function fetchRecent(client, services, maxNameLen, tailLines) {
+	const showTags = services.length > 1;
+	const allEntries = (await Promise.allSettled(services.map(async ({ service, index }) => {
+		return (await client.logs.getRecent({
+			serviceId: service.id,
+			tailLines
+		})).map((e) => ({
+			...e,
+			serviceIndex: index,
+			serviceName: service.name
+		}));
+	}))).filter((r) => r.status === "fulfilled").flatMap((r) => r.value).sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+	if (allEntries.length === 0) {
+		info("Nenhum log encontrado.");
+		return;
+	}
+	console.log();
+	for (const entry of allEntries) {
+		const tag = showTags ? `${getServiceTag(entry.serviceName, maxNameLen, entry.serviceIndex)} ` : "";
+		console.log(`${tag}${formatTime(entry.timestamp)} ${entry.message}`);
+	}
+	console.log();
+	info(`Mostrando ${allEntries.length} linha(s). Use ${chalk.bold("--follow")} para acompanhar em tempo real.`);
+}
+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);
+		} else {
+			spin.stop();
+			await fetchRecent(client, services, maxNameLen, tailLines);
+		}
+	} catch (error) {
+		spin.stop();
+		handleError(error);
+	}
+});
+
+//#endregion
+//#region src/commands/env.ts
+const envCommand = new Command("env").description("Gerenciar variáveis de ambiente");
+envCommand.command("list").alias("listar").description("Listar variáveis de ambiente").option("--service <service>", "Filtrar por serviço (chave ou nome)").action(async (opts) => {
+	const spin = spinner("Carregando variáveis de ambiente...");
+	try {
+		const { services } = resolveAllServices(opts.service);
+		const client = await getClient();
+		const showHeaders = services.length > 1;
+		let totalVars = 0;
+		for (const { service, index } of services) {
+			const envVars = await client.envVars.list({ serviceId: service.id });
+			totalVars += envVars.length;
+			if (showHeaders) console.log(`\n${getServiceHeader(service.name, index)}`);
+			if (envVars.length === 0) {
+				info("Nenhuma variável de ambiente configurada.");
+				continue;
+			}
+			printTable([
+				"Chave",
+				"Valor (mascarado)",
+				"Atualizado em"
+			], envVars.map((v) => [
+				chalk.bold(v.key),
+				chalk.dim(v.maskedValue),
+				new Date(v.updatedAt).toLocaleDateString("pt-BR")
+			]));
+		}
+		spin.stop();
+		if (totalVars === 0 && !showHeaders) info("Nenhuma variável de ambiente configurada.");
+	} catch (error) {
+		spin.stop();
+		handleError(error);
+	}
+});
+envCommand.command("set <pares...>").description("Definir variável de ambiente (formato: CHAVE=VALOR)").option("--service <service>", "Serviço alvo (chave ou nome)").action(async (pares, opts) => {
+	const spin = spinner("Salvando variáveis de ambiente...");
+	try {
+		const serviceId = await resolveServiceId(opts.service);
+		const client = await getClient();
+		for (const par of pares) {
+			const eqIndex = par.indexOf("=");
+			if (eqIndex === -1) {
+				spin.stop();
+				console.error(chalk.red(`\n✗ Formato inválido: "${par}". Use CHAVE=VALOR.`));
+				process.exit(1);
+			}
+			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);
+			}
+			await client.envVars.set({
+				serviceId,
+				key,
+				value
+			});
+		}
+		spin.stop();
+		if (pares.length === 1) {
+			const key = pares[0].slice(0, pares[0].indexOf("="));
+			success(`Variável ${chalk.bold(key)} definida com sucesso.`);
+		} else success(`${pares.length} variáveis definidas com sucesso.`);
+		info("Faça um novo deploy para aplicar as alterações.");
+	} catch (error) {
+		spin.stop();
+		handleError(error);
+	}
+});
+envCommand.command("delete <chave>").alias("deletar").description("Remover variável de ambiente").option("--service <service>", "Serviço alvo (chave ou nome)").action(async (chave, opts) => {
+	const spin = spinner("Removendo variável de ambiente...");
+	try {
+		const serviceId = await resolveServiceId(opts.service);
+		await (await getClient()).envVars.delete({
+			serviceId,
+			key: chave
+		});
+		spin.stop();
+		success(`Variável ${chalk.bold(chave)} removida com sucesso.`);
+		info("Faça um novo deploy para aplicar as alterações.");
+	} catch (error) {
+		spin.stop();
+		handleError(error);
+	}
+});
+envCommand.command("import [arquivo]").description("Importar variáveis de ambiente de um arquivo .env ou colar diretamente").option("-r, --replace", "Substituir todas as variáveis existentes").option("--service <service>", "Serviço alvo (chave ou nome)").action(async (arquivo, options) => {
+	try {
+		const serviceId = await resolveServiceId(options.service);
+		const client = await getClient();
+		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);
+			}
+			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
+			});
+			const lines$1 = [];
+			await new Promise((resolve$1) => {
+				rl.on("line", (line) => {
+					lines$1.push(line);
+				});
+				rl.on("close", () => {
+					resolve$1();
+				});
+			});
+			envContent = lines$1.join("\n");
+		}
+		const envVars = {};
+		const lines = envContent.split("\n");
+		for (const line of lines) {
+			const trimmed = line.trim();
+			if (!trimmed || trimmed.startsWith("#")) continue;
+			const eqIndex = trimmed.indexOf("=");
+			if (eqIndex === -1) continue;
+			let 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, "\\");
+			envVars[key] = value;
+		}
+		const varsCount = Object.keys(envVars).length;
+		if (varsCount === 0) {
+			console.error(chalk.yellow("⚠ Nenhuma variável válida encontrada."));
+			return;
+		}
+		console.log(chalk.bold("\n📝 Variáveis a serem importadas:\n"));
+		for (const [key, value] of Object.entries(envVars)) {
+			const maskedValue = value.length > 20 ? value.slice(0, 20) + "..." : value;
+			console.log(`  ${chalk.green(key)}=${chalk.dim(maskedValue)}`);
+		}
+		console.log();
+		if (options.replace) console.log(chalk.yellow("⚠ Modo de substituição: TODAS as variáveis existentes serão removidas!\n"));
+		if (!await promptConfirm(`Importar ${varsCount} variável(is) de ambiente?`)) {
+			info("Importação cancelada.");
+			return;
+		}
+		const spin = spinner("Importando variáveis de ambiente...");
+		try {
+			if (options.replace) {
+				const existingVars = await client.envVars.list({ serviceId });
+				for (const envVar of existingVars) await client.envVars.delete({
+					serviceId,
+					key: envVar.key
+				});
+			}
+			await client.envVars.setBulk({
+				serviceId,
+				vars: envVars
+			});
+			spin.stop();
+			success(`${varsCount} variável(is) importada(s) com sucesso!`);
+			info("Faça um novo deploy para aplicar as alterações.");
+		} catch (error) {
+			spin.stop();
+			throw error;
+		}
+	} catch (error) {
+		handleError(error);
+	}
+});
+envCommand.command("export [arquivo]").description("Exportar variáveis de ambiente para um arquivo .env").option("--service <service>", "Serviço alvo (chave ou nome)").action(async (arquivo, opts) => {
+	const spin = spinner("Carregando variáveis de ambiente...");
+	try {
+		const serviceId = await resolveServiceId(opts.service);
+		const envVars = await (await getClient()).envVars.list({ serviceId });
+		spin.stop();
+		if (envVars.length === 0) {
+			info("Nenhuma variável de ambiente para exportar.");
+			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();
+		}
+	} catch (error) {
+		spin.stop();
+		handleError(error);
+	}
+});
+
+//#endregion
+//#region src/commands/domains.ts
+const tlsStatusLabels = {
+	PENDING: "Pendente",
+	PROVISIONING: "Provisionando",
+	ACTIVE: "Ativo",
+	FAILED: "Falhou"
+};
+const domainsCommand = new Command("domains").alias("dominios").description("Gerenciar domínios personalizados");
+domainsCommand.command("list").alias("listar").description("Listar domínios dos serviços").option("--service <service>", "Filtrar por serviço (chave ou nome)").action(async (opts) => {
+	const spin = spinner("Carregando domínios...");
+	try {
+		const { services } = resolveAllServices(opts.service);
+		const client = await getClient();
+		const showHeaders = services.length > 1;
+		let totalDomains = 0;
+		for (const { service, index } of services) {
+			const domains = await client.domains.list({ serviceId: service.id });
+			totalDomains += domains.length;
+			if (showHeaders) console.log(`\n${getServiceHeader(service.name, index)}`);
+			if (domains.length === 0) {
+				info("Nenhum domínio configurado.");
+				continue;
+			}
+			printTable([
+				"ID",
+				"Domínio",
+				"Verificado",
+				"TLS",
+				"Tipo"
+			], domains.map((d) => [
+				d.id.slice(0, 8),
+				chalk.bold(d.domain),
+				d.verified ? chalk.green("✓ Sim") : chalk.yellow("✗ Não"),
+				tlsStatusLabels[d.tlsStatus] ?? d.tlsStatus,
+				d.isAutoGenerated ? "Auto" : "Personalizado"
+			]));
+		}
+		spin.stop();
+		if (totalDomains === 0 && !showHeaders) info("Nenhum domínio configurado.");
+	} catch (error) {
+		spin.stop();
+		handleError(error);
+	}
+});
+domainsCommand.command("add <dominio>").alias("adicionar").description("Adicionar domínio personalizado").option("--service <service>", "Serviço alvo (chave ou nome)").action(async (dominio, opts) => {
+	const spin = spinner("Adicionando domínio...");
+	try {
+		const serviceId = await resolveServiceId(opts.service);
+		const result = await (await getClient()).domains.add({
+			serviceId,
+			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)}`)}`);
+	} catch (error) {
+		spin.stop();
+		handleError(error);
+	}
+});
+domainsCommand.command("verify <domainId>").alias("verificar").description("Verificar configuração DNS de um domínio").action(async (domainId) => {
+	const spin = spinner("Verificando DNS...");
+	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.");
+		}
+	} catch (error) {
+		spin.stop();
+		handleError(error);
+	}
+});
+domainsCommand.command("delete <domainId>").alias("deletar").description("Remover domínio").action(async (domainId) => {
+	const spin = spinner("Removendo domínio...");
+	try {
+		await (await getClient()).domains.delete({ domainId });
+		spin.stop();
+		success("Domínio removido com sucesso.");
+	} catch (error) {
+		spin.stop();
+		handleError(error);
+	}
+});
+
+//#endregion
+//#region src/commands/config.ts
+function formatValue(value) {
+	if (value === null || value === void 0 || value === "") return chalk.dim("—");
+	return chalk.cyan(String(value));
+}
+function printServiceConfig(service) {
+	console.log(`  ${chalk.bold("Nome:")}           ${formatValue(service.name)}`);
+	console.log(`  ${chalk.bold("Tipo:")}           ${formatValue(service.type === "WEB" ? "Serviço Web" : "Site Estático")}`);
+	console.log(`  ${chalk.bold("Branch:")}         ${formatValue(service.branch)}`);
+	console.log(`  ${chalk.bold("Root Dir:")}       ${formatValue(service.rootDirectory || "/")}`);
+	console.log(`  ${chalk.bold("Build Command:")}  ${formatValue(service.buildCommand)}`);
+	console.log(`  ${chalk.bold("Start Command:")}  ${formatValue(service.startCommand)}`);
+	console.log(`  ${chalk.bold("Porta:")}          ${formatValue(service.port)}`);
+	console.log(`  ${chalk.bold("Instâncias:")}     ${formatValue(service.instanceCount)}`);
+	console.log(`  ${chalk.bold("CPU Limit:")}      ${formatValue(service.cpuLimit)}`);
+	console.log(`  ${chalk.bold("Memory Limit:")}   ${formatValue(service.memoryLimit)}`);
+}
+const configCommand = new Command("config").description("Gerenciar configurações do serviço");
+configCommand.command("show").description("Mostrar configurações atuais dos serviços").option("--service <service>", "Filtrar por serviço (chave ou nome)").action(async (opts) => {
+	try {
+		const { services } = resolveAllServices(opts.service);
+		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();
+		}
+		spin.stop();
+	} catch (error) {
+		handleError(error);
+	}
+});
+configCommand.command("set").description("Atualizar configurações do serviço").option("-n, --name <name>", "Nome do serviço").option("-b, --build <command>", "Comando de build").option("-s, --start <command>", "Comando de start").option("-p, --port <port>", "Porta do serviço").option("-r, --root <dir>", "Diretório raiz").option("-i, --instances <count>", "Número de instâncias").option("--cpu <limit>", "Limite de CPU (ex: 500m, 1)").option("--memory <limit>", "Limite de memória (ex: 512Mi, 1Gi)").option("--branch <branch>", "Branch do Git").option("--service <service>", "Serviço alvo (chave ou nome)").action(async (options) => {
+	try {
+		const serviceId = await resolveServiceId(options.service);
+		const client = await getClient();
+		const updates = {};
+		if (options.name) updates.name = options.name;
+		if (options.build !== void 0) updates.buildCommand = options.build === "none" ? null : options.build;
+		if (options.start !== void 0) updates.startCommand = options.start === "none" ? null : options.start;
+		if (options.port) updates.port = parseInt(options.port, 10);
+		if (options.root !== void 0) updates.rootDirectory = options.root === "/" ? null : options.root;
+		if (options.instances) updates.instanceCount = parseInt(options.instances, 10);
+		if (options.cpu) updates.cpuLimit = options.cpu;
+		if (options.memory) updates.memoryLimit = options.memory;
+		if (options.branch) updates.branch = options.branch;
+		if (Object.keys(updates).length === 0) {
+			console.error(chalk.yellow("⚠ Nenhuma configuração fornecida para atualizar."));
+			console.log(chalk.dim("\nUse 'veloz config set --help' para ver as opções disponíveis."));
+			return;
+		}
+		const spin = spinner("Atualizando configurações...");
+		await client.services.update({
+			serviceId,
+			...updates
+		});
+		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.");
+	} catch (error) {
+		handleError(error);
+	}
+});
+configCommand.command("edit").description("Editar configurações interativamente").option("--service <service>", "Serviço alvo (chave ou nome)").action(async (opts) => {
+	try {
+		const serviceId = await resolveServiceId(opts.service);
+		const client = await getClient();
+		const spin = spinner("Buscando configurações atuais...");
+		const service = await client.services.get({ serviceId });
+		spin.stop();
+		console.log(chalk.bold("\n📝 Editar Configurações\n"));
+		console.log(chalk.dim("Pressione Enter para manter o valor atual, digite 'none' para remover\n"));
+		const updates = {};
+		const name = await prompt(`Nome do serviço ${chalk.dim(`(${service.name})`)}: `);
+		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 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 || "/"})`)}: `);
+		if (rootDir) updates.rootDirectory = rootDir === "/" ? null : rootDir;
+		const instances = await prompt(`Número de instâncias ${chalk.dim(`(${service.instanceCount})`)}: `);
+		if (instances) updates.instanceCount = parseInt(instances, 10);
+		const cpu = await prompt(`Limite de CPU ${chalk.dim(`(${service.cpuLimit})`)}: `);
+		if (cpu) updates.cpuLimit = cpu;
+		const memory = await prompt(`Limite de memória ${chalk.dim(`(${service.memoryLimit})`)}: `);
+		if (memory) updates.memoryLimit = memory;
+		if (Object.keys(updates).length === 0) {
+			info("Nenhuma alteração realizada.");
+			return;
+		}
+		const updateSpin = spinner("Salvando configurações...");
+		await client.services.update({
+			serviceId,
+			...updates
+		});
+		updateSpin.stop();
+		success("Configurações atualizadas com sucesso!");
+		info("Execute 'veloz deploy' para aplicar as mudanças.");
+	} catch (error) {
+		handleError(error);
+	}
+});
+configCommand.command("reset").description("Resetar configurações para os padrões").option("--build", "Resetar comando de build").option("--start", "Resetar comando de start").option("--all", "Resetar todas as configurações opcionais").option("--service <service>", "Serviço alvo (chave ou nome)").action(async (options) => {
+	try {
+		const serviceId = await resolveServiceId(options.service);
+		const client = await getClient();
+		const updates = {};
+		if (options.all) {
+			updates.buildCommand = null;
+			updates.startCommand = null;
+			updates.rootDirectory = null;
+		} else {
+			if (options.build) updates.buildCommand = null;
+			if (options.start) updates.startCommand = null;
+		}
+		if (Object.keys(updates).length === 0) {
+			console.error(chalk.yellow("⚠ Especifique o que resetar: --build, --start, ou --all"));
+			return;
+		}
+		const spin = spinner("Resetando configurações...");
+		await client.services.update({
+			serviceId,
+			...updates
+		});
+		spin.stop();
+		success("Configurações resetadas para os padrões!");
+		info("Execute 'veloz deploy' para aplicar as mudanças.");
+	} catch (error) {
+		handleError(error);
+	}
+});
+
+//#endregion
+//#region src/commands/use.ts
+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);
+		}
+		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 === 1) {
+			info("Apenas um serviço configurado — já é o padrão.");
+			return;
+		}
+		const currentDefault = getDefaultServiceKey();
+		let selectedKey;
+		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);
+			}
+			selectedKey = found[0];
+		} else selectedKey = await promptSelect("Qual serviço usar como padrão?", services.map(([key, service]) => ({
+			label: `${service.name} (${key})${key === currentDefault ? chalk.cyan(" ← atual") : ""}`,
+			value: key
+		})));
+		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.`));
+	} catch (error) {
+		handleError(error);
+	}
+});
+
+//#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");
+program.addCommand(loginCommand);
+program.addCommand(logoutCommand);
+program.addCommand(projectsCommand);
+program.addCommand(linkCommand);
+program.addCommand(deployCommand);
+program.addCommand(logsCommand);
+program.addCommand(envCommand);
+program.addCommand(domainsCommand);
+program.addCommand(configCommand);
+program.addCommand(useCommand);
+program.parse();
+
+//#endregion
+export {  };