@tdk-landscape/tdk-cli-core 1.3.49 → 1.3.51

package/engine/assets/docker/wake-gateway/Dockerfile

@@ -0,0 +1,27 @@
+# Wake gateway (see openspec/changes/prioritized-cold-start): fronts every
+# `sablier.deferStart` resource's Traefik static route, triggers cold
+# containers via `tilt trigger` and/or Sablier, then holds the request until
+# healthy. Needs the Docker CLI plus its Compose plugin (client only, talks
+# to the mounted /var/run/docker.sock; compose starts an already-built image
+# directly, ahead of Tilt's build queue) and the real `tilt` CLI (D3: shells out to the
+# documented `tilt trigger` command rather than depending on Tilt's
+# undocumented internal HTTP API).
+
+FROM oven/bun:1.3.11-alpine AS base
+
+# Pin to the same Tilt version this workspace runs (v0.37.7) so `tilt trigger`
+# talks the same protocol as the real daemon it's connecting to. Installed
+# directly (not via tilt-dev's install.sh, which shells out to `sudo` -- not
+# present in this minimal image, and unnecessary since we're already root).
+ARG TILT_VERSION=0.37.7
+RUN apk add --no-cache docker-cli docker-cli-compose curl gcompat \
+    && arch="$(uname -m)" \
+    && case "$arch" in aarch64) tilt_arch=arm64 ;; x86_64) tilt_arch=x86_64 ;; *) echo "unsupported arch: $arch" >&2; exit 1 ;; esac \
+    && curl -fsSL "https://github.com/tilt-dev/tilt/releases/download/v${TILT_VERSION}/tilt.${TILT_VERSION}.linux.${tilt_arch}.tar.gz" \
+       | tar -xz -C /usr/local/bin tilt
+
+WORKDIR /app
+COPY decide.ts server.ts ./
+
+EXPOSE 9999
+CMD ["bun", "run", "server.ts"]

package/engine/assets/docker/wake-gateway/decide.test.ts

