onveloz 0.0.0-beta.22 → 0.0.0-beta.23

package/dist/deploy-tui-U7fsZN6x.mjs

@@ -0,0 +1,1028 @@
+import { a as statusLabels, i as TERMINAL_STATUSES, l as info, n as isHiddenMessage, o as getClient, r as parseBuildLine, t as cleanDisplayLine, u as success } from "./index.mjs";
+import chalk from "chalk";
+import { useEffect, useRef, useState } from "react";
+import { Box, Static, Text, render, useApp } from "ink";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+
+//#region ../../packages/api/src/lib/build-steps.ts
+const TIMESTAMP_RE = /^\[(\d{4}-\d{2}-\d{2}T[\d:.]+Z)\]\s*/;
+const STEP_PREFIX_RE = /^#(\d+)\s+(.*)/;
+const TIMING_PREFIX_RE = /^(\d+\.\d+)\s*(.*)/;
+const DONE_RE = /^DONE\s+([\d.]+s?)$/;
+const STAGE_RE = /^\[([\w-]+)\s+(\d+)\/\d+\]/;
+function parseStageInfo(title) {
+	const match = title.match(STAGE_RE);
+	if (!match) return null;
+	return {
+		stage: match[1].toLowerCase(),
+		substep: parseInt(match[2], 10)
+	};
+}
+/** Derive stage order from first occurrence in the step list (preserves Dockerfile order). */
+function buildStageOrder(steps) {
+	const order = /* @__PURE__ */ new Map();
+	for (const step of steps) {
+		const info$1 = parseStageInfo(step.title);
+		if (info$1 && !order.has(info$1.stage)) order.set(info$1.stage, order.size);
+	}
+	return order;
+}
+const RUNTIME_LINE_PATTERNS = [
+	/^[\u26A0\u{1F680}]/u,
+	/^\{.*"(?:level|msg|pid)"/,
+	/^Error:\s/,
+	/^\s+at\s+/,
+	/^errorno:/i,
+	/^code:\s+'/,
+	/^syscall:\s+'/,
+	/Server (?:running|started)/i
+];
+function isRuntimeLine(content) {
+	return RUNTIME_LINE_PATTERNS.some((p) => p.test(content.trim()));
+}
+function parseBuildSteps(rawText) {
+	const rawLines = rawText.split("\n");
+	let currentPhase = 0;
+	let maxStepInPhase = 0;
+	const phaseStepMap = /* @__PURE__ */ new Map();
+	const allSteps = [];
+	let currentGeneralStep = null;
+	for (const raw of rawLines) {
+		const trimmed = raw.trim();
+		if (!trimmed) continue;
+		const tsMatch = trimmed.match(TIMESTAMP_RE);
+		const timestamp = tsMatch?.[1] ?? null;
+		const line = tsMatch ? trimmed.slice(tsMatch[0].length) : trimmed;
+		if (!line.trim()) continue;
+		const stepMatch = line.match(STEP_PREFIX_RE);
+		if (!stepMatch) {
+			if (!currentGeneralStep) {
+				currentGeneralStep = {
+					stepNumber: null,
+					title: "Configuração",
+					duration: null,
+					status: "done",
+					lines: [],
+					phase: currentPhase,
+					startedAt: timestamp
+				};
+				allSteps.push(currentGeneralStep);
+			}
+			currentGeneralStep.lines.push({
+				content: line,
+				elapsed: null,
+				timestamp
+			});
+			continue;
+		}
+		currentGeneralStep = null;
+		const stepNum = parseInt(stepMatch[1], 10);
+		let content = stepMatch[2];
+		if (content.trim() === "...") continue;
+		const existingKey = `${currentPhase}-${stepNum}`;
+		const existing = phaseStepMap.get(existingKey);
+		if (existing && (existing.status === "done" || existing.status === "cached") && stepNum < maxStepInPhase) {
+			currentPhase++;
+			maxStepInPhase = 0;
+		}
+		if (stepNum > maxStepInPhase) maxStepInPhase = stepNum;
+		const key = `${currentPhase}-${stepNum}`;
+		let step = phaseStepMap.get(key);
+		if (!step) {
+			step = {
+				stepNumber: stepNum,
+				title: "",
+				duration: null,
+				status: "running",
+				lines: [],
+				phase: currentPhase,
+				startedAt: timestamp
+			};
+			phaseStepMap.set(key, step);
+			allSteps.push(step);
+		}
+		const doneMatch = content.match(DONE_RE);
+		if (doneMatch) {
+			step.duration = doneMatch[1];
+			step.status = "done";
+			continue;
+		}
+		if (content.trim() === "CACHED") {
+			step.status = "cached";
+			step.duration = "cached";
+			continue;
+		}
+		let elapsed = null;
+		const timingMatch = content.match(TIMING_PREFIX_RE);
+		if (timingMatch) {
+			elapsed = parseFloat(timingMatch[1]);
+			content = timingMatch[2];
+		}
+		if (!content.trim()) continue;
+		if (!step.title) step.title = content.trim();
+		if (step.lines.length > 0 || content.trim() !== step.title) step.lines.push({
+			content: content.trim(),
+			elapsed,
+			timestamp
+		});
+	}
+	const numberedWithIndex = [];
+	const structure = [];
+	for (let i = 0; i < allSteps.length; i++) {
+		const step = allSteps[i];
+		if (step.stepNumber === null) structure.push({
+			type: "general",
+			origIdx: i
+		});
+		else if (step.title.trim() !== "") {
+			structure.push({
+				type: "numbered",
+				origIdx: i
+			});
+			numberedWithIndex.push({
+				step,
+				origIdx: i
+			});
+		}
+	}
+	const stageOrder = buildStageOrder(numberedWithIndex.map((n) => n.step));
+	numberedWithIndex.sort((a, b) => {
+		if (a.step.phase !== b.step.phase) return a.step.phase - b.step.phase;
+		if (a.step.startedAt && b.step.startedAt) {
+			const tsDiff = new Date(a.step.startedAt).getTime() - new Date(b.step.startedAt).getTime();
+			if (tsDiff !== 0) return tsDiff;
+		}
+		const aInfo = parseStageInfo(a.step.title);
+		const bInfo = parseStageInfo(b.step.title);
+		const aOrder = aInfo ? stageOrder.get(aInfo.stage) ?? 99 : 99;
+		const bOrder = bInfo ? stageOrder.get(bInfo.stage) ?? 99 : 99;
+		if (aOrder !== bOrder) return aOrder - bOrder;
+		return (aInfo?.substep ?? a.step.stepNumber ?? 0) - (bInfo?.substep ?? b.step.stepNumber ?? 0);
+	});
+	const result = [];
+	let nIdx = 0;
+	let generalCount = 0;
+	const totalGenerals = structure.filter((s) => s.type === "general").length;
+	for (const entry of structure) {
+		if (entry.type === "numbered") {
+			result.push(numberedWithIndex[nIdx].step);
+			nIdx++;
+			continue;
+		}
+		generalCount++;
+		const generalStep = allSteps[entry.origIdx];
+		if (generalCount === totalGenerals && totalGenerals > 1) {
+			const deployLines = [];
+			const healthLines = [];
+			let hitRuntime = false;
+			for (const line of generalStep.lines) {
+				if (!hitRuntime && isRuntimeLine(line.content)) hitRuntime = true;
+				if (hitRuntime) healthLines.push(line);
+				else deployLines.push(line);
+			}
+			if (deployLines.length > 0) result.push({
+				stepNumber: null,
+				title: "Finalização",
+				duration: null,
+				status: "done",
+				lines: deployLines,
+				phase: generalStep.phase,
+				startedAt: deployLines[0]?.timestamp ?? generalStep.startedAt
+			});
+			if (healthLines.length > 0) result.push({
+				stepNumber: null,
+				title: "Verificação de saúde",
+				duration: null,
+				status: "done",
+				lines: healthLines,
+				phase: generalStep.phase,
+				startedAt: healthLines[0]?.timestamp ?? null
+			});
+		} else result.push(generalStep);
+	}
+	return result;
+}
+
+//#endregion
+//#region src/components/deploy-tui.tsx
+const BRAND_COLOR = "#FF4D00";
+const BAR_WIDTH = 20;
+const SPINNER_FRAMES = [
+	"⠋",
+	"⠙",
+	"⠹",
+	"⠸",
+	"⠼",
+	"⠴",
+	"⠦",
+	"⠧",
+	"⠇",
+	"⠏"
+];
+const MAX_OUTPUT_LINES = 5;
+/** Regex to extract stage info from BuildStep titles like `[stage-0 3/11] COPY ...` */
+const STAGE_TITLE_RE = /^\[([\w-]+)\s+(\d+)\/(\d+)\]\s+(.+)$/;
+function buildStepsToStages(steps) {
+	const stages = /* @__PURE__ */ new Map();
+	const platformMessages = [];
+	const stepDetails = /* @__PURE__ */ new Map();
+	const displayOrder = [];
+	const seenStages = /* @__PURE__ */ new Set();
+	for (const step of steps) {
+		if (step.stepNumber === null) {
+			for (const line of step.lines) {
+				const cleaned = cleanDisplayLine(line.content);
+				if (cleaned) platformMessages.push(cleaned);
+			}
+			continue;
+		}
+		const match = step.title.match(STAGE_TITLE_RE);
+		if (!match) {
+			if (step.title && !/^\[(?:depot|internal)\]/i.test(step.title)) displayOrder.push({
+				kind: "extra",
+				step
+			});
+			continue;
+		}
+		const stageName = match[1];
+		const substep = parseInt(match[2], 10);
+		const total = parseInt(match[3], 10);
+		const command = match[4];
+		let stage = stages.get(stageName);
+		if (!stage) {
+			stage = {
+				name: stageName,
+				total,
+				steps: /* @__PURE__ */ new Map(),
+				stepNumMap: /* @__PURE__ */ new Map(),
+				cachedStepNums: /* @__PURE__ */ new Set(),
+				doneStepNums: /* @__PURE__ */ new Set()
+			};
+			stages.set(stageName, stage);
+		}
+		if (!seenStages.has(stageName)) {
+			seenStages.add(stageName);
+			displayOrder.push({
+				kind: "stage",
+				name: stageName
+			});
+		}
+		stage.steps.set(substep, command);
+		stage.stepNumMap.set(step.stepNumber, substep);
+		stage.total = Math.max(stage.total, total);
+		if (step.status === "cached") stage.cachedStepNums.add(step.stepNumber);
+		else if (step.status === "done") stage.doneStepNums.add(step.stepNumber);
+		stepDetails.set(`${stageName}-${substep}`, {
+			duration: step.duration !== "cached" ? step.duration : null,
+			status: step.status,
+			lastLines: step.lines.slice(-MAX_OUTPUT_LINES).map((l) => l.content),
+			lineCount: step.lines.length
+		});
+	}
+	return {
+		stages,
+		platformMessages,
+		displayOrder,
+		stepDetails
+	};
+}
+function AnimatedSpinner({ color = "cyan" }) {
+	const [frame, setFrame] = useState(0);
+	useEffect(() => {
+		const timer = setInterval(() => {
+			setFrame((f) => (f + 1) % SPINNER_FRAMES.length);
+		}, 80);
+		return () => clearInterval(timer);
+	}, []);
+	return /* @__PURE__ */ jsx(Text, {
+		color,
+		children: SPINNER_FRAMES[frame]
+	});
+}
+function ProgressBar({ filled, total, allCached, allDone }) {
+	const ratio = total > 0 ? filled / total : 0;
+	const filledChars = Math.round(ratio * BAR_WIDTH);
+	const emptyChars = BAR_WIDTH - filledChars;
+	const counter = `${filled}/${total}`;
+	if (allCached) return /* @__PURE__ */ jsxs(Text, {
+		color: BRAND_COLOR,
+		children: [
+			"━".repeat(BAR_WIDTH),
+			" ",
+			counter,
+			" ✓ veloz cache"
+		]
+	});
+	if (allDone) return /* @__PURE__ */ jsxs(Text, {
+		color: "green",
+		children: [
+			"━".repeat(BAR_WIDTH),
+			" ",
+			counter,
+			" ✓"
+		]
+	});
+	return /* @__PURE__ */ jsxs(Text, { children: [
+		/* @__PURE__ */ jsx(Text, {
+			color: "cyan",
+			children: "━".repeat(filledChars)
+		}),
+		/* @__PURE__ */ jsx(Text, {
+			dimColor: true,
+			children: "─".repeat(emptyChars)
+		}),
+		/* @__PURE__ */ jsxs(Text, {
+			dimColor: true,
+			children: [" ", counter]
+		})
+	] });
+}
+function getStageStats(stage) {
+	let finishedCount = 0;
+	let cachedCount = 0;
+	for (const bkNum of stage.stepNumMap.keys()) if (stage.cachedStepNums.has(bkNum)) {
+		finishedCount++;
+		cachedCount++;
+	} else if (stage.doneStepNums.has(bkNum)) finishedCount++;
+	const allFinished = stage.total > 0 && finishedCount >= stage.total;
+	return {
+		finishedCount,
+		cachedCount,
+		allFinished,
+		allCached: allFinished && cachedCount >= stage.total,
+		allDone: allFinished && cachedCount < stage.total
+	};
+}
+function getStepStatus(stepNum, stage) {
+	for (const [bkNum, dockerStep] of stage.stepNumMap.entries()) if (dockerStep === stepNum) {
+		if (stage.cachedStepNums.has(bkNum)) return "cached";
+		if (stage.doneStepNums.has(bkNum)) return "done";
+		return "running";
+	}
+	return "pending";
+}
+function StepStatusIcon({ status, spinnerFrame }) {
+	switch (status) {
+		case "cached": return /* @__PURE__ */ jsx(Text, {
+			color: BRAND_COLOR,
+			children: "✓"
+		});
+		case "done": return /* @__PURE__ */ jsx(Text, {
+			color: "green",
+			children: "✓"
+		});
+		case "running": return /* @__PURE__ */ jsx(Text, {
+			color: "cyan",
+			children: SPINNER_FRAMES[spinnerFrame]
+		});
+		case "pending": return /* @__PURE__ */ jsx(Text, {
+			dimColor: true,
+			children: "·"
+		});
+	}
+}
+function friendlyExtraTitle(title) {
+	if (/^exporting to image/i.test(title)) return "Código compilado, distribuindo no sistema da Veloz";
+	if (/^exporting to client/i.test(title)) return "Exportando resultado";
+	return title;
+}
+function BuildDashboard({ serviceName, stages, displayOrder, committedCount, platformMessages, stepDetails, spinnerText }) {
+	const [spinnerFrame, setSpinnerFrame] = useState(0);
+	useEffect(() => {
+		const timer = setInterval(() => {
+			setSpinnerFrame((f) => (f + 1) % SPINNER_FRAMES.length);
+		}, 80);
+		return () => clearInterval(timer);
+	}, []);
+	const visibleItems = displayOrder.slice(committedCount);
+	const showHeader = committedCount === 0;
+	const stageNames = displayOrder.filter((d) => d.kind === "stage").map((d) => d.name);
+	const maxNameLen = Math.max(...stageNames.map((n) => n.length), 4);
+	const allStagesComplete = stageNames.length > 0 && stageNames.every((name) => {
+		const stage = stages.get(name);
+		return stage ? getStageStats(stage).allFinished : false;
+	});
+	const hasRunningExtra = displayOrder.some((d) => d.kind === "extra" && d.step.status === "running");
+	const allComplete = displayOrder.length > 0 && displayOrder.every((item) => {
+		if (item.kind === "stage") {
+			const stage = stages.get(item.name);
+			return stage ? getStageStats(stage).allFinished : false;
+		}
+		return item.step.status === "done" || item.step.status === "cached";
+	});
+	let bottomSpinner = spinnerText;
+	if (allComplete) bottomSpinner = "Finalizando build...";
+	else if (allStagesComplete && hasRunningExtra) bottomSpinner = "Distribuindo...";
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		paddingLeft: 2,
+		children: [
+			showHeader && /* @__PURE__ */ jsxs(Fragment, { children: [
+				/* @__PURE__ */ jsxs(Text, {
+					bold: true,
+					color: "cyan",
+					children: ["BUILD ", serviceName ? /* @__PURE__ */ jsxs(Text, {
+						dimColor: true,
+						children: [
+							"(",
+							serviceName,
+							")"
+						]
+					}) : null]
+				}),
+				platformMessages.map((msg, i) => /* @__PURE__ */ jsxs(Text, { children: ["  ", msg] }, `pm-${i}`)),
+				displayOrder.length > 0 && /* @__PURE__ */ jsx(Text, { children: "" })
+			] }),
+			visibleItems.map((item, idx) => {
+				if (item.kind === "stage") {
+					const stage = stages.get(item.name);
+					const stats = getStageStats(stage);
+					const sortedSteps = [...stage.steps.entries()].sort((a, b) => a[0] - b[0]);
+					return /* @__PURE__ */ jsxs(Box, {
+						flexDirection: "column",
+						children: [
+							/* @__PURE__ */ jsxs(Box, { children: [
+								/* @__PURE__ */ jsx(Text, {
+									bold: true,
+									children: item.name.padEnd(maxNameLen)
+								}),
+								/* @__PURE__ */ jsx(Text, { children: " " }),
+								/* @__PURE__ */ jsx(ProgressBar, {
+									filled: stats.finishedCount,
+									total: stage.total,
+									allCached: stats.allCached,
+									allDone: stats.allDone
+								})
+							] }),
+							sortedSteps.map(([stepNum, command]) => {
+								const status$1 = getStepStatus(stepNum, stage);
+								const detail = stepDetails.get(`${item.name}-${stepNum}`);
+								const isDone$1 = status$1 === "done" || status$1 === "cached";
+								const isRunning$1 = status$1 === "running";
+								return /* @__PURE__ */ jsxs(Box, {
+									flexDirection: "column",
+									children: [/* @__PURE__ */ jsxs(Box, { children: [
+										/* @__PURE__ */ jsx(Text, { children: "    " }),
+										/* @__PURE__ */ jsx(StepStatusIcon, {
+											status: status$1,
+											spinnerFrame
+										}),
+										/* @__PURE__ */ jsxs(Text, {
+											dimColor: isDone$1,
+											children: [
+												" ",
+												command,
+												status$1 === "cached" ? /* @__PURE__ */ jsx(Text, {
+													color: BRAND_COLOR,
+													children: " (veloz cache)"
+												}) : isDone$1 && detail?.duration ? /* @__PURE__ */ jsxs(Text, {
+													dimColor: true,
+													children: [" ", detail.duration]
+												}) : null
+											]
+										})
+									] }), isRunning$1 && detail && detail.lastLines.length > 0 && /* @__PURE__ */ jsx(Box, {
+										flexDirection: "column",
+										children: detail.lastLines.map((line, li) => /* @__PURE__ */ jsxs(Text, {
+											dimColor: true,
+											children: ["        ", line]
+										}, li))
+									})]
+								}, stepNum);
+							}),
+							idx < visibleItems.length - 1 && /* @__PURE__ */ jsx(Text, { children: "" })
+						]
+					}, item.name);
+				}
+				const step = item.step;
+				const isDone = step.status === "done" || step.status === "cached";
+				const isRunning = step.status === "running";
+				const status = step.status === "error" ? "running" : step.status;
+				const title = friendlyExtraTitle(step.title);
+				const lastLines = step.lines.slice(-MAX_OUTPUT_LINES).map((l) => l.content);
+				return /* @__PURE__ */ jsxs(Box, {
+					flexDirection: "column",
+					children: [/* @__PURE__ */ jsxs(Box, { children: [
+						/* @__PURE__ */ jsx(Text, { children: "  " }),
+						/* @__PURE__ */ jsx(StepStatusIcon, {
+							status,
+							spinnerFrame
+						}),
+						/* @__PURE__ */ jsxs(Text, {
+							dimColor: isDone,
+							children: [
+								" ",
+								title,
+								isDone && step.duration && step.duration !== "cached" ? /* @__PURE__ */ jsxs(Text, {
+									dimColor: true,
+									children: [" ", step.duration]
+								}) : null
+							]
+						})
+					] }), isRunning && lastLines.length > 0 && /* @__PURE__ */ jsx(Box, {
+						flexDirection: "column",
+						children: lastLines.map((line, li) => /* @__PURE__ */ jsxs(Text, {
+							dimColor: true,
+							children: ["      ", line]
+						}, li))
+					})]
+				}, `extra-${idx}`);
+			}),
+			/* @__PURE__ */ jsxs(Box, {
+				marginTop: 1,
+				children: [/* @__PURE__ */ jsx(AnimatedSpinner, {}), /* @__PURE__ */ jsxs(Text, { children: [" ", bottomSpinner] })]
+			})
+		]
+	});
+}
+function DeployTUIApp({ stream, serviceName, resultRef }) {
+	const { exit } = useApp();
+	const [, forceUpdate] = useState(0);
+	const [staticLines, setStaticLines] = useState([]);
+	const [shouldExit, setShouldExit] = useState(false);
+	const stateRef = useRef({
+		stages: /* @__PURE__ */ new Map(),
+		displayOrder: [],
+		platformMessages: [],
+		stepDetails: /* @__PURE__ */ new Map(),
+		phase: "waiting",
+		finalStatus: "",
+		committedCount: 0,
+		headerCommitted: false
+	});
+	useEffect(() => {
+		if (shouldExit) exit();
+	}, [shouldExit, exit]);
+	useEffect(() => {
+		const state$1 = stateRef.current;
+		const allLogs = [];
+		let accumulatedBuildLogs = "";
+		let runtimeLogId = 0;
+		function applyBuildParse() {
+			const result = buildStepsToStages(parseBuildSteps(accumulatedBuildLogs));
+			state$1.stages = result.stages;
+			state$1.displayOrder = result.displayOrder;
+			state$1.platformMessages = result.platformMessages;
+			state$1.stepDetails = result.stepDetails;
+		}
+		/** Check if a display item is fully complete */
+		function isItemComplete(item) {
+			if (item.kind === "stage") {
+				const stage = state$1.stages.get(item.name);
+				return stage ? getStageStats(stage).allFinished : false;
+			}
+			return item.step.status === "done" || item.step.status === "cached";
+		}
+		/** Progressively commit completed leading items to Static for scrolling */
+		function commitCompleted() {
+			const newItems = [];
+			if (!state$1.headerCommitted && state$1.displayOrder.length > 0) {
+				state$1.headerCommitted = true;
+				newItems.push({
+					id: "build-header",
+					node: /* @__PURE__ */ jsxs(Text, {
+						bold: true,
+						color: "cyan",
+						children: ["  BUILD ", serviceName ? /* @__PURE__ */ jsxs(Text, {
+							dimColor: true,
+							children: [
+								"(",
+								serviceName,
+								")"
+							]
+						}) : null]
+					})
+				});
+				for (const [i, msg] of state$1.platformMessages.entries()) newItems.push({
+					id: `platform-${i}`,
+					node: /* @__PURE__ */ jsxs(Text, { children: ["  ", msg] })
+				});
+				newItems.push({
+					id: "header-gap",
+					node: /* @__PURE__ */ jsx(Text, { children: "" })
+				});
+			}
+			const stageNames = state$1.displayOrder.filter((d) => d.kind === "stage").map((d) => d.name);
+			const maxNameLen = Math.max(...stageNames.map((n) => n.length), 4);
+			for (let i = state$1.committedCount; i < state$1.displayOrder.length; i++) {
+				const item = state$1.displayOrder[i];
+				if (!isItemComplete(item)) break;
+				if (item.kind === "stage") {
+					const stage = state$1.stages.get(item.name);
+					const stats = getStageStats(stage);
+					const counter = `${stats.finishedCount}/${stage.total}`;
+					const barNode = stats.allCached ? /* @__PURE__ */ jsxs(Text, {
+						color: BRAND_COLOR,
+						children: [
+							"━".repeat(BAR_WIDTH),
+							" ",
+							counter,
+							" ✓ veloz cache"
+						]
+					}) : /* @__PURE__ */ jsxs(Text, {
+						color: "green",
+						children: [
+							"━".repeat(BAR_WIDTH),
+							" ",
+							counter,
+							" ✓"
+						]
+					});
+					newItems.push({
+						id: `stage-${item.name}`,
+						node: /* @__PURE__ */ jsxs(Box, { children: [
+							/* @__PURE__ */ jsxs(Text, {
+								bold: true,
+								children: ["  ", item.name.padEnd(maxNameLen)]
+							}),
+							/* @__PURE__ */ jsx(Text, { children: " " }),
+							barNode
+						] })
+					});
+					const sortedSteps = [...stage.steps.entries()].sort((a, b) => a[0] - b[0]);
+					for (const [stepNum, command] of sortedSteps) {
+						const stepStatus = getStepStatus(stepNum, stage);
+						const detail = state$1.stepDetails.get(`${item.name}-${stepNum}`);
+						const icon = stepStatus === "cached" ? /* @__PURE__ */ jsx(Text, {
+							color: BRAND_COLOR,
+							children: "✓"
+						}) : /* @__PURE__ */ jsx(Text, {
+							color: "green",
+							children: "✓"
+						});
+						const suffix = stepStatus === "cached" ? /* @__PURE__ */ jsx(Text, {
+							color: BRAND_COLOR,
+							children: " (veloz cache)"
+						}) : detail?.duration ? /* @__PURE__ */ jsxs(Text, {
+							dimColor: true,
+							children: [" ", detail.duration]
+						}) : null;
+						newItems.push({
+							id: `step-${item.name}-${stepNum}`,
+							node: /* @__PURE__ */ jsxs(Text, { children: [
+								"    ",
+								icon,
+								" ",
+								/* @__PURE__ */ jsx(Text, {
+									dimColor: true,
+									children: command
+								}),
+								suffix
+							] })
+						});
+					}
+				} else {
+					const step = item.step;
+					const title = friendlyExtraTitle(step.title);
+					const duration = step.duration && step.duration !== "cached" ? ` ${step.duration}` : "";
+					newItems.push({
+						id: `extra-${i}`,
+						node: /* @__PURE__ */ jsxs(Text, { children: [
+							"  ",
+							/* @__PURE__ */ jsx(Text, {
+								color: "green",
+								children: "✓"
+							}),
+							" ",
+							/* @__PURE__ */ jsxs(Text, {
+								dimColor: true,
+								children: [title, duration]
+							})
+						] })
+					});
+				}
+				newItems.push({
+					id: `gap-${i}`,
+					node: /* @__PURE__ */ jsx(Text, { children: "" })
+				});
+				state$1.committedCount = i + 1;
+			}
+			if (newItems.length > 0) setStaticLines((prev) => [...prev, ...newItems]);
+		}
+		/** Force-commit all remaining items (even if not complete) — used at phase transitions */
+		function commitAllRemaining() {
+			const newItems = [];
+			const stageNames = state$1.displayOrder.filter((d) => d.kind === "stage").map((d) => d.name);
+			const maxNameLen = Math.max(...stageNames.map((n) => n.length), 4);
+			for (let i = state$1.committedCount; i < state$1.displayOrder.length; i++) {
+				const item = state$1.displayOrder[i];
+				if (item.kind === "stage") {
+					const stage = state$1.stages.get(item.name);
+					const stats = getStageStats(stage);
+					const counter = `${stats.finishedCount}/${stage.total}`;
+					const barNode = stats.allCached ? /* @__PURE__ */ jsxs(Text, {
+						color: BRAND_COLOR,
+						children: [
+							"━".repeat(BAR_WIDTH),
+							" ",
+							counter,
+							" ✓ veloz cache"
+						]
+					}) : stats.allDone ? /* @__PURE__ */ jsxs(Text, {
+						color: "green",
+						children: [
+							"━".repeat(BAR_WIDTH),
+							" ",
+							counter,
+							" ✓"
+						]
+					}) : /* @__PURE__ */ jsxs(Text, { children: [
+						/* @__PURE__ */ jsx(Text, {
+							color: "cyan",
+							children: "━".repeat(Math.round(stats.finishedCount / Math.max(stage.total, 1) * BAR_WIDTH))
+						}),
+						/* @__PURE__ */ jsx(Text, {
+							dimColor: true,
+							children: "─".repeat(BAR_WIDTH - Math.round(stats.finishedCount / Math.max(stage.total, 1) * BAR_WIDTH))
+						}),
+						/* @__PURE__ */ jsxs(Text, {
+							dimColor: true,
+							children: [" ", counter]
+						})
+					] });
+					newItems.push({
+						id: `stage-${item.name}`,
+						node: /* @__PURE__ */ jsxs(Box, { children: [
+							/* @__PURE__ */ jsxs(Text, {
+								bold: true,
+								children: ["  ", item.name.padEnd(maxNameLen)]
+							}),
+							/* @__PURE__ */ jsx(Text, { children: " " }),
+							barNode
+						] })
+					});
+					const sortedSteps = [...stage.steps.entries()].sort((a, b) => a[0] - b[0]);
+					for (const [stepNum, command] of sortedSteps) {
+						const stepStatus = getStepStatus(stepNum, stage);
+						const detail = state$1.stepDetails.get(`${item.name}-${stepNum}`);
+						const icon = stepStatus === "cached" ? /* @__PURE__ */ jsx(Text, {
+							color: BRAND_COLOR,
+							children: "✓"
+						}) : stepStatus === "done" || stepStatus === "cached" ? /* @__PURE__ */ jsx(Text, {
+							color: "green",
+							children: "✓"
+						}) : /* @__PURE__ */ jsx(Text, {
+							dimColor: true,
+							children: "·"
+						});
+						const suffix = stepStatus === "cached" ? /* @__PURE__ */ jsx(Text, {
+							color: BRAND_COLOR,
+							children: " (veloz cache)"
+						}) : detail?.duration ? /* @__PURE__ */ jsxs(Text, {
+							dimColor: true,
+							children: [" ", detail.duration]
+						}) : null;
+						newItems.push({
+							id: `step-${item.name}-${stepNum}`,
+							node: /* @__PURE__ */ jsxs(Text, { children: [
+								"    ",
+								icon,
+								" ",
+								/* @__PURE__ */ jsx(Text, {
+									dimColor: true,
+									children: command
+								}),
+								suffix
+							] })
+						});
+					}
+				} else {
+					const step = item.step;
+					const isDone = step.status === "done" || step.status === "cached";
+					const title = friendlyExtraTitle(step.title);
+					const duration = isDone && step.duration && step.duration !== "cached" ? ` ${step.duration}` : "";
+					const icon = isDone ? /* @__PURE__ */ jsx(Text, {
+						color: "green",
+						children: "✓"
+					}) : /* @__PURE__ */ jsx(Text, {
+						dimColor: true,
+						children: "·"
+					});
+					newItems.push({
+						id: `extra-${i}`,
+						node: /* @__PURE__ */ jsxs(Text, { children: [
+							"  ",
+							icon,
+							" ",
+							/* @__PURE__ */ jsxs(Text, {
+								dimColor: true,
+								children: [title, duration]
+							})
+						] })
+					});
+				}
+				newItems.push({
+					id: `gap-${i}`,
+					node: /* @__PURE__ */ jsx(Text, { children: "" })
+				});
+			}
+			state$1.committedCount = state$1.displayOrder.length;
+			return newItems;
+		}
+		const consume = async () => {
+			try {
+				for await (const event of stream) if (event.type === "status") {
+					state$1.finalStatus = event.content;
+					switch (event.content) {
+						case "BUILDING":
+							state$1.phase = "building";
+							forceUpdate((n) => n + 1);
+							break;
+						case "DEPLOYING":
+							if (accumulatedBuildLogs) applyBuildParse();
+							for (const stage of state$1.stages.values()) if (stage.steps.size > 0 && stage.steps.size < stage.total) stage.total = stage.steps.size;
+							commitCompleted();
+							if (state$1.committedCount < state$1.displayOrder.length) {
+								const remaining = commitAllRemaining();
+								if (remaining.length > 0) setStaticLines((prev) => [...prev, ...remaining]);
+							}
+							state$1.phase = "deploying";
+							forceUpdate((n) => n + 1);
+							break;
+						case "LIVE":
+							setStaticLines((prev) => [...prev, {
+								id: "live-status",
+								node: /* @__PURE__ */ jsxs(Text, {
+									color: "green",
+									children: ["  ", "✓ Publicado"]
+								})
+							}]);
+							state$1.phase = "live";
+							forceUpdate((n) => n + 1);
+							break;
+						default: if (TERMINAL_STATUSES.has(event.content)) {
+							if (accumulatedBuildLogs) applyBuildParse();
+							if (state$1.phase === "building" || state$1.phase === "waiting") {
+								commitCompleted();
+								if (state$1.committedCount < state$1.displayOrder.length) {
+									const remaining = commitAllRemaining();
+									if (remaining.length > 0) setStaticLines((prev) => [...prev, ...remaining]);
+								}
+							}
+							state$1.phase = "failed";
+							forceUpdate((n) => n + 1);
+						}
+					}
+				} else if (event.type === "log") {
+					const lines = event.content.split("\n");
+					allLogs.push(...lines);
+					if (state$1.phase === "deploying" || state$1.phase === "live") {
+						for (const line of lines) {
+							const trimmed = line.trim();
+							if (!trimmed) continue;
+							const parsed = parseBuildLine(trimmed);
+							let text = null;
+							if (parsed.kind === "platform") text = parsed.message;
+							else if (parsed.kind === "other" && parsed.text) text = parsed.text;
+							else if (parsed.kind === "output") text = parsed.text;
+							if (text && !isHiddenMessage(text)) {
+								const logId = runtimeLogId++;
+								const newItems = [];
+								if (logId === 0) newItems.push({
+									id: "runtime-header",
+									node: /* @__PURE__ */ jsx(Text, {
+										bold: true,
+										color: "cyan",
+										children: "\n  RUNTIME"
+									})
+								});
+								newItems.push({
+									id: `log-${logId}`,
+									node: /* @__PURE__ */ jsxs(Text, { children: ["  ", text] })
+								});
+								setStaticLines((prev) => [...prev, ...newItems]);
+							}
+						}
+						continue;
+					}
+					if (state$1.phase === "waiting") state$1.phase = "building";
+					if (accumulatedBuildLogs && !accumulatedBuildLogs.endsWith("\n")) accumulatedBuildLogs += "\n";
+					accumulatedBuildLogs += event.content;
+					applyBuildParse();
+					commitCompleted();
+					forceUpdate((n) => n + 1);
+				}
+			} catch {}
+			resultRef.current = {
+				status: state$1.finalStatus,
+				logs: allLogs.filter((l) => l.trim())
+			};
+			setShouldExit(true);
+		};
+		consume();
+	}, [
+		stream,
+		serviceName,
+		resultRef,
+		exit,
+		setShouldExit
+	]);
+	const state = stateRef.current;
+	const showBuild = state.phase === "waiting" || state.phase === "building";
+	const showDeploySpinner = state.phase === "deploying";
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		children: [
+			/* @__PURE__ */ jsx(Static, {
+				items: staticLines,
+				children: (line) => /* @__PURE__ */ jsx(Box, { children: line.node }, line.id)
+			}),
+			showBuild && /* @__PURE__ */ jsx(BuildDashboard, {
+				serviceName,
+				stages: state.stages,
+				displayOrder: state.displayOrder,
+				committedCount: state.committedCount,
+				platformMessages: state.platformMessages,
+				stepDetails: state.stepDetails,
+				spinnerText: state.phase === "waiting" ? "Aguardando início do build..." : "Compilando..."
+			}),
+			showDeploySpinner && /* @__PURE__ */ jsxs(Box, {
+				paddingLeft: 2,
+				children: [/* @__PURE__ */ jsx(AnimatedSpinner, {}), /* @__PURE__ */ jsx(Text, { children: " Publicando..." })]
+			})
+		]
+	});
+}
+async function fetchDeployUrls(client, serviceId) {
+	try {
+		return (await client.domains.list({ serviceId })).map((d) => `https://${d.domain}`);
+	} catch {
+		return [];
+	}
+}
+function getFailureHints(status) {
+	switch (status) {
+		case "BUILD_FAILED": return [
+			"Verifique os logs de build acima para erros de compilação",
+			"Teste o build localmente: rode o comando de build do seu projeto",
+			"Use 'veloz config show' para verificar as configurações"
+		];
+		case "DEPLOY_FAILED": return [
+			"O build passou mas o serviço falhou ao iniciar",
+			"Verifique se a porta configurada está correta: 'veloz config show'",
+			"Veja os logs de runtime: 'veloz logs -f'"
+		];
+		case "CANCELLED": return ["Deploy cancelado. Execute 'veloz deploy' para tentar novamente."];
+		default: return ["Execute 'veloz logs -f' para mais detalhes."];
+	}
+}
+async function renderDeployTUI(deploymentId, serviceId, serviceName) {
+	const client = await getClient();
+	const stream = await client.logs.streamBuildLogs({ deploymentId });
+	const resultRef = { current: {
+		status: "",
+		logs: []
+	} };
+	const instance = render(/* @__PURE__ */ jsx(DeployTUIApp, {
+		stream,
+		serviceName,
+		resultRef
+	}), {
+		exitOnCtrlC: false,
+		patchConsole: false
+	});
+	try {
+		await instance.waitUntilExit();
+	} catch {
+		instance.unmount();
+	}
+	if (!resultRef.current.status) try {
+		const d = await client.deployments.get({ deploymentId });
+		resultRef.current.status = d.status;
+		try {
+			const logs = await client.logs.getBuildLogs({ deploymentId });
+			if (logs.buildLogs) resultRef.current.logs.push(...logs.buildLogs.split("\n"));
+		} catch {}
+	} catch {}
+	const urls = resultRef.current.status === "LIVE" ? await fetchDeployUrls(client, serviceId) : [];
+	const finalStatus = resultRef.current.status;
+	if (finalStatus === "LIVE") {
+		success(serviceName ? `Deploy de ${chalk.bold(serviceName)} concluído! Serviço ativo.` : "Deploy concluído! Serviço ativo.");
+		for (const url of urls) info(chalk.bold(url));
+	} else if (TERMINAL_STATUSES.has(finalStatus)) {
+		const label = statusLabels[finalStatus] ?? finalStatus;
+		const hints = getFailureHints(finalStatus);
+		const allLogs = resultRef.current.logs;
+		if (allLogs.length > 0) {
+			process.stderr.write("\n");
+			process.stderr.write(chalk.red(`  ${"─".repeat(50)}`) + "\n");
+			process.stderr.write(chalk.red.bold("  Logs de build:") + "\n");
+			process.stderr.write(chalk.red(`  ${"─".repeat(50)}`) + "\n");
+			for (const line of allLogs) if (line.trim()) process.stderr.write(chalk.dim(`  ${line}`) + "\n");
+			process.stderr.write(chalk.red(`  ${"─".repeat(50)}`) + "\n");
+		}
+		const errorMsg = serviceName ? `Deploy de ${chalk.bold(serviceName)} finalizou: ${label}` : `Deploy finalizou: ${label}`;
+		process.stderr.write(chalk.red(`\n✗ ${errorMsg}`) + "\n");
+		for (const hint of hints) process.stderr.write(chalk.yellow(`  → ${hint}`) + "\n");
+		process.exit(1);
+	}
+	return {
+		status: finalStatus,
+		logs: resultRef.current.logs.filter((l) => l.trim()),
+		urls,
+		serviceName
+	};
+}
+
+//#endregion
+export { renderDeployTUI };

