Merge branch 'feat/dashboard-agent-flows' into feat/dashboard-agent-ui

Author: kathiekiwi

apps/webapp/app/routes/api.v1.projects.$projectRef.$env.jwt.ts

@@ -1,18 +1,17 @@
 import { type ActionFunctionArgs, json } from "@remix-run/node";
 import { generateJWT as internal_generateJWT } from "@trigger.dev/core/v3";
+import { isUserActorToken, verifyUserActorToken, type UserActorClaims } from "@trigger.dev/rbac";
 import { z } from "zod";
 import {
   authenticatedEnvironmentForAuthentication,
+  authenticateRequest,
   branchNameFromRequest,
+  type AuthenticationResult,
 } from "~/services/apiAuth.server";
+import { env as appEnv } from "~/env.server";
+import { assertUserActorEnvironment } from "~/services/userActorEnvironment.server";
 import { logger } from "~/services/logger.server";
 import { authorizePatEnvironmentAccess } from "~/services/environmentVariableApiAccess.server";
-import { authenticateUatOrApiRequest } from "~/services/uatRoutePreamble.server";
-import { rbac } from "~/services/rbac.server";
-import {
-  assertUserActorEnvironment,
-  clampUserActorScopes,
-} from "~/services/userActorEnvironment.server";
 
 const ParamsSchema = z.object({
   projectRef: z.string(),
@@ -30,17 +29,46 @@ const RequestBodySchema = z.object({
 
 export async function action({ request, params }: ActionFunctionArgs) {
   try {
-    // A user-actor token authenticates as its user, like a PAT. Its scope cap ceilings the
+    const bearer = request.headers
+      .get("Authorization")
+      ?.replace(/^Bearer /, "")
+      .trim();
+    const isUat = !!bearer && isUserActorToken(bearer);
+
+    // A delegated user-actor token authenticates as its user, like a PAT. We
+    // resolve it here (not through authenticateRequest) so the exchange stays
+    // scoped to this route — UATs deliberately aren't accepted on every
+    // PAT route. `uatCap` (the token's optional scope cap) ceilings the
     // minted env JWT below.
-    const authentication = await authenticateUatOrApiRequest(request);
+    let uatCap: string[] | undefined;
+    let userActorId: string | undefined;
+    let userActor: UserActorClaims | undefined;
+    let authenticationResult: AuthenticationResult | undefined;
+    if (isUat) {
+      const claims = await verifyUserActorToken(appEnv.SESSION_SECRET, bearer!);
+      if (!claims) {
+        return json({ error: "Invalid or Missing Access Token" }, { status: 401 });
+      }
+      uatCap = claims.cap;
+      userActorId = claims.userId;
+      userActor = claims;
+      // The env lookup keys purely on the user, identical to a PAT.
+      authenticationResult = {
+        type: "personalAccessToken",
+        result: { userId: claims.userId },
+      };
+    } else {
+      authenticationResult = await authenticateRequest(request, {
+        personalAccessToken: true,
+        organizationAccessToken: true,
+        apiKey: false,
+      });
+    }
 
-    if (!authentication) {
+    if (!authenticationResult) {
       return json({ error: "Invalid or Missing Access Token" }, { status: 401 });
     }
 
-    const { authenticationResult, userActor } = authentication;
-    const userActorId = userActor?.userId;
-
     const parsedParams = ParamsSchema.safeParse(params);
 
     if (!parsedParams.success) {
@@ -57,7 +85,7 @@ export async function action({ request, params }: ActionFunctionArgs) {
       triggerBranch
     );
 
-    // The exchange only ever mints for the environment the token was signed for.
+    // A user-actor token signed for one environment mints only for that one.
     assertUserActorEnvironment(userActor, runtimeEnv.id);
 
     // This mints a JWT signed with the environment's secret key. For a PAT
@@ -83,32 +111,21 @@ export async function action({ request, params }: ActionFunctionArgs) {
       );
     }
 
-    // The env JWT carries scopes only — downstream auth builds its ability from them with no role
-    // context. So for a user-actor token the ceiling is the actor's own ability (role floor ∩ the
-    // token's cap), never the request: a delegated token can't mint a credential more capable than
-    // itself, and a capless token is read-only rather than unbounded. A PAT passes through, gated
-    // by the env-tier check above.
+    // The env JWT carries scopes only — downstream auth builds its ability
+    // from them with no role context. So for a user-actor token we ceiling
+    // the scopes by the token's own cap here (a read-only agent token can't
+    // widen its grant through the exchange) and stamp the user via `act` so
+    // the minted env JWT stays attributable. The cap is a ceiling, not a
+    // replacement: intersect what the caller asked for with the cap (or use
+    // the full cap if they asked for nothing). No cap → the request passes
+    // through, same as a PAT.
     const requestedScopes = parsedBody.data.claims?.scopes;
-    let scopes = requestedScopes;
-
-    if (userActor) {
-      const actorAuth = await rbac.authenticateUserActor(request, {
-        organizationId: runtimeEnv.organizationId,
-        projectId: runtimeEnv.project.id,
-      });
-      if (!actorAuth.ok) {
-        return json({ error: actorAuth.error }, { status: actorAuth.status });
-      }
-
-      const clamped = clampUserActorScopes(requestedScopes, userActor, actorAuth.ability);
-      if (clamped.scopes.length === 0) {
-        return json(
-          { error: "This token isn't allowed the requested scopes", scopes: clamped.deniedScopes },
-          { status: 403 }
-        );
-      }
-      scopes = clamped.scopes;
-    }
+    const scopes =
+      isUat && uatCap
+        ? requestedScopes && requestedScopes.length > 0
+          ? requestedScopes.filter((scope) => uatCap.includes(scope))
+          : uatCap
+        : requestedScopes;
 
     // Attribution: stamp the acting user on the minted env JWT. A UAT carries
     // its user as `userActorId`; a PAT exchange resolves the user from the
@@ -120,13 +137,14 @@ export async function action({ request, params }: ActionFunctionArgs) {
       (authenticationResult.type === "personalAccessToken"
         ? authenticationResult.result.userId
         : undefined);
-    const actorClient = userActor?.client ?? "personal-access-token";
 
     const claims = {
       sub: runtimeEnv.id,
       pub: true,
       ...(scopes ? { scopes } : {}),
-      ...(actorUserId ? { act: { sub: actorUserId, client: actorClient } } : {}),
+      ...(actorUserId
+        ? { act: { sub: actorUserId, client: userActor?.client ?? "personal-access-token" } }
+        : {}),
     };
 
     const jwt = await internal_generateJWT({

apps/webapp/app/services/userActorEnvironment.server.ts

@@ -9,12 +9,7 @@
  */
 
 import { json } from "@remix-run/server-runtime";
-import {
-  buildJwtAbility,
-  type RbacAbility,
-  scopesWithinAbility,
-  type UserActorClaims,
-} from "@trigger.dev/rbac";
+import { type UserActorClaims } from "@trigger.dev/rbac";
 import { $replica } from "~/db.server";
 
 export const FORBIDDEN_ENVIRONMENT_CODE = "forbidden_environment";
@@ -114,33 +109,6 @@ export async function resolveUserActorEnvironmentScope(
   };
 }
 
-/** Mirrors the RBAC fallback's own default. */
-const CAPLESS_USER_ACTOR_SCOPES = ["read:all"];
-
-/**
- * A delegated token must never mint something more capable than itself. Two ceilings apply:
- * the actor's own ability (their role) and the token's `cap`. The role alone is not enough —
- * a read-only agent token belongs to a user who may well be allowed to write.
- */
-export function clampUserActorScopes(
-  requestedScopes: string[] | undefined,
-  userActor: UserActorClaims,
-  ability: RbacAbility
-): { scopes: string[]; deniedScopes: string[] } {
-  const cap = userActor.cap ?? CAPLESS_USER_ACTOR_SCOPES;
-  const requested = requestedScopes && requestedScopes.length > 0 ? requestedScopes : cap;
-
-  const denied = new Set([
-    ...scopesWithinAbility(requested, ability).deniedScopes,
-    ...scopesWithinAbility(requested, buildJwtAbility(cap)).deniedScopes,
-  ]);
-
-  return {
-    scopes: requested.filter((scope) => !denied.has(scope)),
-    deniedScopes: [...denied],
-  };
-}
-
 function assertClaimIsOptional(userActor: UserActorClaims): void {
   if (userActor.client !== DASHBOARD_AGENT_CLIENT) return;
   throw forbiddenEnvironment("This token isn't scoped to an environment.");

apps/webapp/test/dashboardAgentDelegatedScopeCeiling.test.ts

@@ -1,23 +1,31 @@
 import { beforeEach, describe, expect, it, vi } from "vitest";
 
 const mocks = vi.hoisted(() => ({
+  authenticateRequest: vi.fn<(...args: any[]) => Promise<any>>(),
+  verifyUserActorToken: vi.fn<(...args: any[]) => Promise<any>>(),
+  isUserActorToken: vi.fn<(value: string) => boolean>(),
   authenticateUatOrApiRequest: vi.fn<(...args: any[]) => Promise<any>>(),
   authorizePatEnvironmentAccess: vi.fn<(...args: any[]) => Promise<any>>(),
 }));
 
-vi.mock("~/services/uatRoutePreamble.server", () => ({
-  authenticateUatOrApiRequest: mocks.authenticateUatOrApiRequest,
+vi.mock("@trigger.dev/rbac", async (importOriginal) => ({
+  ...(await importOriginal<Record<string, unknown>>()),
+  isUserActorToken: mocks.isUserActorToken,
+  verifyUserActorToken: mocks.verifyUserActorToken,
 }));
 vi.mock("~/services/environmentVariableApiAccess.server", () => ({
   authorizePatEnvironmentAccess: mocks.authorizePatEnvironmentAccess,
 }));
 vi.mock("~/services/apiAuth.server", () => ({
   authenticatedEnvironmentForAuthentication: vi.fn(async () => environment),
   branchNameFromRequest: () => undefined,
+  authenticateRequest: mocks.authenticateRequest,
 }));
 vi.mock("~/services/logger.server", () => ({
-  logger: { debug: vi.fn(), error: vi.fn(), warn: vi.fn() },
+  logger: { debug: vi.fn(), error: vi.fn(), warn: vi.fn(), info: vi.fn() },
 }));
+vi.mock("~/env.server", () => ({ env: { SESSION_SECRET: "test-session-secret" } }));
+vi.mock("~/db.server", () => ({ prisma: {}, $replica: {} }));
 
 import { validateJWT } from "@trigger.dev/core/v3/jwt";
 import { action } from "~/routes/api.v1.projects.$projectRef.$env.jwt";
@@ -32,10 +40,10 @@ const environment = {
 
 const params = { projectRef: "proj_abc", env: "prod" };
 
-function request(body: unknown = {}) {
+function request(body: unknown = {}, bearer = "tr_pat_test") {
   return new Request("https://example.com/api/v1/projects/proj_abc/prod/jwt", {
     method: "POST",
-    headers: { "Content-Type": "application/json" },
+    headers: { "Content-Type": "application/json", Authorization: `Bearer ${bearer}` },
     body: JSON.stringify(body),
   });
 }
@@ -50,14 +58,18 @@ async function mintedClaims(body?: unknown) {
 
 describe("env JWT exchange — act claim", () => {
   beforeEach(() => {
-    mocks.authenticateUatOrApiRequest.mockReset();
+    mocks.authenticateRequest.mockReset();
+    mocks.verifyUserActorToken.mockReset();
+    mocks.isUserActorToken.mockReset();
+    mocks.isUserActorToken.mockReturnValue(false);
     mocks.authorizePatEnvironmentAccess.mockReset();
     mocks.authorizePatEnvironmentAccess.mockResolvedValue(undefined);
   });
 
   it("stamps the PAT's user with the personal-access-token client", async () => {
-    mocks.authenticateUatOrApiRequest.mockResolvedValue({
-      authenticationResult: { type: "personalAccessToken", result: { userId: "usr_42" } },
+    mocks.authenticateRequest.mockResolvedValue({
+      type: "personalAccessToken",
+      result: { userId: "usr_42" },
     });
 
     const claims = await mintedClaims();
@@ -67,9 +79,13 @@ describe("env JWT exchange — act claim", () => {
   });
 
   it("passes through a user-actor token's own client", async () => {
-    mocks.authenticateUatOrApiRequest.mockResolvedValue({
-      authenticationResult: { type: "personalAccessToken", result: { userId: "usr_7" } },
-      userActor: { userId: "usr_7", client: "dashboard-agent", cap: ["read:runs"] },
+    mocks.isUserActorToken.mockReturnValue(true);
+    mocks.verifyUserActorToken.mockResolvedValue({
+      userId: "usr_7",
+      client: "dashboard-agent",
+      // An agent token always carries the environment it was minted for.
+      environmentId: environment.id,
+      cap: ["read:runs"],
     });
 
     const claims = await mintedClaims({ claims: { scopes: ["read:runs"] } });
@@ -79,11 +95,9 @@ describe("env JWT exchange — act claim", () => {
   });
 
   it("omits act for an org access token (no user)", async () => {
-    mocks.authenticateUatOrApiRequest.mockResolvedValue({
-      authenticationResult: {
-        type: "organizationAccessToken",
-        result: { organizationId: "org_1" },
-      },
+    mocks.authenticateRequest.mockResolvedValue({
+      type: "organizationAccessToken",
+      result: { organizationId: "org_1" },
     });
 
     const claims = await mintedClaims();
@@ -93,7 +107,7 @@ describe("env JWT exchange — act claim", () => {
   });
 
   it("401s without a token", async () => {
-    mocks.authenticateUatOrApiRequest.mockResolvedValue(undefined);
+    mocks.authenticateRequest.mockResolvedValue(undefined);
 
     const response = await action({ request: request(), params, context: {} as any });