@@ -0,0 +1,133 @@
+import { describe, expect, test } from "bun:test";
+import {
+  COMPOSE_START_TIMEOUT_MS,
+  TILT_TRIGGER_TIMEOUT_MS,
+  decideWakeAction,
+  evaluateReadiness,
+  wakeTimeoutMs,
+} from "./decide";
+
+describe("decideWakeAction", () => {
+  test("never-created resource: tilt trigger only, no Sablier start", () => {
+    const action = decideWakeAction({
+      resourceContainerName: "data-governance-api",
+      resourceState: "absent",
+      dependencies: [],
+    });
+    expect(action.tiltTriggerNames).toEqual(["data-governance-api"]);
+    expect(action.useSablierStart).toBe(false);
+  });
+
+  test("previously-run, now-exited resource: both tilt trigger and Sablier start", () => {
+    const action = decideWakeAction({
+      resourceContainerName: "data-governance-api",
+      resourceState: "exited",
+      dependencies: [],
+    });
+    expect(action.tiltTriggerNames).toEqual(["data-governance-api"]);
+    expect(action.useSablierStart).toBe(true);
+  });
+
+  test("created-but-not-started resource: both paths apply", () => {
+    const action = decideWakeAction({
+      resourceContainerName: "data-governance-api",
+      resourceState: "created",
+      dependencies: [],
+    });
+    expect(action.useSablierStart).toBe(true);
+  });
+
+  test("already running: no trigger needed", () => {
+    const action = decideWakeAction({
+      resourceContainerName: "data-governance-api",
+      resourceState: "running",
+      dependencies: [],
+    });
+    expect(action.tiltTriggerNames).toEqual([]);
+    expect(action.useSablierStart).toBe(false);
+  });
+
+  test("cold dependency is triggered alongside the resource (task 1.5 finding)", () => {
+    const action = decideWakeAction({
+      resourceContainerName: "data-governance-api",
+      resourceState: "absent",
+      dependencies: [
+        { name: "postgres", state: "running" },
+        { name: "data-governance-api-db-migrator", state: "absent" },
+      ],
+    });
+    expect(action.tiltTriggerNames).toEqual([
+      "data-governance-api",
+      "data-governance-api-db-migrator",
+    ]);
+  });
+
+  test("never-created resource with compose details: started directly, not queued in Tilt", () => {
+    const action = decideWakeAction({
+      resourceContainerName: "data-governance-api",
+      resourceState: "absent",
+      dependencies: [{ name: "peer-api", state: "absent" }],
+      hasComposeInvocation: true,
+    });
+    expect(action.useComposeStart).toBe(true);
+    // Dependencies carry no compose details, so they still go through Tilt.
+    expect(action.tiltTriggerNames).toEqual(["peer-api"]);
+    expect(action.useSablierStart).toBe(false);
+  });
+
+  test("existing (exited) container keeps the Sablier path even with compose details", () => {
+    const action = decideWakeAction({
+      resourceContainerName: "data-governance-api",
+      resourceState: "exited",
+      dependencies: [],
+      hasComposeInvocation: true,
+    });
+    expect(action.useComposeStart).toBe(false);
+    expect(action.tiltTriggerNames).toEqual(["data-governance-api"]);
+    expect(action.useSablierStart).toBe(true);
+  });
+
+  test("running dependency is not re-triggered", () => {
+    const action = decideWakeAction({
+      resourceContainerName: "data-governance-api",
+      resourceState: "running",
+      dependencies: [{ name: "postgres", state: "running" }],
+    });
+    expect(action.tiltTriggerNames).toEqual([]);
+  });
+});
+
+describe("wakeTimeoutMs", () => {
+  test("a direct compose start only waits for boot + healthcheck", () => {
+    expect(wakeTimeoutMs(true)).toBe(COMPOSE_START_TIMEOUT_MS);
+  });
+
+  test("the tilt trigger path allows for an image build, under Bun's 255s idle cap", () => {
+    expect(wakeTimeoutMs(false)).toBe(TILT_TRIGGER_TIMEOUT_MS);
+    expect(TILT_TRIGGER_TIMEOUT_MS).toBeLessThan(255_000);
+  });
+
+  test("an explicit X-Wake-Timeout-Ms wins", () => {
+    expect(wakeTimeoutMs(false, 5_000)).toBe(5_000);
+  });
+});
+
+describe("evaluateReadiness", () => {
+  test("ready once every required name reports healthy", () => {
+    const outcome = evaluateReadiness(["a", "b"], { a: true, b: true });
+    expect(outcome.ready).toBe(true);
+    expect(outcome.pending).toEqual([]);
+  });
+
+  test("not ready while some names are still unhealthy", () => {
+    const outcome = evaluateReadiness(["a", "b"], { a: true, b: false });
+    expect(outcome.ready).toBe(false);
+    expect(outcome.pending).toEqual(["b"]);
+  });
+
+  test("missing entries count as not healthy", () => {
+    const outcome = evaluateReadiness(["a", "b"], { a: true });
+    expect(outcome.ready).toBe(false);
+    expect(outcome.pending).toEqual(["b"]);
+  });
+});

package/engine/assets/docker/wake-gateway/decide.ts

