@absolutejs/absolute 0.19.0-beta.666 → 0.19.0-beta.668

package/dist/cli/index.js

@@ -669,8 +669,8 @@ var exports_compile = {};
 __export(exports_compile, {
   compile: () => compile
 });
-var {env: env4 } = globalThis.Bun;
-import { existsSync as existsSync9, readdirSync, readFileSync as readFileSync8, unlinkSync } from "fs";
+var {env: env3 } = globalThis.Bun;
+import { existsSync as existsSync9, readdirSync, readFileSync as readFileSync9, unlinkSync } from "fs";
 import { basename as basename2, join as join6, relative, resolve as resolve7 } from "path";
 var cliTag3 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[cli]\x1B[0m ${color}${message}\x1B[0m`, collectFiles2 = (dir) => {
   const result = [];
@@ -686,9 +686,9 @@ var cliTag3 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
       result.push(fullPath);
   }
   return result;
-}, readPackageVersion2 = (candidate) => {
+}, readPackageVersion3 = (candidate) => {
   try {
-    const pkg = JSON.parse(readFileSync8(candidate, "utf-8"));
+    const pkg = JSON.parse(readFileSync9(candidate, "utf-8"));
     if (pkg.name !== "@absolutejs/absolute")
       return null;
     const ver = pkg.version;
@@ -696,9 +696,9 @@ var cliTag3 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   } catch {
     return null;
   }
-}, resolvePackageVersion2 = (candidates) => {
+}, resolvePackageVersion3 = (candidates) => {
   for (const candidate of candidates) {
-    const version2 = readPackageVersion2(candidate);
+    const version2 = readPackageVersion3(candidate);
     if (version2)
       return version2;
   }
@@ -848,12 +848,12 @@ console.log(\`
 \`);
 `;
 }, stubPlugin, FRAMEWORK_EXTERNALS, compile = async (serverEntry, outdir, outfile, configPath2) => {
-  const prerenderPort = Number(env4.COMPILE_PORT) || Number(env4.PORT) || DEFAULT_PORT + 1;
+  const prerenderPort = Number(env3.COMPILE_PORT) || Number(env3.PORT) || DEFAULT_PORT + 1;
   killStaleProcesses(prerenderPort);
   const entryName = basename2(serverEntry).replace(/\.[^.]+$/, "");
   const resolvedOutdir = resolve7(outdir ?? "dist");
   const resolvedOutfile = resolve7(outfile ?? "compiled-server");
-  const absoluteVersion = resolvePackageVersion2([
+  const absoluteVersion = resolvePackageVersion3([
     resolve7(import.meta.dir, "..", "..", "..", "package.json"),
     resolve7(import.meta.dir, "..", "..", "package.json")
   ]);
@@ -1050,17 +1050,17 @@ var run = async (name, command) => {
 }, shellEscape = (value) => `'${value.replaceAll("'", "'\\''")}'`, runShell = async (name, command) => run(name, ["/bin/bash", "-lc", command]), findBin = (name) => {
   const local = resolve8("node_modules", ".bin", name);
   return existsSync10(local) ? local : null;
-}, stripAnsi = (str) => str.replace(/\x1b\[[0-9;]*m/g, ""), formatSvelteOutput = (output) => {
+}, stripAnsi2 = (str) => str.replace(/\x1b\[[0-9;]*m/g, ""), formatSvelteOutput = (output) => {
   const cwd = `${process.cwd()}/`;
-  const summaryMatch = stripAnsi(output).match(/svelte-check found (\d+) error/);
+  const summaryMatch = stripAnsi2(output).match(/svelte-check found (\d+) error/);
   const errorCount = summaryMatch ? parseInt(summaryMatch[1] ?? "0", 10) : 0;
   const formatted = output.split(`
 `).filter((line) => {
-    const plain = stripAnsi(line);
+    const plain = stripAnsi2(line);
     return !plain.startsWith("Loading svelte-check") && !plain.startsWith("Getting Svelte") && !plain.startsWith("====") && !plain.startsWith("svelte-check found") && !/^\d+ (START|COMPLETED)/.test(plain) && plain.trim() !== "";
   }).flatMap((line) => {
     const result = line.replaceAll(cwd, "");
-    const plain = stripAnsi(result);
+    const plain = stripAnsi2(result);
     const pathMatch = plain.match(/^(\S+\.svelte):(\d+:\d+)$/);
     if (pathMatch) {
       return [
@@ -1068,9 +1068,9 @@ var run = async (name, command) => {
       ];
     }
     if (result.includes("\x1B[35m")) {
-      const plainLine = stripAnsi(result);
-      const before = stripAnsi(result.split("\x1B[35m")[0] ?? "");
-      const token = stripAnsi((result.split("\x1B[35m")[1] ?? "").split(/\x1b\[3[69]m/)[0] ?? "");
+      const plainLine = stripAnsi2(result);
+      const before = stripAnsi2(result.split("\x1B[35m")[0] ?? "");
+      const token = stripAnsi2((result.split("\x1B[35m")[1] ?? "").split(/\x1b\[3[69]m/)[0] ?? "");
       if (!token)
         return [result];
       const expanded = before.replace(/\t/g, "        ");
@@ -2379,14 +2379,568 @@ var start = async (serverEntry, outdir, configPath2) => {
 // src/cli/scripts/workspace.ts
 init_constants();
 init_loadConfig();
-init_startupBanner();
-var {$: $3 } = globalThis.Bun;
-import { existsSync as existsSync8 } from "fs";
+import { existsSync as existsSync8, readFileSync as readFileSync8 } from "fs";
 import { resolve as resolve6 } from "path";
+
+// src/cli/workspaceTui.ts
+init_constants();
+init_getDurationString();
+import { openSync as openSync2 } from "fs";
+import { ReadStream as ReadStream2 } from "tty";
+var MAX_LOG_ENTRIES = 400;
+var ESCAPE = "\x1B";
+var ANSI_REGEX = /\x1B\[[0-?]*[ -/]*[@-~]/g;
+var SHORTCUTS2 = new Map([
+  ["c", "clear"],
+  ["h", "help"],
+  ["o", "open"],
+  ["p", "pause"],
+  ["q", "quit"],
+  ["r", "restart"]
+]);
+var colors = {
+  bold: "\x1B[1m",
+  cyan: "\x1B[36m",
+  dim: "\x1B[2m",
+  green: "\x1B[32m",
+  red: "\x1B[31m",
+  reset: "\x1B[0m",
+  yellow: "\x1B[33m"
+};
+var helpLines = [
+  "Hotkeys",
+  "  h  Toggle help",
+  "  o  Open the first public service",
+  "  r  Restart the workspace",
+  "  p  Pause or resume all services",
+  "  c  Clear the log pane",
+  "  q  Quit",
+  "  $  Enter shell mode",
+  "",
+  "Shell mode",
+  '  Type a shell command after "$" and press enter.',
+  "  Press Esc to exit shell mode or dismiss help.",
+  "  Use \u2191 and \u2193 to recall prior shell commands."
+];
+var trySetRawMode2 = () => {
+  if (typeof process.stdin.setRawMode !== "function") {
+    return null;
+  }
+  try {
+    process.stdin.setRawMode(true);
+  } catch {
+    return null;
+  }
+  return process.stdin;
+};
+var openTtyStream2 = () => {
+  const fromStdin = trySetRawMode2();
+  if (fromStdin) {
+    return fromStdin;
+  }
+  try {
+    const ttyStream = new ReadStream2(openSync2("/dev/tty", "r"));
+    ttyStream.setRawMode(true);
+    return ttyStream;
+  } catch {
+    return null;
+  }
+};
+var stripAnsi = (value) => value.replace(ANSI_REGEX, "");
+var visibleLength = (value) => stripAnsi(value).length;
+var truncateText = (value, width) => {
+  if (width <= 0) {
+    return "";
+  }
+  if (value.length <= width) {
+    return value;
+  }
+  if (width <= 1) {
+    return value.slice(0, width);
+  }
+  return `${value.slice(0, width - 1)}\u2026`;
+};
+var padLine = (value, width) => {
+  const plainLength = visibleLength(value);
+  if (plainLength >= width) {
+    return value;
+  }
+  return `${value}${" ".repeat(width - plainLength)}`;
+};
+var wrapText = (value, width) => {
+  if (width <= 0) {
+    return [""];
+  }
+  const lines = [];
+  for (const rawLine of value.split(`
+`)) {
+    const line = rawLine.trimEnd();
+    if (line.length === 0) {
+      lines.push("");
+      continue;
+    }
+    if (line.length <= width) {
+      lines.push(line);
+      continue;
+    }
+    const words = line.split(/\s+/);
+    let current = "";
+    for (const word of words) {
+      if (current.length === 0) {
+        if (word.length <= width) {
+          current = word;
+          continue;
+        }
+        for (let index = 0;index < word.length; index += width) {
+          lines.push(word.slice(index, index + width));
+        }
+        continue;
+      }
+      const next = `${current} ${word}`;
+      if (next.length <= width) {
+        current = next;
+        continue;
+      }
+      lines.push(current);
+      if (word.length <= width) {
+        current = word;
+        continue;
+      }
+      for (let index = 0;index < word.length; index += width) {
+        lines.push(word.slice(index, index + width));
+      }
+      current = "";
+    }
+    if (current.length > 0) {
+      lines.push(current);
+    }
+  }
+  return lines.length > 0 ? lines : [""];
+};
+var formatTimestamp2 = () => new Date().toLocaleTimeString([], {
+  hour: "numeric",
+  hour12: true,
+  minute: "2-digit",
+  second: "2-digit"
+});
+var getStatusColor = (status2) => {
+  if (status2 === "ready")
+    return colors.green;
+  if (status2 === "paused")
+    return colors.yellow;
+  if (status2 === "starting" || status2 === "restarting")
+    return colors.cyan;
+  if (status2 === "error")
+    return colors.red;
+  return colors.dim;
+};
+var getLogColor = (level) => {
+  if (level === "error")
+    return colors.red;
+  if (level === "warn")
+    return colors.yellow;
+  if (level === "success")
+    return colors.green;
+  return colors.reset;
+};
+var getSourceColor = (source) => {
+  if (source === "workspace")
+    return colors.cyan;
+  if (source === "shell")
+    return colors.yellow;
+  return colors.reset;
+};
+var getTargetLabel = (service) => {
+  if (service.visibility === "public" && service.url) {
+    return service.url;
+  }
+  if (service.port) {
+    return `localhost:${service.port} (internal)`;
+  }
+  return service.visibility === "internal" ? "internal service" : "no endpoint";
+};
+var getWorkspaceStatus = (services) => {
+  if (services.some((service) => service.status === "error")) {
+    return "error";
+  }
+  if (services.some((service) => service.status === "paused")) {
+    return "paused";
+  }
+  if (services.some((service) => ["pending", "starting", "restarting"].includes(service.status))) {
+    return "booting";
+  }
+  return "ready";
+};
+var createWorkspaceTui = ({
+  actions,
+  services,
+  version: version2
+}) => {
+  let input = null;
+  let disposed = false;
+  let renderTimer = null;
+  let shellMode = false;
+  let helpVisible = false;
+  let promptBuffer = "";
+  let escapeTimer = null;
+  let escapeBuffer = "";
+  let readyDurationMs = null;
+  const shellHistory = [];
+  let shellHistoryIndex = UNFOUND_INDEX;
+  const serviceStates = new Map(services.map((service) => [
+    service.name,
+    {
+      ...service,
+      status: "pending"
+    }
+  ]));
+  const logEntries = [];
+  const setRawMode = (enabled) => {
+    if (!input || typeof input.setRawMode !== "function") {
+      return;
+    }
+    try {
+      input.setRawMode(enabled);
+    } catch {}
+  };
+  const scheduleRender = () => {
+    if (disposed || renderTimer) {
+      return;
+    }
+    renderTimer = setTimeout(() => {
+      renderTimer = null;
+      render();
+    }, 16);
+  };
+  const clearPendingEscape = () => {
+    if (!escapeTimer) {
+      return;
+    }
+    clearTimeout(escapeTimer);
+    escapeTimer = null;
+  };
+  const armEscapeTimer = () => {
+    clearPendingEscape();
+    escapeTimer = setTimeout(() => {
+      escapeTimer = null;
+      escapeBuffer = "";
+      exitEscapeMode();
+    }, 30);
+  };
+  const resetPrompt = () => {
+    promptBuffer = "";
+    shellMode = false;
+    shellHistoryIndex = UNFOUND_INDEX;
+    scheduleRender();
+  };
+  const exitEscapeMode = () => {
+    clearPendingEscape();
+    escapeBuffer = "";
+    if (helpVisible) {
+      helpVisible = false;
+    } else {
+      resetPrompt();
+    }
+    scheduleRender();
+  };
+  const render = () => {
+    if (disposed) {
+      return;
+    }
+    const width = process.stdout.columns ?? 100;
+    const height = process.stdout.rows ?? 28;
+    const servicesSnapshot = [...serviceStates.values()];
+    const workspaceStatus = getWorkspaceStatus(servicesSnapshot);
+    const statusLabel = workspaceStatus === "ready" && readyDurationMs !== null ? `${colors.dim}ready in${colors.reset} ${colors.bold}${getDurationString(readyDurationMs)}${colors.reset}` : `${colors.dim}${workspaceStatus}${colors.reset}`;
+    const title = `${colors.cyan}${colors.bold}ABSOLUTEJS WORKSPACE${colors.reset} ${colors.dim}v${version2}${colors.reset}  ${statusLabel}`;
+    const divider = `${colors.dim}${"\u2500".repeat(Math.max(width, 1))}${colors.reset}`;
+    const serviceNameWidth = Math.max(7, ...servicesSnapshot.map((service) => service.name.length));
+    const visibilityWidth = 8;
+    const statusWidth = 10;
+    const rows = [];
+    rows.push(padLine(title, width));
+    rows.push(padLine(`${colors.bold}Services${colors.reset}`, width));
+    rows.push(divider);
+    for (const service of servicesSnapshot) {
+      const stateColor = getStatusColor(service.status);
+      const detail = service.detail ? ` \xB7 ${service.detail}` : "";
+      const targetWidth = Math.max(width - serviceNameWidth - visibilityWidth - statusWidth - 6, 8);
+      const target = truncateText(`${getTargetLabel(service)}${detail}`, targetWidth);
+      const row = `${colors.bold}${service.name.padEnd(serviceNameWidth)}${colors.reset}  ${colors.dim}${service.visibility.padEnd(visibilityWidth)}${colors.reset}  ${stateColor}${service.status.padEnd(statusWidth)}${colors.reset}  ${target}`;
+      rows.push(padLine(row, width));
+    }
+    rows.push(divider);
+    const footerLines = 3;
+    const fixedHeight = rows.length + footerLines;
+    const logHeight = Math.max(height - fixedHeight, 3);
+    const contentLines = helpVisible ? helpLines : logEntries.flatMap((entry) => {
+      const prefixPlain = `${entry.timestamp} [${entry.source}] `;
+      const prefixColor = `${colors.dim}${entry.timestamp}${colors.reset} ${getSourceColor(entry.source)}[${entry.source}]${colors.reset} `;
+      const wrapped = wrapText(entry.message, Math.max(width - prefixPlain.length, 12));
+      return wrapped.map((line, index) => {
+        if (index === 0) {
+          return `${prefixColor}${getLogColor(entry.level)}${line}${colors.reset}`;
+        }
+        return `${" ".repeat(prefixPlain.length)}${getLogColor(entry.level)}${line}${colors.reset}`;
+      });
+    });
+    const visibleContent = contentLines.length > logHeight ? contentLines.slice(contentLines.length - logHeight) : contentLines;
+    for (const line of visibleContent) {
+      rows.push(padLine(line, width));
+    }
+    for (let index = visibleContent.length;index < logHeight; index++) {
+      rows.push(" ".repeat(width));
+    }
+    rows.push(divider);
+    const footerText = helpVisible ? "Esc or h closes help" : "Hotkeys: h help  o open  r restart  p pause  c clear logs  q quit  $ shell";
+    rows.push(padLine(`${colors.dim}${truncateText(footerText, width)}${colors.reset}`, width));
+    const promptLine = shellMode ? `${colors.yellow}$ ${colors.reset}${truncateText(promptBuffer, Math.max(width - 2, 0))}` : `${colors.dim}Press a hotkey or $ for shell mode${colors.reset}`;
+    rows.push(padLine(promptLine, width));
+    const screen = rows.slice(0, height).map((line) => `\x1B[2K${line}`).join(`
+`);
+    process.stdout.write(`\x1B[H${screen}`);
+    if (shellMode) {
+      const promptColumn = Math.min(promptBuffer.length + 3, width);
+      const promptRow = Math.min(rows.length, height);
+      process.stdout.write(`\x1B[${promptRow};${promptColumn}H\x1B[?25h`);
+      return;
+    }
+    process.stdout.write("\x1B[?25l");
+  };
+  const setServiceStatus = (name, status2, detail) => {
+    const existing = serviceStates.get(name);
+    if (!existing) {
+      return;
+    }
+    existing.status = status2;
+    existing.detail = detail;
+    scheduleRender();
+  };
+  const setReadyDuration = (durationMs) => {
+    readyDurationMs = durationMs;
+    scheduleRender();
+  };
+  const addLog = (source, message, level = "info") => {
+    const cleanMessage = stripAnsi(message).trimEnd();
+    if (!cleanMessage) {
+      return;
+    }
+    for (const line of cleanMessage.split(`
+`)) {
+      logEntries.push({
+        level,
+        message: line,
+        source,
+        timestamp: formatTimestamp2()
+      });
+    }
+    if (logEntries.length > MAX_LOG_ENTRIES) {
+      logEntries.splice(0, logEntries.length - MAX_LOG_ENTRIES);
+    }
+    scheduleRender();
+  };
+  const clearLogs = () => {
+    logEntries.length = 0;
+    scheduleRender();
+  };
+  const navigateShellHistory = (direction) => {
+    if (!shellMode || shellHistory.length === 0) {
+      return;
+    }
+    if (direction === "up") {
+      if (shellHistoryIndex < shellHistory.length - 1) {
+        shellHistoryIndex++;
+      }
+    } else if (shellHistoryIndex <= 0) {
+      shellHistoryIndex = UNFOUND_INDEX;
+      promptBuffer = "";
+      scheduleRender();
+      return;
+    } else {
+      shellHistoryIndex--;
+    }
+    promptBuffer = shellHistoryIndex === UNFOUND_INDEX ? "" : shellHistory[shellHistory.length - 1 - shellHistoryIndex] ?? "";
+    scheduleRender();
+  };
+  const runShortcut = async (action) => {
+    if (action === "clear") {
+      clearLogs();
+      return;
+    }
+    if (action === "help") {
+      helpVisible = !helpVisible;
+      scheduleRender();
+      return;
+    }
+    await actions[action]();
+  };
+  const submitShellCommand = async () => {
+    const command = promptBuffer.trim();
+    if (!command) {
+      resetPrompt();
+      return;
+    }
+    shellHistory.push(command);
+    resetPrompt();
+    addLog("shell", `$ ${command}`, "info");
+    await actions.shell(command);
+  };
+  const handleEscapeSequence = (char) => {
+    if (!escapeBuffer) {
+      escapeBuffer = ESCAPE;
+    }
+    escapeBuffer += char;
+    if (escapeBuffer === `${ESCAPE}[`) {
+      armEscapeTimer();
+      return;
+    }
+    if (escapeBuffer === `${ESCAPE}[A`) {
+      clearPendingEscape();
+      escapeBuffer = "";
+      navigateShellHistory("up");
+      return;
+    }
+    if (escapeBuffer === `${ESCAPE}[B`) {
+      clearPendingEscape();
+      escapeBuffer = "";
+      navigateShellHistory("down");
+      return;
+    }
+    exitEscapeMode();
+  };
+  const handleChar = async (char) => {
+    if (char === "\x03") {
+      await actions.quit();
+      return;
+    }
+    if (char === ESCAPE) {
+      escapeBuffer = ESCAPE;
+      armEscapeTimer();
+      return;
+    }
+    if (escapeBuffer) {
+      handleEscapeSequence(char);
+      return;
+    }
+    if (char === "\x7F" || char === "\b") {
+      if (!shellMode) {
+        return;
+      }
+      if (promptBuffer.length > 0) {
+        promptBuffer = promptBuffer.slice(0, UNFOUND_INDEX);
+        scheduleRender();
+        return;
+      }
+      resetPrompt();
+      return;
+    }
+    if (char === "\r" || char === `
+`) {
+      if (shellMode) {
+        await submitShellCommand();
+      }
+      return;
+    }
+    if (char.charCodeAt(0) < ASCII_SPACE) {
+      return;
+    }
+    if (!shellMode) {
+      if (char === "$") {
+        shellMode = true;
+        promptBuffer = "";
+        scheduleRender();
+        return;
+      }
+      const shortcut = SHORTCUTS2.get(char.toLowerCase());
+      if (shortcut) {
+        await runShortcut(shortcut);
+      }
+      return;
+    }
+    promptBuffer += char;
+    scheduleRender();
+  };
+  const onResize = () => {
+    scheduleRender();
+  };
+  const onData = (chunk) => {
+    const chars = chunk.toString();
+    (async () => {
+      for (const char of chars) {
+        await handleChar(char);
+      }
+    })();
+  };
+  const start2 = () => {
+    process.stdout.write("\x1B[?1049h\x1B[2J\x1B[H\x1B[?25l");
+    input = openTtyStream2();
+    if (input) {
+      input.resume();
+      input.on("data", onData);
+    } else {
+      addLog("workspace", "Interactive TTY input is unavailable in this terminal.", "warn");
+    }
+    process.stdout.on("resize", onResize);
+    render();
+  };
+  const dispose = () => {
+    if (disposed) {
+      return;
+    }
+    disposed = true;
+    clearPendingEscape();
+    if (renderTimer) {
+      clearTimeout(renderTimer);
+      renderTimer = null;
+    }
+    process.stdout.off("resize", onResize);
+    if (input) {
+      input.off("data", onData);
+      setRawMode(false);
+      if (input !== process.stdin) {
+        input.destroy();
+      }
+    }
+    process.stdout.write("\x1B[?25h\x1B[?1049l");
+  };
+  return {
+    addLog,
+    clearLogs,
+    dispose,
+    setReadyDuration,
+    setServiceStatus,
+    start: start2
+  };
+};
+
+// src/cli/scripts/workspace.ts
 init_utils();
-var serviceTag = (name, color) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[${name}]\x1B[0m`;
-var workspaceTag = (color, message) => `${serviceTag("workspace", color)} ${color}${message}\x1B[0m`;
 var sleep = (ms) => new Promise((resolvePromise) => setTimeout(resolvePromise, ms));
+var readPackageVersion2 = (candidate) => {
+  try {
+    const pkg = JSON.parse(readFileSync8(candidate, "utf-8"));
+    if (pkg.name !== "@absolutejs/absolute") {
+      return null;
+    }
+    const version2 = pkg.version;
+    return version2;
+  } catch {
+    return null;
+  }
+};
+var resolvePackageVersion2 = () => {
+  const candidates = [
+    resolve6(import.meta.dir, "..", "..", "..", "package.json"),
+    resolve6(import.meta.dir, "..", "..", "..", "..", "package.json")
+  ];
+  for (const candidate of candidates) {
+    const version2 = readPackageVersion2(candidate);
+    if (version2) {
+      return version2;
+    }
+  }
+  return process.env.ABSOLUTE_VERSION || "unknown";
+};
 var getVisibility = (service) => service.visibility ?? "public";
 var getServiceUrl = (service) => {
   if (!service.port) {
@@ -2394,7 +2948,6 @@ var getServiceUrl = (service) => {
   }
   return `http://localhost:${service.port}/`;
 };
-var getServicePortLabel = (service) => service.port ? `${service.port}` : "no-port";
 var getHealthcheckUrl = (service) => {
   if (service.healthcheck) {
     return service.healthcheck;
@@ -2475,60 +3028,9 @@ var topologicallySortServices = (services) => {
   }
   return ordered;
 };
-var createLineForwarder = (name, color, dest, onBeforeWrite, onAfterWrite) => {
-  let buffer = "";
-  const writeLine = (line) => {
-    if (line.trim().length === 0) {
-      return;
-    }
-    onBeforeWrite?.();
-    dest.write(`${serviceTag(name, color)} ${line}
-`);
-    onAfterWrite?.();
-  };
-  return {
-    push: (chunk) => {
-      buffer += Buffer.from(chunk).toString();
-      const lines = buffer.split(`
-`);
-      buffer = lines.pop() ?? "";
-      for (const line of lines) {
-        writeLine(line);
-      }
-    },
-    flush: () => {
-      if (!buffer || buffer.trim().length === 0) {
-        buffer = "";
-        return;
-      }
-      writeLine(buffer);
-      buffer = "";
-    }
-  };
-};
-var pipeProcessLogs = (name, processHandle, onBeforeWrite, onAfterWrite) => {
-  const stdoutForwarder = createLineForwarder(name, "\x1B[36m", process.stdout, onBeforeWrite, onAfterWrite);
-  const stderrForwarder = createLineForwarder(name, "\x1B[31m", process.stderr, onBeforeWrite, onAfterWrite);
-  let bufferingStartupLogs = true;
-  const stdoutStartupChunks = [];
-  const stderrStartupChunks = [];
-  const releaseStartupLogs = () => {
-    if (!bufferingStartupLogs) {
-      return;
-    }
-    bufferingStartupLogs = false;
-    for (const chunk of stdoutStartupChunks) {
-      stdoutForwarder.push(chunk);
-    }
-    stdoutStartupChunks.length = 0;
-    stdoutForwarder.flush();
-    for (const chunk of stderrStartupChunks) {
-      stderrForwarder.push(chunk);
-    }
-    stderrStartupChunks.length = 0;
-    stderrForwarder.flush();
-  };
-  const forward = async (stream, forwarder, startupBuffer) => {
+var pipeProcessLogs = (name, processHandle, appendLog) => {
+  const forward = async (stream, level) => {
+    let buffer = "";
     const reader = stream.getReader();
     try {
       while (true) {
@@ -2539,28 +3041,33 @@ var pipeProcessLogs = (name, processHandle, onBeforeWrite, onAfterWrite) => {
         if (!value) {
           continue;
         }
-        if (bufferingStartupLogs) {
-          startupBuffer.push(value);
-          continue;
+        buffer += Buffer.from(value).toString();
+        const lines = buffer.split(`
+`);
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          if (line.trim().length === 0) {
+            continue;
+          }
+          appendLog(name, line, level);
         }
-        forwarder.push(value);
       }
     } finally {
-      if (!bufferingStartupLogs) {
-        forwarder.flush();
+      if (buffer.trim().length > 0) {
+        appendLog(name, buffer, level);
       }
       reader.releaseLock();
     }
   };
-  forward(processHandle.stdout, stdoutForwarder, stdoutStartupChunks);
-  forward(processHandle.stderr, stderrForwarder, stderrStartupChunks);
-  return { releaseStartupLogs };
+  forward(processHandle.stdout, "info");
+  forward(processHandle.stderr, "error");
 };
 var resolveService = (name, service, options) => {
   const cwd = resolve6(service.cwd ?? ".");
   const envVars = {
     ...process.env,
     ...service.env,
+    ABSOLUTE_WORKSPACE_MANAGED: "1",
     ABSOLUTE_WORKSPACE_SERVICE_NAME: name,
     ABSOLUTE_WORKSPACE_SERVICE_VISIBILITY: getVisibility(service),
     FORCE_COLOR: "1",
@@ -2599,13 +3106,6 @@ var resolveService = (name, service, options) => {
     visibility: getVisibility(service)
   };
 };
-var renderWorkspaceStepStart = (message) => {
-  process.stdout.write(`${workspaceTag("\x1B[36m", message)}\r`);
-};
-var renderWorkspaceStepDone = (message, color = "\x1B[32m") => {
-  process.stdout.write(`\r\x1B[2K${workspaceTag(color, message)}
-`);
-};
 var workspace = async (subcommand, options) => {
   if (subcommand !== "dev") {
     throw new Error(subcommand ? `Unknown workspace command: ${subcommand}` : "No workspace subcommand specified. Use `absolute workspace dev`.");
@@ -2617,20 +3117,31 @@ var workspace = async (subcommand, options) => {
   let shuttingDown = false;
   let restarting = false;
   let paused = false;
-  let workspaceReady = false;
-  let interactive = null;
-  const withPromptHidden = () => {
-    if (!workspaceReady) {
-      return;
-    }
-    interactive?.clearPrompt();
-  };
-  const restorePrompt = () => {
-    if (!workspaceReady) {
-      return;
-    }
-    interactive?.showPrompt();
-  };
+  let workspaceBootStartedAt = performance.now();
+  const absoluteVersion = resolvePackageVersion2();
+  const tui = createWorkspaceTui({
+    actions: {
+      open: () => openInBrowser(),
+      pause: () => {
+        togglePause();
+      },
+      quit: () => {
+        shutdown(0);
+      },
+      restart: () => restartWorkspace(),
+      shell: (command) => runShellCommand2(command)
+    },
+    services: orderedNames.map((name) => {
+      const service = workspaceConfig.services[name];
+      return {
+        name,
+        port: service?.port,
+        url: service ? getServiceUrl(service) : null,
+        visibility: service ? getVisibility(service) : "public"
+      };
+    }),
+    version: absoluteVersion
+  });
   const killProcesses = async () => {
     const snapshot = [...running];
     running.length = 0;
@@ -2655,9 +3166,7 @@ var workspace = async (subcommand, options) => {
       return;
     }
     shuttingDown = true;
-    if (interactive) {
-      interactive.dispose();
-    }
+    tui.dispose();
     if (paused) {
       for (const service of running) {
         sendSignalToService(service.process, "SIGCONT");
@@ -2667,33 +3176,8 @@ var workspace = async (subcommand, options) => {
     await killProcesses();
     process.exit(exitCode);
   };
-  const buildWorkspaceReadySummary = () => {
-    const publicServices = orderedNames.map((name) => {
-      const service = workspaceConfig.services[name];
-      if (!service || getVisibility(service) !== "public") {
-        return null;
-      }
-      const url = getServiceUrl(service);
-      return url ? `${name} ${url}` : name;
-    }).filter((value) => Boolean(value));
-    const internalServices = orderedNames.map((name) => {
-      const service = workspaceConfig.services[name];
-      if (!service || getVisibility(service) !== "internal") {
-        return null;
-      }
-      return service.port ? `${name} on ${service.port}` : name;
-    }).filter((value) => Boolean(value));
-    const segments = [];
-    if (publicServices.length > 0) {
-      segments.push(...publicServices);
-    }
-    if (internalServices.length > 0) {
-      segments.push(`internal: ${internalServices.join(", ")}`);
-    }
-    return segments.join(" \xB7 ");
-  };
   const startServices = async () => {
-    workspaceReady = false;
+    tui.setReadyDuration(null);
     for (const name of orderedNames) {
       const service = workspaceConfig.services[name];
       if (!service) {
@@ -2707,7 +3191,7 @@ var workspace = async (subcommand, options) => {
       if (resolved.service.kind === "absolute" && resolved.configPath && !existsSync8(resolved.configPath)) {
         throw new Error(`${name} references missing config "${resolved.configPath}"`);
       }
-      renderWorkspaceStepStart(`Starting ${name} (${resolved.visibility}, ${getServicePortLabel(resolved.service)})...`);
+      tui.setServiceStatus(name, restarting ? "restarting" : "starting");
       const processHandle = Bun.spawn(resolved.command, {
         cwd: resolved.cwd,
         env: resolved.env,
@@ -2715,12 +3199,11 @@ var workspace = async (subcommand, options) => {
         stdin: "ignore",
         stdout: "pipe"
       });
-      const { releaseStartupLogs } = pipeProcessLogs(name, processHandle, withPromptHidden, restorePrompt);
+      pipeProcessLogs(name, processHandle, tui.addLog);
       const runningService = {
         name,
         process: processHandle,
-        resolved,
-        releaseStartupLogs
+        resolved
       };
       running.push(runningService);
       processHandle.exited.then((exitCode) => {
@@ -2730,59 +3213,72 @@ var workspace = async (subcommand, options) => {
         if (!running.includes(runningService)) {
           return;
         }
-        console.error(workspaceTag("\x1B[31m", `${name} exited with code ${exitCode}. Shutting down workspace.`));
+        tui.setServiceStatus(name, "error", `exit code ${exitCode || 1}`);
+        tui.addLog("workspace", `${name} exited with code ${exitCode || 1}. Shutting down workspace.`, "error");
         shutdown(exitCode || 1);
       });
       await waitForHealthcheck(getHealthcheckUrl(resolved.service));
-      renderWorkspaceStepDone(`${name} ready`);
-      releaseStartupLogs();
+      tui.setServiceStatus(name, "ready");
     }
-    workspaceReady = true;
-    console.log(workspaceTag("\x1B[32m", `Ready \xB7 ${buildWorkspaceReadySummary()}`));
-    printHint();
-    interactive?.showPrompt();
   };
   const restartWorkspace = async () => {
     if (shuttingDown || restarting) {
       return;
     }
     restarting = true;
-    workspaceReady = false;
     if (paused) {
       for (const service of running) {
         sendSignalToService(service.process, "SIGCONT");
       }
       paused = false;
     }
-    withPromptHidden();
-    console.log(workspaceTag("\x1B[36m", "Restarting workspace..."));
+    tui.addLog("workspace", "Restarting workspace...", "info");
+    for (const name of orderedNames) {
+      tui.setServiceStatus(name, "restarting");
+    }
     await killProcesses();
     restarting = false;
+    workspaceBootStartedAt = performance.now();
     await startServices();
+    tui.setReadyDuration(performance.now() - workspaceBootStartedAt);
+    tui.addLog("workspace", "Workspace ready.", "success");
   };
   const togglePause = () => {
     if (paused) {
       for (const service of running) {
         sendSignalToService(service.process, "SIGCONT");
+        tui.setServiceStatus(service.name, "ready");
       }
       paused = false;
-      console.log(workspaceTag("\x1B[32m", "Workspace resumed."));
+      tui.addLog("workspace", "Workspace resumed.", "success");
     } else {
       for (const service of running) {
         sendSignalToService(service.process, "SIGSTOP");
+        tui.setServiceStatus(service.name, "paused");
       }
       paused = true;
-      console.log(`${workspaceTag("\x1B[33m", "Workspace paused.")} \x1B[90m[paused]\x1B[0m`);
+      tui.addLog("workspace", "Workspace paused.", "warn");
     }
   };
   const runShellCommand2 = async (command) => {
-    await $3`${{ raw: command }}`.env({ ...process.env, FORCE_COLOR: "1" }).nothrow();
+    const processHandle = Bun.spawn(["bash", "-lc", command], {
+      env: { ...process.env, FORCE_COLOR: "1" },
+      stderr: "pipe",
+      stdout: "pipe"
+    });
+    pipeProcessLogs("shell", processHandle, tui.addLog);
+    const exitCode = await processHandle.exited;
+    if (exitCode === 0) {
+      tui.addLog("workspace", `Shell command finished: ${command}`, "success");
+      return;
+    }
+    tui.addLog("workspace", `Shell command failed with exit code ${exitCode}: ${command}`, "error");
   };
   const openInBrowser = async () => {
     const publicService = orderedNames.map((name) => workspaceConfig.services[name]).find((service) => service && getVisibility(service) === "public");
     const url = publicService ? getServiceUrl(publicService) : null;
     if (!url) {
-      console.log(workspaceTag("\x1B[33m", "No public service to open."));
+      tui.addLog("workspace", "No public service to open.", "warn");
       return;
     }
     const { platform: platform4 } = process;
@@ -2803,35 +3299,22 @@ var workspace = async (subcommand, options) => {
         stderr: "ignore",
         stdout: "ignore"
       });
-      console.log(workspaceTag("\x1B[36m", `Opening ${url}`));
+      tui.addLog("workspace", `Opening ${url}`, "info");
     } catch {
-      console.log(workspaceTag("\x1B[33m", `Could not open browser. Visit ${url}`));
+      tui.addLog("workspace", `Could not open browser automatically. Visit ${url}`, "warn");
     }
   };
-  interactive = createInteractiveHandler({
-    shell: runShellCommand2,
-    clear: () => {
-      process.stdout.write("\x1Bc");
-    },
-    help: () => {
-      printHelp("workspace");
-    },
-    open: () => openInBrowser(),
-    pause: () => {
-      togglePause();
-    },
-    quit: () => {
-      shutdown(0);
-    },
-    restart: () => restartWorkspace()
-  });
   process.on("SIGINT", () => {
     shutdown(0);
   });
   process.on("SIGTERM", () => {
     shutdown(0);
   });
+  tui.start();
+  tui.addLog("workspace", `Workspace booting ${orderedNames.length} services.`, "info");
   await startServices();
+  tui.setReadyDuration(performance.now() - workspaceBootStartedAt);
+  tui.addLog("workspace", "Workspace ready.", "success");
   await new Promise(() => {});
 };