refactor(cli): swap CliApiClient for an offline shim instead of forking indexDeployment

Previous offline-mode plumbing carved branching into indexDeployment:
discriminated union types, `result.mode === "offline"` checks at every
API call site, parallel disk-write paths next to the API-call paths.

Replace with a CliApiClient stub that, instead of issuing HTTP
requests, writes the same payloads to disk:

  - getEnvironmentVariables → returns `{ variables: {} }`
  - createDeploymentBackgroundWorker → writes the body's metadata (plus
    buildPlatform / targetPlatform) to `index-metadata.json`
  - failDeployment → writes the error to `index-error.json`

bootstrap() picks the shim when TRIGGER_INDEX_OFFLINE=1 and the real
CliApiClient otherwise. indexDeployment is unchanged — bit-identical to
upstream — because both implementations satisfy the same interface for
the three methods it actually uses.

Diff vs upstream collapses to just two hunks: a 14-line offline branch
at the top of bootstrap() and the ~65-line shim factory at the bottom
of the file.

The flattened `index-metadata.json` shape matches what
register-tasks/register.mjs (in govsignals) already reads, so no
downstream consumer change.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: ConProgramming

packages/cli-v3/src/entryPoints/managed-index-controller.ts

@@ -12,67 +12,30 @@ import { resolveSourceFiles } from "../utilities/sourceFiles.js";
 import { execOptionsForRuntime } from "@trigger.dev/core/v3/build";
 import { writeJSONFile } from "../utilities/fileSystem.js";
 
-/**
- * The managed index controller runs inside the build container at deploy time
- * and indexes the user's tasks. It supports two modes:
- *
- *   1. **Online mode (default, used by Trigger.dev cloud)**:
- *      - Fetches environment variables from the API via `CliApiClient`.
- *      - Registers the resulting BackgroundWorker via the API.
- *      - Reports indexing failures via `failDeployment`.
- *
- *   2. **Offline mode (opt-in via `TRIGGER_INDEX_OFFLINE=1` build arg)**:
- *      - Skips the API entirely; no env vars are fetched, no
- *        BackgroundWorker is registered, no failures are reported.
- *      - Writes `index-metadata.json` (or `index-error.json` on failure)
- *        to the working directory inside the build container. The multi-stage
- *        Containerfile copies them into the final image so downstream tooling
- *        can read them out of the runtime image (and on failure the indexer
- *        process exits non-zero, failing the build).
- *      - Intended for self-hosted setups that drive the build via
- *        `trigger.dev/internal`'s `buildImage({ offlineIndex: true })`
- *        without API credentials in the build environment.
- *
- * Mode is selected by the `TRIGGER_INDEX_OFFLINE=1` env var.
- */
-
 async function loadBuildManifest() {
   const manifestContents = await readFile("./build.json", "utf-8");
   const raw = JSON.parse(manifestContents);
 
   return BuildManifest.parse(raw);
 }
 
