fix(api): env-aware GitHub check-run details_url (staging linked to prod domain) (#196)

The "Void Build" check-run's details_url was hardcoded
`https://${projectSlug}.void.app` at every call site, so on staging the check
run linked to the production traffic domain instead of `*.staging.void.app`
(observed live: a staging build's check-run pointed at `moonglade.void.app`).

Add a `projectUrl(config)` helper that resolves the base domain from the
per-environment `SITE_DOMAIN` binding (`env.SITE_DOMAIN ?? SITE_DOMAIN`) — the
same source the deploy-URL output uses — and route all 8 check-run details_url
emitters through it: the create POST, the 5 direct terminal finalizes, the
`finalizeCheckRunToStatus` status→conclusion helper, and cancelBuild's finalize
(which previously passed no details_url at all). Prod (SITE_DOMAIN unset or
`void.app`) is byte-identical to before.

Tests: staging create+finalize link to `{slug}.staging.void.app`; the
finalizeCheckRunToStatus PATCH path (pre-start prior-run finalize) links to
staging; unset SITE_DOMAIN falls back to prod; cancelBuild now emits details_url.

Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>

Author: Brooooooklyn

packages/api/src/build-manager.ts

@@ -5,6 +5,7 @@ import {
   signDeployToken,
 } from './auth/deploy-token.ts';
 import { type BuildConfig, type BuildLogLine, isContainerCapacityError } from './build-types.ts';
+import { SITE_DOMAIN } from './constants.ts';
 import {
   createDb,
   getBuild,
@@ -339,7 +340,7 @@ export class BuildManager extends Container<ApiEnv['Bindings']> {
           name: 'Void Build',
           headSha: config.commitSha,
           externalId: config.buildId,
-          detailsUrl: `https://${config.projectSlug}.void.app`,
+          detailsUrl: this.projectUrl(config),
           title: 'Void build in progress',
           summary: `Building \`${config.branch}\` @ ${config.commitSha.slice(0, 7)}`,
         });
@@ -591,7 +592,7 @@ export class BuildManager extends Container<ApiEnv['Bindings']> {
         // never contradicts the DB.
         if (won) {
           await this.finalizeCheckRun(config, 'failure', {
-            detailsUrl: `https://${config.projectSlug}.void.app`,
+            detailsUrl: this.projectUrl(config),
             title: 'Void build failed',
             summary: message,
           });
@@ -605,6 +606,17 @@ export class BuildManager extends Container<ApiEnv['Bindings']> {
     }
   }
 
+  /**
+   * The project's public traffic URL — used as the check-run `details_url`. Staging
+   * and production serve user traffic on different base domains (`staging.void.app`
+   * vs `void.app`), so the link must be env-aware: read the per-environment
+   * `SITE_DOMAIN` binding (the same source the deploy-URL output uses), falling back
+   * to the production constant when unset.
+   */
+  private projectUrl(config: BuildConfig): string {
+    return `https://${config.projectSlug}.${this.env.SITE_DOMAIN ?? SITE_DOMAIN}`;
+  }
+
   /**
    * Finalize this build's GitHub Check Run with a terminal conclusion. BEST-EFFORT:
    * resolves the run id from, in order, an explicit in-hand id → the in-memory
@@ -680,7 +692,7 @@ export class BuildManager extends Container<ApiEnv['Bindings']> {
       config,
       conclusion as CheckRunConclusion,
       {
-        detailsUrl: `https://${config.projectSlug}.void.app`,
+        detailsUrl: this.projectUrl(config),
         title: `Void build ${conclusion === 'success' ? 'succeeded' : conclusion}`,
         summary: `Build ${status}.`,
       },
@@ -797,7 +809,7 @@ export class BuildManager extends Container<ApiEnv['Bindings']> {
         // hand) so a deployment lookup miss does NOT cost the link.
         if (won) {
           await this.finalizeCheckRun(config, 'success', {
-            detailsUrl: `https://${config.projectSlug}.void.app`,
+            detailsUrl: this.projectUrl(config),
             title: 'Void build succeeded',
             summary: deploymentId ? 'Deployment is live.' : 'Build complete.',
           });
@@ -820,7 +832,7 @@ export class BuildManager extends Container<ApiEnv['Bindings']> {
         // the out-of-band recorded outcome so GitHub matches the DB.
         if (won) {
           await this.finalizeCheckRun(config, 'failure', {
-            detailsUrl: `https://${config.projectSlug}.void.app`,
+            detailsUrl: this.projectUrl(config),
             title: 'Void build failed',
             summary: `Build exited with code ${params.exitCode}.`,
           });
@@ -860,7 +872,7 @@ export class BuildManager extends Container<ApiEnv['Bindings']> {
       // the out-of-band recorded outcome so GitHub matches the DB.
       if (won) {
         await this.finalizeCheckRun(config, 'failure', {
-          detailsUrl: `https://${config.projectSlug}.void.app`,
+          detailsUrl: this.projectUrl(config),
           title: 'Void build failed',
           summary: message,
         });
@@ -939,7 +951,7 @@ export class BuildManager extends Container<ApiEnv['Bindings']> {
       // the out-of-band recorded outcome so GitHub matches the DB.
       if (won) {
         await this.finalizeCheckRun(config, 'failure', {
-          detailsUrl: `https://${config.projectSlug}.void.app`,
+          detailsUrl: this.projectUrl(config),
           title: 'Void build failed',
           summary: 'build timed out',
         });
@@ -995,6 +1007,7 @@ export class BuildManager extends Container<ApiEnv['Bindings']> {
         // outcome so GitHub matches the DB.
         if (won) {
           await this.finalizeCheckRun(config, 'cancelled', {
+            detailsUrl: this.projectUrl(config),
             title: 'Void build cancelled',
             summary: reason,
           });

packages/api/test/integration/api-check-runs.test.ts

@@ -646,7 +646,12 @@ describe('BuildManager check-run lifecycle — finalize terminal sites', () => {
     await m.cancelBuild('project disconnected');
 
     expect(patches).toHaveLength(1);
-    expect(patches[0].body).toMatchObject({ conclusion: 'cancelled' });
+    // details_url is now set on the cancel finalize (was previously omitted) and is
+    // env-aware via projectUrl() — default env (no SITE_DOMAIN) → prod fallback.
+    expect(patches[0].body).toMatchObject({
+      conclusion: 'cancelled',
+      details_url: 'https://my-app.void.app',
+    });
     const output = patches[0].body?.output as { summary?: string };
     expect(output.summary).toBe('project disconnected');
   });
@@ -1383,3 +1388,63 @@ describe('BuildManager check-run lifecycle — pre-start finalize is CAS-aware (
     expect(dbState.status.get('b1')).toBe('cancelled');
   });
 });
+
+describe('BuildManager check-run lifecycle — details_url is env-aware (SITE_DOMAIN)', () => {
+  // The check-run details_url links to the project's public traffic URL. Staging and
+  // production serve on different base domains, so the link must follow the
+  // per-environment SITE_DOMAIN binding (the same source the deploy-URL output uses),
+  // not a hardcoded `.void.app`.
+  it('staging SITE_DOMAIN → create + finalize link to {slug}.staging.void.app', async () => {
+    const { posts, patches } = installFetch();
+    const ctx = makeStubCtx();
+    const env = makeEnv();
+    env.SITE_DOMAIN = 'staging.void.app';
+    const m = makeManager(ctx, env);
+
+    await m.startBuild(makeConfig());
+    expect(posts).toHaveLength(1);
+    expect(posts[0].body).toMatchObject({ details_url: 'https://my-app.staging.void.app' });
+
+    await m.onStop({ exitCode: 0, reason: 'exit' });
+    expect(patches).toHaveLength(1);
+    expect(patches[0].body).toMatchObject({ details_url: 'https://my-app.staging.void.app' });
+  });
+
+  it('unset SITE_DOMAIN → falls back to the production {slug}.void.app', async () => {
+    const { posts } = installFetch();
+    const ctx = makeStubCtx();
+    const env = makeEnv(); // SITE_DOMAIN unset
+    const m = makeManager(ctx, env);
+
+    await m.startBuild(makeConfig());
+    expect(posts).toHaveLength(1);
+    expect(posts[0].body).toMatchObject({ details_url: 'https://my-app.void.app' });
+  });
+
+  // The status→conclusion helper (`finalizeCheckRunToStatus`) is a SEPARATE detailsUrl
+  // site from the create POST + the direct finalizeCheckRun terminal sites. It is reached
+  // by the pre-start prior-run finalizes and by the lost-CAS recorded-outcome path, so it
+  // must be env-aware too. Exercise it via the non-identical-head pre-start branch with a
+  // prior-attempt run id, and assert the PATCH links to the staging domain.
+  it('staging SITE_DOMAIN → finalizeCheckRunToStatus PATCH links to the staging domain', async () => {
+    vi.mocked(getBranchHeadComparisonStatus).mockResolvedValueOnce('behind');
+    dbState.checkRunIds.set('b1', String(CHECK_RUN_ID)); // prior-attempt run to finalize
+    const { posts, patches } = installFetch();
+    const ctx = makeStubCtx();
+    const env = makeEnv();
+    env.SITE_DOMAIN = 'staging.void.app';
+    const m = makeManager(ctx, env);
+
+    await m.startBuild(makeConfig());
+
+    // Cancelled before the create block → no POST; the prior run is finalized via
+    // finalizeCheckRunToStatus, whose PATCH must use the staging domain.
+    expect(posts).toHaveLength(0);
+    expect(patches).toHaveLength(1);
+    expect(patches[0].body).toMatchObject({
+      status: 'completed',
+      conclusion: 'cancelled',
+      details_url: 'https://my-app.staging.void.app',
+    });
+  });
+});