feat(webapp): configurable deploy template presets via env (multi-preset prep)

Author: nicktrn

.server-changes/multi-preset-template-creation.md

@@ -0,0 +1,6 @@
+---
+area: webapp
+type: feature
+---
+
+Configure the set of machine presets to build boot snapshots for at deploy time via `COMPUTE_TEMPLATE_MACHINE_PRESETS` (CSV of preset names, default `small-1x`). Use `COMPUTE_TEMPLATE_MACHINE_PRESETS_REQUIRED` (CSV, default = full PRESETS list) to scope which preset failures fail a required-mode deploy. Optional preset failures are logged and don't block the deploy.

apps/webapp/app/env.server.ts

@@ -1,8 +1,42 @@
 import { z } from "zod";
+import { MachinePresetName } from "@trigger.dev/core/v3";
 import { BoolEnv } from "./utils/boolEnv";
 import { isValidDatabaseUrl } from "./utils/db";
 import { isValidRegex } from "./utils/regex";
 
+// Parses a CSV of machine preset names (e.g. "small-1x,small-2x") into a
+// non-empty array of MachinePresetName. Used by COMPUTE_TEMPLATE_MACHINE_PRESETS
+// and its _REQUIRED variant. Adds zod issues for empty input or unknown names.
+const parseMachinePresetCsv = (
+  raw: string,
+  ctx: z.RefinementCtx
+): MachinePresetName[] => {
+  const names = raw
+    .split(",")
+    .map((s) => s.trim())
+    .filter(Boolean);
+  if (names.length === 0) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "must list at least one machine preset",
+    });
+    return z.NEVER;
+  }
+  const out: MachinePresetName[] = [];
+  for (const name of names) {
+    const parsed = MachinePresetName.safeParse(name);
+    if (!parsed.success) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `unknown machine preset: "${name}"`,
+      });
+      return z.NEVER;
+    }
+    out.push(parsed.data);
+  }
+  return out;
+};
+
 const GithubAppEnvSchema = z.preprocess(
   (val) => {
     const obj = val as any;
@@ -342,6 +376,25 @@ const EnvironmentSchema = z
     COMPUTE_GATEWAY_URL: z.string().optional(),
     COMPUTE_GATEWAY_AUTH_TOKEN: z.string().optional(),
     COMPUTE_TEMPLATE_SHADOW_ROLLOUT_PCT: z.string().optional(),
+    // Comma-separated machine preset names to build boot snapshots for on
+    // deploy (e.g. "small-1x,small-2x,medium-1x"). Default: "small-1x".
+    COMPUTE_TEMPLATE_MACHINE_PRESETS: z
+      .string()
+      .default("small-1x")
+      .transform(parseMachinePresetCsv),
+    // Subset of COMPUTE_TEMPLATE_MACHINE_PRESETS that must succeed for a
+    // required-mode deploy to be considered successful. Failures of presets
+    // outside this list are logged but don't fail the deploy. Defaults to the
+    // full COMPUTE_TEMPLATE_MACHINE_PRESETS list when unset (everything required).
+    COMPUTE_TEMPLATE_MACHINE_PRESETS_REQUIRED: z
+      .string()
+      .optional()
+      .transform((v, ctx) =>
+        parseMachinePresetCsv(
+          v ?? process.env.COMPUTE_TEMPLATE_MACHINE_PRESETS ?? "small-1x",
+          ctx
+        )
+      ),
 
     DEPLOY_IMAGE_PLATFORM: z.string().default("linux/amd64"),
     DEPLOY_TIMEOUT_MS: z.coerce

apps/webapp/app/v3/services/computeTemplateCreation.server.ts

@@ -1,4 +1,6 @@
 import { ComputeClient, stripImageDigest } from "@internal/compute";
+import type { TemplateCreateResultEntry } from "@internal/compute";
+import { MachinePresetName } from "@trigger.dev/core/v3";
 import { machinePresetFromName } from "~/v3/machinePresets.server";
 import { env } from "~/env.server";
 import { logger } from "~/services/logger.server";
@@ -10,8 +12,16 @@ import { resolveComputeAccess } from "../regionAccess.server";
 
 type TemplateCreationMode = "required" | "shadow" | "skip";
 
+type ResolvedPreset = {
+  name: MachinePresetName;
+  cpu: number;
+  memory_gb: number;
+};
+
 export class ComputeTemplateCreationService {
   private client: ComputeClient | undefined;
+  private presets: ResolvedPreset[];
+  private requiredPresets: Set<MachinePresetName>;
 
   constructor() {
     if (env.COMPUTE_GATEWAY_URL) {
@@ -21,6 +31,24 @@ export class ComputeTemplateCreationService {
         timeoutMs: 5 * 60 * 1000, // 5 minutes
       });
     }
+
+    this.presets = env.COMPUTE_TEMPLATE_MACHINE_PRESETS.map((name) => {
+      const machine = machinePresetFromName(name);
+      return { name, cpu: machine.cpu, memory_gb: machine.memory };
+    });
+
+    // Sanity-check that required is a subset of the configured presets.
+    // env-layer parsing already validated each name; this catches the cross-
+    // field invariant that env-level transforms can't easily express.
+    const presetNames = new Set(this.presets.map((p) => p.name));
+    for (const required of env.COMPUTE_TEMPLATE_MACHINE_PRESETS_REQUIRED) {
+      if (!presetNames.has(required)) {
+        throw new Error(
+          `COMPUTE_TEMPLATE_MACHINE_PRESETS_REQUIRED includes "${required}" which is not in COMPUTE_TEMPLATE_MACHINE_PRESETS`
+        );
+      }
+    }
+    this.requiredPresets = new Set(env.COMPUTE_TEMPLATE_MACHINE_PRESETS_REQUIRED);
   }
 
   /**
@@ -48,12 +76,12 @@ export class ComputeTemplateCreationService {
 
     if (mode === "shadow") {
       this.createTemplate(options.imageReference, { background: true })
-        .then((result) => {
-          if (!result.success) {
+        .then((outcome) => {
+          if (outcome.error) {
             logger.error("Shadow template creation failed", {
               id: options.deploymentFriendlyId,
               imageReference: options.imageReference,
-              error: result.error,
+              error: outcome.error,
             });
           }
         })
@@ -81,31 +109,39 @@ export class ComputeTemplateCreationService {
     logger.info("Creating compute template (required mode)", {
       id: options.deploymentFriendlyId,
       imageReference: options.imageReference,
+      presets: this.presets.map((p) => p.name),
+      requiredPresets: [...this.requiredPresets],
     });
 
-    const result = await this.createTemplate(options.imageReference);
+    const outcome = await this.createTemplate(options.imageReference);
+    const failureMessage = this.failureMessageForRequiredMode(
+      outcome,
+      options.deploymentFriendlyId,
+      options.imageReference
+    );
 
-    if (!result.success) {
+    if (failureMessage) {
       logger.error("Compute template creation failed", {
         id: options.deploymentFriendlyId,
         imageReference: options.imageReference,
-        error: result.error,
+        error: failureMessage,
       });
 
       const failService = new FailDeploymentService();
       await failService.call(options.authenticatedEnv, options.deploymentFriendlyId, {
         error: {
           name: "TemplateCreationFailed",
-          message: `Failed to create compute template: ${result.error}`,
+          message: `Failed to create compute template: ${failureMessage}`,
         },
       });
 
-      throw new ServiceValidationError(`Compute template creation failed: ${result.error}`);
+      throw new ServiceValidationError(`Compute template creation failed: ${failureMessage}`);
     }
 
     logger.info("Compute template created", {
       id: options.deploymentFriendlyId,
       imageReference: options.imageReference,
+      results: outcome.results.length,
     });
   }
 
@@ -154,29 +190,108 @@ export class ComputeTemplateCreationService {
   async createTemplate(
     imageReference: string,
     options?: { background?: boolean }
-  ): Promise<{ success: boolean; error?: string }> {
+  ): Promise<CreateTemplateOutcome> {
     if (!this.client) {
-      return { success: false, error: "Compute gateway not configured" };
+      return { error: "Compute gateway not configured", results: [] };
     }
 
     try {
-      // Templates are resource-agnostic - these values don't affect template content.
-      const machine = machinePresetFromName("small-1x");
+      const machineConfigs = this.presets.map((p) => ({
+        cpu: p.cpu,
+        memory_gb: p.memory_gb,
+      }));
 
-      await this.client.templates.create({
+      const response = await this.client.templates.create({
         image: stripImageDigest(imageReference),
-        cpu: machine.cpu,
-        memory_gb: machine.memory,
+        machine_configs: machineConfigs,
         background: options?.background,
       });
-      return { success: true };
+
+      // Background mode (202 Accepted): no body to inspect.
+      if (options?.background || !response) {
+        return { results: [] };
+      }
+
+      return {
+        error: response.error,
+        results: response.results,
+      };
     } catch (error) {
       const message = error instanceof Error ? error.message : "Unknown error";
       logger.error("Failed to create compute template", {
         imageReference,
         error: message,
       });
-      return { success: false, error: message };
+      return { error: message, results: [] };
+    }
+  }
+
+  // Returns a human-readable failure message if any required preset failed
+  // or the request itself failed. Optional preset failures are logged and
+  // do not contribute to the message. Returns undefined on success.
+  //
+  // Result-to-preset matching is by index: response.results[i] corresponds
+  // to this.presets[i]. While the multi-config compute path is being built
+  // out, the gateway may return fewer entries than presets requested - any
+  // unbuilt required preset is still treated as a failure.
+  private failureMessageForRequiredMode(
+    outcome: CreateTemplateOutcome,
+    deploymentFriendlyId: string,
+    imageReference: string
+  ): string | undefined {
+    if (this.presets.length === 0) {
+      return undefined;
     }
+
+    const failures: string[] = [];
+
+    this.presets.forEach((preset, i) => {
+      const isRequired = this.requiredPresets.has(preset.name);
+      const result = outcome.results[i];
+
+      if (!result) {
+        if (isRequired) {
+          failures.push(`${preset.name}: not built`);
+        } else {
+          logger.warn("Optional compute template preset not built", {
+            id: deploymentFriendlyId,
+            imageReference,
+            preset: preset.name,
+          });
+        }
+        return;
+      }
+
+      if (result.error) {
+        if (isRequired) {
+          failures.push(`${preset.name}: ${result.error}`);
+        } else {
+          logger.warn("Optional compute template preset failed", {
+            id: deploymentFriendlyId,
+            imageReference,
+            preset: preset.name,
+            error: result.error,
+          });
+        }
+      }
+    });
+
+    // Top-level error not tied to a specific preset (e.g. gateway unreachable,
+    // image pull failed). Surface it if no per-preset failure was attributed.
+    if (outcome.error && failures.length === 0) {
+      failures.push(outcome.error);
+    }
+
+    return failures.length > 0 ? failures.join("; ") : undefined;
   }
 }
+
+type CreateTemplateOutcome = {
+  // Top-level error - request didn't reach gateway, image pull/squashfs
+  // failed, or any per-result failure that was promoted to a request-level
+  // failure by the gateway. Empty if all succeeded.
+  error?: string;
+  // Per-preset results in input order. Empty for background mode or when
+  // the request didn't reach the gateway.
+  results: TemplateCreateResultEntry[];
+};

internal-packages/compute/src/client.ts

@@ -1,5 +1,6 @@
 import type {
   TemplateCreateRequest,
+  TemplateCreateResponse,
   InstanceCreateRequest,
   InstanceCreateResponse,
   InstanceSnapshotRequest,
@@ -106,8 +107,10 @@ class TemplatesNamespace {
   async create(
     req: TemplateCreateRequest,
     options?: RequestOptions
-  ): Promise<void> {
-    await this.http.post("/api/templates", req, options);
+  ): Promise<TemplateCreateResponse | undefined> {
+    // Background mode returns 202 with no body; sync/callback mode returns
+    // the full result. Caller decides whether to inspect.
+    return this.http.post<TemplateCreateResponse>("/api/templates", req, options);
   }
 }
 

internal-packages/compute/src/index.ts

@@ -2,7 +2,11 @@ export { ComputeClient, ComputeClientError } from "./client.js";
 export type { ComputeClientOptions } from "./client.js";
 export { stripImageDigest } from "./imageRef.js";
 export {
+  MachineConfigSchema,
+  BootSnapshotInfoSchema,
   TemplateCreateRequestSchema,
+  TemplateCreateResultEntrySchema,
+  TemplateCreateResponseSchema,
   TemplateCallbackPayloadSchema,
   InstanceCreateRequestSchema,
   InstanceCreateResponseSchema,
@@ -11,7 +15,11 @@ export {
   SnapshotCallbackPayloadSchema,
 } from "./types.js";
 export type {
+  MachineConfig,
+  BootSnapshotInfo,
   TemplateCreateRequest,
+  TemplateCreateResultEntry,
+  TemplateCreateResponse,
   TemplateCallbackPayload,
   InstanceCreateRequest,
   InstanceCreateResponse,