onveloz 0.0.0-beta.4 → 0.0.0-beta.40

package/dist/deploy-tui-6DaoY351.mjs

@@ -0,0 +1,1097 @@
+import { a as statusLabels, i as TERMINAL_STATUSES, m as success, n as isHiddenMessage, o as getClient, p as info, r as parseBuildLine, t as cleanDisplayLine } 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 = /^\[\s*(?:([\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;
+}
+/** Matches the pre-start log section header written by the reconciler. */
+const PRE_START_HEADER_RE = /^──\s*Logs do comando pre-start/;
+/** Matches the pre-start unavailable message. */
+const PRE_START_UNAVAILABLE_RE = /^──\s*Logs do comando pre-start indisponíveis/;
+/** Matches the crash log section header written by the reconciler. */
+const CRASH_LOG_HEADER_RE = /^──\s*Logs do (?:serviço \(falha\)|container \(crash\))/;
+/** Matches the crash logs unavailable message. */
+const CRASH_LOG_UNAVAILABLE_RE = /^──\s*Logs do (?:serviço|container) indisponíveis/;
+/** Lines that mark the beginning of the deploy/rollout phase. */
+const DEPLOY_PHASE_MARKERS = [
+	/^Realizando deploy/,
+	/^Atualizando serviço/,
+	/^Criando serviço/,
+	/^Waiting for rollout/,
+	/^Updating deployment/,
+	/^Creating K8s deployment/
+];
+/** Lines that indicate the pre-start command is starting. */
+const PRE_START_MARKER_RE = /^Executando comando pre-start:/;
+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 isPreStartLine(content) {
+	const trimmed = content.trim();
+	return PRE_START_MARKER_RE.test(trimmed) || PRE_START_HEADER_RE.test(trimmed) || PRE_START_UNAVAILABLE_RE.test(trimmed);
+}
+function isDeployPhaseLine(content) {
+	const trimmed = content.trim();
+	return DEPLOY_PHASE_MARKERS.some((p) => p.test(trimmed)) || CRASH_LOG_HEADER_RE.test(trimmed) || CRASH_LOG_UNAVAILABLE_RE.test(trimmed);
+}
+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;
+		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;
+		const aSubstep = aInfo?.substep ?? a.step.stepNumber ?? 0;
+		const bSubstep = bInfo?.substep ?? b.step.stepNumber ?? 0;
+		if (aSubstep !== bSubstep) return aSubstep - bSubstep;
+		if (a.step.startedAt && b.step.startedAt) return new Date(a.step.startedAt).getTime() - new Date(b.step.startedAt).getTime();
+		return 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 finalizationLines = [];
+			const preStartLines = [];
+			const deployLines = [];
+			const healthLines = [];
+			let phase = "finalization";
+			let inCrashLogBlock = false;
+			for (const line of generalStep.lines) {
+				const content = line.content.trim();
+				if (CRASH_LOG_HEADER_RE.test(content) || PRE_START_HEADER_RE.test(content)) inCrashLogBlock = true;
+				if (phase === "finalization" && isPreStartLine(content)) phase = "prestart";
+				else if ((phase === "finalization" || phase === "prestart") && isDeployPhaseLine(content)) phase = "deploy";
+				else if ((phase === "finalization" || phase === "deploy") && !inCrashLogBlock && isRuntimeLine(content)) phase = "health";
+				switch (phase) {
+					case "finalization":
+						finalizationLines.push(line);
+						break;
+					case "prestart":
+						preStartLines.push(line);
+						break;
+					case "deploy":
+						deployLines.push(line);
+						break;
+					case "health":
+						healthLines.push(line);
+						break;
+				}
+			}
+			const hasPreStartError = preStartLines.some((l) => /pre-start falhou|FAILED/i.test(l.content));
+			const hasDeployError = deployLines.some((l) => /DEPLOY FAILED/i.test(l.content));
+			if (finalizationLines.length > 0) result.push({
+				stepNumber: null,
+				title: "Finalização",
+				duration: null,
+				status: "done",
+				lines: finalizationLines,
+				phase: generalStep.phase,
+				startedAt: finalizationLines[0]?.timestamp ?? generalStep.startedAt
+			});
+			if (preStartLines.length > 0) result.push({
+				stepNumber: null,
+				title: "Pre-start",
+				duration: null,
+				status: hasPreStartError ? "error" : "done",
+				lines: preStartLines,
+				phase: generalStep.phase,
+				startedAt: preStartLines[0]?.timestamp ?? null
+			});
+			if (deployLines.length > 0) result.push({
+				stepNumber: null,
+				title: "Deploy",
+				duration: null,
+				status: hasDeployError ? "error" : "done",
+				lines: deployLines,
+				phase: generalStep.phase,
+				startedAt: deployLines[0]?.timestamp ?? null
+			});
+			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 && !/^\[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 builds list' e 'veloz builds logs <id>' para revisar o build",
+			"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.stderr.write(chalk.yellow(`  → Use 'veloz builds logs ${deploymentId}' para ver os logs completos`) + "\n");
+		process.exit(1);
+	}
+	return {
+		deploymentId,
+		status: finalStatus,
+		logs: resultRef.current.logs.filter((l) => l.trim()),
+		urls,
+		serviceName
+	};
+}
+
+//#endregion
+export { renderDeployTUI };