@@ -0,0 +1,105 @@
+/**
+ * Pure decision logic for the wake gateway (see openspec/changes/prioritized-cold-start).
+ *
+ * The gateway sits behind a Traefik static (file-provider) route for every
+ * `sablier: {enable: true, deferStart: true}` resource. This module decides
+ * what to *do* given a snapshot of container state; the actual Docker/Tilt
+ * I/O and the healthcheck-polling loop live in server.ts, which is a thin
+ * wrapper around this so the decision itself stays testable without a live
+ * Docker daemon or Tilt instance.
+ */
+
+export type ContainerState = "absent" | "created" | "running" | "exited";
+
+export interface DependencySnapshot {
+  name: string;
+  state: ContainerState;
+}
+
+export interface WakeRequestSnapshot {
+  resourceContainerName: string;
+  resourceState: ContainerState;
+  dependencies: DependencySnapshot[];
+  /**
+   * Whether the route carried enough compose detail (project, files, image)
+   * for the gateway to create the resource's container itself.
+   */
+  hasComposeInvocation?: boolean;
+}
+
+export interface WakeAction {
+  /** Resources to `tilt trigger` (task 1.5: Tilt never cascades this on its own). */
+  tiltTriggerNames: string[];
+  /**
+   * Whether to create/start the resource's container directly with
+   * `docker compose up --no-build` instead of `tilt trigger`. `tilt trigger`
+   * only queues the resource: with Tilt's build slots busy (e.g. 100+
+   * resources rebuilding after a re-vendor), a triggered resource waited
+   * behind them and the request timed out (observed live against
+   * tdk-erp-system, see tasks.md 7.2). server.ts falls back to `tilt trigger`
+   * when no image exists yet to start from.
+   */
+  useComposeStart: boolean;
+  /**
+   * Whether to also try Sablier's own Docker-level start for the resource.
+   * Only meaningful when the resource's container already exists (D2/D3):
+   * Sablier has nothing to manage for a container that was never created.
+   */
+  useSablierStart: boolean;
+}
+
+/**
+ * Decide which resources need `tilt trigger` and whether Sablier's Docker-level
+ * start also applies, given one point-in-time snapshot (D2/D3/D5).
+ */
+export function decideWakeAction(snapshot: WakeRequestSnapshot): WakeAction {
+  const tiltTriggerNames: string[] = [];
+  const useComposeStart = snapshot.resourceState === "absent" && snapshot.hasComposeInvocation === true;
+
+  if (snapshot.resourceState !== "running" && !useComposeStart) {
+    tiltTriggerNames.push(snapshot.resourceContainerName);
+  }
+  for (const dep of snapshot.dependencies) {
+    if (dep.state !== "running") {
+      tiltTriggerNames.push(dep.name);
+    }
+  }
+
+  const useSablierStart = snapshot.resourceState === "exited" || snapshot.resourceState === "created";
+
+  return { tiltTriggerNames, useComposeStart, useSablierStart };
+}
+
+/** Wait budget when the gateway starts an existing image itself (boot + healthcheck only). */
+export const COMPOSE_START_TIMEOUT_MS = 180_000;
+/**
+ * Wait budget when the resource has to go through `tilt trigger` (image build
+ * included). Kept under Bun.serve's 255s idleTimeout cap in server.ts.
+ */
+export const TILT_TRIGGER_TIMEOUT_MS = 240_000;
+
+/** The wait budget for a wake: an explicit X-Wake-Timeout-Ms wins, else by start path. */
+export function wakeTimeoutMs(startedViaCompose: boolean, overrideMs?: number): number {
+  if (overrideMs && overrideMs > 0) return overrideMs;
+  return startedViaCompose ? COMPOSE_START_TIMEOUT_MS : TILT_TRIGGER_TIMEOUT_MS;
+}
+
+export interface WaitOutcome {
+  ready: boolean;
+  /** Names still not running/healthy when the wait ended (empty when ready). */
+  pending: string[];
+}
+
+/**
+ * Decide whether a set of health polls (resource + dependencies) means the
+ * request can be let through yet, or should keep waiting / time out.
+ * `healthy` maps each name from a WakeAction's tiltTriggerNames (plus the
+ * resource itself) to its latest observed health state.
+ */
+export function evaluateReadiness(
+  requiredNames: string[],
+  healthy: Record<string, boolean>,
+): WaitOutcome {
+  const pending = requiredNames.filter((name) => !healthy[name]);
+  return { ready: pending.length === 0, pending };
+}

package/engine/assets/docker/wake-gateway/server.ts

