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

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

@@ -1,8 +1,9 @@
 # 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 (client only, talks to the mounted
-# /var/run/docker.sock) and the real `tilt` CLI (D3: shells out to the
+# 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).
 
@@ -13,7 +14,7 @@ FROM oven/bun:1.3.11-alpine AS base
 # 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 curl gcompat \
+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" \

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

@@ -1,5 +1,11 @@
 import { describe, expect, test } from "bun:test";
-import { decideWakeAction, evaluateReadiness } from "./decide";
+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", () => {
@@ -56,6 +62,31 @@ describe("decideWakeAction", () => {
     ]);
   });
 
+  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",
@@ -66,6 +97,21 @@ describe("decideWakeAction", () => {
   });
 });
 
+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 });

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

@@ -20,11 +20,26 @@ 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):
@@ -39,8 +54,9 @@ export interface WakeAction {
  */
 export function decideWakeAction(snapshot: WakeRequestSnapshot): WakeAction {
   const tiltTriggerNames: string[] = [];
+  const useComposeStart = snapshot.resourceState === "absent" && snapshot.hasComposeInvocation === true;
 
-  if (snapshot.resourceState !== "running") {
+  if (snapshot.resourceState !== "running" && !useComposeStart) {
     tiltTriggerNames.push(snapshot.resourceContainerName);
   }
   for (const dep of snapshot.dependencies) {
@@ -51,7 +67,21 @@ export function decideWakeAction(snapshot: WakeRequestSnapshot): WakeAction {
 
   const useSablierStart = snapshot.resourceState === "exited" || snapshot.resourceState === "created";
 
-  return { tiltTriggerNames, useSablierStart };
+  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 {

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

@@ -10,11 +10,10 @@
  * 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 the proxy target -- Compose's embedded DNS
- *                          resolves a service by this name too).
+ *   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 -- NOT the same string as
+ *                          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.
@@ -23,15 +22,28 @@
  *   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, type ContainerState } from "./decide";
+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;
-const DEFAULT_TIMEOUT_MS = 60_000;
 
 async function run(cmd: string[]): Promise<{ code: number; stdout: string; stderr: string }> {
   const proc = Bun.spawn(cmd, { stdout: "pipe", stderr: "pipe" });
@@ -66,7 +78,52 @@ async function isHealthy(name: string): Promise<boolean> {
 }
 
 async function tiltTrigger(name: string): Promise<void> {
-  await run(["tilt", "trigger", name, "--host", TILT_HOST, "--port", TILT_PORT]);
+  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;
 }
 
 /**
@@ -110,14 +167,23 @@ 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 timeoutMs = Number(req.headers.get("X-Wake-Timeout-Ms")) || DEFAULT_TIMEOUT_MS;
+  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";
-  return { resource, container, deps, timeoutMs, proxyPort, sessionDuration };
+  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, timeoutMs, proxyPort, sessionDuration } = parseRequest(req);
+  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 });
   }
@@ -127,14 +193,32 @@ async function handleWake(req: Request): Promise<Response> {
     deps.map(async (dep) => ({ name: dep.resourceName, state: await containerState(dep.containerName) })),
   );
 
-  const action = decideWakeAction({ resourceContainerName: resource, resourceState, dependencies });
+  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;
 
-  // tilt trigger runs for everything cold (task 1.5: Tilt never cascades this
-  // on its own); Sablier's blocking call, when applicable, both starts AND
-  // waits for the resource itself in one round trip.
+  // 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(action.tiltTriggerNames.map(tiltTrigger)),
+    Promise.all(tiltNames.map(tiltTrigger)),
     action.useSablierStart
       ? sablierBlockingWait(resource, sessionDuration, timeoutMs)
       : Promise.resolve(false),
@@ -154,7 +238,7 @@ async function handleWake(req: Request): Promise<Response> {
     }
     const outcome = evaluateReadiness(requiredNames, healthy);
     if (outcome.ready) {
-      return proxyThrough(req, resource, proxyPort);
+      return proxyThrough(req, container, proxyPort);
     }
     await Bun.sleep(POLL_INTERVAL_MS);
   }
@@ -176,9 +260,16 @@ const STRIPPED_REQUEST_HEADERS = new Set([
   "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",
 ]);
 
-async function proxyThrough(req: Request, resource: string, port: string): Promise<Response> {
+// 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);
@@ -186,7 +277,7 @@ async function proxyThrough(req: Request, resource: string, port: string): Promi
   // 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 = resource;
+  target.hostname = container;
   target.port = port;
 
   const headers = new Headers();

package/engine/topologies/platform/docker/compose/traefik_standalone.star

@@ -7,6 +7,7 @@
 
 load("../constants.star", "PlatformDockerConstants")
 load("../config/healthcheck.star", "compose_healthcheck_timing")
+load("../networking/traefik_static_routes.star", "normalize_abs_path")
 
 
 def generate_standalone_traefik_compose():
@@ -91,7 +92,7 @@ services:
       - PORT={gateway_port}
     volumes:
       - /var/run/docker.sock:/var/run/docker.sock
-      - {tilt_dev_dir}:/root/.tilt-dev:ro
+      - {tilt_dev_dir}:/root/.tilt-dev:ro{project_root_mount}
     networks:
       - traefik-public
 
@@ -108,4 +109,25 @@ networks:
         gateway_container=PlatformDockerConstants.TRAEFIK_WAKE_GATEWAY_CONTAINER,
         gateway_port=PlatformDockerConstants.TRAEFIK_WAKE_GATEWAY_PORT,
         tilt_dev_dir=os.environ.get("HOME", "") + "/.tilt-dev",
+        project_root_mount=_project_root_mount(),
     )
+
+
+def _project_root_mount():
+    """Read-only mount of the project at its own absolute host path.
+
+    The gateway runs `docker compose up --no-build` for a deferred resource
+    itself (bypassing Tilt's build queue), using the compose files Tilt uses.
+    Compose resolves relative paths in them (env_file etc.) client-side, so
+    they must exist at the same absolute paths inside the gateway container.
+    Empty when TDK_PROJECT_ROOT is unset (the generated Tiltfile sets it).
+    """
+    root = project_root_abspath()
+    if not root:
+        return ""
+    return "\n      - " + root + ":" + root + ":ro"
+
+
+def project_root_abspath():
+    """Absolute, normalized project root (TDK_PROJECT_ROOT), or "" when unset."""
+    return normalize_abs_path(os.environ.get("TDK_PROJECT_ROOT", ""))

package/engine/topologies/platform/docker/networking/traefik_static_routes.star

@@ -13,10 +13,15 @@
 # backend was healthy).
 #
 # Config for a request travels to the gateway via headers (X-Wake-*), not
-# the path/query, so the original request path reaches the real backend
-# unchanged once the resource is ready (see wake-gateway/server.ts).
+# the path/query. The route still strips the same `apiPath` prefix the real
+# Docker-label `-project` router strips (get_backend_traefik_labels) before
+# forwarding -- confirmed live against tdk-erp-system (task 7.2) that a
+# backend's app only serves its bare health path (e.g. `/health`), not the
+# full `/api/{name}/health` the public route is matched on; without this, the
+# gateway's own proxy-through would forward the unstripped path once healthy
+# and the app would 404 on it, even though the wake itself succeeded.
 
-load("./traefik_helpers.star", "project_backend_rule", "build_entrypoints")
+load("./traefik_helpers.star", "project_backend_rule", "cli_api_path", "build_entrypoints")
 load("./traefik_constants.star",
     "TRAEFIK_BACKEND_ENABLE_HTTP",
     "TRAEFIK_BACKEND_ENABLE_HTTPS",
@@ -25,6 +30,29 @@ load("./traefik_constants.star",
 STATIC_ROUTE_PRIORITY = 1
 
 
+def normalize_abs_path(path):
+    """Absolute path with `.`/`..` segments collapsed, or "" for "".
+
+    Tilt's os.path.abspath does not collapse `..` (confirmed:
+    abspath("/a/.tdk/.tdk-out/../..") comes back unchanged), and the
+    generated Tiltfile's project root is exactly that shape
+    (config.main_dir + "/../.."). The gateway's project mount and the compose
+    paths in its route headers must match byte-for-byte, so both go through here.
+    """
+    if not path:
+        return ""
+    parts = []
+    for segment in os.path.abspath(path).split("/"):
+        if segment == "" or segment == ".":
+            continue
+        if segment == "..":
+            if parts:
+                parts.pop()
+            continue
+        parts.append(segment)
+    return "/" + "/".join(parts)
+
+
 def _container_name(compose_project_name, res_name):
     """Docker Compose's own naming convention: <project>-<service>-<replica>.
 
@@ -43,6 +71,9 @@ def generate_static_wake_route(
     gateway_host,
     gateway_port,
     dependencies=None,
+    compose_files=None,
+    env_file="",
+    image="",
 ):
     """YAML for one resource's Traefik file-provider dynamic-config entry.
 
@@ -51,21 +82,36 @@ def generate_static_wake_route(
     different compose project than the resource itself, so the project name
     travels alongside the resource name rather than being assumed shared.
 
+    `compose_files` (absolute paths), `env_file` and `image` let the gateway
+    create the container itself with `docker compose up --no-build` when the
+    image already exists, instead of waiting in Tilt's build queue behind
+    `tilt trigger`. Omitted headers make the gateway use `tilt trigger` only.
+
     Written to the directory PlatformDockerConstants.TRAEFIK_DYNAMIC_DIR_REL
     mounts into the standalone Traefik container (traefik_standalone.star).
     """
     dependencies = dependencies or []
 
     rule = project_backend_rule(manifest, resource_entry_name)
+    api_path = cli_api_path(resource_entry_name, manifest)
     entrypoints = build_entrypoints(TRAEFIK_BACKEND_ENABLE_HTTP, TRAEFIK_BACKEND_ENABLE_HTTPS)
     router_name = resource_entry_name + "-wake"
-    middleware_name = resource_entry_name + "-wake-headers"
+    headers_middleware_name = resource_entry_name + "-wake-headers"
+    strip_middleware_name = resource_entry_name + "-wake-strip"
     service_name = resource_entry_name + "-wake-gateway"
     container_name = _container_name(compose_project_name, resource_entry_name)
     deps_header = ",".join([
         dep_res_name + "=" + _container_name(dep_project_name, dep_res_name)
         for dep_res_name, dep_project_name in dependencies
     ])
+    compose_headers = ""
+    if compose_files and image:
+        compose_headers = (
+            '\n          X-Wake-Compose-Project: "' + compose_project_name + '"'
+            + '\n          X-Wake-Compose-Files: "' + ",".join(compose_files) + '"'
+            + '\n          X-Wake-Env-File: "' + env_file + '"'
+            + '\n          X-Wake-Image: "' + image + '"'
+        )
 
     return """# SYSTEM-GENERATED - DO NOT EDIT (sablier.deferStart static wake route)
 http:
@@ -76,16 +122,21 @@ http:
         - {entrypoint}
       service: {service_name}
       middlewares:
-        - {middleware_name}
+        - {strip_middleware_name}
+        - {headers_middleware_name}
       priority: {priority}
   middlewares:
-    {middleware_name}:
+    {strip_middleware_name}:
+      stripPrefix:
+        prefixes:
+          - "{api_path}"
+    {headers_middleware_name}:
       headers:
         customRequestHeaders:
           X-Wake-Resource: "{resource_entry_name}"
           X-Wake-Container: "{container_name}"
           X-Wake-Deps: "{deps_header}"
-          X-Wake-Proxy-Port: "{internal_port}"
+          X-Wake-Proxy-Port: "{internal_port}"{compose_headers}
   services:
     {service_name}:
       loadBalancer:
@@ -96,12 +147,15 @@ http:
         rule=rule,
         entrypoint=entrypoints.split(",")[0],
         service_name=service_name,
-        middleware_name=middleware_name,
+        strip_middleware_name=strip_middleware_name,
+        headers_middleware_name=headers_middleware_name,
+        api_path=api_path,
         priority=STATIC_ROUTE_PRIORITY,
         resource_entry_name=resource_entry_name,
         container_name=container_name,
         deps_header=deps_header,
         internal_port=internal_port,
+        compose_headers=compose_headers,
         gateway_host=gateway_host,
         gateway_port=gateway_port,
     )

package/engine/topologies/tilt/resources/orchestrator/apply_compose_resource_registration.star

@@ -10,7 +10,7 @@ OUTPUT = struct(AUTOGENERATED_FOLDER = ".autogenerated")
 load('../../../platform/docker/index.star', 'Docker')
 load('../../../platform/docker/constants.star', 'PlatformDockerConstants')
 load('../../../tilt/manifest/constants.star', 'BASE_PORT_FRONTEND', 'BASE_PORT_BACKEND')
-load('../../../platform/docker/networking/traefik_static_routes.star', 'generate_static_wake_route')
+load('../../../platform/docker/networking/traefik_static_routes.star', 'generate_static_wake_route', 'normalize_abs_path')
 load('../../../platform/docker/networking/sablier_container_cycle.star', 'sablier_middleware_suffix')
 
 load('./builders/typescript.star', 'TypescriptBuilders')
@@ -213,9 +213,38 @@ def _build_live_update_rules(res_path, full_res_path, syncs):
     return live_update_rules
 
 
+def _app_image_name(resource_name, res_name):
+    """The image ref docker_build builds and the app compose service declares."""
+    return resource_name + '_' + res_name + ':dev'
+
+
+def _wake_compose_invocation(project_root, resource_path, res_name, resource_name):
+    """Compose files, env file and image for the wake gateway's direct start.
+
+    The same files/--env-file the `-run-only` resource passes, as absolute
+    normalized paths: the gateway mounts the project at the same normalized
+    root (traefik_standalone.star), so these resolve identically there.
+    Returns None without a project root (paths would be relative to Tilt's cwd).
+    """
+    if not project_root:
+        return None
+    root = normalize_abs_path(project_root)
+    compose_dir = root + '/' + resource_path + '/' + OUTPUT.AUTOGENERATED_FOLDER
+    files = [compose_dir + '/docker-compose.app.autogenerated.yml']
+    port_override = compose_dir + '/docker-compose.port-override.yml'
+    if os.path.exists(port_override):
+        files.append(port_override)
+    env_file = root + '/.env'
+    return {
+        'compose_files': files,
+        'env_file': env_file if os.path.exists(env_file) else '',
+        'image': _app_image_name(resource_name, res_name),
+    }
+
+
 def _register_docker_build(config, live_update_rules):
     """Register docker_build with live_update for hot-reload support."""
-    image_name = config['resource_name'] + '_' + config['res_name'] + ':dev'
+    image_name = _app_image_name(config['resource_name'], config['res_name'])
     project_root = config.get('project_root', '')
     # Use custom dockerfile from config if specified, otherwise use autogenerated default
     # The res_path is relative to project_root (e.g., 'services/product/...')
@@ -478,6 +507,9 @@ def register_compose_resources(resource_config, ctx, runtime_flags, manifest_sta
             if resource_defers_start(manifest) and write_file:
                 internal_port = res.get('port', manifest.get('port', BASE_PORT_BACKEND))
                 static_route_path = PlatformDockerConstants.TRAEFIK_DYNAMIC_DIR_REL + '/' + res['name'] + '.yml'
+                compose_invocation = _wake_compose_invocation(
+                    ctx.get('project_root', ''), resource_path, res['name'], resource_name,
+                ) or {}
                 write_file(static_route_path, generate_static_wake_route(
                     resource_entry_name=res['name'],
                     compose_project_name=compose_project_name,
@@ -486,6 +518,9 @@ def register_compose_resources(resource_config, ctx, runtime_flags, manifest_sta
                     gateway_host=PlatformDockerConstants.TRAEFIK_WAKE_GATEWAY_CONTAINER,
                     gateway_port=PlatformDockerConstants.TRAEFIK_WAKE_GATEWAY_PORT,
                     dependencies=resolve_defer_start_dependencies(manifest, resource_manifests, all_services_map),
+                    compose_files=compose_invocation.get('compose_files'),
+                    env_file=compose_invocation.get('env_file', ''),
+                    image=compose_invocation.get('image', ''),
                 ))
 
         resource_entries.append(entry)