fix(v2): require user-bound runtime context for tool credentials

Make MCP and runtime callbacks run with mandatory account identity and propagate it through task runs into source credential resolution. Tighten control-plane auth defaults and sanitize proxied response headers for safer direct Convex access.

Rhys Sullivan committed 8 months ago

Commit bb5e3e01 parent 1db806a11 files · +123 −84Browse files

Unified · Split

11 files

apps/convex/convex/_generated/api.d.ts +2 −0
apps/convex/convex/auth.config.ts +0 −1
apps/convex/convex/control_plane/actor.ts +33 −3
apps/convex/convex/executor.test.ts +1 −0
apps/convex/convex/mcp.ts +30 −43
apps/convex/convex/runtimeCallbacks.ts +10 −5
apps/convex/convex/source_tool_registry.ts +10 −16
apps/convex/convex/task_runs.ts +9 −4
apps/web/app/api/control-plane/[...path]/route.ts +21 −1
apps/web/next.config.ts +6 −10
packages/schema/src/models/task-run.ts +1 −1

apps/convex/convex/_generated/api.d.ts+2−0

 import type * as credential_crypto from "../credential_crypto.js";
 import type * as executor from "../executor.js";
 import type * as http from "../http.js";
+import type * as http_security from "../http_security.js";
 import type * as mcp from "../mcp.js";
 import type * as mcp_auth from "../mcp_auth.js";
 import type * as run_executor from "../run_executor.js";
   credential_crypto: typeof credential_crypto;
   executor: typeof executor;
   http: typeof http;
+  http_security: typeof http_security;
   mcp: typeof mcp;
   mcp_auth: typeof mcp_auth;
   run_executor: typeof run_executor;

apps/convex/convex/auth.config.ts+0−1

@@ -21,7 +21,6 @@ const providers: AuthConfig["providers"] = clientId · 20 unmodified lines
21	type: "customJwt",	21	type: "customJwt",
22	issuer: `https://api.workos.com/user_management/${clientId}`,	22	issuer: `https://api.workos.com/user_management/${clientId}`,
23	algorithm: "RS256",	23	algorithm: "RS256",
24	applicationID: clientId,
25	jwks: `https://api.workos.com/sso/jwks/${clientId}`,	24	jwks: `https://api.workos.com/sso/jwks/${clientId}`,
26	},	25	},
27	]	26	]

apps/convex/convex/control_plane/actor.ts+33−3

@@ -294,7 +294,7 @@ export const ConvexControlPlaneActorLive = (ctx: ActionCtx) => · 293 unmodified lines
294		294
295	const principal = yield* resolveAuthenticatedPrincipal(ctx);	295	const principal = yield* resolveAuthenticatedPrincipal(ctx);
296		296
297	const organizationMemberships = yield* runQueryEffect(	297	let organizationMemberships = yield* runQueryEffect(
298	"organizationMembership.list",	298	"organizationMembership.list",
299	() =>	299	() =>
300	ctx.runQuery(internal.control_plane.actor.listOrganizationMembershipsForActor, {	300	ctx.runQuery(internal.control_plane.actor.listOrganizationMembershipsForActor, {
@@ -302,17 +302,47 @@ export const ConvexControlPlaneActorLive = (ctx: ActionCtx) => · 1 unmodified line
302	}),	302	}),
303	);	303	);
304		304
305	const organizationIds = organizationMemberships.map(	305	let organizationIds = organizationMemberships.map(
306	(membership) => membership.organizationId,	306	(membership) => membership.organizationId,
307	);	307	);
308		308
309	const workspaces = yield* runQueryEffect("workspace.list", () =>	309	let workspaces = yield* runQueryEffect("workspace.list", () =>
310	ctx.runQuery(internal.control_plane.actor.listWorkspacesForActor, {	310	ctx.runQuery(internal.control_plane.actor.listWorkspacesForActor, {
311	accountId: principal.accountId,	311	accountId: principal.accountId,
312	organizationIds,	312	organizationIds,
313	}),	313	}),
314	);	314	);
315		315
		316	if (organizationMemberships.length === 0) {
		317	const workspaceId = workspaces[0]?.id ?? `ws_${principal.accountId}`;
		318
		319	yield* runQueryEffect("workspace.ensureDefault", () =>
		320	ctx.runMutation(internal.control_plane.actor.ensureWorkspaceForActor, {
		321	workspaceId,
		322	accountId: principal.accountId,
		323	}),
		324	);
		325
		326	organizationMemberships = yield* runQueryEffect(
		327	"organizationMembership.list",
		328	() =>
		329	ctx.runQuery(internal.control_plane.actor.listOrganizationMembershipsForActor, {
		330	accountId: principal.accountId,
		331	}),
		332	);
		333
		334	organizationIds = organizationMemberships.map(
		335	(membership) => membership.organizationId,
		336	);
		337
		338	workspaces = yield* runQueryEffect("workspace.list", () =>
		339	ctx.runQuery(internal.control_plane.actor.listWorkspacesForActor, {
		340	accountId: principal.accountId,
		341	organizationIds,
		342	}),
		343	);
		344	}
		345