@@ -0,0 +1,311 @@
+/**
+ * Wake gateway: fronts every `sablier.deferStart` resource's Traefik static
+ * route (see openspec/changes/prioritized-cold-start). On the first request
+ * for a resource with no running container, it triggers the resource (and
+ * its cold dependencies) via `tilt trigger`, and/or Sablier's own start for
+ * an already-created container, then holds the request until the resource
+ * answers its healthcheck or the configured timeout elapses.
+ *
+ * Config for each request comes from headers a Traefik `headers` middleware
+ * injects (set by the file-provider entry generated in
+ * traefik_static_routes.star) rather than the path, so the original request
+ * path/query reach the real backend unchanged once it's ready:
+ *   X-Wake-Resource        Tilt/Compose resource name (for `tilt trigger` and
+ *                          `docker compose up <service>`).
+ *   X-Wake-Container       The actual Docker container name (for `docker
+ *                          inspect` state/health and the proxy target -- NOT the same string as
+ *                          the resource name; Compose derives it as
+ *                          <project>-<service>-<replica>, confirmed empirically
+ *                          against a live TDK container, e.g.
+ *                          "analytics-autogenerated-data-governance-api-1"
+ *                          for the "data-governance-api" resource).
+ *   X-Wake-Deps            Comma-separated "resourceName=containerName" pairs
+ *                          for required dependencies (task 1.5: Tilt never
+ *                          cascades a trigger to these on its own).
+ *   X-Wake-Compose-Project The resource's Compose project (e.g. "analytics-autogenerated").
+ *   X-Wake-Compose-Files   Comma-separated absolute compose file paths, the
+ *                          same ones Tilt's `<resource>-run-only` resource
+ *                          passes. The project root is mounted into this
+ *                          container at the same absolute path, so relative
+ *                          paths inside those files resolve exactly as for Tilt.
+ *   X-Wake-Env-File        Absolute path of the project's .env (optional).
+ *   X-Wake-Image           The image the compose service declares
+ *                          (<service>_<resource>:dev).
+ *   X-Wake-Timeout-Ms, X-Wake-Proxy-Port, X-Wake-Session-Duration
+ */
+import {
+  decideWakeAction,
+  evaluateReadiness,
+  wakeTimeoutMs,
+  type ContainerState,
+} from "./decide";
+
+const TILT_HOST = process.env.TILT_HOST || "host.docker.internal";
+const TILT_PORT = process.env.TILT_PORT || "10350";
+const SABLIER_URL = process.env.SABLIER_URL || "http://sablier:10000";
+const POLL_INTERVAL_MS = 1000;
+
+async function run(cmd: string[]): Promise<{ code: number; stdout: string; stderr: string }> {
+  const proc = Bun.spawn(cmd, { stdout: "pipe", stderr: "pipe" });
+  const [stdout, stderr, code] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+    proc.exited,
+  ]);
+  return { code, stdout, stderr };
+}
+
+async function containerState(name: string): Promise<ContainerState> {
+  const { code, stdout } = await run([
+    "docker", "inspect", "--format", "{{.State.Status}}", name,
+  ]);
+  if (code !== 0) return "absent";
+  const status = stdout.trim();
+  if (status === "running") return "running";
+  if (status === "created") return "created";
+  return "exited";
+}
+
+async function isHealthy(name: string): Promise<boolean> {
+  const { code, stdout } = await run([
+    "docker", "inspect",
+    "--format", "{{if .State.Health}}{{.State.Health.Status}}{{else}}{{.State.Status}}{{end}}",
+    name,
+  ]);
+  if (code !== 0) return false;
+  const status = stdout.trim();
+  return status === "healthy" || status === "running";
+}
+
+async function tiltTrigger(name: string): Promise<void> {
+  const { code, stderr } = await run(["tilt", "trigger", name, "--host", TILT_HOST, "--port", TILT_PORT]);
+  console.log(`tilt trigger ${name}: ${code === 0 ? "queued" : `failed (${stderr.trim()})`}`);
+}
+
+interface ComposeInvocation {
+  project: string;
+  files: string[];
+  envFile: string;
+  image: string;
+}
+
+/**
+ * Make sure the compose service's declared image exists locally. Tilt tags its
+ * own builds `<repo>:tilt-<hash>` and injects that tag when it runs compose, so
+ * the declared `<repo>:dev` tag may be missing even though the resource was
+ * built; retag Tilt's newest build in that case. False when nothing was ever
+ * built -- only `tilt trigger` (which builds) can wake the resource then.
+ */
+async function ensureImage(image: string): Promise<boolean> {
+  if ((await run(["docker", "image", "inspect", "--format", "{{.Id}}", image])).code === 0) return true;
+  const repo = image.split(":")[0];
+  // `docker images` lists newest first.
+  const { code, stdout } = await run(["docker", "images", repo, "--format", "{{.Tag}}"]);
+  if (code !== 0) return false;
+  const tiltTag = stdout.split("\n").map((t) => t.trim()).find((t) => t.startsWith("tilt-"));
+  if (!tiltTag) return false;
+  return (await run(["docker", "tag", `${repo}:${tiltTag}`, image])).code === 0;
+}
+
+/**
+ * Create and start the resource's container directly, with the same
+ * `docker compose ... up -d --no-build` its Tilt `-run-only` resource runs,
+ * bypassing Tilt's build queue (see decide.ts useComposeStart).
+ */
+async function composeStart(compose: ComposeInvocation, service: string): Promise<boolean> {
+  if (!(await ensureImage(compose.image))) {
+    console.log(`compose start ${service}: no local image for ${compose.image}, falling back to tilt trigger`);
+    return false;
+  }
+  const args = ["docker", "compose", "-p", compose.project];
+  for (const file of compose.files) args.push("-f", file);
+  if (compose.envFile) args.push("--env-file", compose.envFile);
+  args.push("up", "-d", "--no-build", "--no-deps", service);
+  const { code, stderr } = await run(args);
+  console.log(`compose start ${service}: ${code === 0 ? "started" : `failed (${stderr.trim()})`}`);
+  return code === 0;
+}
+
+/**
+ * Sablier's real blocking-strategy endpoint (GET /api/strategies/blocking,
+ * per https://sablierapp.dev/openapi.json): starts the named instance and
+ * holds until it's ready or `timeoutMs` elapses, returning that outcome via
+ * the X-Sablier-Session-Status header. Only valid for an instance Sablier
+ * already knows about (a container that exists with sablier.enable=true) --
+ * see decide.ts's useSablierStart.
+ */
+async function sablierBlockingWait(resource: string, sessionDuration: string, timeoutMs: number): Promise<boolean> {
+  const params = new URLSearchParams({
+    names: resource,
+    session_duration: sessionDuration,
+    timeout: `${Math.max(1, Math.round(timeoutMs / 1000))}s`,
+  });
+  try {
+    const res = await fetch(`${SABLIER_URL}/api/strategies/blocking?${params}`);
+    return res.headers.get("X-Sablier-Session-Status") === "ready";
+  } catch {
+    return false;
+  }
+}
+
+interface NamedDep {
+  resourceName: string;
+  containerName: string;
+}
+
+function parseDeps(raw: string): NamedDep[] {
+  return raw
+    .split(",")
+    .filter(Boolean)
+    .map((pair) => {
+      const [resourceName, containerName] = pair.split("=");
+      return { resourceName, containerName: containerName || resourceName };
+    });
+}
+
+function parseRequest(req: Request) {
+  const resource = req.headers.get("X-Wake-Resource") || "";
+  const container = req.headers.get("X-Wake-Container") || resource;
+  const deps = parseDeps(req.headers.get("X-Wake-Deps") || "");
+  const timeoutOverrideMs = Number(req.headers.get("X-Wake-Timeout-Ms")) || undefined;
+  const proxyPort = req.headers.get("X-Wake-Proxy-Port") || "80";
+  const sessionDuration = req.headers.get("X-Wake-Session-Duration") || "10m";
+  const composeFiles = (req.headers.get("X-Wake-Compose-Files") || "").split(",").filter(Boolean);
+  const compose: ComposeInvocation = {
+    project: req.headers.get("X-Wake-Compose-Project") || "",
+    files: composeFiles,
+    envFile: req.headers.get("X-Wake-Env-File") || "",
+    image: req.headers.get("X-Wake-Image") || "",
+  };
+  const hasCompose = Boolean(compose.project && compose.files.length && compose.image);
+  return { resource, container, deps, timeoutOverrideMs, proxyPort, sessionDuration, compose, hasCompose };
+}
+
+async function handleWake(req: Request): Promise<Response> {
+  const { resource, container, deps, timeoutOverrideMs, proxyPort, sessionDuration, compose, hasCompose } =
+    parseRequest(req);
+  if (!resource) {
+    return new Response("wake gateway: missing X-Wake-Resource header (set by the generated Traefik static route)", { status: 400 });
+  }
+
+  const resourceState = await containerState(container);
+  const dependencies = await Promise.all(
+    deps.map(async (dep) => ({ name: dep.resourceName, state: await containerState(dep.containerName) })),
+  );
+
+  const action = decideWakeAction({
+    resourceContainerName: resource,
+    resourceState,
+    dependencies,
+    hasComposeInvocation: hasCompose,
+  });
+  console.log(
+    `wake ${resource}: state=${resourceState} compose=${action.useComposeStart} ` +
+      `trigger=[${action.tiltTriggerNames.join(",")}] sablier=${action.useSablierStart}`,
+  );
+
+  // Dependencies (and the resource itself when it can't be started directly)
+  // go through tilt trigger (task 1.5: Tilt never cascades this on its own).
+  const tiltNames = [...action.tiltTriggerNames];
+  let startedViaCompose = false;
+  if (action.useComposeStart) {
+    startedViaCompose = await composeStart(compose, resource);
+    if (!startedViaCompose) tiltNames.unshift(resource);
+  }
+  const timeoutMs = wakeTimeoutMs(startedViaCompose, timeoutOverrideMs);
+  const deadline = Date.now() + timeoutMs;
+
+  // Sablier's blocking call, when applicable, both starts AND waits for the
+  // resource itself in one round trip.
+  const [, resourceReadyViaSablier] = await Promise.all([
+    Promise.all(tiltNames.map(tiltTrigger)),
+    action.useSablierStart
+      ? sablierBlockingWait(resource, sessionDuration, timeoutMs)
+      : Promise.resolve(false),
+  ]);
+
+  const requiredNames = [resource, ...deps.map((d) => d.resourceName)];
+  const containerByName: Record<string, string> = { [resource]: container };
+  for (const dep of deps) containerByName[dep.resourceName] = dep.containerName;
+
+  while (Date.now() < deadline) {
+    const healthy: Record<string, boolean> = {};
+    // Sablier's blocking call already confirmed the resource itself; re-check
+    // it too (cheap) so a false result from Sablier still gets a fair retry.
+    healthy[resource] = resourceReadyViaSablier || (await isHealthy(container));
+    for (const dep of deps) {
+      healthy[dep.resourceName] = await isHealthy(dep.containerName);
+    }
+    const outcome = evaluateReadiness(requiredNames, healthy);
+    if (outcome.ready) {
+      return proxyThrough(req, container, proxyPort);
+    }
+    await Bun.sleep(POLL_INTERVAL_MS);
+  }
+
+  return new Response(
+    `wake gateway: timed out after ${timeoutMs}ms waiting for ${resource} and its dependencies to become healthy`,
+    { status: 504 },
+  );
+}
+
+// Headers that must not be forwarded verbatim to the upstream fetch: Host
+// would otherwise carry the gateway's own address, and the X-Wake-* control
+// headers are gateway-internal, not part of the real app request.
+const STRIPPED_REQUEST_HEADERS = new Set([
+  "host",
+  "x-wake-resource",
+  "x-wake-container",
+  "x-wake-deps",
+  "x-wake-timeout-ms",
+  "x-wake-proxy-port",
+  "x-wake-session-duration",
+  "x-wake-compose-project",
+  "x-wake-compose-files",
+  "x-wake-env-file",
+  "x-wake-image",
+]);
+
+// Proxies to the container name rather than the Compose service name: every
+// TDK project's resources share the traefik-public network, where a bare
+// service name is only an alias and could collide across projects.
+async function proxyThrough(req: Request, container: string, port: string): Promise<Response> {
+  // The original path/query reach the gateway untouched (config travels via
+  // X-Wake-* headers, not the path), so they're forwarded as-is.
+  const target = new URL(req.url);
+  target.protocol = "http:";
+  // Set hostname/port separately, not via `.host` -- confirmed empirically
+  // that `target.host = "name:port"` silently keeps the URL's original port
+  // when one is already present instead of replacing it.
+  target.hostname = container;
+  target.port = port;
+
+  const headers = new Headers();
+  for (const [key, value] of req.headers) {
+    if (!STRIPPED_REQUEST_HEADERS.has(key.toLowerCase())) headers.set(key, value);
+  }
+
+  const upstream = await fetch(target.toString(), {
+    method: req.method,
+    headers,
+    body: req.method === "GET" || req.method === "HEAD" ? undefined : await req.arrayBuffer(),
+  });
+  return new Response(upstream.body, { status: upstream.status, headers: upstream.headers });
+}
+
+Bun.serve({
+  port: Number(process.env.PORT) || 9999,
+  // Bun's default idleTimeout (10s) is shorter than a real wake can take
+  // (tilt trigger + healthcheck polling) -- confirmed empirically: a request
+  // was killed mid-wait with "request timed out after 10 seconds" before this
+  // was raised. 255s is Bun's own max for this setting.
+  idleTimeout: 255,
+  fetch(req) {
+    return handleWake(req).catch((err) => {
+      console.error("wake gateway error:", err);
+      return new Response(`wake gateway error: ${String(err)}`, { status: 500 });
+    });
+  },
+});
+
+console.log(`wake gateway listening on :${Number(process.env.PORT) || 9999}`);

