optional machine preset overrides

Author: nicktrn

apps/webapp/app/env.server.ts

@@ -776,6 +776,9 @@ const EnvironmentSchema = z.object({
   TRIGGER_BOOTSTRAP_ENABLED: z.string().default("0"),
   TRIGGER_BOOTSTRAP_WORKER_GROUP_NAME: z.string().optional(),
   TRIGGER_BOOTSTRAP_WORKER_TOKEN_PATH: z.string().optional(),
+
+  // Machine presets
+  MACHINE_PRESETS_OVERRIDE_PATH: z.string().optional(),
 });
 
 export type Environment = z.infer<typeof EnvironmentSchema>;

apps/webapp/app/routes/engine.v1.dev.runs.$runFriendlyId.snapshots.$snapshotFriendlyId.attempts.start.ts

@@ -6,7 +6,7 @@ import {
   WorkerApiRunAttemptStartResponseBody,
 } from "@trigger.dev/core/v3/workers";
 import { RuntimeEnvironment } from "@trigger.dev/database";
-import { defaultMachine } from "@trigger.dev/platform/v3";
+import { defaultMachine } from "~/services/platform.v3.server";
 import { z } from "zod";
 import { prisma } from "~/db.server";
 import { generateJWTTokenForEnvironment } from "~/services/apiAuth.server";

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

@@ -1,10 +1,13 @@
-import { Organization, Project } from "@trigger.dev/database";
+import type { Organization, Project } from "@trigger.dev/database";
 import {
   BillingClient,
-  Limits,
-  SetPlanBody,
-  UsageSeriesParams,
-  UsageResult,
+  type Limits,
+  type SetPlanBody,
+  type UsageSeriesParams,
+  type UsageResult,
+  defaultMachine as defaultMachineFromPlatform,
+  machines as machinesFromPlatform,
+  type MachineCode,
 } from "@trigger.dev/platform/v3";
 import { createCache, DefaultStatefulContext, Namespace } from "@unkey/cache";
 import { MemoryStore } from "@unkey/cache/stores";
@@ -17,6 +20,9 @@ import { logger } from "~/services/logger.server";
 import { newProjectPath, organizationBillingPath } from "~/utils/pathBuilder";
 import { singleton } from "~/utils/singleton";
 import { RedisCacheStore } from "./unkey/redisCacheStore.server";
