@stacksjs/buddy 0.70.88 → 0.70.90

package/dist/commands/dev.js

@@ -0,0 +1,907 @@
+import { execSync } from "node:child_process";
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import readline from "node:readline";
+import process from "node:process";
+import { bold, cyan, dim, green, intro, log, onUnknownSubcommand, outro, prompts, runCommand, yellow } from "@stacksjs/cli";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { Action } from "@stacksjs/enums";
+import { libsPath, projectPath } from "@stacksjs/path";
+import { ExitCode } from "@stacksjs/types";
+import { version } from "../../package.json";
+const DEV_BOOT_STARTING_LINE_COUNT = 3;
+function eraseDevBootStartingLines() {
+  if (!process.stdout.isTTY)
+    return;
+  for (let i = 0;i < DEV_BOOT_STARTING_LINE_COUNT; i++) {
+    readline.moveCursor(process.stdout, 0, -1);
+    readline.clearLine(process.stdout, 0);
+  }
+}
+let developmentRpx;
+function resolveRpxEntryPath() {
+  return [
+    projectPath("node_modules/@stacksjs/rpx/dist/index.js"),
+    join(homedir(), "Code/Tools/rpx/packages/rpx/dist/index.js"),
+    projectPath("pantry/@stacksjs/rpx/dist/src/index.js")
+  ].find((entry) => existsSync(entry)) ?? null;
+}
+async function importDevelopmentRpx() {
+  if (developmentRpx)
+    return developmentRpx;
+  const entry = resolveRpxEntryPath();
+  developmentRpx = entry ? await import(entry) : await import("@stacksjs/rpx");
+  return developmentRpx;
+}
+const activeRpxRegistryIds = [];
+let _actions;
+async function actions() {
+  if (!_actions)
+    _actions = await import("@stacksjs/actions");
+  return _actions;
+}
+export function dev(buddy) {
+  const descriptions = {
+    dev: "Start development server",
+    frontend: "Start the frontend development server",
+    components: "Start the Components development server",
+    desktop: "Start the Desktop App development server",
+    native: "Start the app in a native Craft window",
+    dashboard: "Start the Dashboard development server",
+    api: "Start the local API development server",
+    email: "Start the Email development server",
+    docs: "Start the Documentation development server",
+    systemTray: "Start the System Tray development server",
+    interactive: "Get asked which development server to start",
+    select: "Which development server are you trying to start?",
+    withLocalhost: "Include the localhost URL in the output",
+    project: "Target a specific project",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("dev [server]", descriptions.dev).option("-f, --frontend", descriptions.frontend).option("-a, --api", descriptions.api).option("-e, --email", descriptions.email).option("-c, --components", descriptions.components).option("-d, --dashboard", descriptions.dashboard).option("-k, --desktop", descriptions.desktop).option("-n, --native", descriptions.native).option("-o, --docs", descriptions.docs).option("-s, --system-tray", descriptions.systemTray).option("-i, --interactive", descriptions.interactive, { default: !1 }).option("-l, --with-localhost", descriptions.withLocalhost, { default: !1 }).option("-p, --project [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (server, options) => {
+    const perf = Bun.nanoseconds(), target = server || (options.frontend ? "frontend" : void 0) || (options.api ? "api" : void 0) || (options.components ? "components" : void 0) || (options.dashboard ? "dashboard" : void 0) || (options.desktop ? "desktop" : void 0) || (options.native ? "native" : void 0) || (options.systemTray || options["system-tray"] ? "system-tray" : void 0) || (options.docs ? "docs" : void 0);
+    if (target) {
+      const serverOptions = { ...options }, a = await actions();
+      switch (target) {
+        case "native":
+          await startDevelopmentServer({ ...serverOptions, native: !0 }, perf);
+          break;
+        case "frontend":
+          await a.runFrontendDevServer(serverOptions);
+          break;
+        case "api":
+          await a.runApiDevServer(serverOptions);
+          break;
+        case "components":
+          await a.runComponentsDevServer(serverOptions);
+          break;
+        case "dashboard":
+          await a.runDashboardDevServer(serverOptions);
+          break;
+        case "desktop":
+          await a.runDesktopDevServer(serverOptions);
+          break;
+        case "system-tray":
+          await a.runSystemTrayDevServer(serverOptions);
+          break;
+        case "docs":
+          await a.runDocsDevServer(serverOptions);
+          break;
+        default:
+          log.error(`Unknown server: ${target}`);
+          process.exit(ExitCode.InvalidArgument);
+      }
+    } else if (wantsInteractive(options)) {
+      const selectedValue = (await prompts({
+        type: "select",
+        name: "value",
+        message: descriptions.select,
+        choices: [
+          { value: "all", title: "All" },
+          { value: "frontend", title: "Frontend" },
+          { value: "api", title: "Backend" },
+          { value: "dashboard", title: "Dashboard" },
+          { value: "desktop", title: "Desktop" },
+          { value: "native", title: "Native App" },
+          { value: "email", title: "Email" },
+          { value: "components", title: "Components" },
+          { value: "docs", title: "Documentation" }
+        ]
+      })).value;
+      if (selectedValue === "components")
+        await (await actions()).runComponentsDevServer(options);
+      else if (selectedValue === "api")
+        await (await actions()).runApiDevServer(options);
+      else if (selectedValue === "dashboard")
+        await (await actions()).runDashboardDevServer(options);
+      else if (selectedValue === "native")
+        await startDevelopmentServer({ ...options, native: !0 }, perf);
+      else if (selectedValue === "docs")
+        await (await actions()).runDocsDevServer(options);
+      else {
+        log.error("Invalid option during interactive mode");
+        process.exit(ExitCode.InvalidArgument);
+      }
+    } else
+      await startDevelopmentServer(options, perf);
+    outro("Exited", { startTime: perf, useSeconds: !0 });
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("dev:components", descriptions.components).option("-p, --project [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    const perf = await intro("buddy dev:components"), result = await runCommand("bun run dev", {
+      cwd: libsPath("components/vue")
+    });
+    if (options.verbose)
+      log.info("buddy dev:components result", result);
+    if (result.isErr) {
+      await outro("While running the dev:components command, there was an issue", { startTime: perf, useSeconds: !0 }, result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    console.log("");
+    await outro("Exited", { startTime: perf, useSeconds: !0 });
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("dev:docs", descriptions.docs).option("-p, --project [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    const perf = await intro("buddy dev:docs"), result = await (await actions()).runAction(Action.DevDocs, options);
+    if (result.isErr) {
+      await outro("While running the dev:docs command, there was an issue", { startTime: perf, useSeconds: !0 }, result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    console.log("");
+    await outro("Exited", { startTime: perf, useSeconds: !0 });
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("dev:native", descriptions.native).option("-p, --project [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    const perf = await intro("buddy dev:native");
+    await startDevelopmentServer({ ...options, native: !0 }, perf);
+  });
+  buddy.command("dev:desktop", descriptions.desktop).option("-p, --project [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    const perf = await intro("buddy dev:desktop"), result = await (await actions()).runAction(Action.DevDesktop, options);
+    if (result.isErr) {
+      await outro("While running the dev:desktop command, there was an issue", { startTime: perf, useSeconds: !0 }, result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    console.log("");
+    await outro("Exited", { startTime: perf, useSeconds: !0 });
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("dev:api", descriptions.api).option("-p, --project [project]", descriptions.project, { default: !1 }).option("--no-watch-types", "Skip the model/config type-regeneration watcher", { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    const a = await actions();
+    if (options.watchTypes !== !1)
+      a.watchTypes(options).catch((err) => {
+        log.warn("[dev:api] type watcher exited:", err);
+      });
+    await a.runApiDevServer(options);
+  });
+  buddy.command("dev:frontend", descriptions.frontend).alias("dev:pages").alias("dev:views").option("-p, --project [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    await (await actions()).runFrontendDevServer(options);
+  });
+  buddy.command("dev:dashboard", descriptions.dashboard).alias("dev:admin").option("-p, --project [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    await (await actions()).runDashboardDevServer(options);
+  });
+  buddy.command("dev:system-tray", descriptions.systemTray).alias("dev:tray").option("-p, --project [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    await (await actions()).runSystemTrayDevServer(options);
+  });
+  onUnknownSubcommand(buddy, "dev");
+}
+export async function startDevelopmentServer(_options, _startTime) {
+  const options = _options, startedAt = _startTime, appUrl = process.env.APP_URL, nativeMode = options.native === !0, proxyManagedExternally = process.env.STACKS_PROXY_MANAGED === "1", frontendPort = Number(process.env.PORT) || 3000, apiPort = Number(process.env.PORT_API) || 3008, docsPort = Number(process.env.PORT_DOCS) || 3006, dashboardPort = Number(process.env.PORT_ADMIN) || 3002, includeDashboard = process.env.STACKS_DEV_DASHBOARD === "1", appLooksCustom = !nativeMode && appUrl && appUrl !== "localhost" && !appUrl.includes("localhost:"), domain = appLooksCustom ? appUrl.replace(/^https?:\/\//, "") : null, hasCustomDomain = appLooksCustom && !proxyManagedExternally, dashboardDomain = domain ? `dashboard.${domain}` : null, frontendUrl = domain ? `https://${domain}` : `http://localhost:${frontendPort}`, apiUrl = domain ? `https://${domain}/api` : `http://localhost:${apiPort}`, docsUrl = domain ? `https://${domain}/docs` : `http://localhost:${docsPort}`, dashboardUrl = dashboardDomain ? `https://${dashboardDomain}` : `http://localhost:${dashboardPort}`, managedPorts = [
+    frontendPort,
+    apiPort,
+    docsPort,
+    ...includeDashboard ? [dashboardPort] : []
+  ];
+  process.env.STACKS_PROXY_MANAGED = "1";
+  process.env.STACKS_DEV_QUIET = "1";
+  console.log();
+  console.log(`  ${bold(cyan("stacks"))} ${dim(`v${version}`)}  ${dim("starting\u2026")}`);
+  console.log();
+  if (process.env.STACKS_DEV_NO_KILL !== "1")
+    await cleanupStaleDevProcesses(managedPorts);
+  const rpxTlsPreflight = hasCustomDomain && domain ? prepareRpxTlsForDev({ domain, includeDashboard, options }) : Promise.resolve();
+  rpxTlsPreflight.catch(() => {});
+  let isExiting = !1, closeNativeApp;
+  const SHUTDOWN_GRACE_MS = 1500, cleanup = () => {
+    if (isExiting)
+      return;
+    isExiting = !0;
+    closeNativeApp?.();
+    unregisterRpxProxies(activeRpxRegistryIds);
+    activeRpxRegistryIds.length = 0;
+    try {
+      process.kill(-process.pid, "SIGTERM");
+    } catch {
+      try {
+        process.kill(0, "SIGTERM");
+      } catch {}
+    }
+    setTimeout(() => {
+      try {
+        process.kill(0, "SIGKILL");
+      } catch {
+        process.exit(1);
+      }
+    }, SHUTDOWN_GRACE_MS).unref();
+  };
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+  const quietOpts = { ...options, quiet: !0 }, a = await actions(), ports = [
+    { name: "Frontend", port: frontendPort },
+    { name: "API", port: apiPort }
+  ], readinessTimeoutMs = 30000;
+  let readyAnnounced = !1;
+  const nativeUrl = `http://localhost:${frontendPort}`, nativeWindowReady = nativeMode ? waitForPort(frontendPort, readinessTimeoutMs).then(async (ready) => {
+    if (!ready) {
+      log.warn(`Native window skipped because the frontend did not answer within ${readinessTimeoutMs / 1000}s`);
+      return;
+    }
+    closeNativeApp = await launchNativeAppWindow(nativeUrl, options);
+  }) : Promise.resolve();
+  Promise.all(ports.map((p) => waitForPort(p.port, readinessTimeoutMs))).then(async (results) => {
+    if (readyAnnounced)
+      return;
+    readyAnnounced = !0;
+    const failed = results.map((ok, i) => ok ? null : ports[i]?.name ?? null).filter((x) => x !== null);
+    let proxyReachable = !1;
+    if (hasCustomDomain && domain) {
+      (async () => {
+        try {
+          await rpxTlsPreflight;
+          await registerRpxProxiesForDomain({
+            domain,
+            frontendPort,
+            apiPort,
+            docsPort,
+            dashboardPort,
+            includeDashboard,
+            options
+          });
+        } catch {}
+      })();
+      proxyReachable = await waitForHttpsProxy(443, 16000);
+      if (!proxyReachable) {
+        console.log(`  ${yellow("\u26A0")}  ${yellow("HTTPS proxy not reachable on :443")} \u2014 serving ${cyan(`http://localhost:${frontendPort}`)} instead`);
+        console.log(`  ${dim("    ")}${dim("rpx needs a valid SUDO_PASSWORD in .env to bind :443; trust the local CA, then restart `./buddy dev`.")}`);
+        if (options.verbose)
+          console.log(`  ${dim("    ")}${dim(`Trust CA: sh ${join(RPX_SSL_DIR, "trust-rpx-cert.sh")}`)}`);
+      }
+    }
+    eraseDevBootStartingLines();
+    printDevReadyBanner({
+      options,
+      nativeMode,
+      hasCustomDomain: !!appLooksCustom,
+      proxyReachable: proxyManagedExternally ? !0 : proxyReachable,
+      frontendUrl,
+      apiUrl,
+      docsUrl,
+      dashboardUrl,
+      frontendPort,
+      apiPort,
+      docsPort,
+      includeDashboard,
+      domain,
+      dashboardPort,
+      dashboardDomain
+    });
+    if (startedAt) {
+      const elapsedMs = (Bun.nanoseconds() - startedAt) / 1e6, summary = failed.length ? `ready in ${(elapsedMs / 1000).toFixed(1)}s \u2014 ${failed.join(", ")} did not bind within ${readinessTimeoutMs / 1000}s` : `ready in ${(elapsedMs / 1000).toFixed(1)}s`;
+      console.log(`  ${dim(summary)}`);
+      console.log();
+      printDevEngineNotes();
+      console.log();
+    }
+    if (process.env.STACKS_PRINT_ROUTES === "1")
+      await printRegisteredRoutes(apiPort).catch(() => {});
+  }).catch(() => {});
+  await Promise.all([
+    a.runFrontendDevServer(quietOpts).catch((error) => {
+      if (options.verbose)
+        log.error(`Frontend: ${error}`);
+    }),
+    a.runApiDevServer(quietOpts).catch((error) => {
+      if (options.verbose)
+        log.error(`API: ${error}`);
+    }),
+    a.runDocsDevServer(quietOpts).catch((error) => {
+      if (options.verbose)
+        log.error(`Docs: ${error}`);
+    }),
+    includeDashboard ? a.runDashboardDevServer(quietOpts).catch((error) => {
+      if (options.verbose)
+        log.error(`Dashboard: ${error}`);
+    }) : Promise.resolve(),
+    nativeWindowReady.catch((error) => {
+      if (options.verbose)
+        log.warn(`Native window: ${error}`);
+    })
+  ]);
+}
+function isComingSoonMode() {
+  if (existsSync(projectPath("storage/framework/coming-soon")))
+    return !0;
+  try {
+    const idx = projectPath("resources/views/index.stx");
+    return existsSync(idx) && /siteMode\s*=\s*['"]coming-soon['"]/.test(readFileSync(idx, "utf8"));
+  } catch {
+    return !1;
+  }
+}
+function blogIsConfigured() {
+  try {
+    const dir = projectPath("content/blog");
+    return existsSync(dir) && readdirSync(dir).some((f) => f.endsWith(".md"));
+  } catch {
+    return !1;
+  }
+}
+function printDevReadyBanner(input) {
+  const {
+    options,
+    nativeMode,
+    hasCustomDomain,
+    proxyReachable,
+    frontendUrl,
+    apiUrl,
+    docsUrl,
+    dashboardUrl,
+    frontendPort,
+    apiPort,
+    docsPort,
+    includeDashboard,
+    domain,
+    dashboardPort,
+    dashboardDomain
+  } = input, verbose = options.verbose ?? !1, showLocalUrls = verbose || options.withLocalhost === !0, useProxy = hasCustomDomain && proxyReachable, feUrl = useProxy ? frontendUrl : `http://localhost:${frontendPort}`, apUrl = useProxy ? apiUrl : `http://localhost:${apiPort}`, dcUrl = useProxy ? docsUrl : `http://localhost:${docsPort}`, blogUrl = `${feUrl.replace(/\/$/, "")}/blog`;
+  console.log();
+  console.log(`  ${green("\u279C")}  ${bold("Frontend")}:    ${cyan(feUrl)}`);
+  if (showLocalUrls && useProxy)
+    console.log(`  ${dim("\u279C")}  ${dim("Local")}:       ${dim(`http://localhost:${frontendPort}`)}`);
+  if (nativeMode)
+    console.log(`  ${green("\u279C")}  ${bold("Native")}:      ${cyan(`Craft \u2192 http://localhost:${frontendPort}`)}`);
+  console.log(`  ${green("\u279C")}  ${bold("API")}:         ${cyan(apUrl)}`);
+  if (showLocalUrls && useProxy)
+    console.log(`  ${dim("\u279C")}  ${dim("Local API")}:   ${dim(`http://localhost:${apiPort}`)}`);
+  console.log(`  ${green("\u279C")}  ${bold("Docs")}:        ${cyan(dcUrl)}`);
+  if (showLocalUrls && useProxy)
+    console.log(`  ${dim("\u279C")}  ${dim("Local docs")}:  ${dim(`http://localhost:${docsPort}`)}`);
+  if (blogIsConfigured())
+    console.log(`  ${green("\u279C")}  ${bold("Blog")}:        ${cyan(blogUrl)}`);
+  if (includeDashboard)
+    console.log(`  ${green("\u279C")}  ${bold("Dashboard")}:   ${cyan(dashboardUrl)}`);
+  if (isComingSoonMode()) {
+    console.log();
+    console.log(`  ${yellow("\u25CF")}  ${bold(yellow("Coming soon mode"))} ${dim("\u2014 visitors see the holding page; bypass with the coming-soon secret.")}`);
+  }
+  if (verbose && domain) {
+    console.log(`  ${dim("\u279C")}  ${dim("Proxy")}:       ${dim(`localhost:${frontendPort} \u2192 ${domain}`)}`);
+    console.log(`  ${dim("\u279C")}  ${dim("Proxy")}:       ${dim(`${frontendUrl}/api \u2192 localhost:${apiPort}`)}`);
+    console.log(`  ${dim("\u279C")}  ${dim("Proxy")}:       ${dim(`${frontendUrl}/docs \u2192 localhost:${docsPort}`)}`);
+    if (includeDashboard)
+      console.log(`  ${dim("\u279C")}  ${dim("Proxy")}:       ${dim(`localhost:${dashboardPort} \u2192 ${dashboardDomain}`)}`);
+  }
+  console.log();
+}
+function printDevEngineNotes() {
+  const routesFile = join(projectPath(), ".stx/routes.ts"), crosswindConfig = join(projectPath(), "config/crosswind.ts");
+  if (existsSync(crosswindConfig) || existsSync(join(projectPath(), "crosswind.config.ts")))
+    console.log(`  ${green("[Crosswind]")} ${dim("CSS engine loaded")}`);
+  if (existsSync(routesFile))
+    try {
+      const routeCount = (readFileSync(routesFile, "utf8").match(/pattern:/g) ?? []).length;
+      if (routeCount > 0)
+        console.log(`  ${green("[stx]")} ${dim(`Generated ${routeCount} routes \u2192 .stx/routes.ts`)}`);
+    } catch {
+      console.log(`  ${green("[stx]")} ${dim("Routes manifest \u2192 .stx/routes.ts")}`);
+    }
+}
+async function launchNativeAppWindow(url, options) {
+  let createApp;
+  try {
+    createApp = (await importCraftSdk()).createApp;
+  } catch (error) {
+    if (options.verbose)
+      log.warn(`Native window unavailable: ${error}`);
+    console.log(`  ${dim("Native window unavailable. Install craft-native or set CRAFT_BIN to a Craft binary.")}
+`);
+    return;
+  }
+  if (!createApp) {
+    console.log(`  ${dim("Native window unavailable. The Craft SDK did not export createApp.")}
+`);
+    return;
+  }
+  const craftBinaryPath = resolveCraftBinaryPath();
+  if (!craftBinaryPath) {
+    console.log(`  ${dim("Native window unavailable. Set CRAFT_BIN to a Craft binary, or install Craft in ~/Code/Tools/craft.")}
+`);
+    return;
+  }
+  const appIconPath = resolveNativeAppIconPath(), app = createApp({
+    url,
+    quiet: !options.verbose,
+    craftPath: craftBinaryPath,
+    window: {
+      title: await resolveNativeAppTitle(),
+      width: 1280,
+      height: 860,
+      titlebarHidden: !0,
+      webSidebarMaterial: !0,
+      webSidebarWidth: 286,
+      webSidebarMaterialOpacity: 0.78,
+      ...appIconPath && { icon: appIconPath }
+    }
+  });
+  app.show().catch((error) => {
+    if (options.verbose)
+      log.warn(`Native window exited: ${error}`);
+  });
+  return () => app.close();
+}
+async function importCraftSdk() {
+  const localCraftSdk = process.env.HOME ? `${process.env.HOME}/Code/Tools/craft/packages/typescript/src/index.ts` : void 0;
+  if (localCraftSdk && existsSync(localCraftSdk))
+    return await import(localCraftSdk);
+  const packageNames = ["craft-native", "@craft-native/craft", "@stacksjs/ts-craft"];
+  let primaryError;
+  for (const packageName of packageNames)
+    try {
+      return await import(packageName);
+    } catch (error) {
+      primaryError ??= error;
+    }
+  throw primaryError;
+}
+async function cleanupStaleDevProcesses(ports) {
+  const projectRoot = projectPath(), actionDevPath = projectPath("storage/framework/core/actions/src/dev/"), pids = new Set;
+  for (const port of ports)
+    for (const pid of await listenerPids(port)) {
+      if (pid === process.pid)
+        continue;
+      const command = await commandForPid(pid);
+      if (!command.includes(projectRoot))
+        continue;
+      if (command.includes("storage/framework/core/buddy/src/cli.ts dev") || command.includes("storage/framework/core/actions/src/dev/") || command.includes(actionDevPath))
+        pids.add(pid);
+    }
+  if (pids.size === 0)
+    return;
+  for (const pid of pids)
+    try {
+      process.kill(pid, "SIGTERM");
+    } catch {}
+  await new Promise((r) => setTimeout(r, 250));
+  for (const pid of pids)
+    try {
+      process.kill(pid, "SIGKILL");
+    } catch {}
+  await new Promise((r) => setTimeout(r, 150));
+}
+async function listenerPids(port) {
+  try {
+    const proc = Bun.spawn(["lsof", "-nP", `-iTCP:${port}`, "-sTCP:LISTEN", "-t"], {
+      stdout: "pipe",
+      stderr: "ignore"
+    }), output = await new Response(proc.stdout).text();
+    await proc.exited;
+    return output.split(/\s+/).map((value) => Number(value)).filter((pid) => Number.isInteger(pid) && pid > 0);
+  } catch {
+    return [];
+  }
+}
+async function commandForPid(pid) {
+  try {
+    const proc = Bun.spawn(["ps", "-p", String(pid), "-o", "command="], {
+      stdout: "pipe",
+      stderr: "ignore"
+    }), output = await new Response(proc.stdout).text();
+    await proc.exited;
+    return output.trim();
+  } catch {
+    return "";
+  }
+}
+function resolveCraftBinaryPath() {
+  const home = process.env.HOME;
+  return [
+    process.env.CRAFT_BIN,
+    home ? `${home}/Code/Tools/craft/craft` : void 0,
+    home ? `${home}/Code/Tools/craft/bin/craft` : void 0,
+    home ? `${home}/Code/Tools/craft/packages/zig/zig-out/bin/craft` : void 0,
+    home ? `${home}/Documents/Projects/craft/packages/zig/zig-out/bin/craft` : void 0
+  ].filter((candidate) => Boolean(candidate)).find((candidate) => existsSync(candidate));
+}
+function resolveNativeAppIconPath() {
+  return [
+    projectPath("resources/assets/images/app-icon.png"),
+    projectPath("resources/assets/images/icon.png"),
+    projectPath("public/icon.png")
+  ].find((candidate) => existsSync(candidate));
+}
+async function resolveNativeAppTitle() {
+  try {
+    const pkg = await Bun.file(projectPath("package.json")).json(), name = typeof pkg.productName === "string" ? pkg.productName : pkg.name;
+    if (typeof name === "string" && name.length > 0)
+      return name.split(/[-_\s]+/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
+  } catch {}
+  return "Stacks App";
+}
+const METHOD_COLORS = {
+  GET: cyan,
+  POST: green,
+  PUT: cyan,
+  PATCH: cyan,
+  DELETE: cyan,
+  OPTIONS: dim
+};
+async function printRegisteredRoutes(apiPort) {
+  try {
+    const ac = new AbortController, t = setTimeout(() => ac.abort(), 1500), res = await fetch(`http://127.0.0.1:${apiPort}/__routes`, { signal: ac.signal }).catch(() => null);
+    clearTimeout(t);
+    if (!res || !res.ok)
+      return;
+    const routes = await res.json();
+    if (!Array.isArray(routes) || routes.length === 0)
+      return;
+    const sorted = [...routes].sort((a, b) => a.path.localeCompare(b.path) || a.method.localeCompare(b.method)), longestPath = Math.max(...sorted.map((r) => r.path.length));
+    console.log(`  ${dim("Registered routes")}
+`);
+    for (const r of sorted) {
+      const method = (METHOD_COLORS[r.method.toUpperCase()] ?? dim)(r.method.toUpperCase().padEnd(6)), path = r.path.padEnd(longestPath), named = r.name ? `  ${dim(`(${r.name})`)}` : "";
+      console.log(`  ${method}  ${path}${named}`);
+    }
+    console.log();
+  } catch {}
+}
+async function probeDevServerHttp(port) {
+  for (const path of ["/__health", "/"])
+    if (await new Promise((resolve) => {
+      const ac = new AbortController, t = setTimeout(() => ac.abort(), path === "/" ? 8000 : 800);
+      fetch(`http://127.0.0.1:${port}${path}`, { signal: ac.signal, redirect: "manual" }).then(() => {
+        clearTimeout(t);
+        resolve(!0);
+      }).catch(() => {
+        clearTimeout(t);
+        resolve(!1);
+      });
+    }))
+      return !0;
+  return !1;
+}
+async function waitForPort(port, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (await probeDevServerHttp(port))
+      return !0;
+    await new Promise((r) => setTimeout(r, 50));
+  }
+  return !1;
+}
+async function waitForHttpsProxy(port, timeoutMs) {
+  const { connect } = await import("node:net"), deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (await new Promise((resolve) => {
+      const socket = connect({ port, host: "127.0.0.1" }), finish = (v) => {
+        try {
+          socket.destroy();
+        } catch {}
+        resolve(v);
+      };
+      socket.once("connect", () => finish(!0));
+      socket.once("error", () => finish(!1));
+      setTimeout(() => finish(!1), 800).unref?.();
+    }))
+      return !0;
+    await new Promise((r) => setTimeout(r, 200));
+  }
+  return !1;
+}
+const RPX_SSL_DIR = join(homedir(), ".stacks", "ssl"), RPX_ROOT_CA_PATH = join(RPX_SSL_DIR, "rpx-root-ca.crt"), RPX_HOST_CERT_PATH = join(RPX_SSL_DIR, "rpx.localhost.crt"), LOGIN_KEYCHAIN = join(homedir(), "Library/Keychains/login.keychain-db");
+function normalizeSha256Fingerprint(raw) {
+  return (raw.includes("=") ? raw.split("=").pop() : raw).replace(/SHA-256\s+hash:\s*/gi, "").replace(/:/g, "").trim().toUpperCase();
+}
+function readCertFingerprint(certPath) {
+  try {
+    const out = execSync(`openssl x509 -noout -fingerprint -sha256 -in "${certPath}"`, { encoding: "utf8" });
+    return normalizeSha256Fingerprint(out);
+  } catch {
+    return null;
+  }
+}
+function isRpxRootCaInKeychain(caPath) {
+  const fp = readCertFingerprint(caPath);
+  if (!fp)
+    return !1;
+  const keychains = [
+    "/Library/Keychains/System.keychain",
+    LOGIN_KEYCHAIN
+  ];
+  for (const keychain of keychains)
+    try {
+      const listing = execSync(`security find-certificate -a -Z "${keychain}" 2>/dev/null || true`, { encoding: "utf8" });
+      for (const line of listing.split(`
+`))
+        if (line.toUpperCase().includes("SHA-256") && normalizeSha256Fingerprint(line) === fp)
+          return !0;
+    } catch {}
+  return !1;
+}
+function execSudoSh(command) {
+  const sudoPassword = process.env.SUDO_PASSWORD, escaped = command.replace(/'/g, "'\\''");
+  if (sudoPassword)
+    execSync(`echo '${sudoPassword}' | sudo -S sh -c '${escaped}' 2>/dev/null`, { stdio: ["pipe", "pipe", "pipe"] });
+  else
+    execSync(`sudo -n sh -c '${escaped}'`, { stdio: ["pipe", "pipe", "pipe"] });
+}
+const MACOS_CA_TRUST_FLAGS = "-d -r trustRoot -p ssl -p basic";
+function listRpxRootCaHashesInKeychain(keychain) {
+  const listing = execSync(`security find-certificate -a -c "rpx.localhost" -Z "${keychain}" 2>/dev/null || true`, { encoding: "utf8" }), hashes = [];
+  for (const line of listing.split(`
+`)) {
+    const match = line.match(/SHA-256 hash:\s*([A-F0-9]+)/i);
+    if (match)
+      hashes.push(match[1].toUpperCase());
+  }
+  return hashes;
+}
+function pruneStaleRpxRootCas(caPath) {
+  if (process.platform !== "darwin")
+    return;
+  const keep = readCertFingerprint(caPath);
+  if (!keep)
+    return;
+  for (const keychain of ["/Library/Keychains/System.keychain", LOGIN_KEYCHAIN])
+    for (const hash of listRpxRootCaHashesInKeychain(keychain)) {
+      if (hash === keep)
+        continue;
+      try {
+        if (keychain.startsWith("/Library"))
+          execSudoSh(`security delete-certificate -Z ${hash} "${keychain}"`);
+        else
+          execSync(`security delete-certificate -Z ${hash} "${keychain}"`, { stdio: "ignore" });
+      } catch {}
+    }
+}
+function isRpxRootCaTrustedForSsl(caPath, serverName) {
+  if (process.platform !== "darwin")
+    return isRpxRootCaInKeychain(caPath);
+  try {
+    return execSync(`security verify-cert -c "${caPath}" -s "${serverName}" -l -L -R ssl 2>&1`, { encoding: "utf8" }).includes("successful");
+  } catch {
+    return !1;
+  }
+}
+function trustRpxRootCaForBrowsers(caPath, serverName) {
+  if (process.platform !== "darwin")
+    return !1;
+  pruneStaleRpxRootCas(caPath);
+  try {
+    execSync(`security add-trusted-cert ${MACOS_CA_TRUST_FLAGS} -k "${LOGIN_KEYCHAIN}" "${caPath}"`, { stdio: "ignore" });
+  } catch {}
+  try {
+    execSudoSh(`security add-trusted-cert ${MACOS_CA_TRUST_FLAGS} -k /Library/Keychains/System.keychain "${caPath}"`);
+  } catch {
+    return !1;
+  }
+  return isRpxRootCaTrustedForSsl(caPath, serverName) || isRpxRootCaInKeychain(caPath);
+}
+function isLiveHttpsChainValid(domain) {
+  if (!existsSync(RPX_ROOT_CA_PATH))
+    return !1;
+  try {
+    return execSync(`echo | openssl s_client -connect ${domain}:443 -servername ${domain} -CAfile "${RPX_ROOT_CA_PATH}" 2>/dev/null | grep "Verify return code"`, { encoding: "utf8", timeout: 4000 }).includes(": 0 (ok)");
+  } catch {
+    return !1;
+  }
+}
+function buildDevelopmentTlsHostnames(domain, includeDashboard) {
+  return [
+    domain,
+    ...includeDashboard ? [`dashboard.${domain}`] : [],
+    "rpx.localhost"
+  ];
+}
+function readCertCommonName(certPath) {
+  try {
+    return execSync(`openssl x509 -in "${certPath}" -noout -subject -nameopt RFC2253`, { encoding: "utf8" }).match(/CN=([^,/]+)/)?.[1]?.trim() ?? null;
+  } catch {
+    return null;
+  }
+}
+async function buildDevelopmentTlsOptions(domain, includeDashboard, verbose) {
+  const hostnames = buildDevelopmentTlsHostnames(domain, includeDashboard);
+  try {
+    const { getRegistryDir, readAll } = await importDevelopmentRpx(), entries = await readAll(getRegistryDir(), !1);
+    for (const entry of entries) {
+      const host = entry.to?.trim();
+      if (host && !hostnames.includes(host))
+        hostnames.push(host);
+    }
+  } catch {}
+  return {
+    https: {
+      certPath: RPX_HOST_CERT_PATH,
+      keyPath: join(RPX_SSL_DIR, "rpx.localhost.key"),
+      caCertPath: join(RPX_SSL_DIR, "rpx.localhost.ca.crt"),
+      commonName: domain
+    },
+    verbose,
+    regenerateUntrustedCerts: !0,
+    proxies: hostnames.map((to) => ({ from: "localhost:1", to }))
+  };
+}
+async function ensureRpxDevelopmentHttps(domain, options, includeDashboard) {
+  const verbose = options.verbose ?? !1, {
+    checkExistingCertificates,
+    clearSslConfigCache,
+    forceTrustCertificate,
+    generateCertificate,
+    isDaemonRunning,
+    stopDaemon
+  } = await importDevelopmentRpx(), hostnames = buildDevelopmentTlsHostnames(domain, includeDashboard), tlsOptions = await buildDevelopmentTlsOptions(domain, includeDashboard, verbose), hostnameInCert = hostnames.every((host) => {
+    try {
+      return execSync(`openssl x509 -in "${RPX_HOST_CERT_PATH}" -noout -text`, { encoding: "utf8" }).includes(`DNS:${host}`);
+    } catch {
+      return !1;
+    }
+  }), cnMatchesApp = readCertCommonName(RPX_HOST_CERT_PATH) === domain;
+  let certRegenerated = !1;
+  if (!await checkExistingCertificates(tlsOptions) || !hostnameInCert || !cnMatchesApp) {
+    clearSslConfigCache();
+    await generateCertificate({ ...tlsOptions, forceRegenerate: !0 });
+    certRegenerated = !0;
+  }
+  let trusted = isRpxRootCaTrustedForSsl(RPX_ROOT_CA_PATH, domain);
+  if (!trusted) {
+    trusted = trustRpxRootCaForBrowsers(RPX_ROOT_CA_PATH, domain) || await forceTrustCertificate(RPX_ROOT_CA_PATH, { serverName: domain, verbose }) || isRpxRootCaTrustedForSsl(RPX_ROOT_CA_PATH, domain);
+    if (trusted)
+      console.log(`  ${green("\u2713")}  ${dim("HTTPS")}:         ${dim("Local CA trusted \u2014 reload the browser if you still see a warning")}`);
+    else
+      console.log(`  ${yellow("\u26A0")}  ${yellow("HTTPS")}:         ${yellow(`Local CA not trusted \u2014 run: sh ${join(RPX_SSL_DIR, "trust-rpx-cert.sh")}`)}`);
+  } else if (verbose)
+    console.log(`  ${green("\u2713")}  ${dim("HTTPS")}:         ${dim("Local certificate trusted for SSL")}`);
+  const chainOk = isLiveHttpsChainValid(domain);
+  if ((certRegenerated || !hostnameInCert || !cnMatchesApp) && await isDaemonRunning()) {
+    await stopDaemon({ timeoutMs: 8000 }).catch(() => {});
+    if (verbose)
+      log.info("Restarting rpx daemon to load TLS certificates for this app");
+  } else if (!chainOk && verbose)
+    console.log(`  ${dim("    ")}${dim("HTTPS chain not yet valid on :443 \u2014 daemon will (re)start after backends are ready")}`);
+}
+function resolveRpxDaemonSpawnCwd() {
+  const fromEnv = process.env.RPX_BIN || process.env.STACKS_RPX_BIN;
+  if (fromEnv && existsSync(fromEnv))
+    return dirname(fromEnv);
+  const bootstrap = join(dirname(fileURLToPath(import.meta.url)), "../../scripts/rpx-daemon-bootstrap.js");
+  if (existsSync(bootstrap))
+    return dirname(bootstrap);
+  return homedir();
+}
+async function resolveRpxDaemonSpawnCommand() {
+  const bootstrap = join(dirname(fileURLToPath(import.meta.url)), "../../scripts/rpx-daemon-bootstrap.js");
+  if (existsSync(bootstrap))
+    return [process.execPath, bootstrap];
+  const fromEnv = process.env.RPX_BIN || process.env.STACKS_RPX_BIN;
+  if (fromEnv && existsSync(fromEnv))
+    return [fromEnv, "daemon:start"];
+  const pkgUrl = import.meta.resolve("@stacksjs/rpx/package.json"), cli = join(dirname(fileURLToPath(pkgUrl)), "dist/bin/cli.js");
+  return [process.execPath, cli, "daemon:start"];
+}
+function buildRpxProxySpecs(input) {
+  const { domain, frontendPort, apiPort, docsPort, dashboardPort, includeDashboard } = input, dashboardDomain = `dashboard.${domain}`;
+  return [
+    {
+      id: `${domain}-frontend`,
+      from: `localhost:${frontendPort}`,
+      to: domain,
+      pathRewrites: [
+        { from: "/api", to: `localhost:${apiPort}`, stripPrefix: !1 },
+        { from: "/docs", to: `localhost:${docsPort}`, stripPrefix: !0 }
+      ]
+    },
+    ...includeDashboard ? [{ id: `${domain}-dashboard`, from: `localhost:${dashboardPort}`, to: dashboardDomain }] : []
+  ];
+}
+async function unregisterRpxProxies(ids) {
+  if (ids.length === 0)
+    return;
+  try {
+    const { removeEntry } = await importDevelopmentRpx();
+    for (const id of ids)
+      await removeEntry(id).catch(() => {});
+  } catch {}
+}
+async function prepareRpxTlsForDev(input) {
+  const { domain, includeDashboard, options } = input, verbose = options.verbose ?? !1, hosts = [
+    domain,
+    ...includeDashboard ? [`dashboard.${domain}`] : []
+  ], hostsNeedingFile = hosts.filter((host) => {
+    const h = host.trim().toLowerCase();
+    return h !== "localhost" && !h.endsWith(".localhost") && !h.endsWith(".localhost.");
+  }), { addHosts, setupDevelopmentDns } = await importDevelopmentRpx(), dnsDomains = hostsNeedingFile.length > 0 ? hosts : [];
+  if (dnsDomains.length > 0) {
+    if (!await setupDevelopmentDns({ domains: dnsDomains, verbose }).catch(() => !1) && verbose)
+      log.warn(`Dev DNS not configured for ${dnsDomains.join(", ")} \u2014 falling back to /etc/hosts`);
+  }
+  if (hostsNeedingFile.length > 0)
+    await addHosts(hostsNeedingFile, verbose).catch((err) => {
+      log.warn(`Could not update /etc/hosts for ${hostsNeedingFile.join(", ")}: ${err.message}`);
+      log.warn("Add 127.0.0.1 entries manually or set SUDO_PASSWORD in .env");
+    });
+  await ensureRpxDevelopmentHttps(domain, options, includeDashboard);
+}
+async function startRpxDaemonIfNeeded(input) {
+  const { ensureDaemonRunning, isDaemonRunning: isRpxUp } = await importDevelopmentRpx();
+  if (await isRpxUp())
+    return;
+  const spawnOpts = {
+    spawnCommand: input.spawnCommand,
+    spawnCwd: resolveRpxDaemonSpawnCwd(),
+    startupTimeoutMs: 45000,
+    spawnEnv: input.spawnEnv,
+    verbose: input.verbose
+  };
+  try {
+    await ensureDaemonRunning(spawnOpts);
+  } catch (firstError) {
+    await input.stopRpx({ timeoutMs: 5000 }).catch(() => {});
+    await ensureDaemonRunning(spawnOpts).catch(() => {
+      throw firstError;
+    });
+  }
+}
+async function registerRpxProxiesForDomain(input) {
+  const { domain, frontendPort, apiPort, docsPort, dashboardPort, includeDashboard, options } = input, verbose = options.verbose ?? !1, proxies = buildRpxProxySpecs({ domain, frontendPort, apiPort, docsPort, dashboardPort, includeDashboard });
+  await unregisterRpxProxies([`${domain}-api`, `${domain}-docs`]);
+  const {
+    getRegistryDir,
+    readAll,
+    stopDaemon: stopRpx,
+    syncDevelopmentDnsFromRegistry,
+    writeEntry
+  } = await importDevelopmentRpx(), spawnCommand = await resolveRpxDaemonSpawnCommand(), spawnEnv = {};
+  if (process.env.SUDO_PASSWORD)
+    spawnEnv.SUDO_PASSWORD = process.env.SUDO_PASSWORD;
+  if (verbose)
+    spawnEnv.RPX_VERBOSE = "1";
+  const rpxEntry = resolveRpxEntryPath();
+  if (rpxEntry)
+    spawnEnv.RPX_MODULE = rpxEntry;
+  try {
+    await startRpxDaemonIfNeeded({ spawnCommand, spawnEnv, verbose, stopRpx });
+  } catch (error) {
+    const { isDaemonRunning } = await importDevelopmentRpx();
+    if (!await isDaemonRunning())
+      throw error;
+    if (verbose) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.log(`  ${dim("    ")}${dim(`rpx daemon spawn skipped (${message}); reusing existing daemon`)}`);
+    }
+  }
+  const createdAt = new Date().toISOString();
+  for (const proxy of proxies) {
+    await writeEntry({
+      id: proxy.id,
+      from: proxy.from,
+      to: proxy.to,
+      cwd: process.cwd(),
+      createdAt,
+      pathRewrites: proxy.pathRewrites
+    }, void 0, verbose);
+    if (!activeRpxRegistryIds.includes(proxy.id))
+      activeRpxRegistryIds.push(proxy.id);
+    if (verbose)
+      console.log(`  ${dim("\u279C")}  ${dim("Proxy")}:       ${dim(`https://${proxy.to} \u2192 ${proxy.from}`)}`);
+  }
+  const registryDir = getRegistryDir(), entries = await readAll(registryDir, verbose).catch(() => []);
+  await syncDevelopmentDnsFromRegistry(entries, { verbose, ownerPid: process.pid }).catch((err) => {
+    if (verbose) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.log(`  ${dim("    ")}${dim(`Dev DNS sync: ${message}`)}`);
+    }
+  });
+}
+function wantsInteractive(options) {
+  return options.interactive;
+}