package/dist/index.mjs

@@ -943,7 +943,7 @@ const requireAuth = middleware(async (_c, next) => {
 			console.error("Não autorizado. Defina VELOZ_API_KEY ou execute `veloz login`.");
 			process.exit(1);
 		}
-		const { performLogin: performLogin$1 } = await import("./login-jxR-lGEN.mjs");
+		const { performLogin: performLogin$1 } = await import("./login-DEQ5zMzL.mjs");
 		await performLogin$1();
 	}
 	await next();
@@ -4299,236 +4299,19 @@ function parseBuildLine(raw) {
 		text: trimmed
 	};
 }
-const BAR_WIDTH = 20;
-const BRAND = chalk.rgb(255, 77, 0);
-function renderProgressBar(filled, total, allCached, allDone) {
-	const ratio = total > 0 ? filled / total : 0;
-	const filledChars = Math.round(ratio * BAR_WIDTH);
-	const emptyChars = BAR_WIDTH - filledChars;
-	const counter = `${filled}/${total}`;
-	if (allCached) return `${BRAND("━".repeat(BAR_WIDTH))} ${BRAND(`${counter} ◆ cached`)}`;
-	if (allDone) return `${chalk.green("━".repeat(BAR_WIDTH))} ${chalk.green(`${counter} ✓`)}`;
-	return chalk.cyan("━".repeat(filledChars)) + chalk.dim("─".repeat(emptyChars)) + ` ${chalk.dim(counter)}`;
-}
-const SPINNER_FRAMES = [
-	"⠋",
-	"⠙",
-	"⠹",
-	"⠸",
-	"⠼",
-	"⠴",
-	"⠦",
-	"⠧",
-	"⠇",
-	"⠏"
-];
-/**
-* Dashboard-style renderer for compact TTY mode.
-* Redraws the entire build progress block on each update.
-* Includes an integrated spinner that animates via setInterval.
-*/
-var BuildProgressRenderer = class {
-	stages = /* @__PURE__ */ new Map();
-	stageOrder = [];
-	platformMessages = [];
-	renderLineCount = 0;
-	phase = "waiting";
-	runtimeHeaderPrinted = false;
-	serviceName;
-	spinnerFrame = 0;
-	spinnerInterval = null;
-	spinnerText = "Aguardando início do build...";
-	/** External ora spinner reference — used to pause/resume during runtime log output */
-	externalSpinner = null;
-	/** Pending render scheduled via setTimeout for batching rapid updates */
-	pendingRender = null;
-	constructor(serviceName) {
-		this.serviceName = serviceName;
-		this.startSpinner();
-	}
-	setExternalSpinner(spinner$1) {
-		this.externalSpinner = spinner$1;
-	}
-	startSpinner() {
-		if (this.spinnerInterval) return;
-		this.spinnerInterval = setInterval(() => {
-			this.spinnerFrame = (this.spinnerFrame + 1) % SPINNER_FRAMES.length;
-			this.render();
-		}, 120);
-	}
-	stopSpinner() {
-		if (this.spinnerInterval) {
-			clearInterval(this.spinnerInterval);
-			this.spinnerInterval = null;
-		}
-		if (this.pendingRender) {
-			clearTimeout(this.pendingRender);
-			this.pendingRender = null;
-		}
-	}
-	setBuilding() {
-		this.phase = "building";
-		this.spinnerText = "Compilando...";
-	}
-	switchToRuntime() {
-		if (this.phase === "runtime") return;
-		for (const stage of this.stages.values()) if (stage.steps.size > 0 && stage.steps.size < stage.total) stage.total = stage.steps.size;
-		this.stopSpinner();
-		this.render();
-		this.renderLineCount = 0;
-		this.phase = "runtime";
-	}
-	processLine(raw) {
-		const trimmed = raw.trim();
-		if (!trimmed) return;
-		if (this.phase === "runtime") {
-			this.printRuntimeLine(trimmed);
-			return;
-		}
-		if (this.phase === "waiting") {
-			this.phase = "building";
-			this.spinnerText = "Compilando...";
-		}
-		const parsed = parseBuildLine(trimmed);
-		switch (parsed.kind) {
-			case "step": {
-				let stage = this.stages.get(parsed.stage);
-				if (!stage) {
-					stage = {
-						name: parsed.stage,
-						total: parsed.total,
-						steps: /* @__PURE__ */ new Map(),
-						stepNumMap: /* @__PURE__ */ new Map(),
-						cachedStepNums: /* @__PURE__ */ new Set(),
-						doneStepNums: /* @__PURE__ */ new Set()
-					};
-					this.stages.set(parsed.stage, stage);
-					this.stageOrder.push(parsed.stage);
-				}
-				stage.steps.set(parsed.step, parsed.command);
-				stage.stepNumMap.set(parsed.stepNum, parsed.step);
-				stage.total = Math.max(stage.total, parsed.total);
-				break;
-			}
-			case "cached":
-				for (const stage of this.stages.values()) if (stage.stepNumMap.has(parsed.stepNum)) {
-					stage.cachedStepNums.add(parsed.stepNum);
-					break;
-				}
-				break;
-			case "done":
-				for (const stage of this.stages.values()) if (stage.stepNumMap.has(parsed.stepNum)) {
-					stage.doneStepNums.add(parsed.stepNum);
-					break;
-				}
-				break;
-			case "platform": {
-				const cleaned = cleanDisplayLine(parsed.message);
-				if (cleaned) this.platformMessages.push(cleaned);
-				break;
-			}
-			case "output":
-			case "other": break;
-		}
-		this.scheduleRender();
-	}
-	printRuntimeLine(line) {
-		const parsed = parseBuildLine(line);
-		let text = null;
-		if (parsed.kind === "platform") text = parsed.message;
-		else if (parsed.kind === "other" && parsed.text) text = parsed.text;
-		else if (parsed.kind === "output") text = parsed.text;
-		if (!text) return;
-		if (isHiddenMessage(text)) return;
-		if (this.externalSpinner) this.externalSpinner.clear();
-		if (!this.runtimeHeaderPrinted) {
-			this.runtimeHeaderPrinted = true;
-			console.log(chalk.cyan.bold(`\n  RUNTIME`));
-		}
-		console.log(`  ${text}`);
-		if (this.externalSpinner) this.externalSpinner.render();
-	}
-	isStageComplete(stage) {
-		return stage.steps.size >= stage.total;
-	}
-	/**
-	* Schedule a render on the next tick — batches rapid processLine() calls
-	* so we don't re-render for every single log line in a burst.
-	*/
-	scheduleRender() {
-		if (this.pendingRender) return;
-		this.pendingRender = setTimeout(() => {
-			this.pendingRender = null;
-			this.render();
-		}, 0);
-	}
-	render() {
-		const buf = [];
-		if (this.renderLineCount > 0) buf.push(`\x1b[${this.renderLineCount}A\x1b[J`);
-		let lines = 0;
-		const label = this.serviceName ? `BUILD ${chalk.dim(`(${this.serviceName})`)}` : "BUILD";
-		buf.push(`${chalk.cyan.bold(`  ${label}`)}\n`);
-		lines++;
-		for (const msg of this.platformMessages) {
-			buf.push(`  ${msg}\n`);
-			lines++;
-		}
-		if (this.stageOrder.length > 0) {
-			buf.push("\n");
-			lines++;
-		}
-		const maxNameLen = Math.max(...this.stageOrder.map((n) => n.length), 4);
-		for (let i = 0; i < this.stageOrder.length; i++) {
-			const stageName = this.stageOrder[i];
-			const stage = this.stages.get(stageName);
-			const complete = this.isStageComplete(stage);
-			const allCached = complete && stage.cachedStepNums.size === stage.steps.size;
-			const allDone = complete && !allCached;
-			const bar = renderProgressBar(stage.steps.size, stage.total, allCached, allDone);
-			const paddedName = chalk.bold(stageName.padEnd(maxNameLen));
-			buf.push(`  ${paddedName} ${bar}\n`);
-			lines++;
-			const sortedSteps = [...stage.steps.entries()].sort((a, b) => a[0] - b[0]);
-			const spinnerChar = SPINNER_FRAMES[this.spinnerFrame];
-			for (const [stepNum, command] of sortedSteps) {
-				let stepStatus = "";
-				for (const [bkNum, dockerStep] of stage.stepNumMap.entries()) if (dockerStep === stepNum) {
-					if (stage.cachedStepNums.has(bkNum)) stepStatus = ` ${BRAND("◆")}`;
-					else if (stage.doneStepNums.has(bkNum)) stepStatus = ` ${chalk.green("✓")}`;
-					else stepStatus = ` ${chalk.cyan(spinnerChar)}`;
-					break;
-				}
-				buf.push(`    ${command}${stepStatus}\n`);
-				lines++;
-			}
-			if (i < this.stageOrder.length - 1) {
-				buf.push("\n");
-				lines++;
-			}
-		}
-		if (this.spinnerInterval) {
-			if (!(this.stageOrder.length > 0 && this.stageOrder.every((name) => this.isStageComplete(this.stages.get(name))))) {
-				const frame = SPINNER_FRAMES[this.spinnerFrame];
-				buf.push(`\n  ${chalk.cyan(frame)} ${this.spinnerText}\n`);
-				lines += 2;
-			}
-		}
-		process.stdout.write(buf.join(""));
-		this.renderLineCount = lines;
-	}
-};
 async function streamDeploymentLogs(deploymentId, serviceId, serviceName) {
 	const client = await getClient();
 	const isVerbose = process.env.VELOZ_VERBOSE === "true";
 	const mcp = isMcpMode();
 	const isTTY = !mcp && process.stdout.isTTY;
 	const isGHA = !mcp && process.env.GITHUB_ACTIONS === "true";
+	if (isTTY && !isVerbose) {
+		const { renderDeployTUI } = await import("./deploy-tui-U7fsZN6x.mjs");
+		return renderDeployTUI(deploymentId, serviceId, serviceName);
+	}
 	const allLogLines = [];
-	let buildSpinner = null;
-	let renderer = null;
 	if (mcp) log(serviceName ? `[deploy] Build: ${serviceName}` : "[deploy] Build iniciando...");
 	else if (isGHA) startGroup(serviceName ? `Build: ${serviceName}` : "Build");
-	else if (isTTY && !isVerbose) renderer = new BuildProgressRenderer(serviceName);
 	else if (isTTY) {
 		const header = serviceName ? `Build: ${chalk.bold(serviceName)}` : "Build";
 		console.log(chalk.cyan(`\n${header}`));
@@ -4544,29 +4327,7 @@ async function streamDeploymentLogs(deploymentId, serviceId, serviceName) {
 			const label = statusLabels[event.content] ?? event.content;
 			finalStatus = event.content;
 			if (mcp) log(`[deploy] Status: ${label}`);
-			else if (renderer) {
-				if (event.content === "BUILDING") renderer.setBuilding();
-				else if (event.content === "DEPLOYING") {
-					renderer.switchToRuntime();
-					buildSpinner = ora({
-						text: "Publicando...",
-						color: "cyan"
-					}).start();
-					renderer.setExternalSpinner(buildSpinner);
-				} else if (event.content === "LIVE") {
-					if (buildSpinner) {
-						renderer.setExternalSpinner(null);
-						buildSpinner.succeed("Publicado");
-						buildSpinner = null;
-					}
-				} else if (TERMINAL_STATUSES.has(event.content) && event.content !== "LIVE") {
-					if (buildSpinner) {
-						renderer.setExternalSpinner(null);
-						buildSpinner.fail(label);
-						buildSpinner = null;
-					}
-				}
-			} else {
+			else {
 				const icon = statusIcons[event.content] ?? chalk.yellow("●");
 				process.stdout.write(`\n${icon} ${chalk.bold(label)}\n`);
 			}
@@ -4575,15 +4336,9 @@ async function streamDeploymentLogs(deploymentId, serviceId, serviceName) {
 			allLogLines.push(...lines);
 			if (mcp) {
 				for (const line of lines) if (line.trim()) log(`[build] ${line.trim()}`);
-			} else if (renderer) for (const line of lines) renderer.processLine(line);
-			else for (const line of lines) if (line.trim()) process.stdout.write(`  ${line}\n`);
+			} else for (const line of lines) if (line.trim()) process.stdout.write(`  ${line}\n`);
 		}
 	} catch {
-		if (renderer) renderer.stopSpinner();
-		if (buildSpinner) {
-			buildSpinner.stop();
-			buildSpinner = null;
-		}
 		try {
 			finalStatus = (await client.deployments.get({ deploymentId })).status;
 			try {
@@ -4593,20 +4348,11 @@ async function streamDeploymentLogs(deploymentId, serviceId, serviceName) {
 		} catch {}
 	}
 	if (isGHA) endGroup();
-	if (renderer) renderer.stopSpinner();
 	const urls = finalStatus === "LIVE" ? await fetchDeployUrls$1(client, serviceId) : [];
 	if (finalStatus === "LIVE") {
-		if (buildSpinner) {
-			buildSpinner.stop();
-			buildSpinner = null;
-		}
 		success(serviceName ? `Deploy de ${mcp ? serviceName : chalk.bold(serviceName)} concluído! Serviço ativo.` : "Deploy concluído! Serviço ativo.");
 		if (urls.length > 0) for (const url of urls) info(mcp ? url : `${chalk.bold(url)}`);
 	} else if (TERMINAL_STATUSES.has(finalStatus)) {
-		if (buildSpinner) {
-			buildSpinner.stop();
-			buildSpinner = null;
-		}
 		const label = statusLabels[finalStatus] ?? finalStatus;
 		const hints = getFailureHints$1(finalStatus);
 		if (mcp) {
@@ -4675,7 +4421,7 @@ const LOGO_LINES = [
 ];
 const BRAND_COLOR = "#FF4D00";
 function getVersion() {
-	return "0.0.0-beta.22";
+	return "0.0.0-beta.23";
 }
 function printBanner(subtitle) {
 	const version = getVersion();
@@ -5701,7 +5447,7 @@ async function autoUpdate() {
 	if (process.env.VELOZ_MCP === "true") return;
 	const pm = detectPackageManager();
 	if (!pm) return;
-	const currentVersion = "0.0.0-beta.22";
+	const currentVersion = "0.0.0-beta.23";
 	const latestVersion = await fetchLatestVersion();
 	if (!latestVersion || latestVersion === currentVersion) return;
 	const installCmd = getInstallCommand(pm, latestVersion);
@@ -7256,7 +7002,7 @@ async function pruneRemovedEntries(config, existingConfig, services, databases)
 //#region src/index.ts
 if (process.argv.includes("--mcp")) process.env.VELOZ_MCP = "true";
 const cli = Cli.create("veloz", {
-	version: "0.0.0-beta.22",
+	version: "0.0.0-beta.23",
 	description: "CLI da plataforma Veloz — deploy rápido para o Brasil",
 	env: z.object({ VELOZ_ENV: z.string().optional().describe("Ambiente alvo (ex: preview, staging)") })
 });
@@ -7332,4 +7078,4 @@ registerPull(cli);
 cli.serve();
 
 //#endregion
-export { registerLogin as n, performLogin as t };
+export { statusLabels as a, registerLogin as c, TERMINAL_STATUSES as i, info as l, isHiddenMessage as n, getClient as o, parseBuildLine as r, performLogin as s, cleanDisplayLine as t, success as u };

package/dist/login-DEQ5zMzL.mjs

@@ -0,0 +1,3 @@
+import { c as registerLogin, s as performLogin } from "./index.mjs";
+
+export { performLogin };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "onveloz",
-  "version": "0.0.0-beta.22",
+  "version": "0.0.0-beta.23",
   "description": "CLI da plataforma Veloz — deploy rápido para o Brasil",
   "keywords": [
     "brasil",
@@ -33,13 +33,16 @@
     "form-data": "^4.0.0",
     "ignore": "^5.3.0",
     "incur": "^0.3.3",
+    "ink": "^6.8.0",
     "ora": "^8.2.0",
+    "react": "^19.2.4",
     "tar": "^6.2.0",
     "ws": "^8.20.0",
     "zod": "^4.1.13"
   },
   "devDependencies": {
     "@types/node": "^22.13.14",
+    "@types/react": "^19.2.14",
     "@types/tar": "^6.1.11",
     "@types/ws": "^8.18.1",
     "@veloz/api": "workspace:*",

package/dist/login-jxR-lGEN.mjs

@@ -1,3 +0,0 @@
-import { n as registerLogin, t as performLogin } from "./index.mjs";
-
-export { performLogin };