package/engine/topologies/platform/docker/build/golden_image_dockerfile.star

@@ -2,16 +2,8 @@
 # 🏗️ TILT SDK - GOLDEN IMAGE DOCKERFILE GENERATOR
 # =============================================================================
 
-# === INLINED CONSTANTS for pure extension loading ===
-get_docker_healthcheck_config = lambda: {"path": "/health", "interval_seconds": 10, "timeout_seconds": 5, "start_period_seconds": 30, "retries": 3, "frontend_start_period_seconds": 30}
-# === END INLINED CONSTANTS ===
-
-
 load('../../../tilt/common/utils.star', 'Utils')
-
-
-# Load centralized healthcheck configuration
-_docker_health = get_docker_healthcheck_config()
+load('../config/healthcheck.star', 'DOCKER_HEALTHCHECK', 'dockerfile_healthcheck_flags')
 
 
 # Load project name for dynamic naming
@@ -76,7 +68,6 @@ RUN apk add --no-cache \
     ca-certificates \
     tzdata \
     curl \
-    file \
     bash \
     openssl
 
@@ -180,9 +171,11 @@ LABEL layer="l4-backend-bun" \
       maintainer="{prefix}"
 
 ENV NODE_ENV=production
+# Smaller heap growth and more frequent GC: idle services dominate a 100-service landscape.
+ENV BUN_OPTIONS=--smol
 