+import { existsSync, readFileSync } from "node:fs";
+import { z } from "zod";
+import { MachinePresetName } from "@trigger.dev/core/v3";
 
 function initializeClient() {
   if (isCloud() && process.env.BILLING_API_URL && process.env.BILLING_API_KEY) {
@@ -67,6 +73,111 @@ function initializePlatformCache() {
 
 const platformCache = singleton("platformCache", initializePlatformCache);
 
+type Machines = typeof machinesFromPlatform;
+
+const MachineOverrideValues = z.object({
+  cpu: z.number(),
+  memory: z.number(),
+});
+type MachineOverrideValues = z.infer<typeof MachineOverrideValues>;
+
+const MachineOverrides = z.record(MachinePresetName, MachineOverrideValues.partial());
+type MachineOverrides = z.infer<typeof MachineOverrides>;
+
+const MachinePresetOverrides = z.object({
+  defaultMachine: MachinePresetName.optional(),
+  machines: MachineOverrides.optional(),
+});
+
+function initializeMachinePresets(): {
+  defaultMachine: MachineCode;
+  machines: Machines;
+} {
+  const overrides = getMachinePresetOverrides();
+
+  if (!overrides) {
+    return {
+      defaultMachine: defaultMachineFromPlatform,
+      machines: machinesFromPlatform,
+    };
+  }
+
+  return {
+    defaultMachine: overrideDefaultMachine(defaultMachineFromPlatform, overrides.defaultMachine),
+    machines: overrideMachines(machinesFromPlatform, overrides.machines),
+  };
+}
+
+export const { defaultMachine, machines } = singleton("machinePresets", initializeMachinePresets);
+
+function overrideDefaultMachine(defaultMachine: MachineCode, override?: MachineCode): MachineCode {
+  if (!override) {
+    return defaultMachine;
+  }
+
+  return override;
+}
+
+function overrideMachines(machines: Machines, overrides?: MachineOverrides): Machines {
+  if (!overrides) {
+    return machines;
+  }
+
+  const mergedMachines = {
+    ...machines,
+  };
+
+  for (const machine of Object.keys(overrides) as MachinePresetName[]) {
+    mergedMachines[machine] = {
+      ...mergedMachines[machine],
+      ...overrides[machine],
+    };
+  }
+
+  return mergedMachines;
+}
+
+function getMachinePresetOverrides() {
+  const path = env.MACHINE_PRESETS_OVERRIDE_PATH;
+  if (!path) {
+    return;
+  }
+
+  const overrides = safeReadMachinePresetOverrides(path);
+  if (!overrides) {
+    return;
+  }
+
+  const parsed = MachinePresetOverrides.safeParse(overrides);
+
+  if (!parsed.success) {
+    logger.error("Error parsing machine preset overrides", { path, error: parsed.error });
+    return;
+  }
+
+  return parsed.data;
+}
+
+function safeReadMachinePresetOverrides(path: string) {
+  try {
+    const fileExists = existsSync(path);
+    if (!fileExists) {
+      logger.error("Machine preset overrides file does not exist", { path });
+      return;
+    }
+
+    const fileContents = readFileSync(path, "utf8");
+
+    return JSON.parse(fileContents);
+  } catch (error) {
+    logger.error("Error reading machine preset overrides", {
+      path,
+      error: error instanceof Error ? error.message : String(error),
+    });
+    return;
+  }
+}
+
 export async function getCurrentPlan(orgId: string) {
   if (!client) return undefined;
 

apps/webapp/app/v3/machinePresets.server.ts

@@ -1,5 +1,5 @@
 import { MachineConfig, MachinePreset, MachinePresetName } from "@trigger.dev/core/v3";
-import { defaultMachine, machines } from "@trigger.dev/platform/v3";
+import { defaultMachine, machines } from "~/services/platform.v3.server";
 import { logger } from "~/services/logger.server";
 
 export function machinePresetFromConfig(config: unknown): MachinePreset {

apps/webapp/app/v3/runEngine.server.ts

@@ -1,5 +1,5 @@
 import { RunEngine } from "@internal/run-engine";
-import { defaultMachine } from "@trigger.dev/platform/v3";
+import { defaultMachine } from "~/services/platform.v3.server";
 import { prisma } from "~/db.server";
 import { env } from "~/env.server";
 import { singleton } from "~/utils/singleton";

apps/webapp/app/v3/services/worker/workerGroupTokenService.server.ts

@@ -29,7 +29,7 @@ import {
   fromFriendlyId,
 } from "@trigger.dev/core/v3/isomorphic";
 import { machinePresetFromName } from "~/v3/machinePresets.server";
-import { defaultMachine } from "@trigger.dev/platform/v3";
+import { defaultMachine } from "~/services/platform.v3.server";
 
 export class WorkerGroupTokenService extends WithRunEngine {
   private readonly tokenPrefix = "tr_wgt_";

packages/cli-v3/src/utilities/fileSystem.ts

@@ -56,20 +56,6 @@ export async function readJSONFile(path: string) {
   return JSON.parse(fileContents);
 }
 
-export async function safeFeadJSONFile(path: string) {
-  try {
-    const fileExists = await pathExists(path);
-
-    if (!fileExists) return;
-
-    const fileContents = await readFile(path);
-
-    return JSON.parse(fileContents);
-  } catch {
-    return;
-  }
-}
-
 export async function writeJSONFile(path: string, json: any, pretty = false) {
   await writeFile(path, JSON.stringify(json, undefined, pretty ? 2 : undefined), "utf8");
 }