onveloz 0.0.0-beta.4 → 0.0.0-beta.6

package/dist/index.mjs

@@ -307,44 +307,6 @@ function createClient(baseUrl, headers) {
 	}));
 }
 
-//#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"]);
@@ -357,10 +319,12 @@ const PackageManagerSchema = z.enum([
 ]);
 const BuildConfigSchema = z.object({
 	command: z.string().nullable().optional(),
-	nodeVersion: z.string().regex(/^[0-9]+(\.x)?$/).default("20").optional(),
+	nodeVersion: z.string().regex(/^[0-9]+(\.[0-9]+){0,2}(\.x)?$/).default("20").optional(),
+	nixpkgsArchive: z.string().regex(/^[a-f0-9]{40}$/).optional(),
 	packageManager: PackageManagerSchema.default("auto").optional(),
 	installCommand: z.string().nullable().optional(),
-	outputDir: z.string().nullable().optional()
+	outputDir: z.string().nullable().optional(),
+	aptPackages: z.array(z.string().regex(/^[a-z0-9][a-z0-9.+\-]+$/, "Nome de pacote inválido")).optional()
 });
 const RuntimeConfigSchema = z.object({
 	command: z.string().nullable().optional(),
@@ -498,7 +462,7 @@ function loadConfig() {
 function saveConfig(config) {
 	const path = getConfigPath();
 	const configWithSchema = {
-		$schema: "https://veloz.app/schemas/veloz-config.schema.json",
+		$schema: "https://onveloz.com/schemas/veloz-config.schema.json",
 		...config
 	};
 	writeFileSync(path, JSON.stringify(configWithSchema, null, 2), "utf-8");
@@ -554,6 +518,49 @@ function getGitBranch() {
 	}
 }
 
+//#endregion
+//#region src/lib/client.ts
+async function getClient() {
+	const authConfig = await requireAuth();
+	const projectConfig = loadConfig();
+	return createClient(authConfig.apiUrl, () => {
+		const headers = { Authorization: `Bearer ${authConfig.apiKey}` };
+		if (projectConfig?.project?.id) headers["X-Project-Id"] = projectConfig.project.id;
+		return headers;
+	});
+}
+
+//#endregion
+//#region src/commands/projects.ts
+const projectsCommand = new Command("projects").alias("projetos").description("Gerenciar projetos");
+projectsCommand.command("list").alias("listar").description("Listar todos os projetos").action(async () => {
+	const spin = spinner("Carregando projetos...");
+	try {
+		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 src/commands/link.ts
 const linkCommand = new Command("link").description("Verificar vínculo do projeto com Veloz").action(async () => {
@@ -741,7 +748,7 @@ const FRAMEWORK_RULES = [
 		port: 3e3
 	}
 ];
-function detectPackageManager$1(files) {
+function detectPackageManager(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";
@@ -939,7 +946,7 @@ function detectMonorepo(files, pm = "npm") {
 	};
 }
 function analyzeRepo(files) {
-	const pm = detectPackageManager$1(files);
+	const pm = detectPackageManager(files);
 	const framework = detectFramework(files["package.json"], pm);
 	const envVars = detectEnvVars(files);
 	const { isMonorepo, apps } = detectMonorepo(files, pm);
@@ -1090,8 +1097,8 @@ async function calculateDirectorySize(directory) {
 }
 
 //#endregion
-//#region src/lib/deploy-stream.ts
-const statusLabels$1 = {
+//#region src/lib/deploy-constants.ts
+const statusLabels = {
 	QUEUED: "Na fila",
 	BUILDING: "Construindo",
 	BUILD_FAILED: "Falha na construção",
@@ -1100,12 +1107,24 @@ const statusLabels$1 = {
 	FAILED: "Falhou",
 	CANCELLED: "Cancelado"
 };
-const TERMINAL_STATUSES$1 = new Set([
+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"
 ]);
+
+//#endregion
+//#region src/lib/deploy-stream.ts
 async function streamDeploymentLogs(deploymentId, serviceName) {
 	const client = await getClient();
 	const isVerbose = process.env.VELOZ_VERBOSE === "true";
@@ -1120,8 +1139,8 @@ async function streamDeploymentLogs(deploymentId, serviceName) {
 		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("●");
+				const label = statusLabels[event.content] ?? event.content;
+				const icon = statusIcons[event.content] ?? 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}`));
@@ -1149,52 +1168,60 @@ async function streamDeploymentLogs(deploymentId, serviceName) {
 	}
 	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}`;
+	else if (TERMINAL_STATUSES.has(finalStatus)) {
+		const errorMsg = serviceName ? `✗ Deploy de ${chalk.bold(serviceName)} finalizou com status: ${statusLabels[finalStatus] ?? finalStatus}` : `✗ Deploy finalizou com status: ${statusLabels[finalStatus] ?? finalStatus}`;
 		console.error(chalk.red(errorMsg));
-		if (!serviceName) process.exit(1);
+		process.exit(1);
 	}
 }
 
 //#endregion
-//#region src/lib/deploy-parallel.ts
-async function withRetry$1(fn, maxRetries = 3) {
+//#region src/lib/retry.ts
+async function withRetry(fn, maxRetries = 3) {
 	for (let attempt = 0; attempt <= maxRetries; attempt++) try {
 		return await fn();
 	} catch (error) {
-		if (attempt < maxRetries) {
+		if (attempt >= maxRetries) throw error;
+		const rateLimit = isRateLimitError(error);
+		if (rateLimit) {
+			const waitMs = Math.min(rateLimit.retryAfterMs, 3e4);
+			await new Promise((r) => setTimeout(r, waitMs));
+		} else {
 			const delay = Math.min(1e3 * Math.pow(2, attempt), 1e4);
-			await new Promise((resolve$1) => setTimeout(resolve$1, delay));
-			continue;
+			await new Promise((r) => setTimeout(r, delay));
 		}
-		throw error;
 	}
 	throw new Error("Max retries exceeded");
 }
-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"
-]);
+
+//#endregion
+//#region src/lib/deploy-cancel.ts
+const activeDeploymentIds = /* @__PURE__ */ new Set();
+let sigintHandlerRegistered = false;
+function trackDeployment(deploymentId) {
+	activeDeploymentIds.add(deploymentId);
+}
+function untrackDeployment(deploymentId) {
+	activeDeploymentIds.delete(deploymentId);
+}
+function setupSigintHandler() {
+	if (sigintHandlerRegistered) return;
+	sigintHandlerRegistered = true;
+	process.on("SIGINT", async () => {
+		if (activeDeploymentIds.size === 0) process.exit(130);
+		console.log(chalk.yellow("\n\nCancelando deploy(s)..."));
+		try {
+			const client = await getClient();
+			const cancelPromises = Array.from(activeDeploymentIds).map((deploymentId) => client.deployments.cancel({ deploymentId }).catch(() => {}));
+			await Promise.all(cancelPromises);
+			console.log(chalk.yellow("Deploy cancelado."));
+		} catch {}
+		process.exit(130);
+	});
+}
+
+//#endregion
+//#region src/lib/deploy-parallel.ts
 function renderProgress(progressMap, prevLineCount) {
 	for (let i = 0; i < prevLineCount; i++) process.stdout.write("\x1B[1A\x1B[2K");
 	let lineCount = 0;
@@ -1225,14 +1252,16 @@ function renderProgress(progressMap, prevLineCount) {
 async function deployServicesInParallel(services) {
 	const client = await getClient();
 	console.log(chalk.cyan("\n🚀 Iniciando deploy paralelo de múltiplos serviços...\n"));
+	setupSigintHandler();
 	const progressMap = /* @__PURE__ */ new Map();
 	const projectRoot = process.cwd();
 	const sizeInBytes = await calculateDirectorySize(projectRoot);
 	const sizeMB = Math.round(sizeInBytes / (1024 * 1024) * 10) / 10;
 	const deploymentPromises = services.map(async (service) => {
 		try {
-			const deployment = await withRetry$1(() => client.deployments.create({ serviceId: service.serviceId }));
-			await withRetry$1(() => uploadSource(deployment.id, projectRoot, service.extraFiles));
+			const deployment = await withRetry(() => client.deployments.create({ serviceId: service.serviceId }));
+			await withRetry(() => uploadSource(deployment.id, projectRoot, service.extraFiles));
+			trackDeployment(deployment.id);
 			progressMap.set(service.serviceId, {
 				serviceName: service.serviceName,
 				deploymentId: deployment.id,
@@ -1262,7 +1291,7 @@ async function deployServicesInParallel(services) {
 	const activeDeployments = (await Promise.allSettled(deploymentPromises)).filter((d) => d.status === "fulfilled").map((d) => d.value);
 	if (activeDeployments.length === 0) {
 		console.error(chalk.red("\n✗ Todos os deploys falharam ao iniciar."));
-		return;
+		process.exit(1);
 	}
 	console.log(chalk.cyan("\n📦 Monitorando progresso dos deploys:\n"));
 	console.log(chalk.dim("─".repeat(60)) + "\n");
@@ -1299,6 +1328,8 @@ async function deployServicesInParallel(services) {
 				progress.completed = true;
 				lineCount = renderProgress(progressMap, lineCount);
 			}
+		} finally {
+			untrackDeployment(deploymentId);
 		}
 	});
 	await Promise.all(streamPromises);
@@ -1323,451 +1354,474 @@ async function deployServicesInParallel(services) {
 		}
 	}
 	if (successful.length > 0) info("\nUse 'veloz logs -f' para acompanhar os logs de execução.");
+	if (failed.length > 0) process.exit(1);
 }
 
 //#endregion
-//#region src/lib/dockerfile-generator.ts
-function pmSetupInstructions(pm) {
-	switch (pm) {
-		case "pnpm": return "RUN corepack enable && corepack prepare pnpm@latest --activate";
-		case "yarn": return "RUN corepack enable";
-		case "bun": return "RUN apk add --no-cache bash curl && curl -fsSL https://bun.sh/install | bash && ln -s /root/.bun/bin/bun /usr/local/bin/bun";
-		case "npm": return "";
-	}
-}
-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";
+//#region src/lib/deploy-config.ts
+function resolveServiceConf(velozConfig, serviceId) {
+	if (!velozConfig) return void 0;
+	for (const [, conf] of Object.entries(velozConfig.services)) if (conf.id === serviceId) {
+		const merged = mergeServiceWithDefaults(conf, velozConfig.defaults);
+		return {
+			type: merged.type,
+			buildCommand: merged.build?.command ?? void 0,
+			startCommand: merged.runtime?.command ?? void 0,
+			port: merged.runtime?.port ?? void 0,
+			rootDirectory: merged.root,
+			outputDir: merged.build?.outputDir ?? void 0,
+			instanceCount: merged.resources?.instances ?? void 0,
+			cpuLimit: merged.resources?.cpu ?? void 0,
+			memoryLimit: merged.resources?.memory ?? void 0,
+			healthCheckPath: merged.runtime?.healthCheck?.path ?? null,
+			aptPackages: merged.build?.aptPackages ?? void 0
+		};
 	}
 }
-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(/^\//, "") : "";
-	if (pm === "pnpm" && hasRoot) {
-		const workdirPrefix$1 = `cd ${cleanRoot} && `;
-		const defaultStart$1 = `${pm} run start`;
-		const finalStart$1 = startCommand || defaultStart$1;
-		return `# ── Stage 1: Install & Build ────────────────────────────
-FROM node:${nodeVersion}-alpine AS builder
-
-WORKDIR /app
-
-${setup}
-
-# Copy full monorepo source
-COPY . .
-
-# Install all dependencies
-RUN ${installCommand(pm)}
-
-# 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$1}${buildCommand}
-
-# ── Stage 2: Production runner ─────────────────────────
-FROM node:${nodeVersion}-alpine
-
-WORKDIR /app
-
-${setup}
-
-# 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 ["sh", "-c", "${workdirPrefix$1}${finalStart$1}"]
-`;
-	}
-	const depsCopy = hasRoot ? [`COPY package.json ${lockfiles.join(" ")} ./`, `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 isPnpmMonorepo = pm === "pnpm" && hasRoot;
-	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)";
-	const installSection = isPnpmMonorepo ? [
-		`# Copy full monorepo source`,
-		`COPY . .`,
-		``,
-		`# Install all dependencies`,
-		`RUN ${installCommand(pm)}`
-	].join("\n") : [
-		`# Install dependencies (cached layer)`,
-		...hasRoot ? [`COPY package.json ${lockfiles.join(" ")} ./`, `COPY ${cleanRoot}/package.json ./${cleanRoot}/`] : [`COPY package.json ${lockfiles.join(" ")} ./`],
-		`RUN ${installCommand(pm)}`,
-		``,
-		`# Copy full source`,
-		`COPY . .`
-	].join("\n");
-	return `# ── Stage 1: Build ──────────────────────────────────────
-FROM node:${nodeVersion}-alpine AS builder
-
-WORKDIR /app
-${setup ? "\n" + setup + "\n" : ""}
-${installSection}
-
-# 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);
+async function syncServiceConfig(client, serviceId, conf) {
+	await withRetry(() => client.services.update({
+		serviceId,
+		port: conf.port,
+		instanceCount: conf.instanceCount,
+		cpuLimit: conf.cpuLimit,
+		memoryLimit: conf.memoryLimit,
+		buildCommand: conf.buildCommand,
+		startCommand: conf.startCommand,
+		rootDirectory: conf.rootDirectory,
+		healthCheckPath: conf.healthCheckPath,
+		aptPackages: conf.aptPackages
+	}));
 }
 
 //#endregion
-//#region src/lib/templates.ts
+//#region src/lib/deploy-checks.ts
 /**
-* Embedded templates for STATIC site builds.
-* These are written to the project directory temporarily before creating the tar,
-* then cleaned up immediately after.
+* Platform-specific presets that won't work on Veloz (generic K8s).
+* Maps preset name to the platform it targets.
 */
-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";
-
+const INCOMPATIBLE_PRESETS = {
+	vercel: "Vercel",
+	"cloudflare-pages": "Cloudflare Pages",
+	"cloudflare-workers": "Cloudflare Workers",
+	"cloudflare-module": "Cloudflare Workers",
+	netlify: "Netlify",
+	"netlify-edge": "Netlify Edge",
+	"aws-lambda": "AWS Lambda",
+	"firebase": "Firebase",
+	"deno-deploy": "Deno Deploy",
+	"render-com": "Render",
+	"flight-control": "Flightcontrol",
+	"stormkit": "Stormkit",
+	"edgio": "Edgio",
+	"lagon": "Lagon"
+};
 /**
- * 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);
+* Recommended preset based on package manager / runtime.
+*/
+function recommendedPreset(basePath) {
+	const pkgPath = resolve(basePath, "package.json");
+	if (!existsSync(pkgPath)) return "node-server";
+	try {
+		const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+		if ("bun" in {
+			...pkg.dependencies,
+			...pkg.devDependencies
+		} || existsSync(resolve(basePath, "bun.lockb")) || existsSync(resolve(basePath, "bun.lock"))) return "bun";
+	} catch {}
+	return "node-server";
 }
-
-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");
+/**
+* Check for Nitro preset misconfigurations in vite/nuxt config files.
+*/
+function checkNitroPreset(basePath) {
+	for (const file of [
+		"vite.config.ts",
+		"vite.config.js",
+		"vite.config.mjs",
+		"nuxt.config.ts",
+		"nuxt.config.js"
+	]) {
+		const filePath = resolve(basePath, file);
+		if (!existsSync(filePath)) continue;
+		let content;
+		try {
+			content = readFileSync(filePath, "utf-8");
+		} catch {
+			continue;
+		}
+		const presetMatch = content.match(/preset\s*:\s*["']([^"']+)["']/);
+		if (!presetMatch) continue;
+		const preset = presetMatch[1];
+		const platform$1 = INCOMPATIBLE_PRESETS[preset];
+		if (!platform$1) continue;
+		const recommended = recommendedPreset(basePath);
+		return {
+			message: `${file} usa preset "${preset}" (${platform$1}) — incompativel com Veloz`,
+			hint: `Altere para preset: "${recommended}" em ${file}`
+		};
+	}
+	return null;
 }
-
-// ── 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");
+/**
+* Check for Dockerfile COPY instructions that reference both bun.lockb and bun.lock.
+* Only one usually exists — the COPY will fail if both are listed but one is missing.
+*/
+function checkDockerfileLockFiles(basePath) {
+	const dockerfilePath = resolve(basePath, "Dockerfile");
+	if (!existsSync(dockerfilePath)) return null;
+	let content;
+	try {
+		content = readFileSync(dockerfilePath, "utf-8");
+	} catch {
+		return null;
+	}
+	const copyLines = content.split("\n").filter((l) => /^COPY\s/.test(l.trim()));
+	for (const line of copyLines) if (line.includes("bun.lockb") && line.includes("bun.lock") && !line.includes("bun.lock*")) {
+		if (!(existsSync(resolve(basePath, "bun.lockb")) && existsSync(resolve(basePath, "bun.lock")))) return {
+			message: "Dockerfile lista bun.lockb e bun.lock mas apenas um existe",
+			hint: "Use \"COPY package.json bun.lock* ./\" para copiar o que existir"
+		};
+	}
+	return null;
 }
-
-// ── 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));
+/**
+* Next.js needs `output: "standalone"` for Docker/K8s deploys.
+* Without it, the build produces a node_modules-dependent output
+* that's huge and doesn't run well in containers.
+*/
+function checkNextStandalone(basePath) {
+	const pkgPath = resolve(basePath, "package.json");
+	if (!existsSync(pkgPath)) return null;
+	try {
+		const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+		if (!("next" in {
+			...pkg.dependencies,
+			...pkg.devDependencies
+		})) return null;
+	} catch {
+		return null;
+	}
+	if (existsSync(resolve(basePath, "Dockerfile"))) return null;
+	for (const file of [
+		"next.config.ts",
+		"next.config.js",
+		"next.config.mjs"
+	]) {
+		const filePath = resolve(basePath, file);
+		if (!existsSync(filePath)) continue;
+		try {
+			const content = readFileSync(filePath, "utf-8");
+			if (content.includes("\"standalone\"") || content.includes("'standalone'")) return null;
+			return {
+				message: `${file} nao tem output: "standalone"`,
+				hint: "Adicione output: \"standalone\" no next.config para deploys em container"
+			};
+		} catch {
 			continue;
 		}
-		throw error;
 	}
-	throw new Error("Max retries exceeded");
+	return null;
 }
-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";
+/**
+* Prisma needs `prisma generate` in the build step.
+* Without it, the Prisma client won't be generated and the app will crash.
+*/
+function checkPrismaGenerate(basePath) {
+	const pkgPath = resolve(basePath, "package.json");
+	if (!existsSync(pkgPath)) return null;
+	try {
+		const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+		const allDeps = {
+			...pkg.dependencies,
+			...pkg.devDependencies
+		};
+		if (!("prisma" in allDeps) && !("@prisma/client" in allDeps)) return null;
+		const scripts = pkg.scripts || {};
+		const buildScript = scripts.build || "";
+		const postinstall = scripts.postinstall || "";
+		if (buildScript.includes("prisma generate") || postinstall.includes("prisma generate") || buildScript.includes("prisma db push")) return null;
+		return {
+			message: "Prisma detectado mas prisma generate nao esta no build/postinstall",
+			hint: "Adicione \"prisma generate\" ao script postinstall ou build no package.json"
+		};
+	} catch {
+		return null;
+	}
 }
-function detectNodeVersion() {
+/**
+* Detect if the app hardcodes a port that doesn't match the configured port.
+* Common issue: app listens on 8080 but service port is 3000.
+*/
+function checkPortMismatch(basePath) {
+	const pkgPath = resolve(basePath, "package.json");
+	if (!existsSync(pkgPath)) return null;
 	try {
-		const 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];
-			}
+		const portMatch = ((JSON.parse(readFileSync(pkgPath, "utf-8")).scripts || {}).start || "").match(/(?:--port|-p)\s+(\d+)/);
+		if (portMatch) {
+			const hardcodedPort = parseInt(portMatch[1], 10);
+			if (hardcodedPort !== 3e3) return {
+				message: `Script start usa porta ${hardcodedPort} — certifique-se de que a porta do servico esta configurada corretamente`,
+				hint: `Configure a porta do servico para ${hardcodedPort} no dashboard ou veloz.json`
+			};
 		}
 	} catch {}
-	return "20";
+	return null;
+}
+/**
+* Check for .env files that might be accidentally uploaded.
+*/
+function checkEnvFileCommitted(basePath) {
+	if (!existsSync(resolve(basePath, ".env"))) return null;
+	const gitignorePath = resolve(basePath, ".gitignore");
+	if (existsSync(gitignorePath)) try {
+		const lines = readFileSync(gitignorePath, "utf-8").split("\n").map((l) => l.trim());
+		if (lines.includes(".env") || lines.includes(".env*") || lines.includes("*.env")) return null;
+	} catch {}
+	return {
+		message: "Arquivo .env encontrado e nao esta no .gitignore",
+		hint: "Adicione .env ao .gitignore — use variaveis de ambiente no dashboard ou CLI"
+	};
 }
-function prepareExtraFiles(detection, serviceConfig) {
+/**
+* Node.js project without a start command — nixpacks won't know how to run it.
+* Checks for: scripts.start, main field, or common entry files.
+*/
+function checkMissingStartCommand(basePath) {
+	const pkgPath = resolve(basePath, "package.json");
+	if (!existsSync(pkgPath)) return null;
+	if (existsSync(resolve(basePath, "Dockerfile"))) return null;
+	try {
+		const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+		if (pkg.scripts?.start) return null;
+		if (pkg.main) return null;
+		const allDeps = {
+			...pkg.dependencies,
+			...pkg.devDependencies
+		};
+		if ([
+			"next",
+			"nuxt",
+			"nuxt3",
+			"@sveltejs/kit",
+			"remix",
+			"astro",
+			"@angular/core",
+			"gatsby"
+		].some((f) => f in allDeps)) return null;
+		if ([
+			"index.js",
+			"index.mjs",
+			"index.ts",
+			"server.js",
+			"server.ts",
+			"app.js",
+			"app.ts",
+			"src/index.js",
+			"src/index.ts",
+			"src/server.js",
+			"src/server.ts"
+		].some((f) => existsSync(resolve(basePath, f)))) return null;
+		return {
+			message: "Nenhum script start encontrado no package.json",
+			hint: "Adicione \"start\" em scripts (ex: \"node dist/index.js\") ou um campo \"main\" no package.json"
+		};
+	} catch {
+		return null;
+	}
+}
+/**
+* packageManager field in package.json doesn't match the lockfile present.
+* e.g., packageManager: "pnpm@9.0.0" but only package-lock.json exists.
+*/
+function checkPackageManagerMismatch(basePath) {
+	const pkgPath = resolve(basePath, "package.json");
+	if (!existsSync(pkgPath)) return null;
+	try {
+		const pmField = JSON.parse(readFileSync(pkgPath, "utf-8")).packageManager;
+		if (!pmField) return null;
+		const declaredPm = pmField.split("@")[0];
+		const lockfileMap = {
+			npm: ["package-lock.json"],
+			yarn: ["yarn.lock"],
+			pnpm: ["pnpm-lock.yaml"],
+			bun: ["bun.lockb", "bun.lock"]
+		};
+		const expectedLockfiles = lockfileMap[declaredPm];
+		if (!expectedLockfiles) return null;
+		if (expectedLockfiles.some((f) => existsSync(resolve(basePath, f)))) return null;
+		const otherPms = Object.entries(lockfileMap).filter(([pm]) => pm !== declaredPm);
+		for (const [pm, files] of otherPms) if (files.some((f) => existsSync(resolve(basePath, f)))) return {
+			message: `packageManager "${pmField}" no package.json mas lockfile de ${pm} encontrado`,
+			hint: `Remova o campo packageManager ou gere o lockfile correto com ${declaredPm} install`
+		};
+	} catch {}
+	return null;
+}
+/**
+* Native modules that need system packages to build.
+* The server auto-detects and injects apt packages for known modules (sharp, canvas,
+* puppeteer, playwright-chromium). This check warns about bcrypt which has a pure-JS
+* alternative, and modules not in the auto-detect list.
+*/
+function checkNativeModules(basePath) {
+	const pkgPath = resolve(basePath, "package.json");
+	if (!existsSync(pkgPath)) return null;
+	if (existsSync(resolve(basePath, "Dockerfile"))) return null;
+	try {
+		const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+		if ("bcrypt" in {
+			...pkg.dependencies,
+			...pkg.devDependencies
+		}) return {
+			message: "bcrypt compila codigo nativo — pode falhar em alguns ambientes",
+			hint: "Considere usar bcryptjs (pure JS) para evitar falhas de build"
+		};
+	} catch {}
+	return null;
+}
+/**
+* nixpacks.toml phases that override defaults instead of extending them.
+* Missing "..." in [phases.X.cmds] replaces all default commands.
+*/
+function checkNixpacksTomlSpread(basePath) {
+	const tomlPath = resolve(basePath, "nixpacks.toml");
+	if (!existsSync(tomlPath)) return null;
+	try {
+		const content = readFileSync(tomlPath, "utf-8");
+		if (!content.match(/\[phases\.\w+\]/g)) return null;
+		const hasCmds = /cmds\s*=\s*\[/.test(content);
+		const hasSpread = content.includes("\"...\"");
+		if (hasCmds && !hasSpread) return {
+			message: "nixpacks.toml define cmds sem \"...\" — isso substitui os comandos padrao",
+			hint: "Adicione \"...\" no array cmds para manter os comandos padrao: cmds = [\"...\", \"seu-comando\"]"
+		};
+	} catch {}
+	return null;
+}
+/**
+* Django project without gunicorn — the dev server isn't suitable for production.
+*/
+function checkDjangoGunicorn(basePath) {
+	if (existsSync(resolve(basePath, "Dockerfile"))) return null;
+	const requirementsFiles = [
+		"requirements.txt",
+		"requirements/production.txt",
+		"requirements/prod.txt"
+	];
+	let hasDjango = false;
+	let hasGunicorn = false;
+	for (const file of requirementsFiles) {
+		const filePath = resolve(basePath, file);
+		if (!existsSync(filePath)) continue;
+		try {
+			const content = readFileSync(filePath, "utf-8").toLowerCase();
+			if (content.includes("django")) hasDjango = true;
+			if (content.includes("gunicorn") || content.includes("uvicorn")) hasGunicorn = true;
+		} catch {
+			continue;
+		}
+	}
+	for (const file of ["pyproject.toml", "Pipfile"]) {
+		const filePath = resolve(basePath, file);
+		if (!existsSync(filePath)) continue;
+		try {
+			const content = readFileSync(filePath, "utf-8").toLowerCase();
+			if (content.includes("django")) hasDjango = true;
+			if (content.includes("gunicorn") || content.includes("uvicorn")) hasGunicorn = true;
+		} catch {
+			continue;
+		}
+	}
+	if (hasDjango && !hasGunicorn) return {
+		message: "Django detectado sem gunicorn/uvicorn — o servidor de dev nao deve ser usado em producao",
+		hint: "Adicione gunicorn ao requirements.txt e configure o start command: \"gunicorn myproject.wsgi\""
+	};
+	return null;
+}
+/**
+* SvelteKit needs adapter-node for container deploys.
+* Default adapter-auto or adapter-vercel/netlify won't work.
+*/
+function checkSvelteKitAdapter(basePath) {
+	const pkgPath = resolve(basePath, "package.json");
+	if (!existsSync(pkgPath)) return null;
+	try {
+		const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+		const allDeps = {
+			...pkg.dependencies,
+			...pkg.devDependencies
+		};
+		if (!("@sveltejs/kit" in allDeps)) return null;
+		const hasNodeAdapter = "@sveltejs/adapter-node" in allDeps;
+		const hasBunAdapter = "svelte-adapter-bun" in allDeps;
+		if (hasNodeAdapter || hasBunAdapter) return null;
+		const installed = [
+			"@sveltejs/adapter-vercel",
+			"@sveltejs/adapter-netlify",
+			"@sveltejs/adapter-cloudflare",
+			"@sveltejs/adapter-cloudflare-workers"
+		].find((a) => a in allDeps);
+		if (installed) return {
+			message: `SvelteKit usa ${installed} — incompativel com Veloz`,
+			hint: "Instale @sveltejs/adapter-node e configure em svelte.config.js"
+		};
+		if ("@sveltejs/adapter-auto" in allDeps) return {
+			message: "SvelteKit usa adapter-auto — pode nao funcionar em container",
+			hint: "Instale @sveltejs/adapter-node para deploys em container"
+		};
+	} catch {}
+	return null;
+}
+/**
+* Run all pre-deploy checks and return warnings.
+* Does not block — just warns the user.
+*/
+function runPreDeployChecks(basePath = ".") {
+	const warnings = [];
+	const fullPath = resolve(process.cwd(), basePath);
+	const checks = [
+		checkNitroPreset,
+		checkDockerfileLockFiles,
+		checkNextStandalone,
+		checkPrismaGenerate,
+		checkPortMismatch,
+		checkEnvFileCommitted,
+		checkSvelteKitAdapter,
+		checkMissingStartCommand,
+		checkPackageManagerMismatch,
+		checkNativeModules,
+		checkNixpacksTomlSpread,
+		checkDjangoGunicorn
+	];
+	for (const check of checks) {
+		const result = check(fullPath);
+		if (result) warnings.push(result);
+	}
+	return warnings;
+}
+/**
+* Print deploy warnings to the console.
+* Returns true if any warnings were found.
+*/
+function printDeployWarnings(warnings) {
+	if (warnings.length === 0) return false;
+	console.log();
+	for (const w of warnings) {
+		console.log(chalk.yellow(`  AVISO: ${w.message}`));
+		console.log(chalk.dim(`         ${w.hint}`));
+	}
+	console.log();
+	return true;
+}
+
+//#endregion
+//#region src/commands/deploy.ts
+/**
+* If a Dockerfile exists in a subdirectory (rootDirectory), copy it to tar root
+* so BuildKit can find it. If no Dockerfile exists anywhere, return nothing —
+* the server will generate one with nixpacks.
+*/
+function prepareExtraFiles(_detection, serviceConfig) {
 	if (existsSync(resolve(process.cwd(), "Dockerfile"))) return [];
 	const rootDir = serviceConfig?.rootDirectory || ".";
 	const serviceDockerfilePath = resolve(process.cwd(), rootDir, "Dockerfile");
@@ -1775,68 +1829,34 @@ function prepareExtraFiles(detection, serviceConfig) {
 		name: "Dockerfile",
 		content: readFileSync(serviceDockerfilePath, "utf-8")
 	}];
-	const fw = detection.framework;
-	const pm = detectPackageManager();
-	const nodeVersion = detectNodeVersion();
-	const type = fw?.type ?? serviceConfig?.type?.toUpperCase() ?? "WEB";
-	const files = [{
-		name: "Dockerfile",
-		content: generateDockerfile({
-			serviceType: type,
-			nodeVersion,
-			pm,
-			buildCommand: serviceConfig?.buildCommand ?? fw?.buildCommand ?? `${pm} run build`,
-			startCommand: serviceConfig?.startCommand ?? fw?.startCommand ?? void 0,
-			outputDir: serviceConfig?.outputDir ?? fw?.outputDir ?? void 0,
-			rootDirectory: serviceConfig?.rootDirectory,
-			port: serviceConfig?.port ?? fw?.port ?? 3e3
-		})
-	}];
-	if (type === "STATIC") files.push({
-		name: "nginx.conf",
-		content: NGINX_CONF
-	}, {
-		name: "generate-nginx-config.cjs",
-		content: GENERATE_NGINX_CONFIG_CJS
-	});
-	return files;
+	return [];
 }
 async function computeExtraFilesForServices(services) {
 	const velozConfig = loadConfig();
 	const client = await getClient();
-	const detection = detectLocalRepo();
 	const results = [];
+	const allWarnings = [];
 	for (const svc of services) {
-		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,
-					instanceCount: merged.resources?.instances ?? void 0,
-					cpuLimit: merged.resources?.cpu ?? void 0,
-					memoryLimit: merged.resources?.memory ?? void 0,
-					healthCheckPath: merged.runtime?.healthCheck?.path ?? null
-				};
-				break;
-			}
-		}
-		if (serviceConf) await client.services.update({
-			serviceId: svc.serviceId,
-			port: serviceConf.port,
-			instanceCount: serviceConf.instanceCount,
-			cpuLimit: serviceConf.cpuLimit,
-			memoryLimit: serviceConf.memoryLimit,
-			buildCommand: serviceConf.buildCommand,
-			startCommand: serviceConf.startCommand,
-			rootDirectory: serviceConf.rootDirectory,
-			healthCheckPath: serviceConf.healthCheckPath
+		const warnings = runPreDeployChecks(resolveServiceConf(velozConfig, svc.serviceId)?.rootDirectory || ".");
+		if (warnings.length > 0) allWarnings.push({
+			service: svc.serviceName,
+			warnings
 		});
+	}
+	if (allWarnings.length > 0) {
+		for (const { service, warnings } of allWarnings) {
+			console.log(chalk.yellow(`\n  ${chalk.bold(service)}:`));
+			printDeployWarnings(warnings);
+		}
+		if (!await promptConfirm("Continuar mesmo assim?", false)) {
+			info("Deploy cancelado.");
+			process.exit(0);
+		}
+	}
+	for (const svc of services) {
+		const serviceConf = resolveServiceConf(velozConfig, svc.serviceId);
+		if (serviceConf) await syncServiceConfig(client, svc.serviceId, serviceConf);
+		const detection = detectLocalRepo(serviceConf?.rootDirectory || ".");
 		results.push({
 			...svc,
 			extraFiles: prepareExtraFiles(detection, serviceConf)
@@ -1851,45 +1871,32 @@ async function triggerDeploy(serviceId, serviceName, preDetection) {
 		const sizeMB = Math.round(sizeInBytes / (1024 * 1024) * 10) / 10;
 		if (sizeMB > 5) spinUpload.text = `Fazendo upload (${sizeMB} MB)...`;
 		const client = await getClient();
-		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,
-					instanceCount: merged.resources?.instances ?? void 0,
-					cpuLimit: merged.resources?.cpu ?? void 0,
-					memoryLimit: merged.resources?.memory ?? void 0,
-					healthCheckPath: merged.runtime?.healthCheck?.path ?? null
-				};
-				break;
+		const serviceConf = resolveServiceConf(loadConfig(), serviceId);
+		if (serviceConf) await syncServiceConfig(client, serviceId, serviceConf);
+		const extraFiles = prepareExtraFiles(preDetection ?? detectLocalRepo(), serviceConf);
+		const warnings = runPreDeployChecks(serviceConf?.rootDirectory || ".");
+		if (warnings.length > 0) {
+			spinUpload.stop();
+			printDeployWarnings(warnings);
+			if (!await promptConfirm("Continuar mesmo assim?", false)) {
+				info("Deploy cancelado.");
+				return;
 			}
+			spinUpload.start();
 		}
-		if (serviceConf) await withRetry(() => client.services.update({
-			serviceId,
-			port: serviceConf.port,
-			instanceCount: serviceConf.instanceCount,
-			cpuLimit: serviceConf.cpuLimit,
-			memoryLimit: serviceConf.memoryLimit,
-			buildCommand: serviceConf.buildCommand,
-			startCommand: serviceConf.startCommand,
-			rootDirectory: serviceConf.rootDirectory,
-			healthCheckPath: serviceConf.healthCheckPath
-		}));
-		const extraFiles = prepareExtraFiles(preDetection ?? detectLocalRepo(), serviceConf);
 		spinUpload.text = "Iniciando deploy...";
 		const deployment = await withRetry(() => client.deployments.create({ serviceId }));
 		spinUpload.text = "Fazendo upload do código...";
 		await withRetry(() => uploadSource(deployment.id, process.cwd(), extraFiles));
 		spinUpload.stop();
 		success("Deploy iniciado com sucesso!");
-		await streamDeploymentLogs(deployment.id, serviceName);
+		setupSigintHandler();
+		trackDeployment(deployment.id);
+		try {
+			await streamDeploymentLogs(deployment.id, serviceName);
+		} finally {
+			untrackDeployment(deployment.id);
+		}
 	} catch (error) {
 		spinUpload.stop();
 		handleError(error);
@@ -3130,10 +3137,23 @@ apikeyCommand.command("delete <keyId>").alias("deletar").description("Deletar um
 	}
 });
 
+//#endregion
+//#region src/commands/whoami.ts
+const whoamiCommand = new Command("whoami").description("Mostrar usuário autenticado").action(async () => {
+	try {
+		const user = await (await getClient()).me();
+		console.log();
+		console.log(`  ${chalk.bold("Nome:")}   ${user.name}`);
+		console.log(`  ${chalk.bold("Email:")}  ${user.email}`);
+		console.log();
+	} 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");
+const program = new Command().name("veloz").description("CLI da plataforma Veloz — deploy rápido para o Brasil").version("0.0.0-beta.6");
 program.addCommand(loginCommand);
 program.addCommand(logoutCommand);
 program.addCommand(projectsCommand);
@@ -3145,6 +3165,7 @@ program.addCommand(domainsCommand);
 program.addCommand(configCommand);
 program.addCommand(useCommand);
 program.addCommand(apikeyCommand);
+program.addCommand(whoamiCommand);
 program.parse();
 
 //#endregion