triggerdotdev
diff --git a/‎.changeset/cli-login-poll-window.md‎
Lines changed: 6 additions & 0 deletions b/‎.changeset/cli-login-poll-window.md‎
Lines changed: 6 additions & 0 deletions
diff --git a/‎apps/webapp/app/routes/account.authorization-code.$authorizationCode/route.tsx‎
Lines changed: 121 additions & 50 deletions b/‎apps/webapp/app/routes/account.authorization-code.$authorizationCode/route.tsx‎
Lines changed: 121 additions & 50 deletions
diff --git a/‎apps/webapp/app/routes/api.v1.authorization-code.ts‎
Lines changed: 23 additions & 2 deletions b/‎apps/webapp/app/routes/api.v1.authorization-code.ts‎
Lines changed: 23 additions & 2 deletions
diff --git a/‎apps/webapp/app/routes/api.v1.token.ts‎
Lines changed: 18 additions & 0 deletions b/‎apps/webapp/app/routes/api.v1.token.ts‎
Lines changed: 18 additions & 0 deletions
diff --git a/‎apps/webapp/app/services/apiRateLimit.server.ts‎
Lines changed: 3 additions & 0 deletions b/‎apps/webapp/app/services/apiRateLimit.server.ts‎
Lines changed: 3 additions & 0 deletions
@@ -0,0 +1,6 @@
+---
+"@trigger.dev/core": patch
+"trigger.dev": patch
+---
+
+Require explicit browser approval for CLI and MCP login, with resilient polling while approval is pending.
@@ -1,14 +1,19 @@
 import { CheckCircleIcon } from "@heroicons/react/24/solid";
-import type { LoaderFunctionArgs } from "@remix-run/server-runtime";
-import { typedjson, useTypedLoaderData } from "remix-typedjson";
+import { Form } from "@remix-run/react";
+import type { ActionFunctionArgs, LoaderFunctionArgs } from "@remix-run/server-runtime";
+import { typedjson, useTypedActionData, useTypedLoaderData } from "remix-typedjson";
 import { z } from "zod";
 import { AppContainer, MainCenteredContainer } from "~/components/layout/AppLayout";
+import { Button } from "~/components/primitives/Buttons";
 import { Callout } from "~/components/primitives/Callout";
 import { Header1 } from "~/components/primitives/Headers";
 import { Icon } from "~/components/primitives/Icon";
 import { Paragraph } from "~/components/primitives/Paragraph";
 import { logger } from "~/services/logger.server";
