fix: shadow mode uses fire-and-forget HTTP to avoid holding connections

Author: nicktrn

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

@@ -83,4 +83,20 @@ export class ComputeTemplateCreationService {
       return { success: false, error: message };
     }
   }
+
+  /**
+   * Fire-and-forget template creation. No HTTP connection held open,
+   * no response awaited. Used for shadow rollout mode.
+   */
+  createTemplateBackground(imageReference: string): void {
+    if (!this.client) {
+      return;
+    }
+
+    this.client.createTemplateBackground({
+      image: imageReference,
+      cpu: 0.5,
+      memory_mb: 512,
+    });
+  }
 }

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

@@ -191,13 +191,11 @@ export class FinalizeDeploymentService extends BaseService {
 
     // Shadow mode: fire-and-forget template creation after deploy is finalized
     if (templateMode === "shadow" && deployment.imageReference) {
-      templateService.createTemplate(deployment.imageReference).catch((error) => {
-        logger.error("Shadow compute template creation failed", {
-          id,
-          imageReference: deployment.imageReference,
-          error: error instanceof Error ? error.message : String(error),
-        });
+      logger.debug("Shadow compute template creation (background)", {
+        id,
+        imageReference: deployment.imageReference,
       });
+      templateService.createTemplateBackground(deployment.imageReference);
     }
 
     return finalizedDeployment;

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

@@ -241,13 +241,11 @@ export class FinalizeDeploymentV2Service extends BaseService {
     imageReference: string,
     deploymentFriendlyId: string
   ) {
-    templateService.createTemplate(imageReference).catch((error) => {
-      logger.error("Shadow compute template creation failed", {
-        id: deploymentFriendlyId,
-        imageReference,
-        error: error instanceof Error ? error.message : String(error),
-      });
+    logger.debug("Shadow compute template creation (background)", {
+      id: deploymentFriendlyId,
+      imageReference,
     });
+    templateService.createTemplateBackground(imageReference);
   }
 }
 

internal-packages/compute/src/gatewayClient.ts

@@ -13,6 +13,32 @@ export class ComputeGatewayClient {
     req: TemplateCreateRequest,
     options?: { signal?: AbortSignal }
   ): Promise<{ accepted: boolean }> {
+    const response = await this.#fetch(req, options?.signal);
+
+    if (!response.ok) {
+      const errorBody = await response.text().catch(() => "unknown error");
+      throw new Error(`Gateway template creation failed (${response.status}): ${errorBody}`);
+    }
+
+    return { accepted: response.status === 202 };
+  }
+
+  /**
+   * Fire-and-forget template creation. Sends the request but does not
+   * await the response, so no HTTP connection is held open.
+   */
+  createTemplateBackground(req: TemplateCreateRequest): void {
+    this.#fetch(req).then(
+      (response) => {
+        if (!response.ok) {
+          response.text().catch(() => {});
+        }
+      },
+      () => {} // swallow network errors
+    );
+  }
+
+  #fetch(req: TemplateCreateRequest, signal?: AbortSignal): Promise<Response> {
     const url = `${this.opts.gatewayUrl}/api/templates`;
 
     const headers: Record<string, string> = {
@@ -22,20 +48,11 @@ export class ComputeGatewayClient {
       headers["Authorization"] = `Bearer ${this.opts.authToken}`;
     }
 
-    const signal = options?.signal ?? AbortSignal.timeout(this.opts.timeoutMs);
-
-    const response = await fetch(url, {
+    return fetch(url, {
       method: "POST",
       headers,
       body: JSON.stringify(req),
-      signal,
+      signal: signal ?? AbortSignal.timeout(this.opts.timeoutMs),
     });
-
-    if (!response.ok) {
-      const errorBody = await response.text().catch(() => "unknown error");
-      throw new Error(`Gateway template creation failed (${response.status}): ${errorBody}`);
-    }
-
-    return { accepted: response.status === 202 };
   }
 }