feat(supervisor): add ComputeWorkloadManager for compute gateway

Add a third WorkloadManager implementation that creates sandboxes via
the compute gateway HTTP API (POST /api/sandboxes). Uses native fetch
with no new dependencies. Enabled by setting COMPUTE_GATEWAY_URL, which
takes priority over Kubernetes and Docker providers.

Author: nicktrn

apps/supervisor/src/env.ts

@@ -77,6 +77,10 @@ const Env = z.object({
    */
   DOCKER_RUNNER_NETWORKS: z.string().default("host"),
 
+  // Compute settings
+  COMPUTE_GATEWAY_URL: z.string().url().optional(),
+  COMPUTE_GATEWAY_AUTH_TOKEN: z.string().optional(),
+
   // Kubernetes settings
   KUBERNETES_FORCE_ENABLED: BoolEnv.default(false),
   KUBERNETES_NAMESPACE: z.string().default("default"),

apps/supervisor/src/index.ts

@@ -14,6 +14,7 @@ import {
 } from "./resourceMonitor.js";
 import { KubernetesWorkloadManager } from "./workloadManager/kubernetes.js";
 import { DockerWorkloadManager } from "./workloadManager/docker.js";
+import { ComputeWorkloadManager } from "./workloadManager/compute.js";
 import {
   HttpServer,
   CheckpointClient,
@@ -77,9 +78,15 @@ class ManagedSupervisor {
         : new DockerResourceMonitor(new Docker())
       : new NoopResourceMonitor();
 
-    this.workloadManager = this.isKubernetes
-      ? new KubernetesWorkloadManager(workloadManagerOptions)
-      : new DockerWorkloadManager(workloadManagerOptions);
+    this.workloadManager = env.COMPUTE_GATEWAY_URL
+      ? new ComputeWorkloadManager({
+          ...workloadManagerOptions,
+          gatewayUrl: env.COMPUTE_GATEWAY_URL,
+          gatewayAuthToken: env.COMPUTE_GATEWAY_AUTH_TOKEN,
+        })
+      : this.isKubernetes
+        ? new KubernetesWorkloadManager(workloadManagerOptions)
+        : new DockerWorkloadManager(workloadManagerOptions);
 
     if (this.isKubernetes) {
       if (env.POD_CLEANER_ENABLED) {

apps/supervisor/src/workloadManager/compute.ts

@@ -0,0 +1,116 @@
+import { SimpleStructuredLogger } from "@trigger.dev/core/v3/utils/structuredLogger";
+import {
+  type WorkloadManager,
+  type WorkloadManagerCreateOptions,
+  type WorkloadManagerOptions,
+} from "./types.js";
+import { env } from "../env.js";
+import { getRunnerId } from "../util.js";
+import { tryCatch } from "@trigger.dev/core";
+
+type ComputeWorkloadManagerOptions = WorkloadManagerOptions & {
+  gatewayUrl: string;
+  gatewayAuthToken?: string;
+};
+
+export class ComputeWorkloadManager implements WorkloadManager {
+  private readonly logger = new SimpleStructuredLogger("compute-workload-manager");
+
+  constructor(private opts: ComputeWorkloadManagerOptions) {
+    if (!opts.workloadApiDomain) {
+      this.logger.warn(
+        "⚠️ workloadApiDomain is unset — VMs need an explicit host IP to reach the supervisor"
+      );
+    }
+  }
+
+  async create(opts: WorkloadManagerCreateOptions) {
+    this.logger.log("create()", { opts });
+
+    const runnerId = getRunnerId(opts.runFriendlyId, opts.nextAttemptNumber);
+
+    const envVars: Record<string, string> = {
+      OTEL_EXPORTER_OTLP_ENDPOINT: env.OTEL_EXPORTER_OTLP_ENDPOINT,
+      TRIGGER_DEQUEUED_AT_MS: String(opts.dequeuedAt.getTime()),
+      TRIGGER_POD_SCHEDULED_AT_MS: String(Date.now()),
+      TRIGGER_ENV_ID: opts.envId,
+      TRIGGER_DEPLOYMENT_ID: opts.deploymentFriendlyId,
+      TRIGGER_DEPLOYMENT_VERSION: opts.deploymentVersion,
+      TRIGGER_RUN_ID: opts.runFriendlyId,
+      TRIGGER_SNAPSHOT_ID: opts.snapshotFriendlyId,
+      TRIGGER_SUPERVISOR_API_PROTOCOL: this.opts.workloadApiProtocol,
+      TRIGGER_SUPERVISOR_API_PORT: String(this.opts.workloadApiPort),
+      TRIGGER_SUPERVISOR_API_DOMAIN: this.opts.workloadApiDomain ?? "",
+      TRIGGER_WORKER_INSTANCE_NAME: env.TRIGGER_WORKER_INSTANCE_NAME,
+      TRIGGER_RUNNER_ID: runnerId,
+      TRIGGER_MACHINE_CPU: String(opts.machine.cpu),
+      TRIGGER_MACHINE_MEMORY: String(opts.machine.memory),
+      PRETTY_LOGS: String(env.RUNNER_PRETTY_LOGS),
+    };
+
+    if (this.opts.warmStartUrl) {
+      envVars.TRIGGER_WARM_START_URL = this.opts.warmStartUrl;
+    }
+
+    if (this.opts.metadataUrl) {
+      envVars.TRIGGER_METADATA_URL = this.opts.metadataUrl;
+    }
+
+    if (this.opts.heartbeatIntervalSeconds) {
+      envVars.TRIGGER_HEARTBEAT_INTERVAL_SECONDS = String(this.opts.heartbeatIntervalSeconds);
+    }
+
+    if (this.opts.snapshotPollIntervalSeconds) {
+      envVars.TRIGGER_SNAPSHOT_POLL_INTERVAL_SECONDS = String(this.opts.snapshotPollIntervalSeconds);
+    }
+
+    if (this.opts.additionalEnvVars) {
+      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}`;
+    }
+
+    const url = `${this.opts.gatewayUrl}/api/sandboxes`;
+
+    const [fetchError, response] = await tryCatch(
+      fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          image: opts.image,
+          env: envVars,
+        }),
+      })
+    );
+
+    if (fetchError) {
+      this.logger.error("Failed to create sandbox", { error: fetchError, url });
+      return;
+    }
+
+    if (!response.ok) {
+      const [bodyError, body] = await tryCatch(response.text());
+      this.logger.error("Gateway returned error", {
+        status: response.status,
+        body: bodyError ? undefined : body,
+        url,
+      });
+      return;
+    }
+
+    const [parseError, data] = await tryCatch(response.json());
+
+    if (parseError) {
+      this.logger.error("Failed to parse gateway response", { error: parseError });
+      return;
+    }
+
+    this.logger.debug("create succeeded", { sandboxId: data.id, runnerId });
+  }
+}