fix(webapp): read deployment runtime from the indexed worker

Deployments now show the runtime their worker actually reported. Bun
deployments were being labelled "Node.js" because the runtime recorded
against the deployment was usually empty and the dashboard filled the
gap with a default. A deployment with no recorded runtime now shows a
dash instead of a guess.

Fixes #3105.

Mono-RevId: b68e8835841d7a47c44ed9bfd6a0927ab6ca0edf

Author: claude[bot]

.server-changes/deployment-unknown-runtime.md

@@ -0,0 +1,6 @@
+---
+area: webapp
+type: fix
+---
+
+Deployments now show the runtime their worker actually reported, so Bun deployments are no longer labelled Node.js; a deployment with no recorded runtime shows a dash instead of a guess.

apps/webapp/app/components/RuntimeIcon.tsx

@@ -29,15 +29,12 @@ export function RuntimeIcon({
 }: RuntimeIconProps) {
   const parsedRuntime = parseRuntime(runtime);
 
-  // Default to Node.js if no runtime is specified
-  const effectiveRuntime = parsedRuntime || {
-    runtime: "node" as const,
-    originalRuntime: "node",
-    displayName: "Node.js",
-  };
+  if (!parsedRuntime) {
+    return <span className="text-text-dimmed">–</span>;
+  }
 
-  const icon = getIcon(effectiveRuntime.runtime, className);
-  const formattedText = formatRuntimeWithVersion(effectiveRuntime.originalRuntime, runtimeVersion);
+  const icon = getIcon(parsedRuntime.runtime, className);
+  const formattedText = formatRuntimeWithVersion(parsedRuntime.originalRuntime, runtimeVersion);
 
   if (withLabel) {
     return (
@@ -48,11 +45,5 @@ export function RuntimeIcon({
     );
   }
 
-  if (typeof icon === "object" && "type" in icon) {
-    return (
-      <SimpleTooltip button={icon} content={formattedText} side="top" disableHoverableContent />
-    );
-  }
-
-  return icon;
+  return <SimpleTooltip button={icon} content={formattedText} side="top" disableHoverableContent />;
 }

apps/webapp/app/presenters/v3/DeploymentListPresenter.server.ts

@@ -162,8 +162,8 @@ export class DeploymentListPresenter {
   wd."id",
   wd."shortCode",
   wd."version",
-  wd."runtime",
-  wd."runtimeVersion",
+  COALESCE(bw."runtime", wd."runtime") AS "runtime",
+  COALESCE(bw."runtimeVersion", wd."runtimeVersion") AS "runtimeVersion",
   (SELECT COUNT(*) FROM ${sqlDatabaseSchema}."BackgroundWorkerTask" WHERE "BackgroundWorkerTask"."workerId" = wd."workerId") AS "tasksCount",
   wd."environmentId",
   wd."status",
@@ -181,6 +181,8 @@ FROM
   ${sqlDatabaseSchema}."WorkerDeployment" as wd
 LEFT JOIN
   ${sqlDatabaseSchema}."User" as u ON wd."triggeredById" = u."id"
+LEFT JOIN
+  ${sqlDatabaseSchema}."BackgroundWorker" as bw ON wd."workerId" = bw."id"
 ${vercelJoin}
 WHERE
   wd."projectId" = ${project.id}

apps/webapp/app/presenters/v3/DeploymentPresenter.server.ts

@@ -147,6 +147,8 @@ export class DeploymentPresenter {
             },
             sdkVersion: true,
             cliVersion: true,
+            runtime: true,
+            runtimeVersion: true,
           },
         },
         triggeredBy: {
@@ -262,8 +264,8 @@ export class DeploymentPresenter {
         deployedBy: deployment.triggeredBy,
         sdkVersion: deployment.worker?.sdkVersion,
         cliVersion: deployment.worker?.cliVersion,
-        runtime: deployment.runtime,
-        runtimeVersion: deployment.runtimeVersion,
+        runtime: deployment.worker?.runtime ?? deployment.runtime,
+        runtimeVersion: deployment.worker?.runtimeVersion ?? deployment.runtimeVersion,
         imageReference: deployment.imageReference,
         imagePlatform: deployment.imagePlatform,
         externalBuildData:

apps/webapp/test/runtime.test.ts

@@ -0,0 +1,61 @@
+import { describe, expect, it } from "vitest";
+import { formatRuntimeWithVersion, parseRuntime } from "~/utils/runtime";
+
+describe("parseRuntime", () => {
+  it("normalizes bun runtimes", () => {
+    expect(parseRuntime("bun")).toEqual({
+      runtime: "bun",
+      originalRuntime: "bun",
+      displayName: "Bun",
+    });
+    expect(parseRuntime("bun-1.2")).toEqual({
+      runtime: "bun",
+      originalRuntime: "bun-1.2",
+      displayName: "Bun",
+    });
+  });
+
+  it("normalizes node runtimes", () => {
+    expect(parseRuntime("node")).toEqual({
+      runtime: "node",
+      originalRuntime: "node",
+      displayName: "Node.js",
+    });
+    expect(parseRuntime("node-24")).toEqual({
+      runtime: "node",
+      originalRuntime: "node-24",
+      displayName: "Node.js",
+    });
+  });
+
+  it("returns null for a missing runtime instead of assuming node", () => {
+    expect(parseRuntime(null)).toBeNull();
+    expect(parseRuntime(undefined)).toBeNull();
+    expect(parseRuntime("")).toBeNull();
+  });
+
+  it("returns null for an unrecognized runtime", () => {
+    expect(parseRuntime("deno")).toBeNull();
+    expect(parseRuntime("python3.12")).toBeNull();
+    expect(parseRuntime("Node")).toBeNull();
+  });
+});
+
+describe("formatRuntimeWithVersion", () => {
+  it("appends the version when there is one", () => {
+    expect(formatRuntimeWithVersion("bun", "1.2.23")).toBe("Bun v1.2.23");
+    expect(formatRuntimeWithVersion("node-24", "24.9.0")).toBe("Node.js v24.9.0");
+  });
+
+  it("falls back to the display name without a version", () => {
+    expect(formatRuntimeWithVersion("bun", null)).toBe("Bun");
+    expect(formatRuntimeWithVersion("node-24", undefined)).toBe("Node.js");
+    expect(formatRuntimeWithVersion("node", "")).toBe("Node.js");
+  });
+
+  it("reports an unknown runtime rather than a default", () => {
+    expect(formatRuntimeWithVersion(null, null)).toBe("Unknown runtime");
+    expect(formatRuntimeWithVersion(undefined, "24.9.0")).toBe("Unknown runtime");
+    expect(formatRuntimeWithVersion("deno", "2.1.0")).toBe("Unknown runtime");
+  });
+});

apps/webapp/test/runtimeIcon.dom.test.ts

@@ -0,0 +1,54 @@
+// @vitest-environment jsdom
+import { createElement } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import { act } from "react-dom/test-utils";
+import { afterEach, describe, expect, it } from "vitest";
+import { RuntimeIcon } from "~/components/RuntimeIcon";
+
+let container: HTMLDivElement | undefined;
+let root: Root | undefined;
+
+afterEach(() => {
+  if (root) {
+    act(() => root!.unmount());
+  }
+  container?.remove();
+  container = undefined;
+  root = undefined;
+});
+
+function render(props: { runtime?: string | null; runtimeVersion?: string | null }) {
+  container = document.createElement("div");
+  document.body.appendChild(container);
+  root = createRoot(container);
+  act(() => {
+    root!.render(createElement(RuntimeIcon, { ...props, withLabel: true }));
+  });
+  return container.textContent ?? "";
+}
+
+describe("RuntimeIcon", () => {
+  const unknownRuntimes: (string | null | undefined)[] = [null, undefined, "", "deno"];
+
+  it.each(unknownRuntimes)("does not claim Node.js for runtime %o", (runtime) => {
+    const text = render({ runtime, runtimeVersion: null });
+
+    expect(text).not.toContain("Node.js");
+    expect(text).toContain("–");
+  });
+
+  it("does not claim Node.js when only a version is recorded", () => {
+    const text = render({ runtime: null, runtimeVersion: "24.9.0" });
+
+    expect(text).not.toContain("Node.js");
+    expect(text).not.toContain("24.9.0");
+  });
+
+  it("labels a bun runtime as Bun", () => {
+    expect(render({ runtime: "bun", runtimeVersion: "1.2.23" })).toContain("Bun v1.2.23");
+  });
+
+  it("labels a node runtime as Node.js", () => {
+    expect(render({ runtime: "node-24", runtimeVersion: "24.9.0" })).toContain("Node.js v24.9.0");
+  });
+});