-# Install hugo for services that require static site generation (specified via manifest features)
-RUN apk add --no-cache hugo
+# Service-specific tooling (e.g. hugo) is installed per service by the L4 runtime
+# layer when the manifest lists it in featuresEnabled - not here for every backend.
 
 # ⚠️ Infisical CLI is NOT installed in golden L4 images
 # Services use TypeScript SDK (fetch API) or read from env vars - no CLI needed
@@ -192,7 +185,7 @@ RUN apk add --no-cache hugo
 USER bun
 
 # Backend-specific healthcheck (checks Bun runtime)
-HEALTHCHECK --interval={interval}s --timeout={timeout}s --start-period={start_period}s --retries={retries} \
+HEALTHCHECK {hc_flags} \
   CMD bun --version || exit 1
 
 WORKDIR /app
@@ -221,7 +214,7 @@ RUN addgroup -S app && adduser -S app -G app
 USER app
 
 # Backend-specific healthcheck (checks Node.js runtime)
-HEALTHCHECK --interval={interval}s --timeout={timeout}s --start-period={start_period}s --retries={retries} \
+HEALTHCHECK {hc_flags} \
   CMD node --version || exit 1
 
 WORKDIR /app
@@ -246,7 +239,7 @@ ENV NODE_ENV=production
 RUN apk add --no-cache curl
 
 # Frontend-specific healthcheck (checks Nginx)
