feat(vercel): refine integration defaults and surface settings

Change default Vercel integration data to enable atomic builds only
for production and keep pull env vars enabled for all non-dev
environments. This tightens build behavior to match expected defaults
and avoids enabling atomic builds for staging/preview by default.

Add optional integrationDeployments field to deployment schema and
include it in the deployment API response. This introduces a typed
array of integration deployment records (id, integrationName,
integrationDeploymentId, commitSHA, createdAt) so downstream clients
can surface related integration deployment metadata.

Expose Vercel project setting autoAssignCustomDomains in presenter by
fetching it alongside custom environments. Combine fetching of custom
environments and the auto-assign setting into a single helper that
returns both values (or null when unknown), and thread the new
autoAssignCustomDomains flag through the presenter types.

Also rename a UI label from "Pull from Vercel" to "Sync" for clarity.

Author: 0ski

apps/webapp/app/models/vercelIntegration.server.ts

@@ -1678,6 +1678,71 @@ export class VercelIntegrationRepository {
     }
   }
 
+  /**
+   * Get the autoAssignCustomDomains setting for a Vercel project.
+   * Returns true if auto-assign is enabled, false if disabled, null on error.
+   */
+  static async getAutoAssignCustomDomains(
+    client: Vercel,
+    vercelProjectId: string,
+    teamId?: string | null
+  ): Promise<boolean | null> {
+    try {
+      // The Vercel SDK doesn't have a getProject method, so we use updateProject
+      // with an empty requestBody to read the project data without changing anything.
+      const project = await client.projects.updateProject({
+        idOrName: vercelProjectId,
+        ...(teamId && { teamId }),
+        requestBody: {},
+      });
+
+      return project.autoAssignCustomDomains ?? null;
+    } catch (error) {
+      logger.error("Failed to get Vercel project autoAssignCustomDomains", {
+        vercelProjectId,
+        teamId,
+        error,
+      });
+      return null;
+    }
+  }
+
+  /**
+   * Disable autoAssignCustomDomains on a Vercel project.
+   * This is required for atomic deployments — prevents Vercel from auto-promoting
+   * deployments before TRIGGER_VERSION is set.
+   */
+  static async disableAutoAssignCustomDomains(
+    client: Vercel,
+    vercelProjectId: string,
+    teamId?: string | null
+  ): Promise<{ success: boolean; error?: string }> {
+    try {
+      await client.projects.updateProject({
+        idOrName: vercelProjectId,
+        ...(teamId && { teamId }),
+        requestBody: {
+          autoAssignCustomDomains: false,
+        },
+      });
+
+      logger.info("Disabled autoAssignCustomDomains on Vercel project", {
+        vercelProjectId,
+        teamId,
+      });
+
+      return { success: true };
+    } catch (error) {
+      const errorMessage = `Failed to disable autoAssignCustomDomains: ${error instanceof Error ? error.message : "Unknown error"}`;
+      logger.error(errorMessage, {
+        vercelProjectId,
+        teamId,
+        error,
+      });
+      return { success: false, error: errorMessage };
+    }
+  }
+
   static async uninstallVercelIntegration(
     integration: OrganizationIntegration & { tokenReference: SecretReference }
   ): Promise<{ authInvalid: boolean }> {

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

@@ -35,6 +35,8 @@ export type VercelSettingsResult = {
   hasStagingEnvironment: boolean;
   hasPreviewEnvironment: boolean;
   customEnvironments: VercelCustomEnvironment[];
+  /** Whether autoAssignCustomDomains is enabled on the Vercel project. null if unknown. */
+  autoAssignCustomDomains?: boolean | null;
 };
 
 export type VercelAvailableProject = {
@@ -234,26 +236,41 @@ export class VercelSettingsPresenter extends BasePresenter {
           checkPreviewEnvironment(),
           getVercelProjectIntegration(),
         ]).andThen(([hasOrgIntegration, isGitHubConnected, hasStagingEnvironment, hasPreviewEnvironment, connectedProject]) => {
-          const fetchCustomEnvs = async (): Promise<VercelCustomEnvironment[]> => {
-            if (!connectedProject || !orgIntegration) return [];
+          const fetchCustomEnvsAndProjectSettings = async (): Promise<{
+            customEnvironments: VercelCustomEnvironment[];
+            autoAssignCustomDomains: boolean | null;
+          }> => {
+            if (!connectedProject || !orgIntegration) {
+              return { customEnvironments: [], autoAssignCustomDomains: null };
+            }
             try {
               const client = await VercelIntegrationRepository.getVercelClient(orgIntegration);
               const teamId = await VercelIntegrationRepository.getTeamIdFromIntegration(orgIntegration);
-              const result = await VercelIntegrationRepository.getVercelCustomEnvironments(
-                client,
-                connectedProject.vercelProjectId,
-                teamId
-              );
-              return result.success ? result.data : [];
+              const [customEnvsResult, autoAssign] = await Promise.all([
+                VercelIntegrationRepository.getVercelCustomEnvironments(
+                  client,
+                  connectedProject.vercelProjectId,
+                  teamId
+                ),
+                VercelIntegrationRepository.getAutoAssignCustomDomains(
+                  client,
+                  connectedProject.vercelProjectId,
+                  teamId
+                ),
+              ]);
+              return {
+                customEnvironments: customEnvsResult.success ? customEnvsResult.data : [],
+                autoAssignCustomDomains: autoAssign,
+              };
             } catch {
-              return [];
+              return { customEnvironments: [], autoAssignCustomDomains: null };
             }
           };
 
           return fromPromise(
-            fetchCustomEnvs(),
+            fetchCustomEnvsAndProjectSettings(),
             (error) => ({ type: "other" as const, cause: error })
-          ).map((customEnvironments) => ({
+          ).map(({ customEnvironments, autoAssignCustomDomains }) => ({
             enabled: true,
             hasOrgIntegration,
             authInvalid: false,
@@ -262,6 +279,7 @@ export class VercelSettingsPresenter extends BasePresenter {
             hasStagingEnvironment,
             hasPreviewEnvironment,
             customEnvironments,
+            autoAssignCustomDomains,
           } as VercelSettingsResult));
         }).mapErr((error) => {
           // Log the error and return a safe fallback

apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.environment-variables/route.tsx

@@ -330,7 +330,7 @@ export default function Page() {
                     <SimpleTooltip
                       button={
                         <span className="flex items-center gap-1">
-                          Pull from Vercel
+                          Sync
                           <InformationCircleIcon className="size-4 text-text-dimmed" />
                         </span>
                       }

apps/webapp/app/routes/api.v1.deployments.$deploymentId.ts

@@ -39,6 +39,7 @@ export async function loader({ request, params }: LoaderFunctionArgs) {
           tasks: true,
         },
       },
+      integrationDeployments: true,
     },
   });
 
@@ -69,5 +70,15 @@ export async function loader({ request, params }: LoaderFunctionArgs) {
           })),
         }
       : undefined,
+    integrationDeployments:
+      deployment.integrationDeployments.length > 0
+        ? deployment.integrationDeployments.map((id) => ({
+            id: id.id,
+            integrationName: id.integrationName,
+            integrationDeploymentId: id.integrationDeploymentId,
+            commitSHA: id.commitSHA,
+            createdAt: id.createdAt,
+          }))
+        : undefined,
   } satisfies GetDeploymentResponseBody);
 }