-// In offline mode (TRIGGER_INDEX_OFFLINE=1) the bootstrap skips API client
-// construction entirely. Downstream code treats `cliApiClient === undefined`
-// as the signal that we're running offline.
-type BootstrapResult = {
-  buildManifest: BuildManifest;
-  cliApiClient?: CliApiClient;
-  projectRef?: string;
-  deploymentId?: string;
-};
-
-/**
- * Returns the same shape as `cliApiClient.getEnvironmentVariables` for the
- * offline path. We never have project env vars at index time in offline mode
- * (the build container has no API access), so it's just an empty `variables`
- * map wrapped in the success envelope so downstream code can branch once on
- * `$env.success`.
- */
-const offlineEnvShim = () =>
-  ({ success: true as const, data: { variables: {} as Record<string, string> } });
-
-async function bootstrap(): Promise<BootstrapResult> {
+async function bootstrap() {
   const buildManifest = await loadBuildManifest();
 
-  // Offline mode: API access is unavailable. The artifacts produced by
-  // indexDeployment are baked into the final image by the Containerfile.
+  // Offline mode (TRIGGER_INDEX_OFFLINE=1): swap in a CliApiClient shim that
+  // writes the same payloads to disk that the real client would have sent
+  // over the wire. indexDeployment is unchanged — it just gets a different
+  // implementation of the same interface.
   if (env.TRIGGER_INDEX_OFFLINE === "1") {
-    return { buildManifest };
+    return {
+      buildManifest,
+      cliApiClient: createOfflineCliApiClient(),
+      // The shim ignores these but the shape needs to match.
+      projectRef: env.TRIGGER_PROJECT_REF ?? "offline",
+      deploymentId: env.TRIGGER_DEPLOYMENT_ID ?? "offline",
+    };
   }
 
-  // Online mode (default): use the API for env vars and registration.
   if (typeof env.TRIGGER_API_URL !== "string") {
     console.error("TRIGGER_API_URL is not set");
     process.exit(1);
@@ -102,6 +65,8 @@ async function bootstrap(): Promise<BootstrapResult> {
   };
 }
 
+type BootstrapResult = Awaited<ReturnType<typeof bootstrap>>;
+
 async function indexDeployment({
   cliApiClient,
   projectRef,
@@ -112,10 +77,7 @@ async function indexDeployment({
   const stderr: string[] = [];
 
   try {
-    const $env =
-      cliApiClient && projectRef
-        ? await cliApiClient.getEnvironmentVariables(projectRef)
-        : offlineEnvShim();
+    const $env = await cliApiClient.getEnvironmentVariables(projectRef);
 
     if (!$env.success) {
       throw new Error(`Failed to fetch environment variables: ${$env.error}`);
@@ -149,41 +111,6 @@ async function indexDeployment({
     const buildPlatform = process.env.BUILDPLATFORM;
     const targetPlatform = process.env.TARGETPLATFORM;
 
-    if (!cliApiClient || !deploymentId) {
-      // Offline mode: write metadata to disk; the multi-stage Containerfile
-      // copies it into the final image where downstream tooling reads it.
-      const indexMetadata = {
-        contentHash: buildManifest.contentHash,
-        packageVersion: buildManifest.packageVersion,
-        cliPackageVersion: buildManifest.cliPackageVersion,
-        tasks: workerManifest.tasks,
-        queues: workerManifest.queues,
-        sourceFiles,
-        runtime: workerManifest.runtime,
-        runtimeVersion: workerManifest.runtimeVersion,
-        buildPlatform,
-        targetPlatform,
-      };
-
-      console.log("Writing index-metadata.json");
-
-      await writeFile(
-        join(process.cwd(), "index-metadata.json"),
-        JSON.stringify(indexMetadata, null, 2)
-      );
-
-      console.log(
-        JSON.stringify({
-          message: "Indexing completed (offline mode)",
-          buildPlatform,
-          targetPlatform,
-          taskCount: workerManifest.tasks.length,
-        })
-      );
-      return;
-    }
-
-    // Online mode: register the BackgroundWorker via the API.
     const backgroundWorkerBody: CreateBackgroundWorkerRequestBody = {
       localOnly: true,
       metadata: {
@@ -233,20 +160,71 @@ async function indexDeployment({
 
     console.error("Failed to index deployment", serialiedIndexError);
 
-    if (cliApiClient && deploymentId) {
-      await cliApiClient.failDeployment(deploymentId, { error: serialiedIndexError });
-    } else {
-      // Offline mode: write error to disk so downstream tooling can surface it.
-      await writeFile(
-        join(process.cwd(), "index-error.json"),
-        JSON.stringify({ error: serialiedIndexError }, null, 2)
-      );
-    }
+    await cliApiClient.failDeployment(deploymentId, { error: serialiedIndexError });
 
     process.exit(1);
   }
 }
 
+/**
+ * Stub `CliApiClient` for offline indexing (TRIGGER_INDEX_OFFLINE=1).
+ *
+ * indexDeployment makes three calls on the API client:
+ *
+ *   1. `getEnvironmentVariables(projectRef)` — returns an empty `variables`
+ *      map. The build container has no API access in offline mode, so we
+ *      can't fetch project env vars; the indexer runs with `{}`.
+ *   2. `createDeploymentBackgroundWorker(deploymentId, body)` — writes the
+ *      flattened body to `index-metadata.json`. Downstream tooling (e.g.
+ *      a register-only Job in the cluster) re-issues this payload to the
+ *      real API.
+ *   3. `failDeployment(deploymentId, body)` — writes the error to
+ *      `index-error.json`.
+ *
+ * The multi-stage Containerfile copies these files into the final image so
+ * downstream tooling reads them out of the runtime image.
+ *
+ * Cast through `unknown` because `CliApiClient` is a concrete class with
+ * private fields and methods we don't need to stub. indexDeployment only
+ * touches the three methods above.
+ */
+function createOfflineCliApiClient(): CliApiClient {
+  return {
+    async getEnvironmentVariables() {
+      return { success: true as const, data: { variables: {} as Record<string, string> } };
+    },
+    async createDeploymentBackgroundWorker(
+      _deploymentId: string,
+      body: CreateBackgroundWorkerRequestBody
+    ) {
+      const indexMetadata = {
+        ...body.metadata,
+        buildPlatform: body.buildPlatform,
+        targetPlatform: body.targetPlatform,
+      };
+      await writeFile(
+        join(process.cwd(), "index-metadata.json"),
+        JSON.stringify(indexMetadata, null, 2)
+      );
+      return {
+        success: true as const,
+        data: {
+          id: "offline",
+          version: "offline",
+          contentHash: body.metadata.contentHash,
+        },
+      };
+    },
+    async failDeployment(_deploymentId: string, body: { error: unknown }) {
+      await writeFile(
+        join(process.cwd(), "index-error.json"),
+        JSON.stringify(body, null, 2)
+      );
+      return { success: true as const, data: { id: "offline" } };
+    },
+  } as unknown as CliApiClient;
+}
+
 const results = await bootstrap();
 
 await indexDeployment(results);