{environmentVariables.length === 0 ? (
You haven't set any environment variables yet.
@@ -430,7 +551,7 @@ function EditEnvironmentVariablePanel({
- Edit
+
@@ -526,8 +647,82 @@ function DeleteEnvironmentVariableButton({
leadingIconClassName="text-rose-500 group-hover/button:text-text-bright transition-colors"
className="ml-0.5 transition-colors group-hover/button:bg-error"
>
- {isLoading ? "Deleting" : "Delete"}
+ {isLoading ? "Deleting" : ""}
);
}
+
+/**
+ * Toggle component for controlling whether an environment variable is pulled from Vercel.
+ *
+ * When enabled, the variable will be pulled from Vercel during builds.
+ * By default, all variables are pulled unless explicitly disabled.
+ *
+ * Note: If the env slug is missing from syncEnvVarsMapping, all vars are pulled by default.
+ * Only when syncEnvVarsMapping[envSlug][envVarName] = false, the env var is skipped during builds.
+ */
+function VercelSyncCheckbox({
+ envVarKey,
+ environmentType,
+ syncEnabled,
+ pullEnvVarsEnabledForEnv,
+}: {
+ envVarKey: string;
+ environmentType: "PRODUCTION" | "STAGING" | "PREVIEW" | "DEVELOPMENT";
+ syncEnabled: boolean;
+ pullEnvVarsEnabledForEnv: boolean;
+}) {
+ const fetcher = useFetcher();
+ const revalidator = useRevalidator();
+
+ const isLoading = fetcher.state !== "idle";
+
+ // Revalidate loader data after successful submission (without full page reload)
+ useEffect(() => {
+ if (fetcher.state === "idle" && fetcher.data) {
+ const data = fetcher.data as { success?: boolean };
+ if (data.success) {
+ revalidator.revalidate();
+ }
+ }
+ }, [fetcher.state, fetcher.data, revalidator]);
+
+ const handleChange = (checked: boolean) => {
+ fetcher.submit(
+ {
+ action: "update-vercel-sync",
+ key: envVarKey,
+ environmentType,
+ syncEnabled: checked.toString(),
+ },
+ { method: "post" }
+ );
+ };
+
+ // If pull env vars is disabled for this environment, show disabled state
+ if (!pullEnvVarsEnabledForEnv) {
+ return (
+ {}}
+ />
+ }
+ content="Enable 'Pull env vars before build' for this environment in Vercel settings."
+ />
+ );
+ }
+
+ return (
+ ();
+ const { githubAppEnabled, buildSettings, vercelIntegrationEnabled } =
+ useTypedLoaderData();
const project = useProject();
const organization = useOrganization();
const environment = useEnvironment();
const lastSubmission = useActionData();
const navigation = useNavigation();
+ const [searchParams, setSearchParams] = useSearchParams();
+
+ // Vercel onboarding modal state
+ const hasQueryParam = searchParams.get("vercelOnboarding") === "true";
+ const nextUrl = searchParams.get("next");
+ const [isModalOpen, setIsModalOpen] = useState(false);
+ const vercelFetcher = useTypedFetcher();
+
+ // Helper to open modal and ensure query param is present
+ const openVercelOnboarding = useCallback(() => {
+ setIsModalOpen(true);
+ // Ensure query param is present to maintain state during form submissions
+ if (!hasQueryParam) {
+ setSearchParams((prev) => {
+ prev.set("vercelOnboarding", "true");
+ return prev;
+ });
+ }
+ }, [hasQueryParam, setSearchParams]);
+
+ const closeVercelOnboarding = useCallback(() => {
+ // Remove query param if present
+ if (hasQueryParam) {
+ setSearchParams((prev) => {
+ prev.delete("vercelOnboarding");
+ return prev;
+ });
+ }
+ // Close modal
+ setIsModalOpen(false);
+ }, [hasQueryParam, setSearchParams]);
+
+ // When query param is present, handle modal opening
+ // Note: We don't close the modal based on data state during onboarding - only when explicitly closed
+ useEffect(() => {
+ if (hasQueryParam && vercelIntegrationEnabled) {
+ // Ensure query param is present and modal is open
+ if (vercelFetcher.data?.onboardingData && vercelFetcher.state === "idle") {
+ // Data is loaded, ensure modal is open (query param takes precedence)
+ if (!isModalOpen) {
+ openVercelOnboarding();
+ }
+ } else if (vercelFetcher.state === "idle" && !vercelFetcher.data?.onboardingData) {
+ // Load onboarding data
+ vercelFetcher.load(
+ `${vercelResourcePath(organization.slug, project.slug, environment.slug)}?vercelOnboarding=true`
+ );
+ }
+ } else if (!hasQueryParam && isModalOpen) {
+ // Query param removed but modal is open, close modal
+ setIsModalOpen(false);
+ }
+ }, [hasQueryParam, vercelIntegrationEnabled, organization.slug, project.slug, environment.slug, vercelFetcher.data, vercelFetcher.state, isModalOpen, openVercelOnboarding]);
+
+ // Ensure modal stays open when query param is present (even after data reloads)
+ // This is a safeguard to prevent the modal from closing during form submissions
+ useEffect(() => {
+ if (hasQueryParam && !isModalOpen) {
+ // Query param is present but modal is closed, open it
+ // This ensures the modal stays open during the onboarding flow
+ openVercelOnboarding();
+ }
+ }, [hasQueryParam, isModalOpen, openVercelOnboarding]);
+
+ // When data finishes loading (from query param), ensure modal is open
+ useEffect(() => {
+ if (hasQueryParam && vercelFetcher.data?.onboardingData && vercelFetcher.state === "idle") {
+ // Data loaded and query param is present, ensure modal is open
+ if (!isModalOpen) {
+ openVercelOnboarding();
+ }
+ }
+ }, [hasQueryParam, vercelFetcher.data, vercelFetcher.state, isModalOpen, openVercelOnboarding]);
+
+
+ // Track if we're waiting for data from button click (not query param)
+ const waitingForButtonClickRef = useRef(false);
+
+ // Handle opening modal from button click (without query param)
+ const handleOpenVercelModal = useCallback(() => {
+ // Add query param to maintain state during form submissions
+ if (!hasQueryParam) {
+ setSearchParams((prev) => {
+ prev.set("vercelOnboarding", "true");
+ return prev;
+ });
+ }
+
+ if (vercelFetcher.data && vercelFetcher.data.onboardingData) {
+ // Data already loaded, open modal immediately
+ openVercelOnboarding();
+ } else {
+ // Need to load data first, mark that we're waiting for button click
+ waitingForButtonClickRef.current = true;
+ vercelFetcher.load(
+ `${vercelResourcePath(organization.slug, project.slug, environment.slug)}?vercelOnboarding=true`
+ );
+ }
+ }, [organization.slug, project.slug, environment.slug, vercelFetcher, setSearchParams, hasQueryParam, openVercelOnboarding]);
+
+ // When data loads from button click, open modal
+ useEffect(() => {
+ if (waitingForButtonClickRef.current && vercelFetcher.data?.onboardingData && vercelFetcher.state === "idle") {
+ // Data loaded from button click, open modal and ensure query param is present
+ waitingForButtonClickRef.current = false;
+ openVercelOnboarding();
+ }
+ }, [vercelFetcher.data, vercelFetcher.state, openVercelOnboarding]);
const [hasRenameFormChanges, setHasRenameFormChanges] = useState(false);
@@ -425,6 +544,21 @@ export default function Page() {
+ {vercelIntegrationEnabled && (
+
+
Vercel integration
+
+
+
Build settings
@@ -477,6 +611,29 @@ export default function Page() {
+
+ {/* Vercel Onboarding Modal */}
+ {vercelIntegrationEnabled && (
+
{
+ vercelFetcher.load(
+ `${vercelResourcePath(organization.slug, project.slug, environment.slug)}?vercelOnboarding=true${
+ vercelEnvironmentId ? `&vercelEnvironmentId=${vercelEnvironmentId}` : ""
+ }`
+ );
+ }}
+ />
+ )}
);
}
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.settings.integrations.vercel.tsx b/apps/webapp/app/routes/_app.orgs.$organizationSlug.settings.integrations.vercel.tsx
new file mode 100644
index 0000000000..413bea3e10
--- /dev/null
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug.settings.integrations.vercel.tsx
@@ -0,0 +1,370 @@
+import type {
+ ActionFunctionArgs,
+ LoaderFunctionArgs,
+} from "@remix-run/node";
+import { json, redirect } from "@remix-run/node";
+import { fromPromise } from "neverthrow";
+import { Form, useActionData, useNavigation } from "@remix-run/react";
+import { typedjson, useTypedLoaderData } from "remix-typedjson";
+import { z } from "zod";
+import { DialogClose } from "@radix-ui/react-dialog";
+import { Button } from "~/components/primitives/Buttons";
+import {
+ Dialog,
+ DialogContent,
+ DialogDescription,
+ DialogHeader,
+ DialogTitle,
+ DialogTrigger,
+} from "~/components/primitives/Dialog";
+import { FormButtons } from "~/components/primitives/FormButtons";
+import { Header1 } from "~/components/primitives/Headers";
+import { PageBody, PageContainer } from "~/components/layout/AppLayout";
+import { Paragraph } from "~/components/primitives/Paragraph";
+import { Table, TableBody, TableCell, TableHeader, TableHeaderCell, TableRow } from "~/components/primitives/Table";
+import { VercelIntegrationRepository } from "~/models/vercelIntegration.server";
+import { $transaction, prisma } from "~/db.server";
+import { requireOrganization } from "~/services/org.server";
+import { OrganizationParamsSchema } from "~/utils/pathBuilder";
+import { logger } from "~/services/logger.server";
+import { TrashIcon } from "@heroicons/react/20/solid";
+import { v3ProjectSettingsPath } from "~/utils/pathBuilder";
+import { LinkButton } from "~/components/primitives/Buttons";
+
+function formatDate(date: Date): string {
+ return new Intl.DateTimeFormat("en-US", {
+ month: "short",
+ day: "numeric",
+ year: "numeric",
+ hour: "numeric",
+ minute: "2-digit",
+ second: "2-digit",
+ hour12: true,
+ }).format(date);
+}
+
+const SearchParamsSchema = OrganizationParamsSchema.extend({
+ configurationId: z.string().optional(),
+});
+
+export const loader = async ({ request, params }: LoaderFunctionArgs) => {
+ const { organizationSlug, configurationId } = SearchParamsSchema.parse(params);
+ const { organization } = await requireOrganization(request, organizationSlug);
+
+ const url = new URL(request.url);
+
+ // Find Vercel integration for this organization
+ let vercelIntegration = await prisma.organizationIntegration.findFirst({
+ where: {
+ organizationId: organization.id,
+ service: "VERCEL",
+ deletedAt: null,
+ // If configurationId is provided, filter by it in integrationData
+ ...(configurationId && {
+ integrationData: {
+ path: ["installationId"],
+ equals: configurationId,
+ },
+ }),
+ },
+ include: {
+ tokenReference: true,
+ },
+ });
+
+ if (!vercelIntegration) {
+ return typedjson({
+ organization,
+ vercelIntegration: null,
+ connectedProjects: [],
+ teamId: null,
+ installationId: null,
+ });
+ }
+
+ // Get team ID from integrationData
+ const integrationData = vercelIntegration.integrationData as any;
+ const teamId = integrationData?.teamId ?? null;
+ const installationId = integrationData?.installationId ?? null;
+
+ // Get all connected projects for this integration
+ const connectedProjects = await prisma.organizationProjectIntegration.findMany({
+ where: {
+ organizationIntegrationId: vercelIntegration.id,
+ deletedAt: null,
+ },
+ include: {
+ project: {
+ select: {
+ id: true,
+ slug: true,
+ name: true,
+ },
+ },
+ },
+ orderBy: {
+ createdAt: "desc",
+ },
+ });
+
+ return typedjson({
+ organization,
+ vercelIntegration,
+ connectedProjects,
+ teamId,
+ installationId,
+ });
+};
+
+const ActionSchema = z.object({
+ intent: z.literal("uninstall"),
+});
+
+export const action = async ({ request, params }: ActionFunctionArgs) => {
+ const { organizationSlug } = OrganizationParamsSchema.parse(params);
+ const { organization, userId } = await requireOrganization(request, organizationSlug);
+
+ const formData = await request.formData();
+ const result = ActionSchema.safeParse({ intent: formData.get("intent") });
+ if (!result.success) {
+ return json({ error: "Invalid action" }, { status: 400 });
+ }
+
+ // Find Vercel integration
+ const vercelIntegration = await prisma.organizationIntegration.findFirst({
+ where: {
+ organizationId: organization.id,
+ service: "VERCEL",
+ deletedAt: null,
+ },
+ include: {
+ tokenReference: true,
+ },
+ });
+
+ if (!vercelIntegration) {
+ return json({ error: "Vercel integration not found" }, { status: 404 });
+ }
+
+ const uninstallActionResult = await fromPromise(
+ (async () => {
+ // First, attempt to uninstall the integration from Vercel side
+ const uninstallResult = await VercelIntegrationRepository.uninstallVercelIntegration(vercelIntegration);
+
+ // Then soft-delete the integration and all connected projects in a transaction
+ await $transaction(prisma, async (tx) => {
+ // Soft-delete all connected projects
+ await tx.organizationProjectIntegration.updateMany({
+ where: {
+ organizationIntegrationId: vercelIntegration.id,
+ deletedAt: null,
+ },
+ data: { deletedAt: new Date() },
+ });
+
+ // Soft-delete the integration record
+ await tx.organizationIntegration.update({
+ where: { id: vercelIntegration.id },
+ data: { deletedAt: new Date() },
+ });
+ });
+
+ return uninstallResult;
+ })(),
+ (error) => error
+ );
+
+ if (uninstallActionResult.isErr()) {
+ logger.error("Failed to uninstall Vercel integration", {
+ organizationId: organization.id,
+ organizationSlug,
+ userId,
+ integrationId: vercelIntegration.id,
+ error: uninstallActionResult.error instanceof Error ? uninstallActionResult.error.message : String(uninstallActionResult.error),
+ });
+
+ return json(
+ { error: "Failed to uninstall Vercel integration. Please try again." },
+ { status: 500 }
+ );
+ }
+
+ if (uninstallActionResult.value.authInvalid) {
+ logger.warn("Vercel integration uninstalled with auth error - token invalid", {
+ organizationId: organization.id,
+ organizationSlug,
+ userId,
+ integrationId: vercelIntegration.id,
+ });
+ } else {
+ logger.info("Vercel integration uninstalled successfully", {
+ organizationId: organization.id,
+ organizationSlug,
+ userId,
+ integrationId: vercelIntegration.id,
+ });
+ }
+
+ // Redirect back to organization settings
+ return redirect(`/orgs/${organizationSlug}/settings`);
+};
+
+export default function VercelIntegrationPage() {
+ const { organization, vercelIntegration, connectedProjects, teamId, installationId } =
+ useTypedLoaderData();
+ const actionData = useActionData();
+ const navigation = useNavigation();
+ const isUninstalling = navigation.state === "submitting" &&
+ navigation.formData?.get("intent") === "uninstall";
+
+ if (!vercelIntegration) {
+ return (
+
+
+
+
No Vercel Integration Found
+
+ This organization doesn't have a Vercel integration configured.
+
+
+
+ );
+ }
+
+ return (
+
+
+
+
Vercel Integration
+
+ Manage your organization's Vercel integration and connected projects.
+
+
+
+
+
Integration Details
+
+ {teamId && (
+
+ Vercel Team ID: {teamId}
+
+ )}
+ {installationId && (
+
+ Installation ID: {installationId}
+
+ )}
+
+ Installed: {" "}
+ {formatDate(new Date(vercelIntegration.createdAt))}
+
+
+
+
+
+
+
+ Remove Integration
+
+
+
+
+ Remove Vercel Integration
+
+
+ This will permanently remove the Vercel integration and disconnect all projects.
+ This action cannot be undone.
+
+
+
+ {isUninstalling ? "Removing..." : "Remove Integration"}
+
+
+ }
+ cancelButton={
+
+ Cancel
+
+ }
+ />
+
+
+ {actionData?.error && (
+
+ {actionData.error}
+
+ )}
+
+
+
+
+ Connected Projects ({connectedProjects.length})
+
+
+ {connectedProjects.length === 0 ? (
+
+
+ No projects are currently connected to this Vercel integration.
+
+
+ ) : (
+
+
+
+ Project Name
+ Vercel Project ID
+ Connected
+ Actions
+
+
+
+ {connectedProjects.map((projectIntegration) => (
+
+ {projectIntegration.project.name}
+
+ {projectIntegration.externalEntityId}
+
+
+ {formatDate(new Date(projectIntegration.createdAt))}
+
+
+
+ Configure
+
+
+
+ ))}
+
+
+ )}
+
+
+ );
+}
\ No newline at end of file
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug_.projects.new/route.tsx b/apps/webapp/app/routes/_app.orgs.$organizationSlug_.projects.new/route.tsx
index 68c3306e28..46768f8326 100644
--- a/apps/webapp/app/routes/_app.orgs.$organizationSlug_.projects.new/route.tsx
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug_.projects.new/route.tsx
@@ -31,7 +31,9 @@ import {
organizationPath,
selectPlanPath,
v3ProjectPath,
+ v3ProjectSettingsPath,
} from "~/utils/pathBuilder";
+import { generateVercelOAuthState } from "~/v3/vercel/vercelOAuthState.server";
export async function loader({ params, request }: LoaderFunctionArgs) {
const userId = await requireUserId(request);
@@ -103,6 +105,12 @@ export const action: ActionFunction = async ({ request, params }) => {
return json(submission);
}
+ // Check for Vercel integration params in URL
+ const url = new URL(request.url);
+ const code = url.searchParams.get("code");
+ const configurationId = url.searchParams.get("configurationId");
+ const next = url.searchParams.get("next");
+
try {
const project = await createProject({
organizationSlug: organizationSlug,
@@ -111,6 +119,44 @@ export const action: ActionFunction = async ({ request, params }) => {
version: submission.value.projectVersion,
});
+ // If this is a Vercel integration flow, generate state and redirect to connect
+ if (code && configurationId) {
+ const environment = await prisma.runtimeEnvironment.findFirst({
+ where: {
+ projectId: project.id,
+ slug: "prod",
+ archivedAt: null,
+ },
+ });
+
+ if (!environment) {
+ return redirectWithErrorMessage(
+ newProjectPath({ slug: organizationSlug }),
+ request,
+ "Failed to find project environment."
+ );
+ }
+
+ const state = await generateVercelOAuthState({
+ organizationId: project.organization.id,
+ projectId: project.id,
+ environmentSlug: environment.slug,
+ organizationSlug: project.organization.slug,
+ projectSlug: project.slug,
+ });
+
+ const params = new URLSearchParams({
+ state,
+ code,
+ configurationId,
+ origin: "marketplace",
+ });
+ if (next) {
+ params.set("next", next);
+ }
+ return redirect(`/vercel/connect?${params.toString()}`);
+ }
+
return redirectWithSuccessMessage(
v3ProjectPath(project.organization, project),
request,
diff --git a/apps/webapp/app/routes/_app.orgs.new/route.tsx b/apps/webapp/app/routes/_app.orgs.new/route.tsx
index a677782eae..0a5c7fdd6a 100644
--- a/apps/webapp/app/routes/_app.orgs.new/route.tsx
+++ b/apps/webapp/app/routes/_app.orgs.new/route.tsx
@@ -69,6 +69,27 @@ export const action: ActionFunction = async ({ request }) => {
});
}
+ // Preserve Vercel integration params if present
+ const url = new URL(request.url);
+ const code = url.searchParams.get("code");
+ const configurationId = url.searchParams.get("configurationId");
+ const integration = url.searchParams.get("integration");
+ const next = url.searchParams.get("next");
+
+ if (code && configurationId && integration === "vercel") {
+ // Redirect to projects/new with params preserved
+ const params = new URLSearchParams({
+ code,
+ configurationId,
+ integration,
+ });
+ if (next) {
+ params.set("next", next);
+ }
+ const redirectUrl = `${organizationPath(organization)}/projects/new?${params.toString()}`;
+ return redirect(redirectUrl);
+ }
+
return redirect(organizationPath(organization));
} catch (error: any) {
return json({ errors: { body: error.message } }, { status: 400 });
diff --git a/apps/webapp/app/routes/api.v1.deployments.$deploymentId.ts b/apps/webapp/app/routes/api.v1.deployments.$deploymentId.ts
index ca3417b75b..d9ee637a7c 100644
--- a/apps/webapp/app/routes/api.v1.deployments.$deploymentId.ts
+++ b/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);
}
diff --git a/apps/webapp/app/routes/api.v1.orgs.$organizationSlug.projects.$projectParam.vercel.projects.ts b/apps/webapp/app/routes/api.v1.orgs.$organizationSlug.projects.$projectParam.vercel.projects.ts
new file mode 100644
index 0000000000..aaf5468588
--- /dev/null
+++ b/apps/webapp/app/routes/api.v1.orgs.$organizationSlug.projects.$projectParam.vercel.projects.ts
@@ -0,0 +1,147 @@
+import type { LoaderFunctionArgs } from "@remix-run/server-runtime";
+import { json } from "@remix-run/server-runtime";
+import { fromPromise } from "neverthrow";
+import { z } from "zod";
+import { prisma } from "~/db.server";
+import { apiCors } from "~/utils/apiCors";
+import { logger } from "~/services/logger.server";
+import { authenticateApiRequestWithPersonalAccessToken } from "~/services/personalAccessToken.server";
+import { VercelIntegrationService } from "~/services/vercelIntegration.server";
+
+const ParamsSchema = z.object({
+ organizationSlug: z.string(),
+ projectParam: z.string(),
+});
+
+/**
+ * API endpoint to retrieve connected Vercel projects for a Trigger.dev project.
+ *
+ * GET /api/v1/orgs/:organizationSlug/projects/:projectParam/vercel/projects
+ *
+ * Returns:
+ * - vercelProject: The connected Vercel project details (if any)
+ * - config: The Vercel integration configuration
+ * - syncEnvVarsMapping: The environment variable sync mapping
+ */
+export async function loader({ request, params }: LoaderFunctionArgs) {
+ // Handle CORS
+ if (request.method === "OPTIONS") {
+ return apiCors(request, json({}));
+ }
+
+ const authenticationResult = await authenticateApiRequestWithPersonalAccessToken(request);
+
+ if (!authenticationResult) {
+ return apiCors(
+ request,
+ json({ error: "Invalid or Missing Access Token" }, { status: 401 })
+ );
+ }
+
+ const parsedParams = ParamsSchema.safeParse(params);
+ if (!parsedParams.success) {
+ return apiCors(
+ request,
+ json({ error: "Invalid parameters" }, { status: 400 })
+ );
+ }
+
+ const { organizationSlug, projectParam } = parsedParams.data;
+
+ const result = await fromPromise(
+ (async () => {
+ // Find the project, verifying org membership
+ const project = await prisma.project.findFirst({
+ where: {
+ slug: projectParam,
+ organization: {
+ slug: organizationSlug,
+ members: {
+ some: {
+ userId: authenticationResult.userId,
+ },
+ },
+ },
+ deletedAt: null,
+ },
+ select: {
+ id: true,
+ name: true,
+ slug: true,
+ organizationId: true,
+ },
+ });
+
+ if (!project) {
+ return { type: "not_found" as const };
+ }
+
+ // Get Vercel integration for the project
+ const vercelService = new VercelIntegrationService();
+ const integration = await vercelService.getVercelProjectIntegration(project.id);
+
+ return { type: "success" as const, project, integration };
+ })(),
+ (error) => error
+ );
+
+ if (result.isErr()) {
+ logger.error("Failed to fetch Vercel projects", {
+ error: result.error,
+ organizationSlug,
+ projectParam,
+ });
+
+ return apiCors(
+ request,
+ json({ error: "Internal server error" }, { status: 500 })
+ );
+ }
+
+ if (result.value.type === "not_found") {
+ return apiCors(
+ request,
+ json({ error: "Project not found" }, { status: 404 })
+ );
+ }
+
+ const { project, integration } = result.value;
+
+ if (!integration) {
+ return apiCors(
+ request,
+ json({
+ connected: false,
+ vercelProject: null,
+ config: null,
+ syncEnvVarsMapping: null,
+ })
+ );
+ }
+
+ const { parsedIntegrationData } = integration;
+
+ return apiCors(
+ request,
+ json({
+ connected: true,
+ vercelProject: {
+ id: parsedIntegrationData.vercelProjectId,
+ name: parsedIntegrationData.vercelProjectName,
+ teamId: parsedIntegrationData.vercelTeamId,
+ },
+ config: {
+ atomicBuilds: parsedIntegrationData.config.atomicBuilds,
+ pullEnvVarsBeforeBuild: parsedIntegrationData.config.pullEnvVarsBeforeBuild,
+ vercelStagingEnvironment: parsedIntegrationData.config.vercelStagingEnvironment,
+ },
+ syncEnvVarsMapping: parsedIntegrationData.syncEnvVarsMapping,
+ triggerProject: {
+ id: project.id,
+ name: project.name,
+ slug: project.slug,
+ },
+ })
+ );
+}
+
diff --git a/apps/webapp/app/routes/api.v1.projects.$projectRef.envvars.$slug.import.ts b/apps/webapp/app/routes/api.v1.projects.$projectRef.envvars.$slug.import.ts
index ad2372a654..53bc4429c1 100644
--- a/apps/webapp/app/routes/api.v1.projects.$projectRef.envvars.$slug.import.ts
+++ b/apps/webapp/app/routes/api.v1.projects.$projectRef.envvars.$slug.import.ts
@@ -41,10 +41,13 @@ export async function action({ params, request }: ActionFunctionArgs) {
const result = await repository.create(environment.project.id, {
override: typeof body.override === "boolean" ? body.override : false,
environmentIds: [environment.id],
+ // Pass parent environment ID so new variables can inherit isSecret from parent
+ parentEnvironmentId: environment.parentEnvironmentId ?? undefined,
variables: Object.entries(body.variables).map(([key, value]) => ({
key,
value,
})),
+ lastUpdatedBy: body.source,
});
// Only sync parent variables if this is a branch environment
@@ -56,6 +59,7 @@ export async function action({ params, request }: ActionFunctionArgs) {
key,
value,
})),
+ lastUpdatedBy: body.source,
});
let childFailure = !result.success ? result : undefined;
diff --git a/apps/webapp/app/routes/auth.github.callback.tsx b/apps/webapp/app/routes/auth.github.callback.tsx
index 42473c64a4..2313b348f4 100644
--- a/apps/webapp/app/routes/auth.github.callback.tsx
+++ b/apps/webapp/app/routes/auth.github.callback.tsx
@@ -5,6 +5,7 @@ import { getSession, redirectWithErrorMessage } from "~/models/message.server";
import { authenticator } from "~/services/auth.server";
import { setLastAuthMethodHeader } from "~/services/lastAuthMethod.server";
import { commitSession } from "~/services/sessionStorage.server";
+import { trackAndClearReferralSource } from "~/services/referralSource.server";
import { redirectCookie } from "./auth.github";
import { sanitizeRedirectPath } from "~/utils";
@@ -17,7 +18,6 @@ export let loader: LoaderFunction = async ({ request }) => {
failureRedirect: "/login", // If auth fails, the failureRedirect will be thrown as a Response
});
- // manually get the session
const session = await getSession(request.headers.get("cookie"));
const userRecord = await prisma.user.findFirst({
@@ -49,12 +49,13 @@ export let loader: LoaderFunction = async ({ request }) => {
return redirect("/login/mfa", { headers });
}
- // and store the user data
session.set(authenticator.sessionKey, auth);
const headers = new Headers();
headers.append("Set-Cookie", await commitSession(session));
headers.append("Set-Cookie", await setLastAuthMethodHeader("github"));
+ await trackAndClearReferralSource(request, auth.userId, headers);
+
return redirect(redirectTo, { headers });
};
diff --git a/apps/webapp/app/routes/auth.google.callback.tsx b/apps/webapp/app/routes/auth.google.callback.tsx
index 783ddce3a3..65dabd605c 100644
--- a/apps/webapp/app/routes/auth.google.callback.tsx
+++ b/apps/webapp/app/routes/auth.google.callback.tsx
@@ -5,6 +5,7 @@ import { getSession, redirectWithErrorMessage } from "~/models/message.server";
import { authenticator } from "~/services/auth.server";
import { setLastAuthMethodHeader } from "~/services/lastAuthMethod.server";
import { commitSession } from "~/services/sessionStorage.server";
+import { trackAndClearReferralSource } from "~/services/referralSource.server";
import { redirectCookie } from "./auth.google";
import { sanitizeRedirectPath } from "~/utils";
@@ -17,7 +18,6 @@ export let loader: LoaderFunction = async ({ request }) => {
failureRedirect: "/login", // If auth fails, the failureRedirect will be thrown as a Response
});
- // manually get the session
const session = await getSession(request.headers.get("cookie"));
const userRecord = await prisma.user.findFirst({
@@ -49,13 +49,14 @@ export let loader: LoaderFunction = async ({ request }) => {
return redirect("/login/mfa", { headers });
}
- // and store the user data
session.set(authenticator.sessionKey, auth);
const headers = new Headers();
headers.append("Set-Cookie", await commitSession(session));
headers.append("Set-Cookie", await setLastAuthMethodHeader("google"));
+ await trackAndClearReferralSource(request, auth.userId, headers);
+
return redirect(redirectTo, { headers });
};
diff --git a/apps/webapp/app/routes/confirm-basic-details.tsx b/apps/webapp/app/routes/confirm-basic-details.tsx
index 4187a2e9d0..0596ee8b52 100644
--- a/apps/webapp/app/routes/confirm-basic-details.tsx
+++ b/apps/webapp/app/routes/confirm-basic-details.tsx
@@ -25,6 +25,7 @@ import { redirectWithSuccessMessage } from "~/models/message.server";
import { updateUser } from "~/models/user.server";
import { requireUserId } from "~/services/session.server";
import { rootPath } from "~/utils/pathBuilder";
+import { getVercelInstallParams } from "~/v3/vercel";
function createSchema(
constraints: {
@@ -105,7 +106,24 @@ export const action: ActionFunction = async ({ request }) => {
referralSource: submission.value.referralSource,
});
- return redirectWithSuccessMessage(rootPath(), request, "Your details have been updated.");
+ // Preserve Vercel integration params if present
+ const vercelParams = getVercelInstallParams(request);
+ let redirectUrl = rootPath();
+
+ if (vercelParams) {
+ // Redirect to orgs/new with params preserved
+ const params = new URLSearchParams({
+ code: vercelParams.code,
+ configurationId: vercelParams.configurationId,
+ integration: "vercel",
+ });
+ if (vercelParams.next) {
+ params.set("next", vercelParams.next);
+ }
+ redirectUrl = `/orgs/new?${params.toString()}`;
+ }
+
+ return redirectWithSuccessMessage(redirectUrl, request, "Your details have been updated.");
} catch (error: any) {
return json({ errors: { body: error.message } }, { status: 400 });
}
diff --git a/apps/webapp/app/routes/login._index/route.tsx b/apps/webapp/app/routes/login._index/route.tsx
index 40cea7905c..8878ffc888 100644
--- a/apps/webapp/app/routes/login._index/route.tsx
+++ b/apps/webapp/app/routes/login._index/route.tsx
@@ -167,7 +167,7 @@ export default function LoginPage() {
{data.lastAuthMethod === "email" &&
}
{
const parentMeta = matches
@@ -160,11 +161,13 @@ async function completeLogin(request: Request, session: Session, userId: string)
session.unset("pending-mfa-user-id");
session.unset("pending-mfa-redirect-to");
- return redirect(redirectTo, {
- headers: {
- "Set-Cookie": await sessionStorage.commitSession(authSession),
- },
- });
+ const headers = new Headers();
+ headers.append("Set-Cookie", await sessionStorage.commitSession(authSession));
+ headers.append("Set-Cookie", await commitSession(session));
+
+ await trackAndClearReferralSource(request, userId, headers);
+
+ return redirect(redirectTo, { headers });
}
export default function LoginMfaPage() {
diff --git a/apps/webapp/app/routes/magic.tsx b/apps/webapp/app/routes/magic.tsx
index c45b6882ca..682f0ef46e 100644
--- a/apps/webapp/app/routes/magic.tsx
+++ b/apps/webapp/app/routes/magic.tsx
@@ -6,6 +6,7 @@ import { authenticator } from "~/services/auth.server";
import { setLastAuthMethodHeader } from "~/services/lastAuthMethod.server";
import { getRedirectTo } from "~/services/redirectTo.server";
import { commitSession, getSession } from "~/services/sessionStorage.server";
+import { trackAndClearReferralSource } from "~/services/referralSource.server";
export async function loader({ request }: LoaderFunctionArgs) {
const redirectTo = await getRedirectTo(request);
@@ -53,5 +54,7 @@ export async function loader({ request }: LoaderFunctionArgs) {
headers.append("Set-Cookie", await commitSession(session));
headers.append("Set-Cookie", await setLastAuthMethodHeader("email"));
+ await trackAndClearReferralSource(request, auth.userId, headers);
+
return redirect(redirectTo ?? "/", { headers });
}
diff --git a/apps/webapp/app/routes/resources.environments.$environmentId.regenerate-api-key.tsx b/apps/webapp/app/routes/resources.environments.$environmentId.regenerate-api-key.tsx
index 7ad6b1c6c5..534a07d7fb 100644
--- a/apps/webapp/app/routes/resources.environments.$environmentId.regenerate-api-key.tsx
+++ b/apps/webapp/app/routes/resources.environments.$environmentId.regenerate-api-key.tsx
@@ -2,8 +2,10 @@ import type { ActionFunctionArgs } from "@remix-run/server-runtime";
import { z } from "zod";
import { environmentFullTitle } from "~/components/environments/EnvironmentLabel";
import { regenerateApiKey } from "~/models/api-key.server";
+import { VercelIntegrationRepository } from "~/models/vercelIntegration.server";
import { jsonWithErrorMessage, jsonWithSuccessMessage } from "~/models/message.server";
import { requireUserId } from "~/services/session.server";
+import { logger } from "~/services/logger.server";
const ParamsSchema = z.object({
environmentId: z.string(),
@@ -22,6 +24,13 @@ export async function action({ request, params }: ActionFunctionArgs) {
try {
const updatedEnvironment = await regenerateApiKey({ userId, environmentId });
+ // Sync the regenerated API key to Vercel if integration exists
+ await syncApiKeyToVercelInBackground(
+ updatedEnvironment.projectId,
+ updatedEnvironment.type as "PRODUCTION" | "STAGING" | "PREVIEW" | "DEVELOPMENT",
+ updatedEnvironment.apiKey
+ );
+
return jsonWithSuccessMessage(
{ ok: true },
request,
@@ -37,3 +46,28 @@ export async function action({ request, params }: ActionFunctionArgs) {
);
}
}
+
+/**
+ * Sync the API key to Vercel.
+ * Errors are logged but won't fail the API key regeneration.
+ */
+async function syncApiKeyToVercelInBackground(
+ projectId: string,
+ environmentType: "PRODUCTION" | "STAGING" | "PREVIEW" | "DEVELOPMENT",
+ apiKey: string
+): Promise {
+ try {
+ const result = await VercelIntegrationRepository.syncSingleApiKeyToVercel({
+ projectId,
+ environmentType,
+ apiKey,
+ });
+ } catch (error) {
+ // Log but don't throw - we don't want to fail the main operation
+ logger.warn("Error syncing regenerated API key to Vercel", {
+ projectId,
+ environmentType,
+ error,
+ });
+ }
+}
diff --git a/apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.github.tsx b/apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.github.tsx
index bb7406ed44..2673a9c464 100644
--- a/apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.github.tsx
+++ b/apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.github.tsx
@@ -330,12 +330,15 @@ export function ConnectGitHubRepoModal({
projectSlug,
environmentSlug,
redirectUrl,
+ preventDismiss,
}: {
gitHubAppInstallations: GitHubAppInstallation[];
organizationSlug: string;
projectSlug: string;
environmentSlug: string;
redirectUrl?: string;
+ /** When true, prevents closing the modal via Escape key or clicking outside */
+ preventDismiss?: boolean;
}) {
const [isModalOpen, setIsModalOpen] = useState(false);
const lastSubmission = useActionData() as any;
@@ -385,13 +388,34 @@ export function ConnectGitHubRepoModal({
const actionUrl = gitHubResourcePath(organizationSlug, projectSlug, environmentSlug);
return (
-
+ {
+ // When preventDismiss is true, only allow opening, not closing
+ if (preventDismiss && !open) {
+ return;
+ }
+ setIsModalOpen(open);
+ }}
+ >
Connect GitHub repo
-
+ {
+ if (preventDismiss) {
+ e.preventDefault();
+ }
+ }}
+ onEscapeKeyDown={(e) => {
+ if (preventDismiss) {
+ e.preventDefault();
+ }
+ }}
+ >
Connect GitHub repository
+
+ );
+}
+
+function VercelSettingsPanel({
+ organizationSlug,
+ projectSlug,
+ environmentSlug,
+ onOpenVercelModal,
+ isLoadingVercelData,
+}: {
+ organizationSlug: string;
+ projectSlug: string;
+ environmentSlug: string;
+ onOpenVercelModal?: () => void;
+ isLoadingVercelData?: boolean;
+}) {
+ const fetcher = useTypedFetcher
();
+ const location = useLocation();
+ const data = fetcher.data;
+ const [hasError, setHasError] = useState(false);
+ const [hasFetched, setHasFetched] = useState(false);
+
+ useEffect(() => {
+ if (!data?.authInvalid && !hasError && !data && !hasFetched) {
+ fetcher.load(vercelResourcePath(organizationSlug, projectSlug, environmentSlug));
+ setHasFetched(true);
+ }
+ }, [organizationSlug, projectSlug, environmentSlug, data?.authInvalid, hasError, data, hasFetched]);
+
+ useEffect(() => {
+ if (hasFetched && fetcher.state === "idle" && fetcher.data === undefined && !hasError) {
+ setHasError(true);
+ }
+ }, [fetcher.state, fetcher.data, hasError, hasFetched]);
+
+ if (hasError) {
+ return (
+
+
+
+
+
Failed to load Vercel settings
+
+ There was an error loading the Vercel integration settings. Please refresh the page to try again.
+
+
+
+
+ Loading Vercel settings...
+
+ );
+ }
+
+ if (!data || !data.enabled) {
+ return null;
+ }
+
+ const showGitHubWarning = data.connectedProject && !data.isGitHubConnected;
+ const showAuthInvalid = data.authInvalid || data.onboardingData?.authInvalid;
+
+ if (data.connectedProject) {
+ return (
+ <>
+ {showAuthInvalid &&
+ {showAuthInvalid &&
+ {data.hasOrgIntegration
+ ? "Connect your Vercel project to pull environment variables and trigger builds automatically."
+ : "Install the Vercel app to connect your projects and pull environment variables."}
+
+ {!data.isGitHubConnected && (
+
+ GitHub integration is not connected. Vercel integration cannot pull environment variables or
+ spawn Trigger.dev builds without a properly installed GitHub integration.
+
+ )}
+
+ )}
+
+ );
+}
+
+
+import { VercelOnboardingModal } from "~/components/integrations/VercelOnboardingModal";
+
+export { VercelSettingsPanel, VercelOnboardingModal };
diff --git a/apps/webapp/app/routes/vercel.callback.ts b/apps/webapp/app/routes/vercel.callback.ts
new file mode 100644
index 0000000000..e42951c5e8
--- /dev/null
+++ b/apps/webapp/app/routes/vercel.callback.ts
@@ -0,0 +1,74 @@
+import type { LoaderFunctionArgs } from "@remix-run/server-runtime";
+import { redirect } from "@remix-run/server-runtime";
+import { z } from "zod";
+import { logger } from "~/services/logger.server";
+import { getUserId } from "~/services/session.server";
+import { setReferralSourceCookie } from "~/services/referralSource.server";
+import { requestUrl } from "~/utils/requestUrl.server";
+
+const VercelCallbackSchema = z
+ .object({
+ code: z.string().optional(),
+ state: z.string().optional(),
+ error: z.string().optional(),
+ error_description: z.string().optional(),
+ configurationId: z.string().optional(),
+ next: z.string().optional()
+ })
+ .passthrough();
+
+export async function loader({ request }: LoaderFunctionArgs) {
+ if (request.method.toUpperCase() !== "GET") {
+ throw new Response("Method Not Allowed", { status: 405 });
+ }
+
+ const userId = await getUserId(request);
+ if (!userId) {
+ const currentUrl = new URL(request.url);
+ const redirectTo = `${currentUrl.pathname}${currentUrl.search}`;
+ const referralCookie = await setReferralSourceCookie("vercel");
+
+ const headers = new Headers();
+ headers.append("Set-Cookie", referralCookie);
+
+ throw redirect(`/login?redirectTo=${encodeURIComponent(redirectTo)}`, { headers });
+ }
+
+ const url = requestUrl(request);
+ const parsed = VercelCallbackSchema.safeParse(Object.fromEntries(url.searchParams));
+
+ if (!parsed.success) {
+ logger.error("Invalid Vercel callback params", { error: parsed.error });
+ throw new Response("Invalid callback parameters", { status: 400 });
+ }
+
+ const { code, state, error, error_description, configurationId, next: nextUrl } = parsed.data;
+
+ if (error) {
+ logger.error("Vercel OAuth error", { error, error_description });
+ throw new Response("Vercel OAuth error", { status: 500 });
+ }
+
+ if (!code) {
+ logger.error("Missing authorization code from Vercel callback");
+ throw new Response("Missing authorization code", { status: 400 });
+ }
+
+ // Route with state: dashboard-invoked flow
+ if (state) {
+ const params = new URLSearchParams({ state, code, origin: "dashboard" });
+ if (configurationId) params.set("configurationId", configurationId);
+ if (nextUrl) params.set("next", nextUrl);
+ return redirect(`/vercel/connect?${params.toString()}`);
+ }
+
+ // Route without state but with configurationId: marketplace-invoked flow
+ if (configurationId) {
+ const params = new URLSearchParams({ code, configurationId, origin: "marketplace" });
+ if (nextUrl) params.set("next", nextUrl);
+ return redirect(`/vercel/onboarding?${params.toString()}`);
+ }
+
+ logger.error("Missing both state and configurationId from Vercel callback");
+ throw new Response("Missing state or configurationId parameter", { status: 400 });
+}
diff --git a/apps/webapp/app/routes/vercel.configure.tsx b/apps/webapp/app/routes/vercel.configure.tsx
new file mode 100644
index 0000000000..f79d333509
--- /dev/null
+++ b/apps/webapp/app/routes/vercel.configure.tsx
@@ -0,0 +1,50 @@
+import type { LoaderFunctionArgs } from "@remix-run/node";
+import { redirect } from "@remix-run/node";
+import { z } from "zod";
+import { prisma } from "~/db.server";
+import { organizationVercelIntegrationPath } from "~/utils/pathBuilder";
+
+const SearchParamsSchema = z.object({
+ configurationId: z.string(),
+});
+
+/**
+ * Endpoint to handle Vercel integration configuration request coming from marketplace
+ */
+export const loader = async ({ request }: LoaderFunctionArgs) => {
+ const url = new URL(request.url);
+ const searchParams = Object.fromEntries(url.searchParams);
+
+ const { configurationId } = SearchParamsSchema.parse(searchParams);
+
+ // Find the organization integration by configurationId (installationId in integrationData)
+ const integration = await prisma.organizationIntegration.findFirst({
+ where: {
+ service: "VERCEL",
+ deletedAt: null,
+ integrationData: {
+ path: ["installationId"],
+ equals: configurationId,
+ },
+ },
+ include: {
+ organization: {
+ select: {
+ slug: true,
+ },
+ },
+ },
+ });
+
+ if (!integration) {
+ throw new Response("Integration not found", { status: 404 });
+ }
+
+ // Redirect to the organization's Vercel integration page
+ return redirect(organizationVercelIntegrationPath(integration.organization));
+};
+
+// This route doesn't render anything, it just redirects
+export default function VercelConfigurePage() {
+ return null;
+}
\ No newline at end of file
diff --git a/apps/webapp/app/routes/vercel.connect.tsx b/apps/webapp/app/routes/vercel.connect.tsx
new file mode 100644
index 0000000000..3fdf9653f2
--- /dev/null
+++ b/apps/webapp/app/routes/vercel.connect.tsx
@@ -0,0 +1,169 @@
+import type { LoaderFunctionArgs } from "@remix-run/server-runtime";
+import { redirect } from "@remix-run/server-runtime";
+import { fromPromise } from "neverthrow";
+import { z } from "zod";
+import { prisma } from "~/db.server";
+import { VercelIntegrationRepository, type TokenResponse } from "~/models/vercelIntegration.server";
+import { logger } from "~/services/logger.server";
+import { requireUserId } from "~/services/session.server";
+import { requestUrl } from "~/utils/requestUrl.server";
+import { v3ProjectSettingsPath } from "~/utils/pathBuilder";
+import { validateVercelOAuthState } from "~/v3/vercel/vercelOAuthState.server";
+
+const VercelConnectSchema = z.object({
+ state: z.string(),
+ configurationId: z.string(),
+ code: z.string(),
+ next: z.string().optional(),
+ origin: z.enum(["marketplace", "dashboard"]),
+});
+
+async function createOrFindVercelIntegration(
+ organizationId: string,
+ projectId: string,
+ tokenResponse: TokenResponse,
+ configurationId: string,
+ origin: 'marketplace' | 'dashboard'
+): Promise {
+ const project = await prisma.project.findUnique({
+ where: { id: projectId },
+ include: { organization: true },
+ });
+
+ if (!project) {
+ throw new Error("Project not found");
+ }
+
+ let orgIntegration = await VercelIntegrationRepository.findVercelOrgIntegrationByTeamId(
+ organizationId,
+ tokenResponse.teamId ?? null
+ );
+
+ if (orgIntegration) {
+ await VercelIntegrationRepository.updateVercelOrgIntegrationToken({
+ integrationId: orgIntegration.id,
+ accessToken: tokenResponse.accessToken,
+ tokenType: tokenResponse.tokenType,
+ teamId: tokenResponse.teamId ?? null,
+ userId: tokenResponse.userId,
+ installationId: configurationId,
+ raw: tokenResponse.raw
+ });
+ } else {
+ await VercelIntegrationRepository.createVercelOrgIntegration({
+ accessToken: tokenResponse.accessToken,
+ tokenType: tokenResponse.tokenType,
+ teamId: tokenResponse.teamId ?? null,
+ userId: tokenResponse.userId,
+ installationId: configurationId,
+ organization: project.organization,
+ raw: tokenResponse.raw,
+ origin,
+ });
+ }
+}
+
+export async function loader({ request }: LoaderFunctionArgs) {
+ const userId = await requireUserId(request);
+ const url = requestUrl(request);
+
+ const parsed = VercelConnectSchema.safeParse(Object.fromEntries(url.searchParams));
+ if (!parsed.success) {
+ logger.error("Invalid Vercel connect params", { error: parsed.error });
+ throw new Response("Invalid parameters", { status: 400 });
+ }
+
+ const { state, configurationId, code, next, origin } = parsed.data;
+
+ const validationResult = await validateVercelOAuthState(state);
+ if (!validationResult.ok) {
+ logger.error("Invalid Vercel OAuth state JWT", { error: validationResult.error });
+
+ if (
+ validationResult.error?.includes("expired") ||
+ validationResult.error?.includes("Token has expired")
+ ) {
+ const params = new URLSearchParams({ error: "expired" });
+ return redirect(`/vercel/onboarding?${params.toString()}`);
+ }
+
+ throw new Response("Invalid state", { status: 400 });
+ }
+
+ const stateData = validationResult.state;
+
+ const project = await prisma.project.findFirst({
+ where: {
+ id: stateData.projectId,
+ organizationId: stateData.organizationId,
+ deletedAt: null,
+ organization: {
+ members: {
+ some: { userId },
+ },
+ },
+ },
+ include: {
+ organization: true,
+ },
+ });
+
+ if (!project) {
+ logger.error("Project not found or access denied", {
+ projectId: stateData.projectId,
+ userId,
+ });
+ throw new Response("Project not found", { status: 404 });
+ }
+
+ const tokenResponse = await VercelIntegrationRepository.exchangeCodeForToken(code);
+ if (!tokenResponse) {
+ const params = new URLSearchParams({ error: "expired" });
+ return redirect(`/vercel/onboarding?${params.toString()}`);
+ }
+
+ const environment = await prisma.runtimeEnvironment.findFirst({
+ where: {
+ projectId: project.id,
+ slug: stateData.environmentSlug,
+ archivedAt: null,
+ },
+ });
+
+ if (!environment) {
+ logger.error("Environment not found", {
+ projectId: project.id,
+ environmentSlug: stateData.environmentSlug,
+ });
+ throw new Response("Environment not found", { status: 404 });
+ }
+
+ const settingsPath = v3ProjectSettingsPath(
+ { slug: stateData.organizationSlug },
+ { slug: stateData.projectSlug },
+ { slug: environment.slug }
+ );
+
+ const result = await fromPromise(
+ createOrFindVercelIntegration(stateData.organizationId, stateData.projectId, tokenResponse, configurationId, origin),
+ (error) => error
+ );
+
+ if (result.isErr()) {
+ logger.error("Failed to complete Vercel integration", { error: result.error });
+ throw redirect(settingsPath);
+ }
+
+ logger.info("Vercel organization integration created successfully", {
+ organizationId: stateData.organizationId,
+ projectId: stateData.projectId,
+ teamId: tokenResponse.teamId,
+ });
+
+ const params = new URLSearchParams({ vercelOnboarding: "true", origin });
+ if (next) {
+ params.set("next", next);
+ }
+
+ return redirect(`${settingsPath}?${params.toString()}`);
+}
diff --git a/apps/webapp/app/routes/vercel.install.tsx b/apps/webapp/app/routes/vercel.install.tsx
new file mode 100644
index 0000000000..6a1ca4d7a6
--- /dev/null
+++ b/apps/webapp/app/routes/vercel.install.tsx
@@ -0,0 +1,73 @@
+import type { LoaderFunctionArgs } from "@remix-run/server-runtime";
+import { redirect } from "@remix-run/server-runtime";
+import { z } from "zod";
+import { $replica } from "~/db.server";
+import { requireUser } from "~/services/session.server";
+import { logger } from "~/services/logger.server";
+import { OrgIntegrationRepository } from "~/models/orgIntegration.server";
+import { generateVercelOAuthState } from "~/v3/vercel/vercelOAuthState.server";
+import { findProjectBySlug } from "~/models/project.server";
+
+const QuerySchema = z.object({
+ org_slug: z.string(),
+ project_slug: z.string(),
+});
+
+export const loader = async ({ request }: LoaderFunctionArgs) => {
+ const searchParams = new URL(request.url).searchParams;
+ const parsed = QuerySchema.safeParse(Object.fromEntries(searchParams));
+
+ if (!parsed.success) {
+ logger.warn("Vercel App installation redirect with invalid params", {
+ searchParams,
+ error: parsed.error,
+ });
+ throw redirect("/");
+ }
+
+ const { org_slug, project_slug } = parsed.data;
+ const user = await requireUser(request);
+
+ // Find the organization
+ const org = await $replica.organization.findFirst({
+ where: { slug: org_slug, members: { some: { userId: user.id } }, deletedAt: null },
+ orderBy: { createdAt: "desc" },
+ select: {
+ id: true,
+ },
+ });
+
+ if (!org) {
+ throw redirect("/");
+ }
+
+ // Find the project
+ const project = await findProjectBySlug(org_slug, project_slug, user.id);
+ if (!project) {
+ logger.warn("Vercel App installation attempt for non-existent project", {
+ org_slug,
+ project_slug,
+ userId: user.id,
+ });
+ throw redirect("/");
+ }
+
+ // Use "prod" as the default environment slug for the redirect
+ // The callback will redirect to the settings page for this environment
+ const environmentSlug = "prod";
+
+ // Generate JWT state token
+ const stateToken = await generateVercelOAuthState({
+ organizationId: org.id,
+ projectId: project.id,
+ environmentSlug,
+ organizationSlug: org_slug,
+ projectSlug: project_slug,
+ });
+
+ // Generate Vercel install URL
+ const vercelInstallUrl = OrgIntegrationRepository.vercelInstallUrl(stateToken);
+
+ return redirect(vercelInstallUrl);
+};
+
diff --git a/apps/webapp/app/routes/vercel.onboarding.tsx b/apps/webapp/app/routes/vercel.onboarding.tsx
new file mode 100644
index 0000000000..d9406f25b1
--- /dev/null
+++ b/apps/webapp/app/routes/vercel.onboarding.tsx
@@ -0,0 +1,454 @@
+import type { ActionFunctionArgs, LoaderFunctionArgs } from "@remix-run/server-runtime";
+import { json, redirect } from "@remix-run/server-runtime";
+import { fromPromise } from "neverthrow";
+import { useEffect, useState } from "react";
+import { Form, useNavigation } from "@remix-run/react";
+import { typedjson, useTypedLoaderData } from "remix-typedjson";
+import { z } from "zod";
+import { BuildingOfficeIcon, FolderIcon } from "@heroicons/react/20/solid";
+import { AppContainer, MainCenteredContainer } from "~/components/layout/AppLayout";
+import { BackgroundWrapper } from "~/components/BackgroundWrapper";
+import { Button, LinkButton } from "~/components/primitives/Buttons";
+import { Fieldset } from "~/components/primitives/Fieldset";
+import { FormButtons } from "~/components/primitives/FormButtons";
+import { FormTitle } from "~/components/primitives/FormTitle";
+import { InputGroup } from "~/components/primitives/InputGroup";
+import { Label } from "~/components/primitives/Label";
+import { Select, SelectItem } from "~/components/primitives/Select";
+import { ButtonSpinner } from "~/components/primitives/Spinner";
+import { prisma } from "~/db.server";
+import { logger } from "~/services/logger.server";
+import { requireUserId } from "~/services/session.server";
+import { confirmBasicDetailsPath, newProjectPath } from "~/utils/pathBuilder";
+import { redirectWithErrorMessage } from "~/models/message.server";
+import { generateVercelOAuthState } from "~/v3/vercel/vercelOAuthState.server";
+
+const LoaderParamsSchema = z.object({
+ organizationId: z.string().optional().nullable(),
+ code: z.string(),
+ configurationId: z.string().optional().nullable(),
+ next: z.string().optional().nullable(),
+ error: z.string().optional().nullable(),
+});
+
+const SelectOrgActionSchema = z.object({
+ action: z.literal("select-org"),
+ organizationId: z.string(),
+ code: z.string(),
+ configurationId: z.string().optional().nullable(),
+ next: z.string().optional(),
+});
+
+const SelectProjectActionSchema = z.object({
+ action: z.literal("select-project"),
+ projectId: z.string(),
+ organizationId: z.string(),
+ code: z.string(),
+ configurationId: z.string().optional().nullable(),
+ next: z.string().optional().nullable(),
+});
+
+const ActionSchema = z.discriminatedUnion("action", [
+ SelectOrgActionSchema,
+ SelectProjectActionSchema,
+]);
+
+export async function loader({ request }: LoaderFunctionArgs) {
+ const userId = await requireUserId(request);
+ const url = new URL(request.url);
+
+ const params = LoaderParamsSchema.safeParse({
+ organizationId: url.searchParams.get("organizationId"),
+ code: url.searchParams.get("code"),
+ configurationId: url.searchParams.get("configurationId"),
+ next: url.searchParams.get("next"),
+ error: url.searchParams.get("error"),
+ });
+
+ if (!params.success) {
+ logger.error("Invalid params for Vercel onboarding", { error: params.error });
+ throw redirectWithErrorMessage(
+ "/",
+ request,
+ "Invalid installation parameters. Please try again from Vercel."
+ );
+ }
+
+ const { error } = params.data;
+ if (error === "expired") {
+ return typedjson({
+ step: "error" as const,
+ error: "Your installation session has expired. Please start the installation again.",
+ code: params.data.code,
+ configurationId: params.data.configurationId ?? null,
+ next: params.data.next ?? null,
+ });
+ }
+
+ const organizations = await prisma.organization.findMany({
+ where: {
+ members: {
+ some: { userId },
+ },
+ deletedAt: null,
+ },
+ select: {
+ id: true,
+ title: true,
+ slug: true,
+ projects: {
+ where: {
+ deletedAt: null,
+ },
+ select: {
+ id: true,
+ name: true,
+ slug: true,
+ },
+ orderBy: {
+ createdAt: "asc",
+ },
+ },
+ },
+ orderBy: {
+ createdAt: "asc",
+ },
+ });
+
+ // New user: no organizations
+ if (organizations.length === 0) {
+ const onboardingParams = new URLSearchParams();
+ onboardingParams.set("code", params.data.code);
+ if (params.data.configurationId) {
+ onboardingParams.set("configurationId", params.data.configurationId);
+ }
+ onboardingParams.set("integration", "vercel");
+ if (params.data.next) {
+ onboardingParams.set("next", params.data.next);
+ }
+ throw redirect(`${confirmBasicDetailsPath()}?${onboardingParams.toString()}`);
+ }
+
+ // If organizationId is provided, show project selection
+ if (params.data.organizationId) {
+ const organization = organizations.find((org) => org.id === params.data.organizationId);
+
+ if (!organization) {
+ logger.error("Organization not found or access denied", {
+ organizationId: params.data.organizationId,
+ userId,
+ });
+ throw redirectWithErrorMessage(
+ "/",
+ request,
+ "Organization not found. Please try again."
+ );
+ }
+
+ return typedjson({
+ step: "project" as const,
+ organization,
+ organizations,
+ code: params.data.code,
+ configurationId: params.data.configurationId ?? null,
+ next: params.data.next ?? null,
+ });
+ }
+
+ return typedjson({
+ step: "org" as const,
+ organizations,
+ code: params.data.code,
+ configurationId: params.data.configurationId ?? null,
+ next: params.data.next ?? null,
+ });
+}
+
+export async function action({ request }: ActionFunctionArgs) {
+ const userId = await requireUserId(request);
+ const formData = await request.formData();
+
+ const submission = ActionSchema.safeParse({
+ action: formData.get("action"),
+ organizationId: formData.get("organizationId"),
+ projectId: formData.get("projectId"),
+ code: formData.get("code"),
+ configurationId: formData.get("configurationId"),
+ next: formData.get("next"),
+ });
+
+ if (!submission.success) {
+ return json({ error: "Invalid submission" }, { status: 400 });
+ }
+
+ const { code, configurationId, next } = submission.data;
+
+ // Handle org selection
+ if (submission.data.action === "select-org") {
+ const { organizationId } = submission.data;
+
+ const projectParams = new URLSearchParams();
+ projectParams.set("organizationId", organizationId);
+ projectParams.set("code", code);
+ if (configurationId) {
+ projectParams.set("configurationId", configurationId);
+ }
+ if (next) {
+ projectParams.set("next", next);
+ }
+
+ return redirect(`/vercel/onboarding?${projectParams.toString()}`);
+ }
+
+ // Handle project selection
+ const { projectId, organizationId } = submission.data;
+
+ const project = await prisma.project.findFirst({
+ where: {
+ id: projectId,
+ organizationId,
+ deletedAt: null,
+ organization: {
+ members: { some: { userId } },
+ },
+ },
+ include: {
+ organization: true,
+ },
+ });
+
+ if (!project) {
+ logger.error("Project not found or access denied", { projectId, userId });
+ return json({ error: "Project not found" }, { status: 404 });
+ }
+
+ const environment = await prisma.runtimeEnvironment.findFirst({
+ where: {
+ projectId: project.id,
+ slug: "prod",
+ archivedAt: null,
+ },
+ });
+
+ if (!environment) {
+ logger.error("Environment not found", { projectId: project.id });
+ return json({ error: "Environment not found" }, { status: 404 });
+ }
+
+ const stateResult = await fromPromise(
+ generateVercelOAuthState({
+ organizationId: project.organizationId,
+ projectId: project.id,
+ environmentSlug: environment.slug,
+ organizationSlug: project.organization.slug,
+ projectSlug: project.slug,
+ }),
+ (error) => error
+ );
+
+ if (stateResult.isErr()) {
+ logger.error("Failed to generate Vercel OAuth state", { error: stateResult.error });
+ return json({ error: "Failed to generate installation state" }, { status: 500 });
+ }
+
+ const params = new URLSearchParams();
+ params.set("state", stateResult.value);
+ params.set("code", code);
+ if (configurationId) {
+ params.set("configurationId", configurationId);
+ }
+ params.set("origin", "marketplace");
+ if (next) {
+ params.set("next", next);
+ }
+
+ return redirect(`/vercel/connect?${params.toString()}`, 303);
+}
+
+export default function VercelOnboardingPage() {
+ const data = useTypedLoaderData();
+ const navigation = useNavigation();
+ const isSubmitting = navigation.state === "submitting";
+ const [isInstalling, setIsInstalling] = useState(false);
+
+ // Reset isInstalling when navigation returns to idle (e.g. on error)
+ useEffect(() => {
+ if (navigation.state === "idle" && isInstalling) {
+ setIsInstalling(false);
+ }
+ }, [navigation.state, isInstalling]);
+
+ if (data.step === "error") {
+ return (
+
+
+
+ window.close()}
+ className="w-full"
+ >
+ Close
+
+
+
+
+ );
+ }
+
+ if (data.step === "org") {
+ const newOrgUrl = (() => {
+ const params = new URLSearchParams();
+ params.set("code", data.code);
+ if (data.configurationId) {
+ params.set("configurationId", data.configurationId);
+ }
+ params.set("integration", "vercel");
+ if (data.next) {
+ params.set("next", data.next);
+ }
+ return `/orgs/new?${params.toString()}`;
+ })();
+
+ return (
+
+
+
+
+ }
+ />
+
+
+
+
+
+ );
+ }
+
+ const newProjectUrl = (() => {
+ const params = new URLSearchParams();
+ params.set("code", data.code);
+ if (data.configurationId) {
+ params.set("configurationId", data.configurationId);
+ }
+ params.set("integration", "vercel");
+ params.set("organizationId", data.organization.id);
+ if (data.next) {
+ params.set("next", data.next);
+ }
+ return `${newProjectPath({ slug: data.organization.slug })}?${params.toString()}`;
+ })();
+
+ const isLoading = isSubmitting || isInstalling;
+
+ return (
+
+
+
+ {
+ const cookie = request.headers.get("Cookie");
+ const value = await referralSourceCookie.parse(cookie);
+ if (value === "vercel") {
+ return value;
+ }
+ return null;
+}
+
+export async function setReferralSourceCookie(source: ReferralSource): Promise {
+ return referralSourceCookie.serialize(source);
+}
+
+export async function clearReferralSourceCookie(): Promise {
+ return referralSourceCookie.serialize("", {
+ maxAge: 0,
+ });
+}
+
+export async function trackAndClearReferralSource(
+ request: Request,
+ userId: string,
+ headers: Headers
+): Promise {
+ const referralSource = await getReferralSource(request);
+ if (!referralSource) return;
+
+ headers.append("Set-Cookie", await clearReferralSourceCookie());
+
+ const user = await prisma.user.findUnique({ where: { id: userId } });
+ if (!user) return;
+
+ const userAge = Date.now() - user.createdAt.getTime();
+ if (userAge >= 30 * 1000) return;
+
+ telemetry.user.identify({ user, isNewUser: true, referralSource });
+}
diff --git a/apps/webapp/app/services/telemetry.server.ts b/apps/webapp/app/services/telemetry.server.ts
index 98ca11ed90..f8bd3d3d99 100644
--- a/apps/webapp/app/services/telemetry.server.ts
+++ b/apps/webapp/app/services/telemetry.server.ts
@@ -28,18 +28,32 @@ class Telemetry {
}
user = {
- identify: ({ user, isNewUser }: { user: User; isNewUser: boolean }) => {
+ identify: ({
+ user,
+ isNewUser,
+ referralSource,
+ }: {
+ user: User;
+ isNewUser: boolean;
+ referralSource?: string;
+ }) => {
if (this.#posthogClient) {
+ const properties: Record = {
+ email: user.email,
+ name: user.name,
+ authenticationMethod: user.authenticationMethod,
+ admin: user.admin,
+ createdAt: user.createdAt,
+ isNewUser,
+ };
+
+ if (referralSource) {
+ properties.referralSource = referralSource;
+ }
+
this.#posthogClient.identify({
distinctId: user.id,
- properties: {
- email: user.email,
- name: user.name,
- authenticationMethod: user.authenticationMethod,
- admin: user.admin,
- createdAt: user.createdAt,
- isNewUser,
- },
+ properties,
});
}
if (isNewUser) {
diff --git a/apps/webapp/app/services/vercelIntegration.server.ts b/apps/webapp/app/services/vercelIntegration.server.ts
new file mode 100644
index 0000000000..f089369536
--- /dev/null
+++ b/apps/webapp/app/services/vercelIntegration.server.ts
@@ -0,0 +1,600 @@
+import type {
+ PrismaClient,
+ OrganizationProjectIntegration,
+ OrganizationIntegration,
+ SecretReference,
+} from "@trigger.dev/database";
+import { prisma } from "~/db.server";
+import { logger } from "~/services/logger.server";
+import { VercelIntegrationRepository } from "~/models/vercelIntegration.server";
+import { findCurrentWorkerDeployment } from "~/v3/models/workerDeployment.server";
+import {
+ VercelProjectIntegrationDataSchema,
+ VercelProjectIntegrationData,
+ VercelIntegrationConfig,
+ SyncEnvVarsMapping,
+ TriggerEnvironmentType,
+ EnvSlug,
+ envTypeToSlug,
+ createDefaultVercelIntegrationData,
+} from "~/v3/vercel/vercelProjectIntegrationSchema";
+
+export type VercelProjectIntegrationWithParsedData = OrganizationProjectIntegration & {
+ parsedIntegrationData: VercelProjectIntegrationData;
+};
+
+export type VercelProjectIntegrationWithData = VercelProjectIntegrationWithParsedData & {
+ organizationIntegration: OrganizationIntegration;
+};
+
+export type VercelProjectIntegrationWithProject = VercelProjectIntegrationWithData & {
+ project: {
+ id: string;
+ name: string;
+ slug: string;
+ };
+};
+
+export class VercelIntegrationService {
+ #prismaClient: PrismaClient;
+
+ constructor(prismaClient: PrismaClient = prisma) {
+ this.#prismaClient = prismaClient;
+ }
+
+ async getVercelProjectIntegration(
+ projectId: string,
+ migrateIfNeeded: boolean = false
+ ): Promise {
+ const integration = await this.#prismaClient.organizationProjectIntegration.findFirst({
+ where: {
+ projectId,
+ deletedAt: null,
+ organizationIntegration: {
+ service: "VERCEL",
+ deletedAt: null,
+ },
+ },
+ include: {
+ organizationIntegration: true,
+ },
+ });
+
+ if (!integration) {
+ return null;
+ }
+
+ const parsedData = VercelProjectIntegrationDataSchema.safeParse(integration.integrationData);
+
+ if (!parsedData.success) {
+ logger.error("Failed to parse Vercel integration data", {
+ projectId,
+ integrationId: integration.id,
+ error: parsedData.error,
+ });
+ return null;
+ }
+
+ return {
+ ...integration,
+ parsedIntegrationData: parsedData.data,
+ };
+ }
+
+ async getConnectedVercelProjects(
+ organizationId: string
+ ): Promise {
+ const integrations = await this.#prismaClient.organizationProjectIntegration.findMany({
+ where: {
+ deletedAt: null,
+ organizationIntegration: {
+ organizationId,
+ service: "VERCEL",
+ deletedAt: null,
+ },
+ },
+ include: {
+ organizationIntegration: true,
+ project: {
+ select: {
+ id: true,
+ name: true,
+ slug: true,
+ },
+ },
+ },
+ });
+
+ return integrations
+ .map((integration) => {
+ const parsedData = VercelProjectIntegrationDataSchema.safeParse(integration.integrationData);
+ if (!parsedData.success) {
+ logger.error("Failed to parse Vercel integration data", {
+ integrationId: integration.id,
+ error: parsedData.error,
+ });
+ return null;
+ }
+
+ return {
+ ...integration,
+ parsedIntegrationData: parsedData.data,
+ };
+ })
+ .filter((i): i is VercelProjectIntegrationWithProject => i !== null);
+ }
+
+ async createVercelProjectIntegration(params: {
+ organizationIntegrationId: string;
+ projectId: string;
+ vercelProjectId: string;
+ vercelProjectName: string;
+ vercelTeamId: string | null;
+ installedByUserId?: string;
+ }): Promise {
+ const integrationData = createDefaultVercelIntegrationData(
+ params.vercelProjectId,
+ params.vercelProjectName,
+ params.vercelTeamId
+ );
+
+ return this.#prismaClient.organizationProjectIntegration.create({
+ data: {
+ organizationIntegrationId: params.organizationIntegrationId,
+ projectId: params.projectId,
+ externalEntityId: params.vercelProjectId,
+ integrationData: integrationData,
+ installedBy: params.installedByUserId,
+ },
+ });
+ }
+
+ async selectVercelProject(params: {
+ organizationId: string;
+ projectId: string;
+ vercelProjectId: string;
+ vercelProjectName: string;
+ userId: string;
+ }): Promise<{
+ integration: OrganizationProjectIntegration;
+ syncResult: { success: boolean; errors: string[] };
+ }> {
+ const orgIntegration = await VercelIntegrationRepository.findVercelOrgIntegrationByOrganization(
+ params.organizationId
+ );
+
+ if (!orgIntegration) {
+ throw new Error("No Vercel organization integration found");
+ }
+
+ const teamId = await VercelIntegrationRepository.getTeamIdFromIntegration(orgIntegration);
+
+ const existing = await this.getVercelProjectIntegration(params.projectId);
+ if (existing) {
+ const updated = await this.#prismaClient.organizationProjectIntegration.update({
+ where: { id: existing.id },
+ data: {
+ externalEntityId: params.vercelProjectId,
+ integrationData: {
+ ...existing.parsedIntegrationData,
+ vercelProjectId: params.vercelProjectId,
+ vercelProjectName: params.vercelProjectName,
+ vercelTeamId: teamId,
+ },
+ },
+ });
+
+ const syncResult = await VercelIntegrationRepository.syncApiKeysToVercel({
+ projectId: params.projectId,
+ vercelProjectId: params.vercelProjectId,
+ teamId,
+ vercelStagingEnvironment: existing.parsedIntegrationData.config.vercelStagingEnvironment,
+ orgIntegration,
+ });
+
+ return { integration: updated, syncResult };
+ }
+
+ const integration = await this.createVercelProjectIntegration({
+ organizationIntegrationId: orgIntegration.id,
+ projectId: params.projectId,
+ vercelProjectId: params.vercelProjectId,
+ vercelProjectName: params.vercelProjectName,
+ vercelTeamId: teamId,
+ installedByUserId: params.userId,
+ });
+
+ const syncResult = await VercelIntegrationRepository.syncApiKeysToVercel({
+ projectId: params.projectId,
+ vercelProjectId: params.vercelProjectId,
+ teamId,
+ vercelStagingEnvironment: null,
+ orgIntegration,
+ });
+
+ try {
+ const client = await VercelIntegrationRepository.getVercelClient(orgIntegration);
+ await VercelIntegrationRepository.disableAutoAssignCustomDomains(
+ client,
+ params.vercelProjectId,
+ teamId
+ );
+ } catch (error) {
+ logger.warn("Failed to disable autoAssignCustomDomains during project selection", {
+ projectId: params.projectId,
+ vercelProjectId: params.vercelProjectId,
+ error,
+ });
+ }
+
+ logger.info("Vercel project selected and API keys synced", {
+ projectId: params.projectId,
+ vercelProjectId: params.vercelProjectId,
+ vercelProjectName: params.vercelProjectName,
+ syncSuccess: syncResult.success,
+ syncErrors: syncResult.errors,
+ });
+
+ return { integration, syncResult };
+ }
+
+ async updateVercelIntegrationConfig(
+ projectId: string,
+ configUpdates: Partial
+ ): Promise {
+ const existing = await this.getVercelProjectIntegration(projectId);
+ if (!existing) {
+ return null;
+ }
+
+ const updatedConfig = {
+ ...existing.parsedIntegrationData.config,
+ ...configUpdates,
+ };
+
+ const updatedData: VercelProjectIntegrationData = {
+ ...existing.parsedIntegrationData,
+ config: updatedConfig,
+ };
+
+ const updated = await this.#prismaClient.organizationProjectIntegration.update({
+ where: { id: existing.id },
+ data: {
+ integrationData: updatedData,
+ },
+ });
+
+ if (!updatedConfig.atomicBuilds?.includes("prod")) {
+ return { ...updated, parsedIntegrationData: updatedData };
+ }
+
+ const orgIntegration = await VercelIntegrationRepository.findVercelOrgIntegrationForProject(
+ projectId
+ );
+
+ if (orgIntegration) {
+ await this.#syncTriggerVersionToVercelProduction(
+ projectId,
+ updatedConfig.atomicBuilds,
+ orgIntegration
+ );
+ }
+
+ return {
+ ...updated,
+ parsedIntegrationData: updatedData,
+ };
+ }
+
+ async updateSyncEnvVarsMapping(
+ projectId: string,
+ syncEnvVarsMapping: SyncEnvVarsMapping
+ ): Promise {
+ const existing = await this.getVercelProjectIntegration(projectId);
+ if (!existing) {
+ return null;
+ }
+
+ const updatedData: VercelProjectIntegrationData = {
+ ...existing.parsedIntegrationData,
+ syncEnvVarsMapping,
+ };
+
+ const updated = await this.#prismaClient.organizationProjectIntegration.update({
+ where: { id: existing.id },
+ data: {
+ integrationData: updatedData,
+ },
+ });
+
+ return {
+ ...updated,
+ parsedIntegrationData: updatedData,
+ };
+ }
+
+ async updateSyncEnvVarForEnvironment(
+ projectId: string,
+ envVarKey: string,
+ environmentType: TriggerEnvironmentType,
+ syncEnabled: boolean
+ ): Promise {
+ const existing = await this.getVercelProjectIntegration(projectId);
+ if (!existing) {
+ return null;
+ }
+
+ const currentMapping = existing.parsedIntegrationData.syncEnvVarsMapping || {};
+ const envSlug = envTypeToSlug(environmentType);
+
+ const currentEnvSettings = currentMapping[envSlug] || {};
+
+ const updatedMapping: SyncEnvVarsMapping = {
+ ...currentMapping,
+ [envSlug]: {
+ ...currentEnvSettings,
+ [envVarKey]: syncEnabled,
+ },
+ };
+
+ const updatedData: VercelProjectIntegrationData = {
+ ...existing.parsedIntegrationData,
+ syncEnvVarsMapping: updatedMapping,
+ };
+
+ const updated = await this.#prismaClient.organizationProjectIntegration.update({
+ where: { id: existing.id },
+ data: {
+ integrationData: updatedData,
+ },
+ });
+
+ return {
+ ...updated,
+ parsedIntegrationData: updatedData,
+ };
+ }
+
+ async removeSyncEnvVarForEnvironment(
+ projectId: string,
+ envVarKey: string,
+ environmentType: TriggerEnvironmentType
+ ): Promise {
+ const existing = await this.getVercelProjectIntegration(projectId);
+ if (!existing) return;
+
+ const currentMapping = existing.parsedIntegrationData.syncEnvVarsMapping || {};
+ const envSlug = envTypeToSlug(environmentType);
+ const currentEnvSettings = currentMapping[envSlug];
+ if (!currentEnvSettings || !(envVarKey in currentEnvSettings)) return;
+
+ const { [envVarKey]: _, ...rest } = currentEnvSettings;
+ const updatedMapping = { ...currentMapping, [envSlug]: rest };
+
+ await this.#prismaClient.organizationProjectIntegration.update({
+ where: { id: existing.id },
+ data: {
+ integrationData: {
+ ...existing.parsedIntegrationData,
+ syncEnvVarsMapping: updatedMapping,
+ },
+ },
+ });
+ }
+
+ async completeOnboarding(
+ projectId: string,
+ params: {
+ vercelStagingEnvironment?: { environmentId: string; displayName: string } | null;
+ pullEnvVarsBeforeBuild?: EnvSlug[] | null;
+ atomicBuilds?: EnvSlug[] | null;
+ discoverEnvVars?: EnvSlug[] | null;
+ syncEnvVarsMapping: SyncEnvVarsMapping;
+ }
+ ): Promise {
+ const existing = await this.getVercelProjectIntegration(projectId);
+ if (!existing) {
+ return null;
+ }
+
+ const updatedData: VercelProjectIntegrationData = {
+ ...existing.parsedIntegrationData,
+ config: {
+ ...existing.parsedIntegrationData.config,
+ pullEnvVarsBeforeBuild: params.pullEnvVarsBeforeBuild ?? null,
+ atomicBuilds: params.atomicBuilds ?? null,
+ discoverEnvVars: params.discoverEnvVars ?? null,
+ vercelStagingEnvironment: params.vercelStagingEnvironment ?? null,
+ },
+ syncEnvVarsMapping: params.syncEnvVarsMapping ?? existing.parsedIntegrationData.syncEnvVarsMapping,
+ };
+
+ const updated = await this.#prismaClient.organizationProjectIntegration.update({
+ where: { id: existing.id },
+ data: {
+ integrationData: updatedData,
+ },
+ });
+
+ try {
+ const orgIntegration = await VercelIntegrationRepository.findVercelOrgIntegrationForProject(
+ projectId
+ );
+
+ if (!orgIntegration) {
+ return { ...updated, parsedIntegrationData: updatedData };
+ }
+
+ const teamId = await VercelIntegrationRepository.getTeamIdFromIntegration(orgIntegration);
+
+ logger.info("Vercel onboarding: pulling env vars from Vercel", {
+ projectId,
+ vercelProjectId: updatedData.vercelProjectId,
+ teamId,
+ vercelStagingEnvironment: params.vercelStagingEnvironment,
+ syncEnvVarsMappingKeys: Object.keys(params.syncEnvVarsMapping),
+ });
+
+ const pullResult = await VercelIntegrationRepository.pullEnvVarsFromVercel({
+ projectId,
+ vercelProjectId: updatedData.vercelProjectId,
+ teamId,
+ vercelStagingEnvironment: params.vercelStagingEnvironment,
+ syncEnvVarsMapping: params.syncEnvVarsMapping,
+ orgIntegration,
+ });
+
+ if (!pullResult.success) {
+ logger.warn("Some errors occurred while pulling env vars from Vercel", {
+ projectId,
+ vercelProjectId: updatedData.vercelProjectId,
+ errors: pullResult.errors,
+ syncedCount: pullResult.syncedCount,
+ });
+ } else {
+ logger.info("Successfully pulled env vars from Vercel", {
+ projectId,
+ vercelProjectId: updatedData.vercelProjectId,
+ syncedCount: pullResult.syncedCount,
+ });
+ }
+
+ await this.#syncTriggerVersionToVercelProduction(
+ projectId,
+ updatedData.config.atomicBuilds,
+ orgIntegration
+ );
+ } catch (error) {
+ logger.error("Failed to pull env vars from Vercel during onboarding", {
+ projectId,
+ vercelProjectId: updatedData.vercelProjectId,
+ error,
+ });
+ }
+
+ return {
+ ...updated,
+ parsedIntegrationData: updatedData,
+ };
+ }
+
+ async #syncTriggerVersionToVercelProduction(
+ projectId: string,
+ atomicBuilds: string[] | null | undefined,
+ orgIntegration: OrganizationIntegration & { tokenReference: SecretReference }
+ ): Promise {
+ try {
+ if (!atomicBuilds?.includes("prod")) {
+ return;
+ }
+
+ const prodEnvironment = await this.#prismaClient.runtimeEnvironment.findFirst({
+ where: {
+ projectId,
+ type: "PRODUCTION",
+ },
+ select: {
+ id: true,
+ },
+ });
+
+ if (!prodEnvironment) {
+ return;
+ }
+
+ const currentDeployment = await findCurrentWorkerDeployment({
+ environmentId: prodEnvironment.id,
+ });
+
+ if (!currentDeployment?.version) {
+ return;
+ }
+
+ const client = await VercelIntegrationRepository.getVercelClient(orgIntegration);
+ const teamId = await VercelIntegrationRepository.getTeamIdFromIntegration(orgIntegration);
+
+ // Get the Vercel project ID from the project integration
+ const projectIntegration = await this.#prismaClient.organizationProjectIntegration.findFirst({
+ where: {
+ projectId,
+ organizationIntegrationId: orgIntegration.id,
+ deletedAt: null,
+ },
+ select: {
+ externalEntityId: true,
+ },
+ });
+
+ if (!projectIntegration) {
+ return;
+ }
+
+ const vercelProjectId = projectIntegration.externalEntityId;
+
+ // Check if TRIGGER_VERSION already exists targeting production
+ const envVarsResult = await VercelIntegrationRepository.getVercelEnvironmentVariables(
+ client,
+ vercelProjectId,
+ teamId
+ );
+
+ if (!envVarsResult.success) {
+ logger.warn("Failed to fetch Vercel env vars for TRIGGER_VERSION sync", {
+ projectId,
+ vercelProjectId,
+ error: envVarsResult.error,
+ });
+ return;
+ }
+
+ const existingTriggerVersion = envVarsResult.data.find(
+ (env) => env.key === "TRIGGER_VERSION" && env.target.includes("production")
+ );
+
+ if (existingTriggerVersion) {
+ return;
+ }
+
+ // Push TRIGGER_VERSION to Vercel production
+ await client.projects.createProjectEnv({
+ idOrName: vercelProjectId,
+ ...(teamId && { teamId }),
+ upsert: "true",
+ requestBody: {
+ key: "TRIGGER_VERSION",
+ value: currentDeployment.version,
+ target: ["production"] as any,
+ type: "encrypted",
+ },
+ });
+
+ logger.info("Synced TRIGGER_VERSION to Vercel production", {
+ projectId,
+ vercelProjectId,
+ version: currentDeployment.version,
+ });
+ } catch (error) {
+ logger.error("Failed to sync TRIGGER_VERSION to Vercel production", {
+ projectId,
+ error,
+ });
+ }
+ }
+
+ async disconnectVercelProject(projectId: string): Promise {
+ const existing = await this.getVercelProjectIntegration(projectId);
+ if (!existing) {
+ return false;
+ }
+
+ await this.#prismaClient.organizationProjectIntegration.update({
+ where: { id: existing.id },
+ data: {
+ deletedAt: new Date(),
+ },
+ });
+
+ return true;
+ }
+}
+
diff --git a/apps/webapp/app/utils/pathBuilder.ts b/apps/webapp/app/utils/pathBuilder.ts
index 639f2f7294..d82d945ae7 100644
--- a/apps/webapp/app/utils/pathBuilder.ts
+++ b/apps/webapp/app/utils/pathBuilder.ts
@@ -121,6 +121,14 @@ export function organizationSettingsPath(organization: OrgForPath) {
return `${organizationPath(organization)}/settings`;
}
+export function organizationIntegrationsPath(organization: OrgForPath) {
+ return `${organizationPath(organization)}/settings/integrations`;
+}
+
+export function organizationVercelIntegrationPath(organization: OrgForPath) {
+ return `${organizationIntegrationsPath(organization)}/vercel`;
+}
+
function organizationParam(organization: OrgForPath) {
return organization.slug;
}
@@ -151,6 +159,24 @@ export function githubAppInstallPath(organizationSlug: string, redirectTo: strin
)}`;
}
+export function vercelAppInstallPath(organizationSlug: string, projectSlug: string) {
+ return `/vercel/install?org_slug=${organizationSlug}&project_slug=${projectSlug}`;
+}
+
+export function vercelCallbackPath() {
+ return `/vercel/callback`;
+}
+
+export function vercelResourcePath(
+ organization: OrgForPath,
+ project: ProjectForPath,
+ environment: EnvironmentForPath
+) {
+ return `/resources/orgs/${organizationParam(organization)}/projects/${projectParam(
+ project
+ )}/env/${environmentParam(environment)}/vercel`;
+}
+
export function v3EnvironmentPath(
organization: OrgForPath,
project: ProjectForPath,
diff --git a/apps/webapp/app/v3/environmentVariables/environmentVariablesRepository.server.ts b/apps/webapp/app/v3/environmentVariables/environmentVariablesRepository.server.ts
index 0ade9436d4..40a25f212e 100644
--- a/apps/webapp/app/v3/environmentVariables/environmentVariablesRepository.server.ts
+++ b/apps/webapp/app/v3/environmentVariables/environmentVariablesRepository.server.ts
@@ -6,9 +6,12 @@ import { env } from "~/env.server";
import { getSecretStore } from "~/services/secrets/secretStore.server";
import { generateFriendlyId } from "../friendlyIdentifiers";
import {
+ type CreateEnvironmentVariables,
type CreateResult,
type DeleteEnvironmentVariable,
type DeleteEnvironmentVariableValue,
+ type EditEnvironmentVariable,
+ type EditEnvironmentVariableValue,
type EnvironmentVariable,
type EnvironmentVariableWithSecret,
type ProjectEnvironmentVariable,
@@ -45,18 +48,7 @@ const SecretValue = z.object({ secret: z.string() });
export class EnvironmentVariablesRepository implements Repository {
constructor(private prismaClient: PrismaClient = prisma) {}
- async create(
- projectId: string,
- options: {
- override: boolean;
- environmentIds: string[];
- isSecret?: boolean;
- variables: {
- key: string;
- value: string;
- }[];
- }
- ): Promise {
+ async create(projectId: string, options: CreateEnvironmentVariables): Promise {
const project = await this.prismaClient.project.findFirst({
where: {
id: projectId,
@@ -164,10 +156,49 @@ export class EnvironmentVariablesRepository implements Repository {
prismaClient: tx,
});
+ // If parentEnvironmentId is provided and isSecret is not explicitly set,
+ // look up if the parent has this variable marked as secret
+ let inheritedIsSecret: boolean | undefined = undefined;
+ if (options.isSecret === undefined && options.parentEnvironmentId) {
+ const parentVariableValue = await tx.environmentVariableValue.findFirst({
+ where: {
+ variableId: environmentVariable.id,
+ environmentId: options.parentEnvironmentId,
+ },
+ select: {
+ isSecret: true,
+ },
+ });
+ if (parentVariableValue?.isSecret) {
+ inheritedIsSecret = true;
+ }
+ }
+
+ const effectiveIsSecret = options.isSecret ?? inheritedIsSecret;
+
//set the secret values and references
for (const environmentId of options.environmentIds) {
const key = secretKey(projectId, environmentId, variable.key);
+ const existingValueRecord = await tx.environmentVariableValue.findFirst({
+ where: {
+ variableId: environmentVariable.id,
+ environmentId,
+ },
+ });
+
+ // Check if value already exists and is the same, and no metadata change (e.g. isSecret toggle)
+ const existingSecret = await secretStore.getSecret(SecretValue, key);
+ const canSkip =
+ existingSecret &&
+ existingSecret.secret === variable.value &&
+ existingValueRecord &&
+ (options.isSecret === undefined ||
+ existingValueRecord.isSecret === options.isSecret);
+ if (canSkip) {
+ continue;
+ }
+
//create the secret reference
const secretReference = await tx.secretReference.upsert({
where: {
@@ -180,23 +211,36 @@ export class EnvironmentVariablesRepository implements Repository {
update: {},
});
- const variableValue = await tx.environmentVariableValue.upsert({
- where: {
- variableId_environmentId: {
+ if (existingValueRecord) {
+ await tx.environmentVariableValue.update({
+ where: {
+ id: existingValueRecord.id,
+ },
+ data: {
+ version: {
+ increment: 1,
+ },
+ lastUpdatedBy: options.lastUpdatedBy ? options.lastUpdatedBy : undefined,
+ valueReferenceId: secretReference.id,
+ ...(options.isSecret !== undefined
+ ? {
+ isSecret: options.isSecret,
+ }
+ : {}),
+ },
+ });
+ } else {
+ await tx.environmentVariableValue.create({
+ data: {
variableId: environmentVariable.id,
- environmentId,
+ environmentId: environmentId,
+ valueReferenceId: secretReference.id,
+ isSecret: effectiveIsSecret,
+ version: 1,
+ lastUpdatedBy: options.lastUpdatedBy ? options.lastUpdatedBy : Prisma.JsonNull,
},
- },
- create: {
- variableId: environmentVariable.id,
- environmentId: environmentId,
- valueReferenceId: secretReference.id,
- isSecret: options.isSecret,
- },
- update: {
- isSecret: options.isSecret,
- },
- });
+ });
+ }
await secretStore.setSecret<{ secret: string }>(key, {
secret: variable.value,
@@ -226,14 +270,7 @@ export class EnvironmentVariablesRepository implements Repository {
}
}
- async edit(
- projectId: string,
- options: {
- values: { value: string; environmentId: string }[];
- id: string;
- keepEmptyValues?: boolean;
- }
- ): Promise {
+ async edit(projectId: string, options: EditEnvironmentVariable): Promise {
const project = await this.prismaClient.project.findFirst({
where: {
id: projectId,
@@ -323,6 +360,20 @@ export class EnvironmentVariablesRepository implements Repository {
await secretStore.setSecret<{ secret: string }>(key, {
secret: value.value,
});
+ await tx.environmentVariableValue.update({
+ where: {
+ variableId_environmentId: {
+ variableId: environmentVariable.id,
+ environmentId: value.environmentId,
+ },
+ },
+ data: {
+ version: {
+ increment: 1,
+ },
+ lastUpdatedBy: options.lastUpdatedBy ? options.lastUpdatedBy : undefined,
+ },
+ });
}
continue;
}
@@ -340,6 +391,8 @@ export class EnvironmentVariablesRepository implements Repository {
variableId: environmentVariable.id,
environmentId: value.environmentId,
valueReferenceId: secretReference.id,
+ version: 1,
+ lastUpdatedBy: options.lastUpdatedBy ? options.lastUpdatedBy : Prisma.JsonNull,
},
});
@@ -360,14 +413,7 @@ export class EnvironmentVariablesRepository implements Repository {
}
}
- async editValue(
- projectId: string,
- options: {
- id: string;
- environmentId: string;
- value: string;
- }
- ): Promise {
+ async editValue(projectId: string, options: EditEnvironmentVariableValue): Promise {
const project = await this.prismaClient.project.findFirst({
where: {
id: projectId,
@@ -426,6 +472,21 @@ export class EnvironmentVariablesRepository implements Repository {
await secretStore.setSecret<{ secret: string }>(key, {
secret: options.value,
});
+
+ await tx.environmentVariableValue.update({
+ where: {
+ variableId_environmentId: {
+ variableId: environmentVariable.id,
+ environmentId: options.environmentId,
+ },
+ },
+ data: {
+ version: {
+ increment: 1,
+ },
+ lastUpdatedBy: options.lastUpdatedBy ? options.lastUpdatedBy : undefined,
+ },
+ });
});
return {
diff --git a/apps/webapp/app/v3/environmentVariables/repository.ts b/apps/webapp/app/v3/environmentVariables/repository.ts
index 521e22f7a2..ea027bc2ca 100644
--- a/apps/webapp/app/v3/environmentVariables/repository.ts
+++ b/apps/webapp/app/v3/environmentVariables/repository.ts
@@ -6,9 +6,25 @@ export const EnvironmentVariableKey = z
.nonempty("Key is required")
.regex(/^\w+$/, "Keys can only use alphanumeric characters and underscores");
+export const EnvironmentVariableUpdaterSchema = z.discriminatedUnion("type", [
+ z.object({
+ type: z.literal("user"),
+ userId: z.string(),
+ }),
+ z.object({
+ type: z.literal("integration"),
+ integration: z.string(),
+ }),
+]);
+export type EnvironmentVariableUpdater = z.infer;
+
export const CreateEnvironmentVariables = z.object({
+ override: z.boolean(),
environmentIds: z.array(z.string()),
+ isSecret: z.boolean().optional(),
+ parentEnvironmentId: z.string().optional(),
variables: z.array(z.object({ key: EnvironmentVariableKey, value: z.string() })),
+ lastUpdatedBy: EnvironmentVariableUpdaterSchema.optional(),
});
export type CreateEnvironmentVariables = z.infer;
@@ -32,6 +48,7 @@ export const EditEnvironmentVariable = z.object({
})
),
keepEmptyValues: z.boolean().optional(),
+ lastUpdatedBy: EnvironmentVariableUpdaterSchema.optional(),
});
export type EditEnvironmentVariable = z.infer;
@@ -51,6 +68,7 @@ export const EditEnvironmentVariableValue = z.object({
id: z.string(),
environmentId: z.string(),
value: z.string(),
+ lastUpdatedBy: EnvironmentVariableUpdaterSchema.optional(),
});
export type EditEnvironmentVariableValue = z.infer;
diff --git a/apps/webapp/app/v3/services/alerts/deliverAlert.server.ts b/apps/webapp/app/v3/services/alerts/deliverAlert.server.ts
index a27d738094..debb176da5 100644
--- a/apps/webapp/app/v3/services/alerts/deliverAlert.server.ts
+++ b/apps/webapp/app/v3/services/alerts/deliverAlert.server.ts
@@ -22,6 +22,7 @@ import { environmentTitle } from "~/components/environments/EnvironmentLabel";
import { type Prisma, type prisma, type PrismaClientOrTransaction } from "~/db.server";
import { env } from "~/env.server";
import {
+ isIntegrationForService,
type OrganizationIntegrationForService,
OrgIntegrationRepository,
} from "~/models/orgIntegration.server";
@@ -644,7 +645,7 @@ export class DeliverAlertService extends BaseService {
},
});
- if (!integration) {
+ if (!integration || !isIntegrationForService(integration, "SLACK")) {
logger.error("[DeliverAlert] Slack integration not found", {
alert,
});
diff --git a/apps/webapp/app/v3/services/initializeDeployment.server.ts b/apps/webapp/app/v3/services/initializeDeployment.server.ts
index 52a968792c..96439d94d6 100644
--- a/apps/webapp/app/v3/services/initializeDeployment.server.ts
+++ b/apps/webapp/app/v3/services/initializeDeployment.server.ts
@@ -221,6 +221,7 @@ export class InitializeDeploymentService extends BaseService {
imageReference: imageRef,
imagePlatform: env.DEPLOY_IMAGE_PLATFORM,
git: payload.gitMeta ?? undefined,
+ commitSHA: payload.gitMeta?.commitSha ?? undefined,
runtime: payload.runtime ?? undefined,
triggeredVia: payload.triggeredVia ?? undefined,
startedAt: initialStatus === "BUILDING" ? new Date() : undefined,
diff --git a/apps/webapp/app/v3/vercel/index.ts b/apps/webapp/app/v3/vercel/index.ts
new file mode 100644
index 0000000000..f34f0b64c6
--- /dev/null
+++ b/apps/webapp/app/v3/vercel/index.ts
@@ -0,0 +1,17 @@
+export * from "./vercelProjectIntegrationSchema";
+
+export function getVercelInstallParams(request: Request) {
+ const url = new URL(request.url);
+ const code = url.searchParams.get("code");
+ const configurationId = url.searchParams.get("configurationId");
+ const integration = url.searchParams.get("integration");
+ const next = url.searchParams.get("next");
+
+ if (code && configurationId && (integration === "vercel" || !integration)) {
+ return { code, configurationId, next };
+ }
+
+ return null;
+}
+
+
diff --git a/apps/webapp/app/v3/vercel/vercelOAuthState.server.ts b/apps/webapp/app/v3/vercel/vercelOAuthState.server.ts
new file mode 100644
index 0000000000..31f42acc87
--- /dev/null
+++ b/apps/webapp/app/v3/vercel/vercelOAuthState.server.ts
@@ -0,0 +1,40 @@
+import { generateJWT, validateJWT } from "@trigger.dev/core/v3/jwt";
+import { z } from "zod";
+import { env } from "~/env.server";
+
+export const VercelOAuthStateSchema = z.object({
+ organizationId: z.string(),
+ projectId: z.string(),
+ environmentSlug: z.string(),
+ organizationSlug: z.string(),
+ projectSlug: z.string(),
+});
+
+export type VercelOAuthState = z.infer;
+
+export async function generateVercelOAuthState(
+ params: VercelOAuthState
+): Promise {
+ return generateJWT({
+ secretKey: env.ENCRYPTION_KEY,
+ payload: params,
+ expirationTime: "15m",
+ });
+}
+
+export async function validateVercelOAuthState(
+ token: string
+): Promise<{ ok: true; state: VercelOAuthState } | { ok: false; error: string }> {
+ const result = await validateJWT(token, env.ENCRYPTION_KEY);
+
+ if (!result.ok) {
+ return { ok: false, error: result.error };
+ }
+
+ const parseResult = VercelOAuthStateSchema.safeParse(result.payload);
+ if (!parseResult.success) {
+ return { ok: false, error: "Invalid state payload" };
+ }
+
+ return { ok: true, state: parseResult.data };
+}
diff --git a/apps/webapp/app/v3/vercel/vercelProjectIntegrationSchema.ts b/apps/webapp/app/v3/vercel/vercelProjectIntegrationSchema.ts
new file mode 100644
index 0000000000..c8ad68bbb7
--- /dev/null
+++ b/apps/webapp/app/v3/vercel/vercelProjectIntegrationSchema.ts
@@ -0,0 +1,201 @@
+import { z } from "zod";
+
+export const EnvSlugSchema = z.enum(["dev", "stg", "prod", "preview"]);
+export type EnvSlug = z.infer;
+
+export const ALL_ENV_SLUGS: EnvSlug[] = ["dev", "stg", "prod", "preview"];
+
+/**
+ * Zod transform for form fields that submit JSON-encoded arrays.
+ * Parses the string as JSON and returns the array, or null if invalid.
+ */
+export const jsonArrayField = z.string().optional().transform((val) => {
+ if (!val) return null;
+ try {
+ const parsed = JSON.parse(val);
+ return Array.isArray(parsed) ? parsed : null;
+ } catch {
+ return null;
+ }
+});
+
+export const VercelIntegrationConfigSchema = z.object({
+ atomicBuilds: z.array(EnvSlugSchema).nullable().optional(),
+ pullEnvVarsBeforeBuild: z.array(EnvSlugSchema).nullable().optional(),
+ /** Maps a custom Vercel environment to Trigger.dev's staging environment. */
+ vercelStagingEnvironment: z.object({
+ environmentId: z.string(),
+ displayName: z.string(),
+ }).nullable().optional(),
+ discoverEnvVars: z.array(EnvSlugSchema).nullable().optional(),
+});
+
+export type VercelIntegrationConfig = z.infer;
+
+export const TriggerEnvironmentType = z.enum(["PRODUCTION", "STAGING", "PREVIEW", "DEVELOPMENT"]);
+export type TriggerEnvironmentType = z.infer;
+
+/**
+ * Per-environment, per-variable sync settings.
+ * Missing env slug = sync all vars. Missing var in env = sync by default.
+ * Only explicitly `false` entries disable sync.
+ */
+export const SyncEnvVarsMappingSchema = z.record(EnvSlugSchema, z.record(z.string(), z.boolean())).default({});
+
+export type SyncEnvVarsMapping = z.infer;
+
+export const VercelProjectIntegrationDataSchema = z.object({
+ config: VercelIntegrationConfigSchema,
+ syncEnvVarsMapping: SyncEnvVarsMappingSchema,
+ vercelProjectName: z.string(),
+ vercelTeamId: z.string().nullable(),
+ vercelProjectId: z.string(),
+});
+
+export type VercelProjectIntegrationData = z.infer;
+
+export function createDefaultVercelIntegrationData(
+ vercelProjectId: string,
+ vercelProjectName: string,
+ vercelTeamId: string | null
+): VercelProjectIntegrationData {
+ return {
+ config: {
+ atomicBuilds: ["prod"],
+ pullEnvVarsBeforeBuild: ["prod", "stg", "preview"],
+ discoverEnvVars: ["prod", "stg", "preview"],
+ vercelStagingEnvironment: null,
+ },
+ syncEnvVarsMapping: {},
+ vercelProjectId,
+ vercelProjectName,
+ vercelTeamId,
+ };
+}
+
+/**
+ * Maps a Trigger.dev environment type to its Vercel target identifier(s).
+ * Returns null for STAGING when no custom environment is configured.
+ */
+export function envTypeToVercelTarget(
+ envType: TriggerEnvironmentType,
+ stagingEnvironmentId?: string | null
+): string[] | null {
+ switch (envType) {
+ case "PRODUCTION":
+ return ["production"];
+ case "STAGING":
+ return stagingEnvironmentId ? [stagingEnvironmentId] : null;
+ case "PREVIEW":
+ return ["preview"];
+ case "DEVELOPMENT":
+ return ["development"];
+ }
+}
+
+export function getAvailableEnvSlugs(
+ hasStagingEnvironment: boolean,
+ hasPreviewEnvironment: boolean
+): EnvSlug[] {
+ return ALL_ENV_SLUGS.filter((s) => {
+ if (s === "stg" && !hasStagingEnvironment) return false;
+ if (s === "preview" && !hasPreviewEnvironment) return false;
+ return true;
+ });
+}
+
+export function getAvailableEnvSlugsForBuildSettings(
+ hasStagingEnvironment: boolean,
+ hasPreviewEnvironment: boolean
+): EnvSlug[] {
+ return getAvailableEnvSlugs(hasStagingEnvironment, hasPreviewEnvironment).filter((s) => s !== "dev");
+}
+
+export function isDiscoverEnvVarsEnabledForEnvironment(
+ discoverEnvVars: EnvSlug[] | null | undefined,
+ environmentType: TriggerEnvironmentType
+): boolean {
+ if (!discoverEnvVars || discoverEnvVars.length === 0) {
+ return false;
+ }
+ const envSlug = envTypeToSlug(environmentType);
+ return discoverEnvVars.includes(envSlug);
+}
+
+export function envTypeToSlug(environmentType: TriggerEnvironmentType): EnvSlug {
+ switch (environmentType) {
+ case "DEVELOPMENT":
+ return "dev";
+ case "STAGING":
+ return "stg";
+ case "PRODUCTION":
+ return "prod";
+ case "PREVIEW":
+ return "preview";
+ }
+}
+
+export function envSlugToType(slug: EnvSlug): TriggerEnvironmentType {
+ switch (slug) {
+ case "dev":
+ return "DEVELOPMENT";
+ case "stg":
+ return "STAGING";
+ case "prod":
+ return "PRODUCTION";
+ case "preview":
+ return "PREVIEW";
+ }
+}
+
+export function shouldSyncEnvVar(
+ mapping: SyncEnvVarsMapping,
+ envVarName: string,
+ environmentType: TriggerEnvironmentType
+): boolean {
+ const envSlug = envTypeToSlug(environmentType);
+ const envSettings = mapping[envSlug];
+ if (!envSettings) {
+ return true;
+ }
+ return envSettings[envVarName] !== false;
+}
+
+export function shouldSyncEnvVarForAnyEnvironment(
+ mapping: SyncEnvVarsMapping,
+ envVarName: string
+): boolean {
+ for (const slug of ALL_ENV_SLUGS) {
+ const envSettings = mapping[slug];
+ if (!envSettings) {
+ return true;
+ }
+ if (envSettings[envVarName] !== false) {
+ return true;
+ }
+ }
+
+ return false;
+}
+
+export function isPullEnvVarsEnabledForEnvironment(
+ pullEnvVarsBeforeBuild: EnvSlug[] | null | undefined,
+ environmentType: TriggerEnvironmentType
+): boolean {
+ if (!pullEnvVarsBeforeBuild || pullEnvVarsBeforeBuild.length === 0) {
+ return false;
+ }
+ const envSlug = envTypeToSlug(environmentType);
+ return pullEnvVarsBeforeBuild.includes(envSlug);
+}
+
+export function isAtomicBuildsEnabledForEnvironment(
+ atomicBuilds: EnvSlug[] | null | undefined,
+ environmentType: TriggerEnvironmentType
+): boolean {
+ if (!atomicBuilds || atomicBuilds.length === 0) {
+ return false;
+ }
+ const envSlug = envTypeToSlug(environmentType);
+ return atomicBuilds.includes(envSlug);
+}
diff --git a/apps/webapp/package.json b/apps/webapp/package.json
index 51a468b50c..8d3376ecee 100644
--- a/apps/webapp/package.json
+++ b/apps/webapp/package.json
@@ -129,6 +129,7 @@
"@unkey/cache": "^1.5.0",
"@unkey/error": "^0.2.0",
"@upstash/ratelimit": "^1.1.3",
+ "@vercel/sdk": "^1.18.5",
"@whatwg-node/fetch": "^0.9.14",
"ai": "^4.3.19",
"assert-never": "^1.2.1",
diff --git a/internal-packages/database/prisma/migrations/20260126175159_add_environment_variable_versioning/migration.sql b/internal-packages/database/prisma/migrations/20260126175159_add_environment_variable_versioning/migration.sql
new file mode 100644
index 0000000000..17f013f388
--- /dev/null
+++ b/internal-packages/database/prisma/migrations/20260126175159_add_environment_variable_versioning/migration.sql
@@ -0,0 +1,3 @@
+-- AlterTable
+ALTER TABLE "public"."EnvironmentVariableValue" ADD COLUMN "lastUpdatedBy" JSONB,
+ADD COLUMN "version" INTEGER NOT NULL DEFAULT 1;
diff --git a/internal-packages/database/prisma/migrations/20260129162621_add_organization_project_integration/migration.sql b/internal-packages/database/prisma/migrations/20260129162621_add_organization_project_integration/migration.sql
new file mode 100644
index 0000000000..2c18bd2e1d
--- /dev/null
+++ b/internal-packages/database/prisma/migrations/20260129162621_add_organization_project_integration/migration.sql
@@ -0,0 +1,29 @@
+-- CreateTable
+CREATE TABLE "public"."OrganizationProjectIntegration" (
+ "id" TEXT NOT NULL,
+ "organizationIntegrationId" TEXT NOT NULL,
+ "projectId" TEXT NOT NULL,
+ "externalEntityId" TEXT NOT NULL,
+ "integrationData" JSONB NOT NULL,
+ "installedBy" TEXT,
+ "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+ "updatedAt" TIMESTAMP(3) NOT NULL,
+ "deletedAt" TIMESTAMP(3),
+
+ CONSTRAINT "OrganizationProjectIntegration_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE INDEX "OrganizationProjectIntegration_projectId_idx" ON "public"."OrganizationProjectIntegration"("projectId");
+
+-- CreateIndex
+CREATE INDEX "OrganizationProjectIntegration_projectId_organizationIntegr_idx" ON "public"."OrganizationProjectIntegration"("projectId", "organizationIntegrationId");
+
+-- CreateIndex
+CREATE INDEX "OrganizationProjectIntegration_externalEntityId_idx" ON "public"."OrganizationProjectIntegration"("externalEntityId");
+
+-- AddForeignKey
+ALTER TABLE "public"."OrganizationProjectIntegration" ADD CONSTRAINT "OrganizationProjectIntegration_organizationIntegrationId_fkey" FOREIGN KEY ("organizationIntegrationId") REFERENCES "public"."OrganizationIntegration"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "public"."OrganizationProjectIntegration" ADD CONSTRAINT "OrganizationProjectIntegration_projectId_fkey" FOREIGN KEY ("projectId") REFERENCES "public"."Project"("id") ON DELETE CASCADE ON UPDATE CASCADE;
diff --git a/internal-packages/database/prisma/migrations/20260129162810_add_integration_deployment/migration.sql b/internal-packages/database/prisma/migrations/20260129162810_add_integration_deployment/migration.sql
new file mode 100644
index 0000000000..5594398d06
--- /dev/null
+++ b/internal-packages/database/prisma/migrations/20260129162810_add_integration_deployment/migration.sql
@@ -0,0 +1,21 @@
+-- CreateTable
+CREATE TABLE "public"."IntegrationDeployment" (
+ "id" TEXT NOT NULL,
+ "integrationName" TEXT NOT NULL,
+ "integrationDeploymentId" TEXT NOT NULL,
+ "commitSHA" TEXT NOT NULL,
+ "deploymentId" TEXT,
+ "status" TEXT,
+ "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+ CONSTRAINT "IntegrationDeployment_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE INDEX "IntegrationDeployment_deploymentId_idx" ON "public"."IntegrationDeployment"("deploymentId");
+
+-- CreateIndex
+CREATE INDEX "IntegrationDeployment_commitSHA_idx" ON "public"."IntegrationDeployment"("commitSHA");
+
+-- AddForeignKey
+ALTER TABLE "public"."IntegrationDeployment" ADD CONSTRAINT "IntegrationDeployment_deploymentId_fkey" FOREIGN KEY ("deploymentId") REFERENCES "public"."WorkerDeployment"("id") ON DELETE SET NULL ON UPDATE CASCADE;
\ No newline at end of file
diff --git a/internal-packages/database/prisma/migrations/20260129162946_alter_tables_for_integrations_data/migration.sql b/internal-packages/database/prisma/migrations/20260129162946_alter_tables_for_integrations_data/migration.sql
new file mode 100644
index 0000000000..345d337f18
--- /dev/null
+++ b/internal-packages/database/prisma/migrations/20260129162946_alter_tables_for_integrations_data/migration.sql
@@ -0,0 +1,9 @@
+-- AlterEnum
+ALTER TYPE "public"."IntegrationService" ADD VALUE 'VERCEL';
+
+-- AlterTable
+ALTER TABLE "public"."OrganizationIntegration" ADD COLUMN "deletedAt" TIMESTAMP(3),
+ADD COLUMN "externalOrganizationId" TEXT;
+
+-- AlterTable
+ALTER TABLE "public"."WorkerDeployment" ADD COLUMN "commitSHA" TEXT;
diff --git a/internal-packages/database/prisma/migrations/20260129165555_add_organization_integration_idx/migration.sql b/internal-packages/database/prisma/migrations/20260129165555_add_organization_integration_idx/migration.sql
new file mode 100644
index 0000000000..ac24fc4bdb
--- /dev/null
+++ b/internal-packages/database/prisma/migrations/20260129165555_add_organization_integration_idx/migration.sql
@@ -0,0 +1,3 @@
+-- CreateIndex
+CREATE INDEX CONCURRENTLY IF NOT EXISTS "OrganizationIntegration_externalOrganizationId_idx" ON "public"."OrganizationIntegration"("externalOrganizationId");
+
diff --git a/internal-packages/database/prisma/migrations/20260129165809_add_worker_deployment_idx/migration.sql b/internal-packages/database/prisma/migrations/20260129165809_add_worker_deployment_idx/migration.sql
new file mode 100644
index 0000000000..fcf74c0d97
--- /dev/null
+++ b/internal-packages/database/prisma/migrations/20260129165809_add_worker_deployment_idx/migration.sql
@@ -0,0 +1,3 @@
+
+-- CreateIndex
+CREATE INDEX CONCURRENTLY IF NOT EXISTS "WorkerDeployment_commitSHA_idx" ON "public"."WorkerDeployment"("commitSHA");
\ No newline at end of file
diff --git a/internal-packages/database/prisma/schema.prisma b/internal-packages/database/prisma/schema.prisma
index c76b411412..d0fd08b45a 100644
--- a/internal-packages/database/prisma/schema.prisma
+++ b/internal-packages/database/prisma/schema.prisma
@@ -384,28 +384,29 @@ model Project {
/// The master queues they are allowed to use (impacts what they can set as default and trigger runs with)
allowedWorkerQueues String[] @default([]) @map("allowedMasterQueues")
- environments RuntimeEnvironment[]
- backgroundWorkers BackgroundWorker[]
- backgroundWorkerTasks BackgroundWorkerTask[]
- taskRuns TaskRun[]
- runTags TaskRunTag[]
- taskQueues TaskQueue[]
- environmentVariables EnvironmentVariable[]
- checkpoints Checkpoint[]
- WorkerDeployment WorkerDeployment[]
- CheckpointRestoreEvent CheckpointRestoreEvent[]
- taskSchedules TaskSchedule[]
- alertChannels ProjectAlertChannel[]
- alerts ProjectAlert[]
- alertStorages ProjectAlertStorage[]
- bulkActionGroups BulkActionGroup[]
- BackgroundWorkerFile BackgroundWorkerFile[]
- waitpoints Waitpoint[]
- taskRunWaitpoints TaskRunWaitpoint[]
- taskRunCheckpoints TaskRunCheckpoint[]
- waitpointTags WaitpointTag[]
- connectedGithubRepository ConnectedGithubRepository?
- customerQueries CustomerQuery[]
+ environments RuntimeEnvironment[]
+ backgroundWorkers BackgroundWorker[]
+ backgroundWorkerTasks BackgroundWorkerTask[]
+ taskRuns TaskRun[]
+ runTags TaskRunTag[]
+ taskQueues TaskQueue[]
+ environmentVariables EnvironmentVariable[]
+ checkpoints Checkpoint[]
+ WorkerDeployment WorkerDeployment[]
+ CheckpointRestoreEvent CheckpointRestoreEvent[]
+ taskSchedules TaskSchedule[]
+ alertChannels ProjectAlertChannel[]
+ alerts ProjectAlert[]
+ alertStorages ProjectAlertStorage[]
+ bulkActionGroups BulkActionGroup[]
+ BackgroundWorkerFile BackgroundWorkerFile[]
+ waitpoints Waitpoint[]
+ taskRunWaitpoints TaskRunWaitpoint[]
+ taskRunCheckpoints TaskRunCheckpoint[]
+ waitpointTags WaitpointTag[]
+ connectedGithubRepository ConnectedGithubRepository?
+ organizationProjectIntegration OrganizationProjectIntegration[]
+ customerQueries CustomerQuery[]
buildSettings Json?
taskScheduleInstances TaskScheduleInstance[]
@@ -1712,6 +1713,9 @@ model EnvironmentVariableValue {
createdAt DateTime @default(now())
updatedAt DateTime @updatedAt
+ version Int @default(1)
+ lastUpdatedBy Json?
+
@@unique([variableId, environmentId])
}
@@ -1825,9 +1829,10 @@ model WorkerDeployment {
worker BackgroundWorker? @relation(fields: [workerId], references: [id], onDelete: Cascade, onUpdate: Cascade)
workerId String? @unique
- triggeredBy User? @relation(fields: [triggeredById], references: [id], onDelete: SetNull, onUpdate: Cascade)
- triggeredById String?
- triggeredVia String?
+ triggeredBy User? @relation(fields: [triggeredById], references: [id], onDelete: SetNull, onUpdate: Cascade)
+ triggeredById String?
+ triggeredVia String?
+ commitSHA String?
startedAt DateTime?
installedAt DateTime?
@@ -1846,12 +1851,14 @@ model WorkerDeployment {
createdAt DateTime @default(now())
updatedAt DateTime @updatedAt
- promotions WorkerDeploymentPromotion[]
- alerts ProjectAlert[]
- workerInstance WorkerInstance[]
+ promotions WorkerDeploymentPromotion[]
+ alerts ProjectAlert[]
+ workerInstance WorkerInstance[]
+ integrationDeployments IntegrationDeployment[]
@@unique([projectId, shortCode])
@@unique([environmentId, version])
+ @@index([commitSHA])
}
enum WorkerDeploymentStatus {
@@ -2088,7 +2095,8 @@ model OrganizationIntegration {
friendlyId String @unique
- service IntegrationService
+ service IntegrationService
+ externalOrganizationId String? /// Identifier for external, integration's organization (e.g. Vercel's team)
integrationData Json
@@ -2100,12 +2108,39 @@ model OrganizationIntegration {
createdAt DateTime @default(now())
updatedAt DateTime @updatedAt
+ deletedAt DateTime?
- alertChannels ProjectAlertChannel[]
+ alertChannels ProjectAlertChannel[]
+ organizationProjectIntegration OrganizationProjectIntegration[]
+
+ @@index([externalOrganizationId])
+}
+
+model OrganizationProjectIntegration {
+ id String @id @default(cuid())
+
+ organizationIntegration OrganizationIntegration @relation(fields: [organizationIntegrationId], references: [id], onDelete: Cascade, onUpdate: Cascade)
+ organizationIntegrationId String
+
+ project Project @relation(fields: [projectId], references: [id], onDelete: Cascade, onUpdate: Cascade)
+ projectId String
+
+ externalEntityId String /// Identifier for webhooks, for example Vercel's projectId
+ integrationData Json /// Save useful data like config or external entity name
+ installedBy String? /// UserId who installed the integration
+
+ createdAt DateTime @default(now())
+ updatedAt DateTime @updatedAt
+ deletedAt DateTime?
+
+ @@index([projectId])
+ @@index([projectId, organizationIntegrationId])
+ @@index([externalEntityId])
}
enum IntegrationService {
SLACK
+ VERCEL
}
/// Bulk actions, like canceling and replaying runs
@@ -2486,3 +2521,20 @@ model CustomerQuery {
/// For Stripe metering job - find unprocessed queries
@@index([createdAt])
}
+
+model IntegrationDeployment {
+ id String @id @default(cuid())
+
+ integrationName String /// For example Vercel
+ integrationDeploymentId String /// External ID
+ commitSHA String
+ deploymentId String?
+ status String? /// External deployment status
+
+ workerDeployment WorkerDeployment? @relation(fields: [deploymentId], references: [id], onDelete: SetNull, onUpdate: Cascade)
+
+ createdAt DateTime @default(now())
+
+ @@index([commitSHA])
+ @@index([deploymentId])
+}
diff --git a/packages/core/src/v3/schemas/api.ts b/packages/core/src/v3/schemas/api.ts
index 0291d2a05c..4cb5c96503 100644
--- a/packages/core/src/v3/schemas/api.ts
+++ b/packages/core/src/v3/schemas/api.ts
@@ -694,6 +694,7 @@ export const GetDeploymentResponseBody = z.object({
version: z.string(),
imageReference: z.string().nullish(),
imagePlatform: z.string(),
+ commitSHA: z.string().nullish(),
externalBuildData: ExternalBuildData.optional().nullable(),
errorData: DeploymentErrorData.nullish(),
worker: z
@@ -710,6 +711,17 @@ export const GetDeploymentResponseBody = z.object({
),
})
.optional(),
+ integrationDeployments: z
+ .array(
+ z.object({
+ id: z.string(),
+ integrationName: z.string(),
+ integrationDeploymentId: z.string(),
+ commitSHA: z.string(),
+ createdAt: z.coerce.date(),
+ })
+ )
+ .nullish(),
});
export type GetDeploymentResponseBody = z.infer;
@@ -1139,6 +1151,12 @@ export const ImportEnvironmentVariablesRequestBody = z.object({
variables: z.record(z.string()),
parentVariables: z.record(z.string()).optional(),
override: z.boolean().optional(),
+ source: z
+ .discriminatedUnion("type", [
+ z.object({ type: z.literal("user"), userId: z.string() }),
+ z.object({ type: z.literal("integration"), integration: z.string() }),
+ ])
+ .optional(),
});
export type ImportEnvironmentVariablesRequestBody = z.infer<
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 99024a016b..b963c79a92 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -521,6 +521,9 @@ importers:
'@upstash/ratelimit':
specifier: ^1.1.3
version: 1.1.3(patch_hash=e5922e50fbefb7b2b24950c4b1c5c9ddc4cd25464439c9548d2298c432debe74)
+ '@vercel/sdk':
+ specifier: ^1.18.5
+ version: 1.18.5
'@whatwg-node/fetch':
specifier: ^0.9.14
version: 0.9.14
@@ -11115,6 +11118,10 @@ packages:
engines: {node: '>=18.14'}
deprecated: '@vercel/postgres is deprecated. You can either choose an alternate storage solution from the Vercel Marketplace if you want to set up a new database. Or you can follow this guide to migrate your existing Vercel Postgres db: https://neon.com/docs/guides/vercel-postgres-transition-guide'
+ '@vercel/sdk@1.18.5':
+ resolution: {integrity: sha512-tzxGuUxYZQpKsf5WrImp4gnCZu3xhHA4j6KLSAQdXgpi/Lfk3JV5YGEDU6ZZBIwXDMdny5DozLd20tz/bKZsfg==}
+ hasBin: true
+
'@vitest/coverage-v8@3.1.4':
resolution: {integrity: sha512-G4p6OtioySL+hPV7Y6JHlhpsODbJzt1ndwHAFkyk6vVjpK03PFsKnauZIzcd0PrK4zAbc5lc+jeZ+eNGiMA+iw==}
peerDependencies:
@@ -31330,6 +31337,15 @@ snapshots:
transitivePeerDependencies:
- utf-8-validate
+ '@vercel/sdk@1.18.5':
+ dependencies:
+ '@modelcontextprotocol/sdk': 1.25.2(hono@4.5.11)(supports-color@10.0.0)(zod@3.25.76)
+ zod: 3.25.76
+ transitivePeerDependencies:
+ - '@cfworker/json-schema'
+ - hono
+ - supports-color
+
'@vitest/coverage-v8@3.1.4(vitest@3.1.4(@types/debug@4.1.12)(@types/node@20.14.14)(lightningcss@1.29.2)(terser@5.44.1))':
dependencies:
'@ampproject/remapping': 2.3.0