feat(supervisor): add compute checkpoint/restore support

- Fix instance creation URL from /api/sandboxes to /api/instances
- Pass name: runnerId when creating compute instances
- Add snapshot(), deleteInstance(), and restore() methods to ComputeWorkloadManager
- Add /api/v1/compute/snapshot-complete callback endpoint to WorkloadServer
- Handle suspend requests in compute mode via fire-and-forget snapshot with callback
- Handle restore in compute mode by calling gateway restore API directly
- Wire computeManager into WorkloadServer for compute mode suspend/restore

Author: nicktrn

apps/supervisor/src/index.ts

@@ -36,9 +36,11 @@ class ManagedSupervisor {
   private readonly metricsServer?: HttpServer;
   private readonly workloadServer: WorkloadServer;
   private readonly workloadManager: WorkloadManager;
+  private readonly computeManager?: ComputeWorkloadManager;
   private readonly logger = new SimpleStructuredLogger("managed-supervisor");
   private readonly resourceMonitor: ResourceMonitor;
   private readonly checkpointClient?: CheckpointClient;
+  private readonly isComputeMode: boolean;
 
   private readonly podCleaner?: PodCleaner;
   private readonly failedPodHandler?: FailedPodHandler;
@@ -78,16 +80,22 @@ class ManagedSupervisor {
         : new DockerResourceMonitor(new Docker())
       : new NoopResourceMonitor();
 
-    this.workloadManager = env.COMPUTE_GATEWAY_URL
-      ? new ComputeWorkloadManager({
-          ...workloadManagerOptions,
-          gatewayUrl: env.COMPUTE_GATEWAY_URL,
-          gatewayAuthToken: env.COMPUTE_GATEWAY_AUTH_TOKEN,
-          gatewayTimeoutMs: env.COMPUTE_GATEWAY_TIMEOUT_MS,
-        })
-      : this.isKubernetes
+    this.isComputeMode = !!env.COMPUTE_GATEWAY_URL;
+
+    if (env.COMPUTE_GATEWAY_URL) {
+      const computeManager = new ComputeWorkloadManager({
+        ...workloadManagerOptions,
+        gatewayUrl: env.COMPUTE_GATEWAY_URL,
+        gatewayAuthToken: env.COMPUTE_GATEWAY_AUTH_TOKEN,
+        gatewayTimeoutMs: env.COMPUTE_GATEWAY_TIMEOUT_MS,
+      });
+      this.computeManager = computeManager;
+      this.workloadManager = computeManager;
+    } else {
+      this.workloadManager = this.isKubernetes
         ? new KubernetesWorkloadManager(workloadManagerOptions)
         : new DockerWorkloadManager(workloadManagerOptions);
+    }
 
     if (this.isKubernetes) {
       if (env.POD_CLEANER_ENABLED) {
@@ -215,6 +223,22 @@ class ManagedSupervisor {
       if (checkpoint) {
         this.logger.log("Restoring run", { runId: message.run.id });
 
+        if (this.isComputeMode && this.computeManager) {
+          try {
+            const didRestore = await this.computeManager.restore(checkpoint.location);
+
+            if (didRestore) {
+              this.logger.log("Compute restore successful", { runId: message.run.id });
+            } else {
+              this.logger.error("Compute restore failed", { runId: message.run.id });
+            }
+          } catch (error) {
+            this.logger.error("Failed to restore run (compute)", { error });
+          }
+
+          return;
+        }
+
         if (!this.checkpointClient) {
           this.logger.error("No checkpoint client", { runId: message.run.id });
           return;
@@ -309,6 +333,7 @@ class ManagedSupervisor {
       host: env.TRIGGER_WORKLOAD_API_HOST_INTERNAL,
       workerClient: this.workerSession.httpClient,
       checkpointClient: this.checkpointClient,
+      computeManager: this.computeManager,
     });
 
     this.workloadServer.on("runConnected", this.onRunConnected.bind(this));

apps/supervisor/src/workloadManager/compute.ts

@@ -60,7 +60,9 @@ export class ComputeWorkloadManager implements WorkloadManager {
     }
 
     if (this.opts.snapshotPollIntervalSeconds) {
-      envVars.TRIGGER_SNAPSHOT_POLL_INTERVAL_SECONDS = String(this.opts.snapshotPollIntervalSeconds);
+      envVars.TRIGGER_SNAPSHOT_POLL_INTERVAL_SECONDS = String(
+        this.opts.snapshotPollIntervalSeconds
+      );
     }
 
     if (this.opts.additionalEnvVars) {
@@ -78,7 +80,7 @@ export class ComputeWorkloadManager implements WorkloadManager {
     // Strip image digest — resolve by tag, not digest
     const imageRef = opts.image.split("@")[0]!;
 
-    const url = `${this.opts.gatewayUrl}/api/sandboxes`;
+    const url = `${this.opts.gatewayUrl}/api/instances`;
 
     // Wide event: single canonical log line emitted in finally
     const event: Record<string, unknown> = {
@@ -111,6 +113,7 @@ export class ComputeWorkloadManager implements WorkloadManager {
           headers,
           signal: AbortSignal.timeout(this.opts.gatewayTimeoutMs),
           body: JSON.stringify({
+            name: runnerId,
             image: imageRef,
             env: envVars,
             cpu: opts.machine.cpu,
@@ -153,12 +156,125 @@ export class ComputeWorkloadManager implements WorkloadManager {
         return;
       }
 
-      event.sandboxId = data.id;
+      event.instanceId = data.id;
       event.ok = true;
     } finally {
       event.durationMs = Math.round(performance.now() - startMs);
       event.ok ??= false;
-      this.logger.info("create sandbox", event);
+      this.logger.info("create instance", event);
+    }
+  }
+
+  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,
+          },
+        }),
+      })
+    );
+
+    if (error) {
+      this.logger.error("snapshot request failed", {
+        runnerId: opts.runnerId,
+        error: error instanceof Error ? error.message : String(error),
+      });
+      return false;
     }
+
+    if (response.status !== 202) {
+      this.logger.error("snapshot request rejected", {
+        runnerId: opts.runnerId,
+        status: response.status,
+      });
+      return false;
+    }
+
+    this.logger.info("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),
+      })
+    );
+
+    if (error) {
+      this.logger.error("delete instance failed", {
+        runnerId,
+        error: error instanceof Error ? error.message : String(error),
+      });
+      return false;
+    }
+
+    if (!response.ok) {
+      this.logger.error("delete instance rejected", {
+        runnerId,
+        status: response.status,
+      });
+      return false;
+    }
+
+    this.logger.info("delete instance success", { runnerId });
+    return true;
+  }
+
+  async restore(snapshotId: string): Promise<boolean> {
+    const url = `${this.opts.gatewayUrl}/api/snapshots/${snapshotId}/restore`;
+
+    const [error, response] = await tryCatch(
+      fetch(url, {
+        method: "POST",
+        headers: this.authHeaders,
+        signal: AbortSignal.timeout(this.opts.gatewayTimeoutMs),
+      })
+    );
+
+    if (error) {
+      this.logger.error("restore request failed", {
+        snapshotId,
+        error: error instanceof Error ? error.message : String(error),
+      });
+      return false;
+    }
+
+    if (!response.ok) {
+      this.logger.error("restore request rejected", {
+        snapshotId,
+        status: response.status,
+      });
+      return false;
+    }
+
+    this.logger.info("restore request success", { snapshotId });
+    return true;
   }
 }