-import { createPersonalAccessTokenFromAuthorizationCode } from "~/services/personalAccessToken.server";
+import {
+  createPersonalAccessTokenFromAuthorizationCode,
+  isAuthorizationCodeMintable,
+} from "~/services/personalAccessToken.server";
 import { requireUserId } from "~/services/session.server";
 
 const ParamsSchema = z.object({
@@ -20,49 +25,57 @@ const SearchParamsSchema = z.object({
   clientName: z.string().optional(),
 });
 
-export const loader = async ({ request, params }: LoaderFunctionArgs) => {
-  const userId = await requireUserId(request);
-
+function parseParams(params: unknown) {
   const parsedParams = ParamsSchema.safeParse(params);
-
   if (!parsedParams.success) {
     logger.info("Invalid params", { params });
-    throw new Response(undefined, {
-      status: 400,
-      statusText: "Invalid params",
-    });
+    throw new Response(undefined, { status: 400, statusText: "Invalid params" });
   }
+  return parsedParams.data;
+}
 
+function parseSearch(request: Request) {
   const url = new URL(request.url);
   const searchObject = Object.fromEntries(url.searchParams.entries());
-
   const searchParams = SearchParamsSchema.safeParse(searchObject);
-
   const source = (searchParams.success ? searchParams.data.source : undefined) ?? "cli";
   const clientName = (searchParams.success ? searchParams.data.clientName : undefined) ?? "unknown";
+  return { source, clientName };
+}
+
+// The loader only renders a consent screen; minting/binding a PAT happens in
+// the `action`, behind an explicit "Authorize" POST.
+export const loader = async ({ request, params }: LoaderFunctionArgs) => {
+  await requireUserId(request);
+
+  const { authorizationCode } = parseParams(params);
+  const { source, clientName } = parseSearch(request);
+
+  const mintable = await isAuthorizationCodeMintable(authorizationCode);
+
+  return typedjson({
+    status: mintable ? ("consent" as const) : ("invalid" as const),
+    source,
+    clientName,
+  });
+};
+
+export const action = async ({ request, params }: ActionFunctionArgs) => {
+  const userId = await requireUserId(request);
+
+  const { authorizationCode } = parseParams(params);
+  const { source, clientName } = parseSearch(request);
 
   try {
-    const _personalAccessToken = await createPersonalAccessTokenFromAuthorizationCode(
-      parsedParams.data.authorizationCode,
-      userId
-    );
-    return typedjson({
-      success: true as const,
-      source,
-      clientName,
-    });
+    await createPersonalAccessTokenFromAuthorizationCode(authorizationCode, userId);
+    return typedjson({ success: true as const, source, clientName });
   } catch (error) {
     if (error instanceof Response) {
       throw error;
     }
 
     if (error instanceof Error) {
-      return typedjson({
-        success: false as const,
-        error: error.message,
-        source,
-        clientName,
-      });
+      return typedjson({ success: false as const, error: error.message, source, clientName });
     }
 
     logger.error(JSON.stringify(error));
@@ -74,32 +87,78 @@ export const loader = async ({ request, params }: LoaderFunctionArgs) => {
 };
 
 export default function Page() {
-  const result = useTypedLoaderData<typeof loader>();
+  const loaderData = useTypedLoaderData<typeof loader>();
+  const actionData = useTypedActionData<typeof action>();
+
+  // After the consent POST: success or failure.
+  if (actionData) {
+    return (
+      <AuthShell>
+        {actionData.success ? (
+          <div>
+            <Header1 className="mb-2 flex items-center gap-1">
+              <Icon icon={CheckCircleIcon} className="h-6 w-6 text-emerald-500" /> Successfully
+              authenticated
+            </Header1>
+            <Paragraph>
+              {getInstructionsForSource(actionData.source, actionData.clientName)}
+            </Paragraph>
+          </div>
+        ) : (
+          <div>
+            <Header1 className="mb-2">Authentication failed</Header1>
+            <Callout variant="error" className="my-2">
+              {actionData.error}
+            </Callout>
+            <Paragraph spacing>
+              There was a problem authenticating you, please try logging in with your CLI again.
+            </Paragraph>
+          </div>
+        )}
+      </AuthShell>
+    );
+  }
+
+  // Initial GET: invalid/expired code, or the consent prompt.
+  if (loaderData.status === "invalid") {
+    return (
+      <AuthShell>
+        <div>
+          <Header1 className="mb-2">Authentication failed</Header1>
+          <Callout variant="error" className="my-2">
+            This login link is invalid or has expired.
+          </Callout>
+          <Paragraph spacing>
+            Please try logging in with your CLI again to get a fresh link.
+          </Paragraph>
+        </div>
+      </AuthShell>
+    );
+  }
 
+  return (
+    <AuthShell>
+      <div className="flex flex-col gap-4">
+        <Header1>Authorize login</Header1>
+        <Paragraph>{getConsentPrompt(loaderData.source, loaderData.clientName)}</Paragraph>
+        <Form method="post">
+          <Button type="submit" variant="primary/medium" fullWidth>
+            Authorize
+          </Button>
+        </Form>
+        <Paragraph variant="extra-small">
+          Only authorize if you started this login yourself. If you didn't, close this page.
+        </Paragraph>
+      </div>
+    </AuthShell>
+  );
+}
+
+function AuthShell({ children }: { children: React.ReactNode }) {
   return (
     <AppContainer>
       <MainCenteredContainer className="max-w-88">
-        <div className="flex flex-col items-center space-y-4">
-          {result.success ? (
-            <div>
-              <Header1 className="mb-2 flex items-center gap-1">
-                <Icon icon={CheckCircleIcon} className="h-6 w-6 text-emerald-500" /> Successfully
-                authenticated
-              </Header1>
-              <Paragraph>{getInstructionsForSource(result.source, result.clientName)}</Paragraph>
-            </div>
-          ) : (
-            <div>
-              <Header1 className="mb-2">Authentication failed</Header1>
-              <Callout variant="error" className="my-2">
-                {result.error}
-              </Callout>
-              <Paragraph spacing>
-                There was a problem authenticating you, please try logging in with your CLI again.
-              </Paragraph>
-            </div>
-          )}
-        </div>
+        <div className="flex flex-col items-center space-y-4">{children}</div>
       </MainCenteredContainer>
     </AppContainer>
   );
@@ -113,6 +172,18 @@ const prettyClientNames: Record<string, string> = {
   "claude-ai": "Claude Desktop",
 };
 
+function getConsentPrompt(source: string, clientName: string) {
+  if (source === "mcp") {
+    const pretty = prettyClientNames[clientName] ?? clientName;
+    if (pretty && pretty !== "unknown") {
+      return `Authorize ${pretty} to access your Trigger.dev account?`;
+    }
+    return `Authorize this MCP client to access your Trigger.dev account?`;
+  }
+
+  return `Authorize the Trigger.dev CLI to access your account?`;
+}
+
 function getInstructionsForSource(source: string, clientName: string) {
   if (source === "mcp") {
     if (clientName) {
 
@@ -3,7 +3,12 @@ import { json } from "@remix-run/server-runtime";
 import type { CreateAuthorizationCodeResponse } from "@trigger.dev/core/v3";
 import { env } from "~/env.server";
 import { logger } from "~/services/logger.server";
+import {
+  AuthorizationCodeRateLimitError,
+  checkAuthorizationCodeMintRateLimit,
+} from "~/services/authCodeRateLimiter.server";
 import { createAuthorizationCode } from "~/services/personalAccessToken.server";
+import { extractClientIp } from "~/utils/extractClientIp.server";
 
 /** Used to create an AuthorizationCode, that can then be used to obtain a Personal Access Token by logging in with the provided URL */
 export async function action({ request }: ActionFunctionArgs) {
@@ -14,8 +19,24 @@ export async function action({ request }: ActionFunctionArgs) {
     return { status: 405, body: "Method Not Allowed" };
   }
 
-  //there is no authentication on this endpoint, anyone can create an AuthorizationCode.
-  //they're only used to allow a user to login, when they'll then receive a Personal Access Token
+  //this endpoint is unauthenticated (codes only allow a user to log in), so it's
+  //rate-limited per client IP. Keyed by X-Forwarded-For; if there's no trustworthy
+  //client IP we skip the limit rather than bucket everyone together. Self-hosters
+  //wanting per-IP limiting should front the app with a proxy that sets X-Forwarded-For.
+  const clientIp = extractClientIp(request.headers.get("x-forwarded-for"));
+  if (clientIp) {
+    try {
+      await checkAuthorizationCodeMintRateLimit(clientIp);
+    } catch (error) {
+      if (error instanceof AuthorizationCodeRateLimitError) {
+        return json(
+          { error: "Too many requests, please try again later." },
+          { status: 429, headers: { "Retry-After": Math.ceil(error.retryAfter / 1000).toString() } }
+        );
+      }
+      throw error;
+    }
+  }
 
   try {
     const authorizationCode = await createAuthorizationCode();
 
@@ -4,6 +4,10 @@ import type { GetPersonalAccessTokenResponse } from "@trigger.dev/core/v3";
 import { GetPersonalAccessTokenRequestSchema } from "@trigger.dev/core/v3";
 import { generateErrorMessage } from "zod-error";
 import { logger } from "~/services/logger.server";
+import {
+  AuthorizationCodeRateLimitError,
+  checkAuthorizationCodeTokenPollRateLimit,
+} from "~/services/authCodeRateLimiter.server";
 import { getPersonalAccessTokenFromAuthorizationCode } from "~/services/personalAccessToken.server";
 import { clientSafeErrorMessage } from "~/utils/prismaErrors";
 
@@ -25,6 +29,20 @@ export async function action({ request }: ActionFunctionArgs) {
     return json({ error: generateErrorMessage(body.error.issues) }, { status: 422 });
   }
 
+  // Per-code rate limit (keyed by the code, not the IP, so the CLI's poll loop
+  // isn't broken behind a shared NAT).
+  try {
+    await checkAuthorizationCodeTokenPollRateLimit(body.data.authorizationCode);
+  } catch (error) {
+    if (error instanceof AuthorizationCodeRateLimitError) {
+      return json(
+        { error: "Too many requests, please try again later." },
+        { status: 429, headers: { "Retry-After": Math.ceil(error.retryAfter / 1000).toString() } }
+      );
+    }
+    throw error;
+  }
+
   try {
     const personalAccessToken = await getPersonalAccessTokenFromAuthorizationCode(
       body.data.authorizationCode
 
@@ -48,6 +48,9 @@ export const apiRateLimiter = authorizationRateLimitMiddleware({
   // Allow /api/v1/tasks/:id/callback/:secret
   pathWhiteList: [
     "/api/internal/stripe_webhooks",
+    // Keep allowlisted: these CLI endpoints are intentionally unauthenticated,
+    // so this Authorization-header-keyed limiter would 401 them. They are
+    // throttled separately by authCodeRateLimiter.server.ts.
     "/api/v1/authorization-code",
     "/api/v1/token",
     "/api/v1/usage/ingest",