-HEALTHCHECK --interval={interval}s --timeout={timeout}s --start-period={frontend_start_period}s --retries={retries} \
+HEALTHCHECK {hc_flags_frontend} \
   CMD curl -f http://localhost/ || exit 1
 
 WORKDIR /usr/share/nginx/html
@@ -276,16 +269,13 @@ RUN mkdir -p /cache/bun && chown -R bun:bun /cache/bun
 
 USER bun
 
-# Migrator-specific healthcheck (checks Prisma CLI)
-HEALTHCHECK --interval={interval}s --timeout={timeout}s --start-period={start_period}s --retries={retries} \
-  CMD bunx prisma --version || exit 1
+# Migrators are one-shot jobs (migrate.sh runs to completion), so no healthcheck.
+# The per-service l4_migrator_runtime stage sets HEALTHCHECK NONE as well.
+HEALTHCHECK NONE
 
 WORKDIR /app
 """.format(
-    interval=_docker_health["interval_seconds"],
-    timeout=_docker_health["timeout_seconds"],
-    start_period=_docker_health["start_period_seconds"],
-    retries=_docker_health["retries"],
-    frontend_start_period=_docker_health["frontend_start_period_seconds"],
+    hc_flags=dockerfile_healthcheck_flags(),
+    hc_flags_frontend=dockerfile_healthcheck_flags(DOCKER_HEALTHCHECK["frontend_start_period_seconds"]),
     prefix=_GOLDEN_PREFIX,
 )