refactor: consolidate compute gateway clients into shared @internal/compute package

Author: nicktrn

apps/supervisor/package.json

@@ -15,6 +15,7 @@
   "dependencies": {
     "@aws-sdk/client-ecr": "^3.839.0",
     "@kubernetes/client-node": "^1.0.0",
+    "@internal/compute": "workspace:*",
     "@trigger.dev/core": "workspace:*",
     "dockerode": "^4.0.6",
     "prom-client": "^15.1.0",

apps/supervisor/src/workloadManager/compute.ts

@@ -6,6 +6,7 @@ import {
   type WorkloadManagerCreateOptions,
   type WorkloadManagerOptions,
 } from "./types.js";
+import { ComputeClient } from "@internal/compute";
 import { env } from "../env.js";
 import { getRunnerId } from "../util.js";
 import { buildOtlpTracePayload } from "../otlpPayload.js";
@@ -20,13 +21,20 @@ type ComputeWorkloadManagerOptions = WorkloadManagerOptions & {
 
 export class ComputeWorkloadManager implements WorkloadManager {
   private readonly logger = new SimpleStructuredLogger("compute-workload-manager");
+  private readonly compute: ComputeClient;
 
   constructor(private opts: ComputeWorkloadManagerOptions) {
     if (opts.workloadApiDomain) {
       this.logger.warn("⚠️ Custom workload API domain", {
         domain: opts.workloadApiDomain,
       });
     }
+
+    this.compute = new ComputeClient({
+      gatewayUrl: opts.gatewayUrl,
+      authToken: opts.gatewayAuthToken,
+      timeoutMs: opts.gatewayTimeoutMs,
+    });
   }
 
   async create(opts: WorkloadManagerCreateOptions) {
@@ -73,19 +81,9 @@ export class ComputeWorkloadManager implements WorkloadManager {
       Object.assign(envVars, this.opts.additionalEnvVars);
     }
 
-    const headers: Record<string, string> = {
-      "Content-Type": "application/json",
-    };
-
-    if (this.opts.gatewayAuthToken) {
-      headers["Authorization"] = `Bearer ${this.opts.gatewayAuthToken}`;
-    }
-
-    // Strip image digest — resolve by tag, not digest
+    // Strip image digest - resolve by tag, not digest
     const imageRef = opts.image.split("@")[0]!;
 
-    const url = `${this.opts.gatewayUrl}/api/instances`;
-
     // Wide event: single canonical log line emitted in finally
     const event: Record<string, unknown> = {
       // High-cardinality identifiers
@@ -105,58 +103,34 @@ export class ComputeWorkloadManager implements WorkloadManager {
       warmStartCheckMs: opts.warmStartCheckMs,
       // Request
       image: imageRef,
-      url,
     };
 
     const startMs = performance.now();
 
     try {
-      const [fetchError, response] = await tryCatch(
-        fetch(url, {
-          method: "POST",
-          headers,
-          signal: AbortSignal.timeout(this.opts.gatewayTimeoutMs),
-          body: JSON.stringify({
-            name: runnerId,
-            image: imageRef,
-            env: envVars,
-            cpu: opts.machine.cpu,
-            memory_gb: opts.machine.memory,
-            metadata: {
-              runId: opts.runFriendlyId,
-              envId: opts.envId,
-              envType: opts.envType,
-              orgId: opts.orgId,
-              projectId: opts.projectId,
-              deploymentVersion: opts.deploymentVersion,
-              machine: opts.machine.name,
-            },
-          }),
+      const [error, data] = await tryCatch(
+        this.compute.instances.create({
+          name: runnerId,
+          image: imageRef,
+          env: envVars,
+          cpu: opts.machine.cpu,
+          memory_gb: opts.machine.memory,
+          metadata: {
+            runId: opts.runFriendlyId,
+            envId: opts.envId,
+            envType: opts.envType,
+            orgId: opts.orgId,
+            projectId: opts.projectId,
+            deploymentVersion: opts.deploymentVersion,
+            machine: opts.machine.name,
+          },
         })
       );
 
-      if (fetchError) {
-        event.error = fetchError instanceof Error ? fetchError.message : String(fetchError);
+      if (error) {
+        event.error = error instanceof Error ? error.message : String(error);
         event.errorType =
-          fetchError instanceof DOMException && fetchError.name === "TimeoutError"
-            ? "timeout"
-            : "fetch";
-        return;
-      }
-
-      event.status = response.status;
-
-      if (!response.ok) {
-        const [bodyError, body] = await tryCatch(response.text());
-        event.responseBody = bodyError ? undefined : body;
-        return;
-      }
-
-      const [parseError, data] = await tryCatch(response.json());
-
-      if (parseError) {
-        event.error = parseError instanceof Error ? parseError.message : String(parseError);
-        event.errorType = "parse";
+          error instanceof DOMException && error.name === "TimeoutError" ? "timeout" : "fetch";
         return;
       }
 
@@ -176,34 +150,17 @@ export class ComputeWorkloadManager implements WorkloadManager {
     }
   }
 
-  private get authHeaders(): Record<string, string> {
-    const headers: Record<string, string> = {
-      "Content-Type": "application/json",
-    };
-    if (this.opts.gatewayAuthToken) {
-      headers["Authorization"] = `Bearer ${this.opts.gatewayAuthToken}`;
-    }
-    return headers;
-  }
-
   async snapshot(opts: {
     runnerId: string;
     callbackUrl: string;
     metadata: Record<string, string>;
   }): Promise<boolean> {
-    const url = `${this.opts.gatewayUrl}/api/instances/${opts.runnerId}/snapshot`;
-
-    const [error, response] = await tryCatch(
-      fetch(url, {
-        method: "POST",
-        headers: this.authHeaders,
-        signal: AbortSignal.timeout(this.opts.gatewayTimeoutMs),
-        body: JSON.stringify({
-          callback: {
-            url: opts.callbackUrl,
-            metadata: opts.metadata,
-          },
-        }),
+    const [error] = await tryCatch(
+      this.compute.instances.snapshot(opts.runnerId, {
+        callback: {
+          url: opts.callbackUrl,
+          metadata: opts.metadata,
+        },
       })
     );
 
@@ -215,28 +172,12 @@ export class ComputeWorkloadManager implements WorkloadManager {
       return false;
     }
 
-    if (response.status !== 202) {
-      this.logger.error("snapshot request rejected", {
-        runnerId: opts.runnerId,
-        status: response.status,
-      });
-      return false;
-    }
-
     this.logger.debug("snapshot request accepted", { runnerId: opts.runnerId });
     return true;
   }
 
   async deleteInstance(runnerId: string): Promise<boolean> {
-    const url = `${this.opts.gatewayUrl}/api/instances/${runnerId}`;
-
-    const [error, response] = await tryCatch(
-      fetch(url, {
-        method: "DELETE",
-        headers: this.authHeaders,
-        signal: AbortSignal.timeout(this.opts.gatewayTimeoutMs),
-      })
-    );
+    const [error] = await tryCatch(this.compute.instances.delete(runnerId));
 
     if (error) {
       this.logger.error("delete instance failed", {
@@ -246,14 +187,6 @@ export class ComputeWorkloadManager implements WorkloadManager {
       return false;
     }
 
-    if (!response.ok) {
-      this.logger.error("delete instance rejected", {
-        runnerId,
-        status: response.status,
-      });
-      return false;
-    }
-
     this.logger.debug("delete instance success", { runnerId });
     return true;
   }
@@ -329,8 +262,6 @@ export class ComputeWorkloadManager implements WorkloadManager {
     projectId?: string;
     dequeuedAt?: Date;
   }): Promise<boolean> {
-    const url = `${this.opts.gatewayUrl}/api/snapshots/${opts.snapshotId}/restore`;
-
     const metadata: Record<string, string> = {
       TRIGGER_RUNNER_ID: opts.runnerId,
       TRIGGER_RUN_ID: opts.runFriendlyId,
@@ -341,23 +272,19 @@ export class ComputeWorkloadManager implements WorkloadManager {
       TRIGGER_WORKER_INSTANCE_NAME: env.TRIGGER_WORKER_INSTANCE_NAME,
     };
 
-    const body = {
-      name: opts.runnerId,
-      metadata,
-      cpu: opts.machine.cpu,
-      memory_mb: opts.machine.memory * 1024,
-    };
-
-    this.logger.verbose("restore request body", { url, body });
+    this.logger.verbose("restore request body", {
+      snapshotId: opts.snapshotId,
+      runnerId: opts.runnerId,
+    });
 
     const startMs = performance.now();
 
-    const [error, response] = await tryCatch(
-      fetch(url, {
-        method: "POST",
-        headers: this.authHeaders,
-        signal: AbortSignal.timeout(this.opts.gatewayTimeoutMs),
-        body: JSON.stringify(body),
+    const [error] = await tryCatch(
+      this.compute.snapshots.restore(opts.snapshotId, {
+        name: opts.runnerId,
+        metadata,
+        cpu: opts.machine.cpu,
+        memory_mb: opts.machine.memory * 1024,
       })
     );
 
@@ -373,16 +300,6 @@ export class ComputeWorkloadManager implements WorkloadManager {
       return false;
     }
 
-    if (!response.ok) {
-      this.logger.error("restore request rejected", {
-        snapshotId: opts.snapshotId,
-        runnerId: opts.runnerId,
-        status: response.status,
-        durationMs,
-      });
-      return false;
-    }
-
     this.logger.debug("restore request success", {
       snapshotId: opts.snapshotId,
       runnerId: opts.runnerId,
@@ -448,4 +365,3 @@ export class ComputeWorkloadManager implements WorkloadManager {
     sendOtlpTrace(payload);
   }
 }
-

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

@@ -1,4 +1,4 @@
-import { ComputeGatewayClient } from "@internal/compute";
+import { ComputeClient } from "@internal/compute";
 import { env } from "~/env.server";
 import { logger } from "~/services/logger.server";
 import type { PrismaClientOrTransaction } from "~/db.server";
@@ -10,11 +10,11 @@ import { FailDeploymentService } from "./failDeployment.server";
 type TemplateCreationMode = "required" | "shadow" | "skip";
 
 export class ComputeTemplateCreationService {
-  private client: ComputeGatewayClient | undefined;
+  private client: ComputeClient | undefined;
 
   constructor() {
     if (env.COMPUTE_GATEWAY_URL) {
-      this.client = new ComputeGatewayClient({
+      this.client = new ComputeClient({
         gatewayUrl: env.COMPUTE_GATEWAY_URL,
         authToken: env.COMPUTE_GATEWAY_AUTH_TOKEN,
         timeoutMs: 5 * 60 * 1000, // 5 minutes
@@ -158,7 +158,7 @@ export class ComputeTemplateCreationService {
     }
 
     try {
-      await this.client.createTemplate({
+      await this.client.templates.create({
         image: imageReference,
         cpu: 0.5,
         memory_mb: 512,