@absolutejs/absolute 0.19.0-beta.663 → 0.19.0-beta.665

package/dist/cli/index.js

@@ -668,7 +668,7 @@ var exports_compile = {};
 __export(exports_compile, {
   compile: () => compile
 });
-var {env: env3 } = globalThis.Bun;
+var {env: env4 } = globalThis.Bun;
 import { existsSync as existsSync9, readdirSync, readFileSync as readFileSync8, 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) => {
@@ -847,7 +847,7 @@ console.log(\`
 \`);
 `;
 }, stubPlugin, FRAMEWORK_EXTERNALS, compile = async (serverEntry, outdir, outfile, configPath2) => {
-  const prerenderPort = Number(env3.COMPILE_PORT) || Number(env3.PORT) || DEFAULT_PORT + 1;
+  const prerenderPort = Number(env4.COMPILE_PORT) || Number(env4.PORT) || DEFAULT_PORT + 1;
   killStaleProcesses(prerenderPort);
   const entryName = basename2(serverEntry).replace(/\.[^.]+$/, "");
   const resolvedOutdir = resolve7(outdir ?? "dist");
@@ -2379,9 +2379,10 @@ var start = async (serverEntry, outdir, configPath2) => {
 init_constants();
 init_loadConfig();
 init_startupBanner();
-init_utils();
+var {$: $3 } = globalThis.Bun;
 import { existsSync as existsSync8 } from "fs";
 import { resolve as resolve6 } from "path";
+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));
@@ -2392,6 +2393,16 @@ 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;
+  }
+  if (service.kind === "absolute" && service.port) {
+    return `http://127.0.0.1:${service.port}/hmr-status`;
+  }
+  return;
+};
 var ensureWorkspaceConfig = (config) => {
   if (!config.workspace?.services || Object.keys(config.workspace.services).length === 0) {
     throw new Error("absolute.config.ts is missing workspace.services. Add a workspace section before using `absolute workspace dev`.");
@@ -2415,7 +2426,7 @@ var resolveHealthcheck = (healthcheck) => {
     url: healthcheck.url
   };
 };
-var waitForHealthcheck = async (name, healthcheck) => {
+var waitForHealthcheck = async (healthcheck) => {
   const resolved = resolveHealthcheck(healthcheck);
   if (!resolved) {
     return;
@@ -2425,13 +2436,12 @@ var waitForHealthcheck = async (name, healthcheck) => {
     try {
       const response = await fetch(resolved.url);
       if (response.ok) {
-        console.log(workspaceTag("\x1B[32m", `${name} passed healthcheck ${resolved.url}`));
         return;
       }
     } catch {}
     await sleep(resolved.intervalMs);
   }
-  throw new Error(`${name} did not become healthy within ${resolved.timeoutMs}ms (${resolved.url})`);
+  throw new Error(`service did not become healthy within ${resolved.timeoutMs}ms (${resolved.url})`);
 };
 var topologicallySortServices = (services) => {
   const ordered = [];
@@ -2464,8 +2474,17 @@ var topologicallySortServices = (services) => {
   }
   return ordered;
 };
-var createLineForwarder = (name, color, dest) => {
+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();
@@ -2473,24 +2492,42 @@ var createLineForwarder = (name, color, dest) => {
 `);
       buffer = lines.pop() ?? "";
       for (const line of lines) {
-        dest.write(`${serviceTag(name, color)} ${line}
-`);
+        writeLine(line);
       }
     },
     flush: () => {
-      if (!buffer) {
+      if (!buffer || buffer.trim().length === 0) {
+        buffer = "";
         return;
       }
-      dest.write(`${serviceTag(name, color)} ${buffer}
-`);
+      writeLine(buffer);
       buffer = "";
     }
   };
 };
-var pipeProcessLogs = (name, processHandle) => {
-  const stdoutForwarder = createLineForwarder(name, "\x1B[36m", process.stdout);
-  const stderrForwarder = createLineForwarder(name, "\x1B[31m", process.stderr);
-  const forward = async (stream, forwarder) => {
+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) => {
     const reader = stream.getReader();
     try {
       while (true) {
@@ -2498,21 +2535,29 @@ var pipeProcessLogs = (name, processHandle) => {
         if (done) {
           break;
         }
-        if (value) {
-          forwarder.push(value);
+        if (!value) {
+          continue;
+        }
+        if (bufferingStartupLogs) {
+          startupBuffer.push(value);
+          continue;
         }
+        forwarder.push(value);
       }
     } finally {
-      forwarder.flush();
+      if (!bufferingStartupLogs) {
+        forwarder.flush();
+      }
       reader.releaseLock();
     }
   };
-  forward(processHandle.stdout, stdoutForwarder);
-  forward(processHandle.stderr, stderrForwarder);
+  forward(processHandle.stdout, stdoutForwarder, stdoutStartupChunks);
+  forward(processHandle.stderr, stderrForwarder, stderrStartupChunks);
+  return { releaseStartupLogs };
 };
 var resolveService = (name, service, options) => {
   const cwd = resolve6(service.cwd ?? ".");
-  const env3 = {
+  const envVars = {
     ...process.env,
     ...service.env,
     ABSOLUTE_WORKSPACE_SERVICE_NAME: name,
@@ -2520,13 +2565,13 @@ var resolveService = (name, service, options) => {
     FORCE_COLOR: "1",
     NODE_ENV: "development"
   };
-  if (service.port && !env3.PORT) {
-    env3.PORT = String(service.port);
+  if (service.port && !envVars.PORT) {
+    envVars.PORT = String(service.port);
   }
   if (service.kind === "absolute") {
     const configPath2 = service.config ? resolve6(cwd, service.config) : options.configPath ? resolve6(options.configPath) : process.env.ABSOLUTE_CONFIG ? resolve6(process.env.ABSOLUTE_CONFIG) : undefined;
     if (configPath2) {
-      env3.ABSOLUTE_CONFIG = configPath2;
+      envVars.ABSOLUTE_CONFIG = configPath2;
     }
     const command = [
       process.execPath,
@@ -2538,7 +2583,7 @@ var resolveService = (name, service, options) => {
       command,
       configPath: configPath2,
       cwd,
-      env: env3,
+      env: envVars,
       name,
       service,
       visibility: getVisibility(service)
@@ -2547,12 +2592,19 @@ var resolveService = (name, service, options) => {
   return {
     command: service.command,
     cwd,
-    env: env3,
+    env: envVars,
     name,
     service,
     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`.");
@@ -2562,85 +2614,224 @@ var workspace = async (subcommand, options) => {
   const orderedNames = topologicallySortServices(workspaceConfig.services);
   const running = [];
   let shuttingDown = false;
-  const shutdown = async (exitCode = 0) => {
-    if (shuttingDown) {
+  let restarting = false;
+  let paused = false;
+  let workspaceReady = false;
+  let interactive = null;
+  const withPromptHidden = () => {
+    if (!workspaceReady) {
       return;
     }
-    shuttingDown = true;
-    for (const service of running) {
+    interactive?.clearPrompt();
+  };
+  const restorePrompt = () => {
+    if (!workspaceReady) {
+      return;
+    }
+    interactive?.showPrompt();
+  };
+  const killProcesses = async () => {
+    const snapshot = [...running];
+    running.length = 0;
+    for (const service of snapshot) {
       try {
         service.process.kill();
       } catch {}
     }
-    await Promise.all(running.map((service) => service.process.exited));
+    await Promise.all(snapshot.map((service) => service.process.exited));
+  };
+  const sendSignalToService = (processHandle, signal) => {
+    try {
+      process.kill(-processHandle.pid, signal);
+      return;
+    } catch {}
+    try {
+      process.kill(processHandle.pid, signal);
+    } catch {}
+  };
+  const shutdown = async (exitCode = 0) => {
+    if (shuttingDown) {
+      return;
+    }
+    shuttingDown = true;
+    if (interactive) {
+      interactive.dispose();
+    }
+    if (paused) {
+      for (const service of running) {
+        sendSignalToService(service.process, "SIGCONT");
+      }
+      paused = false;
+    }
+    await killProcesses();
     process.exit(exitCode);
   };
-  process.on("SIGINT", () => {
-    shutdown(0);
-  });
-  process.on("SIGTERM", () => {
-    shutdown(0);
-  });
-  console.log(workspaceTag("\x1B[36m", `Starting workspace services: ${orderedNames.map((name) => {
-    const service = workspaceConfig.services[name];
-    const visibility = service ? getVisibility(service) : "public";
-    return visibility === "internal" ? `${name} (internal)` : `${name} (public)`;
-  }).join(", ")}`));
-  for (const name of orderedNames) {
-    const service = workspaceConfig.services[name];
-    if (!service) {
-      throw new Error(`workspace.services is missing "${name}"`);
+  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);
     }
-    const resolved = resolveService(name, service, options);
-    const port = (resolved.service.port ?? Number(resolved.env.PORT ?? "")) || DEFAULT_PORT;
-    if (port > 0) {
-      killStaleProcesses(port);
+    if (internalServices.length > 0) {
+      segments.push(`internal: ${internalServices.join(", ")}`);
     }
-    if (resolved.service.kind === "absolute" && resolved.configPath && !existsSync8(resolved.configPath)) {
-      throw new Error(`${name} references missing config "${resolved.configPath}"`);
+    return segments.join(" \xB7 ");
+  };
+  const startServices = async () => {
+    workspaceReady = false;
+    for (const name of orderedNames) {
+      const service = workspaceConfig.services[name];
+      if (!service) {
+        throw new Error(`workspace.services is missing "${name}"`);
+      }
+      const resolved = resolveService(name, service, options);
+      const port = (resolved.service.port ?? Number(resolved.env.PORT ?? "")) || DEFAULT_PORT;
+      if (port > 0) {
+        killStaleProcesses(port);
+      }
+      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)})...`);
+      const processHandle = Bun.spawn(resolved.command, {
+        cwd: resolved.cwd,
+        env: resolved.env,
+        stderr: "pipe",
+        stdin: "ignore",
+        stdout: "pipe"
+      });
+      const { releaseStartupLogs } = pipeProcessLogs(name, processHandle, withPromptHidden, restorePrompt);
+      const runningService = {
+        name,
+        process: processHandle,
+        resolved,
+        releaseStartupLogs
+      };
+      running.push(runningService);
+      processHandle.exited.then((exitCode) => {
+        if (shuttingDown || restarting) {
+          return;
+        }
+        if (!running.includes(runningService)) {
+          return;
+        }
+        console.error(workspaceTag("\x1B[31m", `${name} exited with code ${exitCode}. Shutting down workspace.`));
+        shutdown(exitCode || 1);
+      });
+      await waitForHealthcheck(getHealthcheckUrl(resolved.service));
+      renderWorkspaceStepDone(`${name} ready`);
+      releaseStartupLogs();
     }
-    console.log(workspaceTag("\x1B[36m", `Starting ${name}: ${resolved.command.join(" ")}`));
-    const processHandle = Bun.spawn(resolved.command, {
-      cwd: resolved.cwd,
-      env: resolved.env,
-      stderr: "pipe",
-      stdin: "ignore",
-      stdout: "pipe"
-    });
-    running.push({ name, process: processHandle });
-    pipeProcessLogs(name, processHandle);
-    processHandle.exited.then((exitCode) => {
-      if (shuttingDown) {
-        return;
+    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");
       }
-      console.error(workspaceTag("\x1B[31m", `${name} exited with code ${exitCode}. Shutting down workspace.`));
-      shutdown(exitCode || 1);
-    });
-    await waitForHealthcheck(name, resolved.service.healthcheck);
-  }
-  console.log(workspaceTag("\x1B[32m", `Workspace ready with ${running.length} services.`));
-  const publicServices = orderedNames.map((name) => {
-    const service = workspaceConfig.services[name];
-    if (!service || getVisibility(service) !== "public") {
-      return null;
+      paused = false;
     }
-    const url = getServiceUrl(service);
-    return url ? `${name}: ${url}` : `${name}`;
-  }).filter(Boolean);
-  const internalServices = orderedNames.map((name) => {
-    const service = workspaceConfig.services[name];
-    if (!service || getVisibility(service) !== "internal") {
-      return null;
+    withPromptHidden();
+    console.log(workspaceTag("\x1B[36m", "Restarting workspace..."));
+    await killProcesses();
+    restarting = false;
+    await startServices();
+  };
+  const togglePause = () => {
+    if (paused) {
+      for (const service of running) {
+        sendSignalToService(service.process, "SIGCONT");
+      }
+      paused = false;
+      console.log(workspaceTag("\x1B[32m", "Workspace resumed."));
+    } else {
+      for (const service of running) {
+        sendSignalToService(service.process, "SIGSTOP");
+      }
+      paused = true;
+      console.log(`${workspaceTag("\x1B[33m", "Workspace paused.")} \x1B[90m[paused]\x1B[0m`);
     }
-    return service.port ? `${name}: :${service.port}` : `${name}`;
-  }).filter(Boolean);
-  if (publicServices.length > 0) {
-    console.log(workspaceTag("\x1B[32m", `Public services: ${publicServices.join(", ")}`));
-  }
-  if (internalServices.length > 0) {
-    console.log(workspaceTag("\x1B[2m", `Internal services: ${internalServices.join(", ")}`));
-  }
-  await Promise.all(running.map((service) => service.process.exited));
+  };
+  const runShellCommand2 = async (command) => {
+    await $3`${{ raw: command }}`.env({ ...process.env, FORCE_COLOR: "1" }).nothrow();
+  };
+  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."));
+      return;
+    }
+    const { platform: platform4 } = process;
+    const isWSL = platform4 === "linux" && isWSLEnvironment();
+    let cmd;
+    if (isWSL) {
+      cmd = "cmd.exe";
+    } else if (platform4 === "darwin") {
+      cmd = "open";
+    } else if (platform4 === "win32") {
+      cmd = "start";
+    } else {
+      cmd = "xdg-open";
+    }
+    const args = isWSL ? ["/c", "start", url] : [url];
+    try {
+      Bun.spawn([cmd, ...args], {
+        stderr: "ignore",
+        stdout: "ignore"
+      });
+      console.log(workspaceTag("\x1B[36m", `Opening ${url}`));
+    } catch {
+      console.log(workspaceTag("\x1B[33m", `Could not open browser. Visit ${url}`));
+    }
+  };
+  interactive = createInteractiveHandler({
+    shell: runShellCommand2,
+    clear: () => {
+      process.stdout.write("\x1Bc");
+    },
+    help: () => {
+      printHelp();
+    },
+    open: () => openInBrowser(),
+    pause: () => {
+      togglePause();
+    },
+    quit: () => {
+      shutdown(0);
+    },
+    restart: () => restartWorkspace()
+  });
+  process.on("SIGINT", () => {
+    shutdown(0);
+  });
+  process.on("SIGTERM", () => {
+    shutdown(0);
+  });
+  await startServices();
+  await new Promise(() => {});
 };
 
 // src/cli/index.ts

package/dist/index.js

@@ -174803,7 +174803,7 @@ ${registrations}
     ({ tsLibDir } = cached);
     cached.lastUsed = Date.now();
   } else {
-    const tsPath = __require.resolve("typescript");
+    const tsPath = __require.resolve("/home/alexkahn/abs/absolutejs/node_modules/typescript/lib/typescript.js");
     const tsRootDir = dirname9(tsPath);
     tsLibDir = tsRootDir.endsWith("lib") ? tsRootDir : resolve18(tsRootDir, "lib");
     const config = readConfiguration("./tsconfig.json");
@@ -188807,5 +188807,5 @@ export {
   ANGULAR_INIT_TIMEOUT_MS
 };
 
-//# debugId=845140FABD0993C064756E2164756E21
+//# debugId=2B2FCBFEECB6C7FA64756E2164756E21
 //# sourceMappingURL=index.js.map