316	const workspaceMemberships = workspaces.flatMap((workspace) =>	346	const workspaceMemberships = workspaces.flatMap((workspace) =>
317	deriveWorkspaceMembershipsForPrincipal({	347	deriveWorkspaceMembershipsForPrincipal({
318	principalAccountId: principal.accountId,	348	principalAccountId: principal.accountId,

apps/convex/convex/executor.test.ts+1−0

@@ -1410,6 +1410,7 @@ describe("Convex executor and control-plane", () => { · 1409 unmodified lines
1410	t.mutation(runtimeInternal.task_runs.startTaskRun, {	1410	t.mutation(runtimeInternal.task_runs.startTaskRun, {
1411	workspaceId: "ws_1",	1411	workspaceId: "ws_1",
1412	runId: "run_approval_1",	1412	runId: "run_approval_1",
		1413	accountId: "acct_1",
1413	}),	1414	}),
1414	);	1415	);
1415		1416

apps/convex/convex/mcp.ts+30−43

@@ -19,19 +19,11 @@ import { · 18 unmodified lines
19	} from "./mcp_auth";	19	} from "./mcp_auth";
20	import { createConvexSourceToolRegistry } from "./source_tool_registry";	20	import { createConvexSourceToolRegistry } from "./source_tool_registry";
21		21
22	const readConfiguredWorkspaceId = (value: string \| undefined): string => {
23	const normalized = value?.trim();
24	return normalized && normalized.length > 0 ? normalized : "ws_local";
25	};
26
27	const readWorkspaceIdFromRequest = (request: Request): string \| null => {	22	const readWorkspaceIdFromRequest = (request: Request): string \| null => {
28	const value = new URL(request.url).searchParams.get("workspaceId")?.trim();	23	const value = new URL(request.url).searchParams.get("workspaceId")?.trim();
29	return value && value.length > 0 ? value : null;	24	return value && value.length > 0 ? value : null;
30	};	25	};
31		26
32	const readRequestedWorkspaceId = (request: Request, fallbackWorkspaceId: string): string =>
33	readWorkspaceIdFromRequest(request) ?? fallbackWorkspaceId;
34
35	const readToolExposureModeFromRequest = (	27	const readToolExposureModeFromRequest = (
36	request: Request,	28	request: Request,
37	fallbackMode: ExecuteToolExposureMode,	29	fallbackMode: ExecuteToolExposureMode,
@@ -96,7 +88,6 @@ const hasWorkspaceAccess = async ( · 58 unmodified lines
96	}	88	}
97	};	89	};
98		90
99	const fallbackWorkspaceId = readConfiguredWorkspaceId(process.env.CONVEX_WORKSPACE_ID);
100	const defaultToolExposureMode =	91	const defaultToolExposureMode =
101	parseExecuteToolExposureMode(process.env.CONVEX_TOOL_EXPOSURE_MODE) ??	92	parseExecuteToolExposureMode(process.env.CONVEX_TOOL_EXPOSURE_MODE) ??
102	defaultExecuteToolExposureMode;	93	defaultExecuteToolExposureMode;
@@ -104,45 +95,41 @@ const runtimeInternal = internal as any; · 1 unmodified line
104		95
105	export const mcpHandler = httpAction(async (ctx, request) => {	96	export const mcpHandler = httpAction(async (ctx, request) => {
106	const mcpAuthConfig = getMcpAuthConfig();	97	const mcpAuthConfig = getMcpAuthConfig();
107	const requestWorkspaceId = readWorkspaceIdFromRequest(request);	98	const workspaceId = readWorkspaceIdFromRequest(request);
108	const workspaceId = readRequestedWorkspaceId(request, fallbackWorkspaceId);
109	let accountId: string \| null = null;
110		99
111	if (!mcpAuthConfig.enabled) {	100	if (!mcpAuthConfig.enabled) {
112	if (mcpAuthConfig.required) {	101	return Response.json(
113	return Response.json(	102	{
114	{	103	error: "MCP OAuth must be configured",
115	error: "MCP OAuth must be configured for cloud deployments",	104	},
116	},	105	{ status: 503 },
117	{ status: 503 },	106	);
118	);	107	}
119	}
120	} else {
121	const auth = await verifyMcpToken(request, mcpAuthConfig);
122	if (!auth) {
123	return unauthorizedMcpResponse(request, "No valid bearer token provided.");
124	}
125		108
126	accountId = auth.subject;	109	const auth = await verifyMcpToken(request, mcpAuthConfig);
		110	if (!auth) {
		111	return unauthorizedMcpResponse(request, "No valid bearer token provided.");
		112	}
127		113
128	if (!requestWorkspaceId) {	114	if (!workspaceId) {
129	return Response.json(	115	return Response.json(
130	{	116	{
131	error: "workspaceId query parameter is required when MCP OAuth is enabled",	117	error: "workspaceId query parameter is required",
132	},	118	},
133	{ status: 400 },	119	{ status: 400 },
134	);	120	);
135	}	121	}
136		122
137	const authorized = await hasWorkspaceAccess(ctx, requestWorkspaceId, auth.subject);	123	const accountId = auth.subject;
138	if (!authorized) {	124
139	return Response.json(	125	const authorized = await hasWorkspaceAccess(ctx, workspaceId, accountId);
140	{	126	if (!authorized) {
141	error: "Workspace authorization failed",	127	return Response.json(
142	},	128	{
143	{ status: 403 },	129	error: "Workspace authorization failed",
144	);	130	},
145	}	131	{ status: 403 },
		132	);
146	}	133	}
147		134
148	const toolRegistry = createConvexSourceToolRegistry(ctx, workspaceId, {	135	const toolRegistry = createConvexSourceToolRegistry(ctx, workspaceId, {

apps/convex/convex/runtimeCallbacks.ts+10−5

 const resolveWorkspaceIdForToolCall = (
   ctx: ActionCtx,
   input: RuntimeToolCallRequest,
-): Effect.Effect<{ workspaceId: string; accountId: string | null }, RuntimeToolCallBadRequestError> =>
+): Effect.Effect<{ workspaceId: string; accountId: string }, RuntimeToolCallBadRequestError> =>
   Effect.gen(function* () {
     const runContext = yield* Effect.tryPromise({
       try: () =>
     });
     if (runContext && runContext.workspaceId.trim().length > 0) {
+      const accountId = runContext.accountId.trim();
+      if (accountId.length === 0) {
+        return yield* new RuntimeToolCallBadRequestError({
+          message: "Runtime callback run is missing account identity",
+          details: `runId=${input.runId}`,
+        });
+      }
       return {
         workspaceId: runContext.workspaceId.trim(),
-        accountId:
+        accountId,
-          typeof runContext.accountId === "string" && runContext.accountId.trim().length > 0
-            ? runContext.accountId.trim()
-            : null,
       };
     }

apps/convex/convex/source_tool_registry.ts+10−16

 const resolveSourceCredentialHeadersForInvocation = async (
   ctx: ActionCtx,
   source: Source,
-  accountId: string | null,
+  accountId: string,
 ): Promise<Record<string, string>> => {
   try {
-    const accountInput = accountId
-      ? {
-          accountId,
-        }
-      : {};
     const resolved = (await ctx.runAction(
       runtimeInternal.control_plane.credentials.resolveSourceCredentialHeaders,
       {
         workspaceId: source.workspaceId,
         sourceId: source.id,
-        ...accountInput,
+        accountId,
       },
     )) as { headers?: unknown };
 const resolveSourceHeadersForInvocation = async (
   ctx: ActionCtx,
   source: Source,
-  accountId: string | null,
+  accountId: string,
 ): Promise<Record<string, string>> => {
   const config = parseSourceConfig(source);
   source: Source,
   artifactTool: ArtifactToolRow,
   args: Record<string, unknown>,
-  accountId: string | null,
+  accountId: string,
 ): Effect.Effect<{ output: unknown; isError: boolean }, RuntimeAdapterError> =>
   Effect.gen(function* () {
     const openApiProvider = makeOpenApiToolProvider();
 }): string => `${row.sourceKind.toUpperCase()} source: ${row.sourceName}`;
 export type ConvexSourceToolRegistryOptions = {
+  accountId: string;
   requireToolApprovals?: boolean;
   approvalRetryAfterMs?: number;
-  accountId?: string | null;
 };
 export const createConvexSourceToolRegistry = (
   ctx: ActionCtx,
   workspaceId: string,
-  options: ConvexSourceToolRegistryOptions = {},
+  options: ConvexSourceToolRegistryOptions,
 ): ToolRegistry => {
   const requireApprovals = options.requireToolApprovals ?? requireToolApprovalsByDefault;
-  const accountId =
+  const accountId = options.accountId.trim();
-    typeof options.accountId === "string" && options.accountId.trim().length > 0
+  if (accountId.length === 0) {
-      ? options.accountId.trim()
+    throw new Error("Tool registry accountId is required");
-      : null;
+  }
   const approvalRetryAfterMs =
     typeof options.approvalRetryAfterMs === "number" &&
     Number.isFinite(options.approvalRetryAfterMs) &&

apps/convex/convex/task_runs.ts+9−4

   args: {
     workspaceId: v.string(),
     runId: v.string(),
-    accountId: v.optional(v.union(v.string(), v.null())),
+    accountId: v.string(),
     sessionId: v.optional(v.string()),
     runtimeId: v.optional(v.string()),
     codeHash: v.optional(v.string()),
       if (existing.workspaceId !== args.workspaceId) {
         throw new Error(`Task run workspace mismatch: ${args.runId}`);
       }
+      if (existing.accountId !== args.accountId) {
+        throw new Error(`Task run account mismatch: ${args.runId}`);
+      }
       return;
     }
     const taskRun = {
       id: args.runId,
       workspaceId: args.workspaceId,
-      accountId: args.accountId ?? null,
+      accountId: args.accountId,
       sessionId: args.sessionId ?? "session_runtime",
       runtimeId: args.runtimeId ?? "runtime",
       codeHash: args.codeHash ?? "runtime",
   args: {
     runId: v.string(),
   },
-  handler: async (ctx, args): Promise<{ workspaceId: string; accountId: string | null } | null> => {
+  handler: async (ctx, args): Promise<{ workspaceId: string; accountId: string } | null> => {
     const existing = await ctx.db
       .query("taskRuns")
       .withIndex("by_domainId", (q) => q.eq("id", args.runId))
     return {
       workspaceId: existing.workspaceId,
-      accountId: typeof existing.accountId === "string" ? existing.accountId : null,
+      accountId: existing.accountId,
     };
   },
 });

apps/web/app/api/control-plane/[...path]/route.ts+21−1

@@ -57,9 +57,29 @@ const buildUpstreamHeaders = ( · 56 unmodified lines
57	}	57	}
58	}	58	}
59		59
		60	headers.set("accept-encoding", "identity");
		61
60	return headers;	62	return headers;
61	};	63	};
62		64
		65	const responseHeadersToStrip = [
		66	"content-encoding",
		67	"content-length",
		68	"transfer-encoding",
		69	"connection",
		70	"keep-alive",
		71	] as const;
		72
		73	const sanitizeUpstreamResponseHeaders = (headers: Headers): Headers => {
		74	const sanitized = new Headers(headers);
		75
		76	for (const name of responseHeadersToStrip) {
		77	sanitized.delete(name);
		78	}
		79
		80	return sanitized;
		81	};
		82
63	const resolveUpstreamUrl = (	83	const resolveUpstreamUrl = (
64	request: NextRequest,	84	request: NextRequest,
65	pathSegments: ReadonlyArray<string>,	85	pathSegments: ReadonlyArray<string>,
@@ -118,7 +138,7 @@ const handle = async (request: NextRequest, context: RouteContext): Promise<Resp · 52 unmodified lines
118	return new Response(upstreamResponse.body, {	138	return new Response(upstreamResponse.body, {
119	status: upstreamResponse.status,	139	status: upstreamResponse.status,
120	statusText: upstreamResponse.statusText,	140	statusText: upstreamResponse.statusText,
121	headers: upstreamResponse.headers,	141	headers: sanitizeUpstreamResponseHeaders(upstreamResponse.headers),
122	});	142	});
123	};	143	};
124		144

apps/web/next.config.ts+6−10

   return candidate && candidate.length > 0 ? candidate : undefined;
 };
-const publicControlPlaneBaseUrl =
+const publicControlPlaneBaseUrl = trim(process.env.NEXT_PUBLIC_CONTROL_PLANE_BASE_URL);
-  trim(process.env.NEXT_PUBLIC_CONTROL_PLANE_BASE_URL)
-  ?? trim(process.env.CONTROL_PLANE_SERVER_BASE_URL)
-  ?? trim(process.env.CONTROL_PLANE_UPSTREAM_URL)
-  ?? trim(process.env.NEXT_PUBLIC_CONVEX_URL)
-  ?? trim(process.env.CONVEX_URL)
-  ?? "";
 const nextConfig: NextConfig = {
   outputFileTracingRoot: resolve(appDir, "../.."),
-  env: {
+  env: publicControlPlaneBaseUrl
-    NEXT_PUBLIC_CONTROL_PLANE_BASE_URL: publicControlPlaneBaseUrl,
+    ? {
-  },
+        NEXT_PUBLIC_CONTROL_PLANE_BASE_URL: publicControlPlaneBaseUrl,
+      }
+    : {},
 };
 export default nextConfig;

packages/schema/src/models/task-run.ts+1−1

@@ -7,7 +7,7 @@ import { AccountIdSchema, TaskRunIdSchema, WorkspaceIdSchema } from "../ids"; · 6 unmodified lines
7	export const TaskRunSchema = Schema.Struct({	7	export const TaskRunSchema = Schema.Struct({
8	id: TaskRunIdSchema,	8	id: TaskRunIdSchema,
9	workspaceId: WorkspaceIdSchema,	9	workspaceId: WorkspaceIdSchema,
10	accountId: Schema.NullOr(AccountIdSchema),	10	accountId: AccountIdSchema,
11	sessionId: Schema.String,	11	sessionId: Schema.String,
12	runtimeId: Schema.String,	12	runtimeId: Schema.String,
13	codeHash: Schema.String,	13	codeHash: Schema.String,

fix(v2): require user-bound runtime context for tool credentials

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code