Skip to content

AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents

feat(mcp): let project members use the platform MCP server, gated on READ_MCP (#15649)

Othman Abu Ajamieha45ecb551210
diff --git a/brain/knowledge/ai-intelligence/mcp-server.md b/brain/knowledge/ai-intelligence/mcp-server.md
index d28cb69017b..490c1215282 100644
--- a/brain/knowledge/ai-intelligence/mcp-server.md
+++ b/brain/knowledge/ai-intelligence/mcp-server.md
@@ -49,6 +49,8 @@ Exposes an Activepieces project as an MCP server so AI clients (Claude Desktop,
its next refresh, which backfills a NULL key), and `NULL` is not a third state — it means "signed in before the
column existed" and reads as `unknown` everywhere, including the `?clientKeys=unknown` filter.
- **Revocation only reaches a live access token through the `grantId` claim, and a token without one is trusted.** `revoked = true` is read by the refresh flow, never by `POST /mcp`, so the Revocation List is what actually cuts a connected client off — see [000033](../decisions/000033-a-revoked-mcp-grant-is-blocked-by-a-redis-revocation-list.md). It is keyed on `grantId` (the `mcp_oauth_token` row id) because `clientId` is a DCR registration shared across users, so revoking by it would kill strangers' tokens. Two populations carry no claim and therefore skip the check entirely: tokens minted before the claim shipped (they age out in 15 minutes, and `refreshAccessToken` stamps the claim) and `issueInternalAccessToken` tokens for EE chat, which have no grant row at all. Anything that mints an MCP access token without a grant row inherits that exemption silently. Platform teardown is a third gap by design — it `DELETE`s the rows instead of revoking them, so no keys are written.
+- **The four `PLATFORM_LEVEL_TOOL_NAMES` never reach `executeInSelectedProject`, so they carry their own permission gate.** `ap_research_pieces`, `ap_search_actions`, `ap_search_triggers` and `ap_get_piece_props` run against `templateMcp` (projectId = platformId) and return early in `registerPlatformTools`, which means the per-project `PermissionChecker` never touches them. Membership is earned by guarding on `mcpUtils.isProjectScoped(mcp)` and passing `undefined` instead of the fake project id — `ap_list_ai_models` was listed here without that guard, so `rowAllowsScope` tested the platform id against an AI provider row's `projectIds`, hiding `selected`-scoped providers from everyone and offering `except`-scoped ones to the very projects they exclude. It routes through the selected project now. Without a gate of their own a member whose `READ_MCP` was revoked everywhere kept calling them on an already-issued token, and kept being charged for it. `withMcpReach` now wraps them with `mcpAccess.hasMcpReach`, the same any-project rule `POST /v1/mcp-oauth/approve` applies at authorization time, and it wraps the `charged` call so a refusal costs nothing. `ap_set_project_context` is wrapped the same way; enforcing the rule from inside its `execute` alone left the denial on the far side of `charged`, so a user with reach nowhere paid a credit per refusal.
+- **`READ_MCP` gates external MCP clients, not the in-app chat.** The chat reaches its tools through `POST /mcp/platform` like any client, and the controller serves it through the project branch once the conversation resolves a project, so `resolveMcpPermissionChecker` would deny every chat tool to a custom role with MCP set to None. `isInAppChatIdentity` in `mcp-oauth.controller.ts` picks the chat out as a *platform-scoped* token carrying `INTERNAL_CHAT_CLIENT_ID`, and `buildMcpServer` then uses `resolvePermissionChecker` (per-tool checks only, as the chat's own `agent-tools.ts` path does). Both halves are needed: `POST /v1/projects/:id/mcp-server/token` mints the same client id, but always project-scoped, and `resolveIdentity` rejects a scope mismatch, so those embed-SDK tokens keep the gate. Only the project branch relaxes; `registerPlatformTools`, `withMcpReach` and `executeInSelectedProject` stay gated, because the platform branch is the fallback for a conversation with no project or one the user lost access to.
- **Claude Code and Codex re-run Dynamic Client Registration on *every* sign-in**, registering the exact
ephemeral loopback port they are about to bind (`http://localhost:<port>/callback`,
`http://127.0.0.1:<port>/callback/<callback_id>`). So the exact-string `validateRedirectUri` works and
@@ -101,6 +103,12 @@ Exposes an Activepieces project as an MCP server so AI clients (Claude Desktop,
- **The Pieces tab's search is server-side, and it only works because `pieceDisplayName` is a Fuse key.** `/v1/pieces?searchQuery=` replaces each piece's `actions` with the matched subset (`searchForSuggestion`), which sounds fatal for a page that shows a per-piece action count and a destructive badge — but `searchForSuggestion` searches `['pieceDisplayName', 'displayName', 'description']`, so querying a *piece* name matches every action inside it and the row still lists the lot. Two more things make it safe: `toPieceMetadataModelSummary` computes `summary.actions` from the pre-search `audiencePieces`, so the total count is never narrowed by a query, and the tab force-expands every row while searching, so the count it renders is visibly the list beneath it. Keep the popular-first sort for the unsearched view only — applying it to search results throws away Fuse's relevance ranking. Rows are still grouped and counted client-side in `piecesUtils.toReachablePieces`, which is a pure function with its own unit test.
+- **The MCP page is gated on MCP *reach*, not on the session project, and `RoutePermissionGuard` cannot express that.** The server rule is "`READ_MCP` in at least one project" — what `POST /v1/mcp-oauth/approve` and `withMcpReach` both enforce — while `checkAccess` resolves the session project alone, so a member holding `READ_MCP` in project B while sitting in project A could use the platform server but got a 404 on the page handing out its address, and no MCP entry in the rail. `GET /v1/mcp-server/reach` answers the right question in one call; nothing else could, because `GET /v1/projects` carries no role or permission field and `listProjectIdsWithPermission` had no HTTP surface. It is the one `publicPlatform` route on a controller whose other three are `platformAdminOnly`, and it returns project ids only. A privileged caller gets `projectIds: null` rather than an enumeration of the platform — `getAllForUser` skips its filter for them, so listing every id would load every project row on a large platform, and both readers, `McpReachGuard` and the `ProjectPicker` filter, already read `null` as "every project". An embedded user is refused in the handler, through `userIdentityHelper.isUserEmbedded`, the same way `POST /v1/mcp-oauth/approve` refuses them the platform-wide branch — their `project_member` rows are never removed, so the id list would span every tenant they ever signed into. The refusal cannot be a route-level `securityAccess.nonEmbedUsersOnly`: despite the name, that helper also demands `WRITE_INVITATION` on some project, so it would refuse the very members this endpoint exists for. Treat it as auxiliary: it fails open, because an outage on it must not lock people out of a page the server would have opened.
+
+- **MCP never lists or authorizes another user's personal project, even for an admin or operator.** `getAllForUser` returns every project of the platform to a privileged user and `getRole` gives an operator EDITOR on each, but `mcp-access.ts` drops a `PERSONAL` project unless the caller owns it, in both `listAccessibleProjects` and `hasMcpAccessToProject`. It matches `getUserProjects` in `ee/agent/agent-helpers.ts`, so the in-app chat and an external client see the same projects. `GET /v1/mcp-server/reach` still answers `null` for a privileged caller; its readers filter `/v1/projects`, which already hides those projects.
+
+- **`mcp-access.ts` is CE code that imports two EE modules, and that is deliberate for now.** It reaches `ee/authentication/project-role/rbac-middleware` and `ee/projects/project-members/project-member.service`, against `.claude/rules/edition-safety.md`. It is safe at run time only because every EE call sits behind `editionRequiresRbac()` and `repoFactory` is lazy, so on Community nothing is touched. `mcp-permissions.ts` opened this breach before `mcp-access.ts` widened it. Moving it behind a `hooksFactory` is the correct fix and is its own change — do not half-do it while editing something else here.
+
### Key files
Entry point: `mcpServerModule`, the Fastify plugin in `mcp/mcp-module.ts` registered from `packages/server/api/src/app/app.ts`.
diff --git a/bun.lock b/bun.lock
index 755ad56a56b..11fdd123d23 100644
--- a/bun.lock
+++ b/bun.lock
@@ -165,7 +165,7 @@
},
"packages/core/shared": {
"name": "@activepieces/shared",
- "version": "0.181.0",
+ "version": "0.182.0",
"dependencies": {
"@activepieces/core-execution": "workspace:*",
"@activepieces/core-formula": "workspace:*",
diff --git a/packages/core/shared/package.json b/packages/core/shared/package.json
index 85f0c5826b7..fc4835eb764 100644
--- a/packages/core/shared/package.json
+++ b/packages/core/shared/package.json
@@ -1,6 +1,6 @@
{
"name": "@activepieces/shared",
- "version": "0.181.0",
+ "version": "0.182.0",
"type": "commonjs",
"sideEffects": false,
"main": "./dist/src/index.js",
diff --git a/packages/core/shared/src/lib/automation/mcp/mcp.ts b/packages/core/shared/src/lib/automation/mcp/mcp.ts
index 6d4d88a8890..2b6ed696e91 100644
--- a/packages/core/shared/src/lib/automation/mcp/mcp.ts
+++ b/packages/core/shared/src/lib/automation/mcp/mcp.ts
@@ -25,6 +25,11 @@ export const PopulatedMcpServer = McpServer.extend({
})
export type PopulatedMcpServer = z.infer<typeof PopulatedMcpServer>
+export const McpReachResponse = z.object({
+ projectIds: z.array(ApId).nullable(),
+})
+export type McpReachResponse = z.infer<typeof McpReachResponse>
+
export type McpServer = z.infer<typeof McpServer>
export type ProjectScopedMcpServer = McpServer & { projectId: string }
diff --git a/packages/server/api/src/app/ee/authentication/project-role/rbac-middleware.ts b/packages/server/api/src/app/ee/authentication/project-role/rbac-middleware.ts
index c4feaf4ffe2..c693ac2f68e 100644
--- a/packages/server/api/src/app/ee/authentication/project-role/rbac-middleware.ts
+++ b/packages/server/api/src/app/ee/authentication/project-role/rbac-middleware.ts
@@ -8,7 +8,9 @@ import { system } from '../../../helper/system/system'
import { projectMemberService } from '../../projects/project-members/project-member.service'
import { projectRoleService } from '../../projects/project-role/project-role.service'
-const EDITION_IS_COMMUNITY = system.getEdition() === ApEdition.COMMUNITY
+export function editionRequiresRbac(): boolean {
+ return [ApEdition.CLOUD, ApEdition.ENTERPRISE].includes(system.getEdition())
+}
export const rbacMiddleware = async (req: FastifyRequest): Promise<void> => {
if (ignoreRequest(req)) {
@@ -28,8 +30,7 @@ export async function assertUserHasPermissionToFlow(
operationType: FlowOperationType,
log: FastifyBaseLogger,
): Promise<void> {
- const edition = system.getEdition()
- if (![ApEdition.CLOUD, ApEdition.ENTERPRISE].includes(edition)) {
+ if (!editionRequiresRbac()) {
return
}
@@ -85,7 +86,7 @@ export const assertRoleHasPermission = async (principal: Principal, projectId: P
}
const ignoreRequest = (req: FastifyRequest): boolean => {
- if (EDITION_IS_COMMUNITY) {
+ if (!editionRequiresRbac()) {
return true
}
const ignoredPrefixes = ['/redirect', '/ui', '/api/ui']
diff --git a/packages/server/api/src/app/mcp/mcp-access.ts b/packages/server/api/src/app/mcp/mcp-access.ts
new file mode 100644
index 00000000000..92fb8792c79
--- /dev/null
+++ b/packages/server/api/src/app/mcp/mcp-access.ts
@@ -0,0 +1,83 @@
+import { isNil, Permission } from '@activepieces/core-utils'
+import { McpReachResponse, McpToolResult, Project, ProjectType } from '@activepieces/shared'
+import { FastifyBaseLogger } from 'fastify'
+import { editionRequiresRbac } from '../ee/authentication/project-role/rbac-middleware'
+import { projectMemberService } from '../ee/projects/project-members/project-member.service'
+import { projectService } from '../project/project-service'
+import { userService } from '../user/user-service'
+import { deny } from './mcp-permissions'
+
+export const mcpAccess = {
+ listAccessibleProjects,
+ resolveReach,
+ hasMcpReach,
+ hasMcpAccessToProject,
+ noMcpReachResult,
+}
+
+async function listAccessibleProjects({ platformId, userId, log }: UserScope): Promise<Project[]> {
+ const isPrivileged = await isUserPrivileged({ userId, log })
+ return listProjectsForUser({ platformId, userId, isPrivileged, log })
+}
+
+async function resolveReach({ platformId, userId, log }: UserScope): Promise<McpReachResponse> {
+ const isPrivileged = await isUserPrivileged({ userId, log })
+ if (isPrivileged) {
+ return { projectIds: null }
+ }
+ const projects = await listProjectsForUser({ platformId, userId, isPrivileged, log })
+ return { projectIds: projects.map((project) => project.id) }
+}
+
+async function hasMcpReach({ platformId, userId, log }: UserScope): Promise<boolean> {
+ const { projectIds } = await resolveReach({ platformId, userId, log })
+ return isNil(projectIds) || projectIds.length > 0
+}
+
+async function hasMcpAccessToProject({ platformId, userId, projectId, log }: UserScope & { projectId: string }): Promise<boolean> {
+ const project = await projectService(log).getOne(projectId)
+ if (isNil(project) || project.platformId !== platformId || !isVisibleToUser({ project, userId })) {
+ return false
+ }
+ if (editionRequiresRbac()) {
+ const role = await projectMemberService(log).getRole({ userId, projectId })
+ return role?.permissions?.includes(Permission.READ_MCP) ?? false
+ }
+ const isPrivileged = await isUserPrivileged({ userId, log })
+ const projects = await listProjectsForUser({ platformId, userId, isPrivileged, log })
+ return projects.some((accessibleProject) => accessibleProject.id === projectId)
+}
+
+function noMcpReachResult(toolTitle: string): McpToolResult {
+ return deny(`❌ Permission denied: your role does not have the "${Permission.READ_MCP}" permission in any project. Cannot execute "${toolTitle}".`)
+}
+
+async function isUserPrivileged({ userId, log }: Omit<UserScope, 'platformId'>): Promise<boolean> {
+ const user = await userService(log).getOneOrFail({ id: userId })
+ return userService(log).isUserPrivileged(user)
+}
+
+async function listProjectsForUser({ platformId, userId, isPrivileged, log }: UserScope & {
+ isPrivileged: boolean
+}): Promise<Project[]> {
+ const allProjects = await projectService(log).getAllForUser({ platformId, userId, isPrivileged })
+ const projects = allProjects.filter((project) => isVisibleToUser({ project, userId }))
+
+ if (!editionRequiresRbac() || isPrivileged || projects.length === 0) {
+ return projects
+ }
+
+ const projectIdsGrantingMcp = new Set(await projectMemberService(log).listProjectIdsWithPermission({ userId, platformId, permission: Permission.READ_MCP }))
+
+ return projects.filter((project) => project.ownerId === userId || projectIdsGrantingMcp.has(project.id))
+}
+
+function isVisibleToUser({ project, userId }: { project: Project, userId: string }): boolean {
+ return project.type !== ProjectType.PERSONAL || project.ownerId === userId
+}
+
+type UserScope = {
+ platformId: string
+ userId: string
+ log: FastifyBaseLogger
+}
diff --git a/packages/server/api/src/app/mcp/mcp-permissions.ts b/packages/server/api/src/app/mcp/mcp-permissions.ts
index bee9f2503c7..dd9d0c3aefd 100644
--- a/packages/server/api/src/app/mcp/mcp-permissions.ts
+++ b/packages/server/api/src/app/mcp/mcp-permissions.ts
@@ -1,70 +1,77 @@
-import { ActivepiecesError, ErrorCode, isNil, Permission } from '@activepieces/core-utils'
-import { ApEdition, McpToolDefinition } from '@activepieces/shared'
+import { ActivepiecesError, ErrorCode, isNil, Permission, tryCatch } from '@activepieces/core-utils'
+import { McpToolDefinition, McpToolResult, ProjectRole } from '@activepieces/shared'
import { FastifyBaseLogger } from 'fastify'
-import { getPrincipalRoleOrThrow } from '../ee/authentication/project-role/rbac-middleware'
-import { system } from '../helper/system/system'
+import { editionRequiresRbac, getPrincipalRoleOrThrow } from '../ee/authentication/project-role/rbac-middleware'
-const EDITION_REQUIRES_RBAC = [ApEdition.CLOUD, ApEdition.ENTERPRISE].includes(system.getEdition())
+export async function resolvePermissionChecker({ userId, projectId, log }: ResolveCheckerParams): Promise<PermissionChecker> {
+ return buildPermissionChecker({ userId, projectId, log })
+}
-export async function resolvePermissionChecker({ userId, projectId, log }: {
- userId: string
- projectId: string
- log: FastifyBaseLogger
+export async function resolveMcpPermissionChecker({ userId, projectId, log }: ResolveCheckerParams): Promise<PermissionChecker> {
+ return buildPermissionChecker({ userId, projectId, log, requiredPermission: Permission.READ_MCP })
+}
+
+export const ALLOW_ALL: PermissionChecker = {
+ check: () => null,
+ wrapExecute: ({ execute }) => execute,
+}
+
+async function buildPermissionChecker({ userId, projectId, log, requiredPermission }: ResolveCheckerParams & {
+ requiredPermission?: Permission
}): Promise<PermissionChecker> {
- if (!EDITION_REQUIRES_RBAC) {
+ if (!editionRequiresRbac()) {
return ALLOW_ALL
}
- try {
- const role = await getPrincipalRoleOrThrow(userId, projectId, log)
- const permissionSet = new Set(role.permissions ?? [])
- return buildChecker((permission, toolTitle) => {
- if (isNil(permission) || permissionSet.has(permission)) {
- return null
- }
- return {
- content: [{ type: 'text' as const, text: `❌ Permission denied: your role does not have the "${permission}" permission required to use "${toolTitle}".` }],
- isError: true,
- }
- })
+ const role = await resolveProjectRole({ userId, projectId, log })
+
+ if (isNil(role)) {
+ return buildChecker((_permission, toolTitle) => deny(`❌ Permission denied: no role found for this user in the project. Cannot execute "${toolTitle}".`))
}
- catch (err) {
- if (err instanceof ActivepiecesError && err.error.code === ErrorCode.AUTHORIZATION) {
- return buildChecker((permission, toolTitle) => {
- if (isNil(permission)) {
- return null
- }
- return {
- content: [{ type: 'text' as const, text: `❌ Permission denied: no role found for this user in the project. Cannot execute "${toolTitle}".` }],
- isError: true,
- }
- })
- }
- throw err
+
+ const permissionSet = new Set(role.permissions ?? [])
+
+ if (!isNil(requiredPermission) && !permissionSet.has(requiredPermission)) {
+ return buildChecker((_permission, toolTitle) => deny(`❌ Permission denied: your role does not have the "${requiredPermission}" permission required to use MCP in this project. Cannot execute "${toolTitle}".`))
}
+
+ return buildChecker((permission, toolTitle) => isNil(permission) || permissionSet.has(permission)
+ ? null
+ : deny(`❌ Permission denied: your role does not have the "${permission}" permission required to use "${toolTitle}".`))
}
-export const ALLOW_ALL: PermissionChecker = {
- check: () => null,
- wrapExecute: ({ execute }) => execute,
+async function resolveProjectRole({ userId, projectId, log }: ResolveCheckerParams): Promise<ProjectRole | null> {
+ const { data, error } = await tryCatch(() => getPrincipalRoleOrThrow(userId, projectId, log))
+ if (isNil(error)) {
+ return data
+ }
+ if (error instanceof ActivepiecesError && error.error.code === ErrorCode.AUTHORIZATION) {
+ return null
+ }
+ throw error
}
function buildChecker(check: PermissionChecker['check']): PermissionChecker {
return {
check,
wrapExecute: ({ execute, permission, toolTitle }) => {
- const error = check(permission, toolTitle)
- return isNil(error) ? execute : async () => error
+ const denial = check(permission, toolTitle)
+ return isNil(denial) ? execute : async () => denial
},
}
}
+export function deny(text: string): McpToolResult {
+ return { content: [{ type: 'text', text }], isError: true }
+}
+
export type PermissionChecker = {
- check: (permission: Permission | undefined, toolTitle: string) => McpToolErrorResult | null
+ check: (permission: Permission | undefined, toolTitle: string) => McpToolResult | null
wrapExecute: (params: { execute: McpToolDefinition['execute'], permission: Permission | undefined, toolTitle: string }) => McpToolDefinition['execute']
}
-type McpToolErrorResult = {
- content: Array<{ type: 'text', text: string }>
- isError: boolean
+type ResolveCheckerParams = {
+ userId: string
+ projectId: string
+ log: FastifyBaseLogger
}
diff --git a/packages/server/api/src/app/mcp/mcp-platform-controller.ts b/packages/server/api/src/app/mcp/mcp-platform-controller.ts
index 63526277118..5443f0093ed 100644
--- a/packages/server/api/src/app/mcp/mcp-platform-controller.ts
+++ b/packages/server/api/src/app/mcp/mcp-platform-controller.ts
@@ -1,6 +1,10 @@
-import { PrincipalType, SERVICE_KEY_SECURITY_OPENAPI, UpdateMcpServerRequest } from '@activepieces/shared'
+import { ActivepiecesError, ErrorCode } from '@activepieces/core-utils'
+import { McpReachResponse, PrincipalType, SERVICE_KEY_SECURITY_OPENAPI, UpdateMcpServerRequest } from '@activepieces/shared'
import { FastifyPluginAsyncZod } from 'fastify-type-provider-zod'
+import { StatusCodes } from 'http-status-codes'
import { securityAccess } from '../core/security/authorization/fastify-security'
+import { userIdentityHelper } from '../helper/user-identity-helper'
+import { mcpAccess } from './mcp-access'
import { mcpServerService } from './mcp-service'
export const mcpPlatformController: FastifyPluginAsyncZod = async (app) => {
@@ -9,6 +13,21 @@ export const mcpPlatformController: FastifyPluginAsyncZod = async (app) => {
return mcpServerService(req.log).getByPlatformId(req.principal.platform.id)
})
+ app.get('/reach', GetMcpReachRoute, async (req) => {
+ const userId = req.principal.id
+ if (await userIdentityHelper(req.log).isUserEmbedded(userId)) {
+ throw new ActivepiecesError({
+ code: ErrorCode.AUTHORIZATION,
+ params: { message: 'Embedded users cannot list MCP reach across projects' },
+ })
+ }
+ return mcpAccess.resolveReach({
+ platformId: req.principal.platform.id,
+ userId,
+ log: req.log,
+ })
+ })
+
app.post('/', UpdatePlatformMcpRoute, async (req) => {
const { disabledTools } = req.body
return mcpServerService(req.log).updatePlatform({
@@ -35,6 +54,19 @@ const GetPlatformMcpRoute = {
},
}
+const GetMcpReachRoute = {
+ config: {
+ security: securityAccess.publicPlatform([PrincipalType.USER]),
+ },
+ schema: {
+ tags: ['mcp'],
+ description: 'List the projects where the caller may use MCP',
+ response: {
+ [StatusCodes.OK]: McpReachResponse,
+ },
+ },
+}
+
const UpdatePlatformMcpRoute = {
config: {
security: securityAccess.platformAdminOnly([PrincipalType.USER]),
diff --git a/packages/server/api/src/app/mcp/mcp-server-builder.ts b/packages/server/api/src/app/mcp/mcp-server-builder.ts
index cc51bc441c0..646764b9b9e 100644
--- a/packages/server/api/src/app/mcp/mcp-server-builder.ts
+++ b/packages/server/api/src/app/mcp/mcp-server-builder.ts
@@ -1,5 +1,5 @@
import { isNil, Permission } from '@activepieces/core-utils'
-import { FlowStatus, McpOAuthClientKey, McpProperty, McpToolDefinition, mcpToolNameUtils, McpToolResult, McpTrigger, PopulatedFlow, PopulatedMcpServer, ProjectScopedMcpServer, TelemetryEventName } from '@activepieces/shared'
+import { FlowStatus, McpOAuthClientKey, McpProperty, McpServer as McpServerSchema, McpToolDefinition, mcpToolNameUtils, McpToolResult, McpTrigger, PopulatedFlow, PopulatedMcpServer, ProjectScopedMcpServer, TelemetryEventName } from '@activepieces/shared'
import { McpServer, ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js'
import { FastifyBaseLogger } from 'fastify'
import { flowService } from '../flows/flow/flow.service'
@@ -9,7 +9,8 @@ import { AppSystemProp } from '../helper/system/system-props'
import { telemetry } from '../helper/telemetry.utils'
import { WebhookFlowVersionToRun, webhookService } from '../webhooks/webhook.service'
import { McpActivityContext, withActivityRecording } from './activity/mcp-activity-recorder'
-import { ALLOW_ALL, PermissionChecker, resolvePermissionChecker } from './mcp-permissions'
+import { mcpAccess } from './mcp-access'
+import { ALLOW_ALL, PermissionChecker, resolveMcpPermissionChecker, resolvePermissionChecker } from './mcp-permissions'
import { mcpProjectSelection, ProjectSelectionScope } from './mcp-project-selection'
import { mcpToolInput } from './mcp-tool-input'
import { McpCallBilling, mcpUsageTracker } from './mcp-usage-tracker'
@@ -21,6 +22,7 @@ const PLATFORM_LEVEL_TOOL_SET = new Set<string>(PLATFORM_LEVEL_TOOL_NAMES)
const MCP_SERVER_INSTRUCTIONS = `## Activepieces MCP Server
### Workflow
+0. Project: on the platform server, call ap_set_project_context first — every project tool, including ap_list_connections and ap_list_ai_models, needs a selected project
1. Discover: ap_research_pieces, ap_list_connections, ap_list_ai_models
2. Schema: ap_get_piece_props (get field names/types before configuring)
3. Build: ap_build_flow (one call for new flows) OR ap_create_flow → ap_update_trigger → ap_add_step (granular)
@@ -36,14 +38,15 @@ const MCP_SERVER_INSTRUCTIONS = `## Activepieces MCP Server
- **CODE steps**: export a \`code\` fn; access inputs via \`inputs.key\`.
- **Tables**: use field names, not IDs.`
-export async function buildMcpServer({ mcp, userId, platformId, clientKey, clientId, log, resolveProjectMcp }: {
+export async function buildMcpServer({ mcp, userId, platformId, clientKey, clientId, isInAppChat, log, resolveProjectMcp }: {
mcp: PopulatedMcpServer
userId?: string
platformId?: string
clientKey: McpOAuthClientKey | null
clientId: string
+ isInAppChat: boolean
log: FastifyBaseLogger
- resolveProjectMcp?: (projectId: string) => Promise<PopulatedMcpServer>
+ resolveProjectMcp?: (projectId: string) => Promise<McpServerSchema>
}): Promise<McpServer> {
const projectId = mcp.projectId
@@ -71,15 +74,16 @@ export async function buildMcpServer({ mcp, userId, platformId, clientKey, clien
const billing = await mcpUsageTracker(log).resolveCallBilling({ mcp, clientId })
if (projectId) {
+ const resolveChecker = isInAppChat ? resolvePermissionChecker : resolveMcpPermissionChecker
const permissionChecker = userId
- ? await resolvePermissionChecker({ userId, projectId, log })
+ ? await resolveChecker({ userId, projectId, log })
: ALLOW_ALL
const activityContext: McpActivityContext | null = isNil(platformId) || isNil(userId) ? null : { platformId, projectId, userId, clientKey }
registerFlowTools({ server, mcp, projectId, permissionChecker, billing, log })
registerStaticTools({ server, mcp, projectId, userId, permissionChecker, activityContext, billing, log })
}
else if (!isNil(mcp.platformId) && !isNil(userId) && !isNil(resolveProjectMcp)) {
- registerPlatformTools({ server, mcp, userId, clientKey, selectionScope: { platformId: mcp.platformId, userId, clientId }, resolveProjectMcp, billing, log })
+ registerPlatformTools({ server, mcp, platformId: mcp.platformId, userId, clientKey, selectionScope: { platformId: mcp.platformId, userId, clientId }, resolveProjectMcp, billing, log })
}
else {
registerPlaceholderTools(server)
@@ -89,19 +93,19 @@ export async function buildMcpServer({ mcp, userId, platformId, clientKey, clien
return server
}
-function registerPlatformTools({ server, mcp, userId, clientKey, selectionScope, resolveProjectMcp, billing, log }: {
+function registerPlatformTools({ server, mcp, platformId, userId, clientKey, selectionScope, resolveProjectMcp, billing, log }: {
server: McpServer
mcp: PopulatedMcpServer
+ platformId: string
userId: string
clientKey: McpOAuthClientKey | null
selectionScope: ProjectSelectionScope
- resolveProjectMcp: (projectId: string) => Promise<PopulatedMcpServer>
+ resolveProjectMcp: (projectId: string) => Promise<McpServerSchema>
billing: McpCallBilling
log: FastifyBaseLogger
}): void {
- const platformId = mcp.platformId!
const contextTool = apSetProjectContextTool({ platformId, userId, selectionScope, log })
- server.registerTool(contextTool.title, buildToolConfig(contextTool), (args: Record<string, unknown>) => charged({ execute: contextTool.execute, toolName: contextTool.title, projectId: null, billing })(args))
+ server.registerTool(contextTool.title, buildToolConfig(contextTool), (args: Record<string, unknown>) => withMcpReach({ execute: charged({ execute: contextTool.execute, toolName: contextTool.title, projectId: null, billing }), toolTitle: contextTool.title, platformId, userId, log })(args))
const templateMcp: ProjectScopedMcpServer = { ...mcp, projectId: platformId }
const allTools = activepiecesTools(templateMcp, userId, log)
@@ -110,7 +114,7 @@ function registerPlatformTools({ server, mcp, userId, clientKey, selectionScope,
tools.forEach((tool) => {
if (PLATFORM_LEVEL_TOOL_SET.has(tool.title)) {
- server.registerTool(tool.title, buildToolConfig(tool), (args: Record<string, unknown>) => charged({ execute: tool.execute, toolName: tool.title, projectId: null, billing })(args))
+ server.registerTool(tool.title, buildToolConfig(tool), (args: Record<string, unknown>) => withMcpReach({ execute: charged({ execute: tool.execute, toolName: tool.title, projectId: null, billing }), toolTitle: tool.title, platformId, userId, log })(args))
return
}
@@ -136,13 +140,13 @@ async function executeInSelectedProject({ toolTitle, args, projectId, userId, re
args: Record<string, unknown>
projectId: string
userId: string
- resolveProjectMcp: (projectId: string) => Promise<PopulatedMcpServer>
+ resolveProjectMcp: (projectId: string) => Promise<McpServerSchema>
billing: McpCallBilling
log: FastifyBaseLogger
}): Promise<McpToolResult> {
const projectMcp = await resolveProjectMcp(projectId)
const projectScopedMcp: ProjectScopedMcpServer = { ...projectMcp, projectId }
- const permissionChecker = await resolvePermissionChecker({ userId, projectId, log })
+ const permissionChecker = await resolveMcpPermissionChecker({ userId, projectId, log })
const realTools = activepiecesTools(projectScopedMcp, userId, log)
const realTool = realTools.find(t => t.title === toolTitle)
if (isNil(realTool)) {
@@ -159,6 +163,22 @@ async function executeInSelectedProject({ toolTitle, args, projectId, userId, re
return execute(args)
}
+function withMcpReach({ execute, toolTitle, platformId, userId, log }: {
+ execute: McpToolDefinition['execute']
+ toolTitle: string
+ platformId: string
+ userId: string
+ log: FastifyBaseLogger
+}): McpToolDefinition['execute'] {
+ return async (args) => {
+ const reachesMcp = await mcpAccess.hasMcpReach({ platformId, userId, log })
+ if (!reachesMcp) {
+ return mcpAccess.noMcpReachResult(toolTitle)
+ }
+ return execute(args)
+ }
+}
+
function noProjectSelectedResult(): McpToolResult {
return {
content: [{
diff --git a/packages/server/api/src/app/mcp/mcp-service.ts b/packages/server/api/src/app/mcp/mcp-service.ts
index 2aa09c971da..5df0d966403 100644
--- a/packages/server/api/src/app/mcp/mcp-service.ts
+++ b/packages/server/api/src/app/mcp/mcp-service.ts
@@ -62,15 +62,16 @@ export const mcpServerService = (log: FastifyBaseLogger) => ({
return mcpServerService(log).getByPlatformId(platformId)
},
- buildServer: async ({ mcp, userId, platformId, clientKey, clientId }: { mcp: PopulatedMcpServer, userId?: string, platformId?: string, clientKey?: McpOAuthClientKey | null, clientId: string }) => {
+ buildServer: async ({ mcp, userId, platformId, clientKey, clientId, isInAppChat }: { mcp: PopulatedMcpServer, userId?: string, platformId?: string, clientKey?: McpOAuthClientKey | null, clientId: string, isInAppChat?: boolean }) => {
return buildMcpServer({
mcp,
userId,
platformId,
clientKey: clientKey ?? null,
clientId,
+ isInAppChat: isInAppChat ?? false,
log,
- resolveProjectMcp: (projectId: string) => mcpServerService(log).getPopulatedByProjectId(projectId),
+ resolveProjectMcp: (projectId: string) => mcpServerService(log).getByProjectId(projectId),
})
},
})
diff --git a/packages/server/api/src/app/mcp/oauth/code/mcp-oauth-approve.controller.ts b/packages/server/api/src/app/mcp/oauth/code/mcp-oauth-approve.controller.ts
index 37344130583..668ccf44a63 100644
--- a/packages/server/api/src/app/mcp/oauth/code/mcp-oauth-approve.controller.ts
+++ b/packages/server/api/src/app/mcp/oauth/code/mcp-oauth-approve.controller.ts
@@ -1,11 +1,11 @@
import { isNil, tryCatch } from '@activepieces/core-utils'
-import { PlatformRole, PrincipalType } from '@activepieces/shared'
+import { PrincipalType } from '@activepieces/shared'
import { FastifyPluginAsyncZod } from 'fastify-type-provider-zod'
import { z } from 'zod'
import { securityAccess } from '../../../core/security/authorization/fastify-security'
import { JwtAudience, jwtUtils } from '../../../helper/jwt-utils'
-import { projectService } from '../../../project/project-service'
-import { userService } from '../../../user/user-service'
+import { userIdentityHelper } from '../../../helper/user-identity-helper'
+import { mcpAccess } from '../../mcp-access'
import { mcpOAuthCodeService } from './mcp-oauth-code.service'
export const mcpOAuthApproveController: FastifyPluginAsyncZod = async (app) => {
@@ -16,22 +16,16 @@ export const mcpOAuthApproveController: FastifyPluginAsyncZod = async (app) => {
const platformId = req.principal.platform.id
if (isNil(projectId)) {
- const user = await userService(req.log).getOneOrFail({ id: userId })
- if (user.platformRole !== PlatformRole.ADMIN) {
- return reply.status(403).send({ error: 'access_denied', error_description: 'Only platform administrators can authorize platform-wide MCP access' })
+ if (await userIdentityHelper(req.log).isUserEmbedded(userId)) {
+ return reply.status(403).send({ error: 'access_denied', error_description: 'Embedded users must authorize MCP for a specific project' })
}
- }
- else {
- const user = await userService(req.log).getOneOrFail({ id: userId })
- const accessibleProjects = await projectService(req.log).getAllForUser({
- platformId,
- userId,
- isPrivileged: userService(req.log).isUserPrivileged(user),
- })
- if (!accessibleProjects.some(p => p.id === projectId)) {
- return reply.status(403).send({ error: 'access_denied', error_description: 'You do not have access to this project' })
+ if (!await mcpAccess.hasMcpReach({ platformId, userId, log: req.log })) {
+ return reply.status(403).send({ error: 'access_denied', error_description: 'You do not have MCP access in any project' })
}
}
+ else if (!await mcpAccess.hasMcpAccessToProject({ platformId, userId, projectId, log: req.log })) {
+ return reply.status(403).send({ error: 'access_denied', error_description: 'You do not have MCP access to this project' })
+ }
const { data: authRequest, error } = await tryCatch(() => verifyAuthRequest(authRequestId))
if (error) {
diff --git a/packages/server/api/src/app/mcp/oauth/mcp-oauth.controller.ts b/packages/server/api/src/app/mcp/oauth/mcp-oauth.controller.ts
index 590b3ff54ce..fffb076599a 100644
--- a/packages/server/api/src/app/mcp/oauth/mcp-oauth.controller.ts
+++ b/packages/server/api/src/app/mcp/oauth/mcp-oauth.controller.ts
@@ -12,7 +12,7 @@ import { domainHelper } from '../../helper/domain-helper'
import { rejectedPromiseHandler } from '../../helper/promise-handler'
import { telemetry, telemetryDedupe } from '../../helper/telemetry.utils'
import { mcpServerService } from '../mcp-service'
-import { mcpOAuthTokenService } from './token/mcp-oauth-token.service'
+import { INTERNAL_CHAT_CLIENT_ID, mcpOAuthTokenService } from './token/mcp-oauth-token.service'
export const mcpOAuthHttpController: FastifyPluginAsyncZod = async (app) => {
registerMcpEndpoint(app, McpServerType.PROJECT)
@@ -77,7 +77,7 @@ function registerMcpEndpoint(app: Parameters<FastifyPluginAsyncZod>[0], scope: M
const serverMcp = conversationProjectId
? await mcpServerService(req.log).getPopulatedByProjectId(conversationProjectId) ?? mcp
: mcp
- const { server } = await mcpServerService(req.log).buildServer({ mcp: serverMcp, userId, platformId, clientKey: identity.clientKey, clientId: identity.clientId })
+ const { server } = await mcpServerService(req.log).buildServer({ mcp: serverMcp, userId, platformId, clientKey: identity.clientKey, clientId: identity.clientId, isInAppChat: isInAppChatIdentity(identity) })
const transport = new StreamableHTTPServerTransport({
sessionIdGenerator: undefined,
@@ -189,6 +189,10 @@ type IdentityResult =
const chatConversationRepo = repoFactory(AgentConversationEntity)
+function isInAppChatIdentity(identity: ResolvedIdentity): boolean {
+ return identity.type === McpServerType.PLATFORM && identity.clientId === INTERNAL_CHAT_CLIENT_ID
+}
+
async function resolveConversationProjectId({ conversationId, identity, log }: {
conversationId: string
identity: ResolvedIdentity
diff --git a/packages/server/api/src/app/mcp/tools/ap-set-project-context.ts b/packages/server/api/src/app/mcp/tools/ap-set-project-context.ts
index 319337f27e8..687700147dc 100644
--- a/packages/server/api/src/app/mcp/tools/ap-set-project-context.ts
+++ b/packages/server/api/src/app/mcp/tools/ap-set-project-context.ts
@@ -2,8 +2,7 @@ import { isNil } from '@activepieces/core-utils'
import { McpToolDefinition } from '@activepieces/shared'
import { FastifyBaseLogger } from 'fastify'
import { z } from 'zod'
-import { projectService } from '../../project/project-service'
-import { userService } from '../../user/user-service'
+import { mcpAccess } from '../mcp-access'
import { mcpProjectSelection, ProjectSelectionScope } from '../mcp-project-selection'
export const apSetProjectContextTool = ({ platformId, userId, selectionScope, log }: {
@@ -12,7 +11,7 @@ export const apSetProjectContextTool = ({ platformId, userId, selectionScope, lo
selectionScope: ProjectSelectionScope
log: FastifyBaseLogger
}): McpToolDefinition => ({
- title: 'ap_set_project_context',
+ title: SET_PROJECT_CONTEXT_TOOL_NAME,
description: 'Set or clear the active project context. All tools require a project context to operate. Call with a projectId to select a project, or without to clear the selection. Always returns the list of available projects.',
inputSchema: {
projectId: z.string().optional().describe('The project ID to select. Omit to clear the current selection and list available projects.'),
@@ -26,12 +25,11 @@ export const apSetProjectContextTool = ({ platformId, userId, selectionScope, lo
execute: async (args: Record<string, unknown>) => {
const projectId = args.projectId as string | undefined
- const user = await userService(log).getOneOrFail({ id: userId })
- const projects = await projectService(log).getAllForUser({
- platformId,
- userId,
- isPrivileged: userService(log).isUserPrivileged(user),
- })
+ const projects = await mcpAccess.listAccessibleProjects({ platformId, userId, log })
+
+ if (projects.length === 0) {
+ return mcpAccess.noMcpReachResult(SET_PROJECT_CONTEXT_TOOL_NAME)
+ }
if (!isNil(projectId) && projectId !== '') {
const targetProject = projects.find(p => p.id === projectId)
@@ -67,3 +65,5 @@ export const apSetProjectContextTool = ({ platformId, userId, selectionScope, lo
}
},
})
+
+export const SET_PROJECT_CONTEXT_TOOL_NAME = 'ap_set_project_context'
diff --git a/packages/server/api/src/app/mcp/tools/index.ts b/packages/server/api/src/app/mcp/tools/index.ts
index 80adb06e2cd..45317e7e84e 100644
--- a/packages/server/api/src/app/mcp/tools/index.ts
+++ b/packages/server/api/src/app/mcp/tools/index.ts
@@ -76,7 +76,6 @@ export const PLATFORM_LEVEL_TOOL_NAMES = [
'ap_research_pieces',
'ap_search_actions',
'ap_search_triggers',
- 'ap_list_ai_models',
'ap_get_piece_props',
] as const
diff --git a/packages/server/api/test/helpers/mcp-client.ts b/packages/server/api/test/helpers/mcp-client.ts
new file mode 100644
index 00000000000..19550de0417
--- /dev/null
+++ b/packages/server/api/test/helpers/mcp-client.ts
@@ -0,0 +1,126 @@
+import { spreadIfDefined } from '@activepieces/core-utils'
+import { FastifyInstance, InjectOptions } from 'fastify'
+import { CONVERSATION_ID_HEADER } from '../../src/app/ee/agent/mcp/agent-mcp'
+import { MCP_OAUTH_REDIRECT_URI, mcpOAuthTestHelpers } from './mcp-oauth'
+
+async function connect({ app, approve, projectId, conversationId }: ConnectParams): Promise<McpClient> {
+ const client = await mcpOAuthTestHelpers.registerClient({ app, tokenEndpointAuthMethod: 'none' })
+ const { verifier, challenge } = mcpOAuthTestHelpers.generatePkce()
+
+ const consent = await app.inject({
+ method: 'GET',
+ url: '/authorize?' + new URLSearchParams({
+ client_id: client.client_id,
+ redirect_uri: MCP_OAUTH_REDIRECT_URI,
+ response_type: 'code',
+ code_challenge: challenge,
+ code_challenge_method: 'S256',
+ scope: 'mcp',
+ resource: projectId ? PROJECT_RESOURCE : PLATFORM_RESOURCE,
+ }).toString(),
+ })
+
+ const authRequestId = new URL(String(consent.headers.location), MCP_OAUTH_REDIRECT_URI).searchParams.get('authRequestId') ?? ''
+ const approved = await approve({
+ authRequestId,
+ ...spreadIfDefined('projectId', projectId),
+ })
+
+ const code = new URL(approved.json().redirectUrl).searchParams.get('code') ?? ''
+ const token = await app.inject({
+ method: 'POST',
+ url: '/token',
+ payload: {
+ grant_type: 'authorization_code',
+ client_id: client.client_id,
+ code,
+ code_verifier: verifier,
+ redirect_uri: MCP_OAUTH_REDIRECT_URI,
+ },
+ })
+
+ return {
+ accessToken: token.json().access_token,
+ endpoint: projectId ? '/mcp' : '/mcp/platform',
+ ...spreadIfDefined('conversationId', conversationId),
+ }
+}
+
+async function callTool({ app, mcpClient, name, args }: CallToolParams): Promise<string> {
+ const message = await rpc({
+ app,
+ mcpClient,
+ body: { method: 'tools/call', params: { name, arguments: args ?? {} } },
+ })
+ return (message.result?.content ?? []).map((part) => part.text ?? '').join('\n')
+}
+
+async function listToolNames({ app, mcpClient }: { app: FastifyInstance, mcpClient: McpClient }): Promise<string[]> {
+ const message = await rpc({
+ app,
+ mcpClient,
+ body: { method: 'tools/list', params: {} },
+ })
+ return (message.result?.tools ?? []).map((tool) => tool.name)
+}
+
+async function rpc({ app, mcpClient, body }: RpcParams): Promise<JsonRpcResponse> {
+ const inject: InjectOptions = {
+ method: 'POST',
+ url: mcpClient.endpoint,
+ headers: {
+ 'authorization': `Bearer ${mcpClient.accessToken}`,
+ 'content-type': 'application/json',
+ 'accept': 'application/json, text/event-stream',
+ ...(mcpClient.conversationId ? { [CONVERSATION_ID_HEADER]: mcpClient.conversationId } : {}),
+ },
+ payload: { jsonrpc: '2.0', id: 1, ...body },
+ }
+ const res = await app.inject(inject)
+ const dataLine = res.body.split('\n').find((line) => line.startsWith('data: '))
+ return JSON.parse(dataLine ? dataLine.slice('data: '.length) : res.body)
+}
+
+export const mcpClientHelpers = {
+ connect,
+ callTool,
+ listToolNames,
+}
+
+export const PLATFORM_RESOURCE = 'https://cloud.activepieces.com/mcp/platform'
+export const PROJECT_RESOURCE = 'https://cloud.activepieces.com/mcp'
+
+export type McpClient = {
+ accessToken: string
+ endpoint: string
+ conversationId?: string
+}
+
+type ApproveRequest = (payload: { authRequestId: string, projectId?: string }) => ReturnType<FastifyInstance['inject']>
+
+type ConnectParams = {
+ app: FastifyInstance
+ approve: ApproveRequest
+ projectId?: string
+ conversationId?: string
+}
+
+type CallToolParams = {
+ app: FastifyInstance
+ mcpClient: McpClient
+ name: string
+ args?: Record<string, unknown>
+}
+
+type RpcParams = {
+ app: FastifyInstance
+ mcpClient: McpClient
+ body: { method: string, params: Record<string, unknown> }
+}
+
+type JsonRpcResponse = {
+ result?: {
+ content?: Array<{ type: string, text?: string }>
+ tools?: Array<{ name: string }>
+ }
+}
diff --git a/packages/server/api/test/integration/ce/mcp/mcp-access-ce.test.ts b/packages/server/api/test/integration/ce/mcp/mcp-access-ce.test.ts
new file mode 100644
index 00000000000..5dc2bec975a
--- /dev/null
+++ b/packages/server/api/test/integration/ce/mcp/mcp-access-ce.test.ts
@@ -0,0 +1,111 @@
+import { apId, Permission, RoleType } from '@activepieces/core-utils'
+import { DefaultProjectRole, ProjectMember } from '@activepieces/shared'
+import { FastifyInstance } from 'fastify'
+import { afterAll, beforeAll, describe, expect, it } from 'vitest'
+import { mcpAccess } from '../../../../src/app/mcp/mcp-access'
+import { db } from '../../../helpers/db'
+import { McpClient, mcpClientHelpers } from '../../../helpers/mcp-client'
+import { createMockProjectRole } from '../../../helpers/mocks'
+import { createMemberContext, createTestContext, TestContext } from '../../../helpers/test-context'
+import { setupTestEnvironment, teardownTestEnvironment } from '../../../helpers/test-setup'
+
+let app: FastifyInstance
+
+const LOCKED_TOOL = 'ap_list_flows'
+const PIECE_CATALOG_TOOL = 'ap_research_pieces'
+
+beforeAll(async () => {
+ app = await setupTestEnvironment()
+})
+
+afterAll(async () => {
+ await teardownTestEnvironment()
+})
+
+async function createCustomRoleMember({ ctx, permissions }: { ctx: TestContext, permissions: Permission[] }): Promise<TestContext> {
+ const role = createMockProjectRole({
+ platformId: ctx.platform.id,
+ name: `role-${apId()}`,
+ permissions,
+ type: RoleType.CUSTOM,
+ })
+ await db.save('project_role', role)
+ return createMemberContext(app, ctx, { projectRole: role.name })
+}
+
+function connectAs({ ctx }: { ctx: TestContext }): Promise<McpClient> {
+ return mcpClientHelpers.connect({
+ app,
+ approve: (payload) => ctx.post('/v1/mcp-oauth/approve', payload),
+ })
+}
+
+function call({ mcpClient, name, args }: { mcpClient: McpClient, name: string, args?: Record<string, unknown> }): Promise<string> {
+ return mcpClientHelpers.callTool({ app, mcpClient, name, args })
+}
+
+describe('MCP access on community edition', () => {
+ it('keeps a project accessible although the role lacks READ_MCP, because community edition has no RBAC', async () => {
+ const ctx = await createTestContext(app)
+ const member = await createCustomRoleMember({ ctx, permissions: [Permission.READ_FLOW] })
+
+ const projects = await mcpAccess.listAccessibleProjects({ platformId: ctx.platform.id, userId: member.user.id, log: app.log })
+
+ expect(projects.map(p => p.id)).toEqual([ctx.project.id])
+ })
+
+ it('lets a member whose role lacks READ_MCP connect and run a read tool', async () => {
+ const ctx = await createTestContext(app)
+ const member = await createCustomRoleMember({ ctx, permissions: [Permission.READ_FLOW] })
+ const mcpClient = await connectAs({ ctx: member })
+
+ await call({ mcpClient, name: 'ap_set_project_context', args: { projectId: ctx.project.id } })
+ const listed = await call({ mcpClient, name: LOCKED_TOOL })
+
+ expect(listed).not.toContain('Permission denied')
+ })
+
+ it('lets a member whose role lacks READ_MCP run a piece-catalog tool', async () => {
+ const ctx = await createTestContext(app)
+ const member = await createCustomRoleMember({ ctx, permissions: [Permission.READ_FLOW] })
+ const mcpClient = await connectAs({ ctx: member })
+
+ const researched = await call({ mcpClient, name: PIECE_CATALOG_TOOL, args: { query: 'slack' } })
+
+ expect(researched).not.toContain('Permission denied')
+ })
+
+ it('refuses a piece-catalog tool on an issued token once the member leaves every project', async () => {
+ const ctx = await createTestContext(app)
+ const member = await createMemberContext(app, ctx, { projectRole: DefaultProjectRole.EDITOR })
+ const mcpClient = await connectAs({ ctx: member })
+ expect(await call({ mcpClient, name: PIECE_CATALOG_TOOL, args: { query: 'slack' } })).not.toContain('Permission denied')
+
+ const membership = await db.findOneByOrFail<ProjectMember>('project_member', { userId: member.user.id })
+ await db.delete('project_member', membership.id)
+
+ expect(await call({ mcpClient, name: PIECE_CATALOG_TOOL, args: { query: 'slack' } })).toContain(Permission.READ_MCP)
+ })
+
+ it('refuses project selection on an issued token once the member leaves every project', async () => {
+ const ctx = await createTestContext(app)
+ const member = await createMemberContext(app, ctx, { projectRole: DefaultProjectRole.EDITOR })
+ const mcpClient = await connectAs({ ctx: member })
+
+ const membership = await db.findOneByOrFail<ProjectMember>('project_member', { userId: member.user.id })
+ await db.delete('project_member', membership.id)
+
+ expect(await call({ mcpClient, name: 'ap_set_project_context', args: { projectId: ctx.project.id } })).toContain(Permission.READ_MCP)
+ })
+
+ it('refuses platform-wide authorization to a member who belongs to no project', async () => {
+ const ctx = await createTestContext(app)
+ const member = await createMemberContext(app, ctx, { projectRole: DefaultProjectRole.EDITOR })
+ const membership = await db.findOneByOrFail<ProjectMember>('project_member', { userId: member.user.id })
+ await db.delete('project_member', membership.id)
+
+ const response = await member.post('/v1/mcp-oauth/approve', { authRequestId: 'unused' })
+
+ expect(response.statusCode).toBe(403)
+ })
+})
diff --git a/packages/server/api/test/integration/cloud/mcp/mcp-access.test.ts b/packages/server/api/test/integration/cloud/mcp/mcp-access.test.ts
new file mode 100644
index 00000000000..6385d445a13
--- /dev/null
+++ b/packages/server/api/test/integration/cloud/mcp/mcp-access.test.ts
@@ -0,0 +1,254 @@
+import { apId, Permission, RoleType } from '@activepieces/core-utils'
+import { DefaultProjectRole, PlatformRole, PrincipalType, ProjectType, UserIdentityProvider } from '@activepieces/shared'
+import { FastifyBaseLogger, FastifyInstance } from 'fastify'
+import { afterAll, beforeAll, describe, expect, it } from 'vitest'
+import { mcpAccess } from '../../../../src/app/mcp/mcp-access'
+import { generateMockToken } from '../../../helpers/auth'
+import { db } from '../../../helpers/db'
+import { createMockProject, createMockProjectMember, createMockProjectRole, mockBasicUser } from '../../../helpers/mocks'
+import { createMemberContext, createTestContext, TestContext } from '../../../helpers/test-context'
+import { setupTestEnvironment, teardownTestEnvironment } from '../../../helpers/test-setup'
+
+let app: FastifyInstance
+let mockLog: FastifyBaseLogger
+
+beforeAll(async () => {
+ app = await setupTestEnvironment()
+ mockLog = app.log
+})
+
+afterAll(async () => {
+ await teardownTestEnvironment()
+})
+
+async function embeddedMemberToken(ctx: TestContext): Promise<string> {
+ const { mockUser } = await mockBasicUser({
+ userIdentity: { provider: UserIdentityProvider.JWT, verified: true },
+ user: { platformId: ctx.platform.id, platformRole: PlatformRole.MEMBER },
+ })
+ const role = createMockProjectRole({
+ platformId: ctx.platform.id,
+ name: `embed-role-${apId()}`,
+ permissions: [Permission.READ_MCP],
+ type: RoleType.CUSTOM,
+ })
+ await db.save('project_role', role)
+ await db.save('project_member', createMockProjectMember({
+ userId: mockUser.id,
+ platformId: ctx.platform.id,
+ projectId: ctx.project.id,
+ projectRoleId: role.id,
+ }))
+ return generateMockToken({
+ id: mockUser.id,
+ type: PrincipalType.USER,
+ platform: { id: ctx.platform.id },
+ })
+}
+
+describe('mcpAccess.listAccessibleProjects', () => {
+ it('returns every project for a privileged (admin) user', async () => {
+ const ctx = await createTestContext(app)
+
+ const projects = await mcpAccess.listAccessibleProjects({ platformId: ctx.platform.id, userId: ctx.user.id, log: mockLog })
+
+ expect(projects.map(p => p.id)).toContain(ctx.project.id)
+ })
+
+ it('includes a project whose member role grants READ_MCP', async () => {
+ const ctx = await createTestContext(app)
+ const member = await createMemberContext(app, ctx, { projectRole: DefaultProjectRole.EDITOR })
+
+ const projects = await mcpAccess.listAccessibleProjects({ platformId: ctx.platform.id, userId: member.user.id, log: mockLog })
+
+ expect(projects.map(p => p.id)).toContain(ctx.project.id)
+ })
+
+ it('excludes a project whose member role lacks READ_MCP', async () => {
+ const ctx = await createTestContext(app)
+ const roleWithoutMcp = createMockProjectRole({
+ platformId: ctx.platform.id,
+ name: `no-mcp-${apId()}`,
+ permissions: [Permission.READ_FLOW],
+ type: RoleType.CUSTOM,
+ })
+ await db.save('project_role', roleWithoutMcp)
+ const member = await createMemberContext(app, ctx, { projectRole: roleWithoutMcp.name })
+
+ const projects = await mcpAccess.listAccessibleProjects({ platformId: ctx.platform.id, userId: member.user.id, log: mockLog })
+
+ expect(projects).toHaveLength(0)
+ })
+
+ it('grants no MCP reach to a member without a personal project, as when autoCreatePersonalProjects is off', async () => {
+ const ctx = await createTestContext(app, { platform: { autoCreatePersonalProjects: false } })
+ const roleWithoutMcp = createMockProjectRole({
+ platformId: ctx.platform.id,
+ name: `no-mcp-${apId()}`,
+ permissions: [Permission.READ_FLOW, Permission.WRITE_FLOW],
+ type: RoleType.CUSTOM,
+ })
+ await db.save('project_role', roleWithoutMcp)
+ const member = await createMemberContext(app, ctx, { projectRole: roleWithoutMcp.name })
+
+ const projects = await mcpAccess.listAccessibleProjects({ platformId: ctx.platform.id, userId: member.user.id, log: mockLog })
+
+ expect(projects).toHaveLength(0)
+ })
+
+ it('returns nothing for a member who has no project at all', async () => {
+ const ctx = await createTestContext(app)
+ const { mockUser: stranger } = await mockBasicUser({
+ user: { platformId: ctx.platform.id, platformRole: PlatformRole.MEMBER },
+ })
+
+ const projects = await mcpAccess.listAccessibleProjects({ platformId: ctx.platform.id, userId: stranger.id, log: mockLog })
+
+ expect(projects).toHaveLength(0)
+ })
+
+ it('includes a project the member owns, which grants them the admin role', async () => {
+ const ctx = await createTestContext(app)
+ const { mockUser: owner } = await mockBasicUser({
+ user: { platformId: ctx.platform.id, platformRole: PlatformRole.MEMBER },
+ })
+ const ownedProject = createMockProject({
+ platformId: ctx.platform.id,
+ ownerId: owner.id,
+ type: ProjectType.PERSONAL,
+ })
+ await db.save('project', ownedProject)
+
+ const projects = await mcpAccess.listAccessibleProjects({ platformId: ctx.platform.id, userId: owner.id, log: mockLog })
+
+ expect(projects.map(p => p.id)).toEqual([ownedProject.id])
+ })
+
+ it('keeps an operator on every team project but hides the personal projects of other users', async () => {
+ const ctx = await createTestContext(app)
+ const { mockUser: operator } = await mockBasicUser({
+ user: { platformId: ctx.platform.id, platformRole: PlatformRole.OPERATOR },
+ })
+ const someonesPersonalProject = createMockProject({
+ platformId: ctx.platform.id,
+ ownerId: ctx.user.id,
+ type: ProjectType.PERSONAL,
+ })
+ await db.save('project', someonesPersonalProject)
+
+ const projects = await mcpAccess.listAccessibleProjects({ platformId: ctx.platform.id, userId: operator.id, log: mockLog })
+ const projectIds = projects.map(p => p.id)
+
+ expect(projectIds).toContain(ctx.project.id)
+ expect(projectIds).not.toContain(someonesPersonalProject.id)
+ })
+
+ it('hides the personal projects of other users from a platform admin', async () => {
+ const ctx = await createTestContext(app)
+ const { mockUser: otherUser } = await mockBasicUser({
+ user: { platformId: ctx.platform.id, platformRole: PlatformRole.MEMBER },
+ })
+ const otherUsersPersonalProject = createMockProject({
+ platformId: ctx.platform.id,
+ ownerId: otherUser.id,
+ type: ProjectType.PERSONAL,
+ })
+ await db.save('project', otherUsersPersonalProject)
+
+ const projects = await mcpAccess.listAccessibleProjects({ platformId: ctx.platform.id, userId: ctx.user.id, log: mockLog })
+ const hasAccess = await mcpAccess.hasMcpAccessToProject({ platformId: ctx.platform.id, userId: ctx.user.id, projectId: otherUsersPersonalProject.id, log: mockLog })
+
+ expect(projects.map(p => p.id)).not.toContain(otherUsersPersonalProject.id)
+ expect(hasAccess).toBe(false)
+ })
+
+ it('keeps the admin on their own personal project', async () => {
+ const ctx = await createTestContext(app)
+ const ownPersonalProject = createMockProject({
+ platformId: ctx.platform.id,
+ ownerId: ctx.user.id,
+ type: ProjectType.PERSONAL,
+ })
+ await db.save('project', ownPersonalProject)
+
+ const projects = await mcpAccess.listAccessibleProjects({ platformId: ctx.platform.id, userId: ctx.user.id, log: mockLog })
+ const hasAccess = await mcpAccess.hasMcpAccessToProject({ platformId: ctx.platform.id, userId: ctx.user.id, projectId: ownPersonalProject.id, log: mockLog })
+
+ expect(projects.map(p => p.id)).toContain(ownPersonalProject.id)
+ expect(hasAccess).toBe(true)
+ })
+})
+
+describe('GET /v1/mcp-server/reach', () => {
+ it('answers a member with only the projects where their role grants READ_MCP', async () => {
+ const ctx = await createTestContext(app)
+ const member = await createMemberContext(app, ctx, { projectRole: DefaultProjectRole.EDITOR })
+ const unreachable = createMockProject({
+ platformId: ctx.platform.id,
+ ownerId: ctx.user.id,
+ displayName: `project-${apId()}`,
+ })
+ await db.save('project', unreachable)
+
+ const response = await member.get('/v1/mcp-server/reach')
+
+ expect(response.statusCode).toBe(200)
+ expect(response.json().projectIds).toEqual([ctx.project.id])
+ })
+
+ it('answers a member holding READ_MCP nowhere with an empty list', async () => {
+ const ctx = await createTestContext(app)
+ const roleWithoutMcp = createMockProjectRole({
+ platformId: ctx.platform.id,
+ name: `no-mcp-${apId()}`,
+ permissions: [Permission.READ_FLOW],
+ type: RoleType.CUSTOM,
+ })
+ await db.save('project_role', roleWithoutMcp)
+ const member = await createMemberContext(app, ctx, { projectRole: roleWithoutMcp.name })
+
+ const response = await member.get('/v1/mcp-server/reach')
+
+ expect(response.statusCode).toBe(200)
+ expect(response.json().projectIds).toEqual([])
+ })
+
+ it('answers a platform admin with null, rather than enumerating every project of the platform', async () => {
+ const ctx = await createTestContext(app)
+ const sibling = createMockProject({
+ platformId: ctx.platform.id,
+ ownerId: ctx.user.id,
+ displayName: `project-${apId()}`,
+ })
+ await db.save('project', sibling)
+
+ const response = await ctx.get('/v1/mcp-server/reach')
+
+ expect(response.statusCode).toBe(200)
+ expect(response.json().projectIds).toBeNull()
+ })
+
+ it('refuses an embedded user, who must not read the project ids of their other tenants', async () => {
+ const ctx = await createTestContext(app)
+ const token = await embeddedMemberToken(ctx)
+
+ const response = await app.inject({
+ method: 'GET',
+ url: '/api/v1/mcp-server/reach',
+ headers: { authorization: `Bearer ${token}` },
+ })
+
+ expect(response.statusCode).toBe(403)
+ })
+
+ it('never answers with the platform server token, unlike the admin-only route beside it', async () => {
+ const ctx = await createTestContext(app)
+ const member = await createMemberContext(app, ctx, { projectRole: DefaultProjectRole.EDITOR })
+
+ const reach = await member.get('/v1/mcp-server/reach')
+ const adminOnly = await member.get('/v1/mcp-server')
+
+ expect(Object.keys(reach.json())).toEqual(['projectIds'])
+ expect(adminOnly.statusCode).toBe(403)
+ })
+})
diff --git a/packages/server/api/test/integration/cloud/mcp/mcp-ai-models-scope.test.ts b/packages/server/api/test/integration/cloud/mcp/mcp-ai-models-scope.test.ts
new file mode 100644
index 00000000000..c105332fd58
--- /dev/null
+++ b/packages/server/api/test/integration/cloud/mcp/mcp-ai-models-scope.test.ts
@@ -0,0 +1,118 @@
+import { AIProviderName, apId } from '@activepieces/core-utils'
+import { AIProviderModelType } from '@activepieces/shared'
+import { FastifyInstance } from 'fastify'
+import { afterAll, beforeAll, describe, expect, it } from 'vitest'
+import { db } from '../../../helpers/db'
+import { McpClient, mcpClientHelpers } from '../../../helpers/mcp-client'
+import { createMockProject, mockAndSaveAIProvider } from '../../../helpers/mocks'
+import { createTestContext, TestContext } from '../../../helpers/test-context'
+import { setupTestEnvironment, teardownTestEnvironment } from '../../../helpers/test-setup'
+
+let app: FastifyInstance
+
+const AI_MODELS_TOOL = 'ap_list_ai_models'
+const SCOPED_PROVIDER = AIProviderName.VERTEX
+
+beforeAll(async () => {
+ app = await setupTestEnvironment()
+})
+
+afterAll(async () => {
+ await teardownTestEnvironment()
+})
+
+function connectAs({ ctx }: { ctx: TestContext }): Promise<McpClient> {
+ return mcpClientHelpers.connect({
+ app,
+ approve: (payload) => ctx.post('/v1/mcp-oauth/approve', payload),
+ })
+}
+
+function call({ mcpClient, name, args }: { mcpClient: McpClient, name: string, args?: Record<string, unknown> }): Promise<string> {
+ return mcpClientHelpers.callTool({ app, mcpClient, name, args })
+}
+
+function selectProject({ mcpClient, projectId }: { mcpClient: McpClient, projectId: string }): Promise<string> {
+ return call({ mcpClient, name: 'ap_set_project_context', args: { projectId } })
+}
+
+async function saveScopedProvider({ platformId, projectScope, projectIds }: {
+ platformId: string
+ projectScope: 'all' | 'selected' | 'except'
+ projectIds: string[]
+}): Promise<void> {
+ await mockAndSaveAIProvider({
+ platformId,
+ displayName: `vertex-${apId()}`,
+ provider: SCOPED_PROVIDER,
+ config: {
+ project: 'test-project',
+ region: 'us-central1',
+ models: [{ modelId: 'gemini-test', modelName: 'Gemini Test', modelType: AIProviderModelType.TEXT }],
+ },
+ projectScope,
+ projectIds,
+ })
+}
+
+describe('ap_list_ai_models on the platform MCP server', () => {
+ it('asks for a project instead of answering against the platform id', async () => {
+ const ctx = await createTestContext(app)
+ await saveScopedProvider({ platformId: ctx.platform.id, projectScope: 'all', projectIds: [] })
+ const mcpClient = await connectAs({ ctx })
+
+ const answer = await call({ mcpClient, name: AI_MODELS_TOOL })
+
+ expect(answer).toContain('No project selected')
+ expect(answer).not.toContain(SCOPED_PROVIDER)
+ })
+
+ it('stays in the tool list, because the project is chosen after connecting', async () => {
+ const ctx = await createTestContext(app)
+ const mcpClient = await connectAs({ ctx })
+
+ const toolNames = await mcpClientHelpers.listToolNames({ app, mcpClient })
+
+ expect(toolNames).toContain(AI_MODELS_TOOL)
+ })
+
+ it('hides a provider the selected project is excluded from', async () => {
+ const ctx = await createTestContext(app)
+ await saveScopedProvider({ platformId: ctx.platform.id, projectScope: 'except', projectIds: [ctx.project.id] })
+ const mcpClient = await connectAs({ ctx })
+ await selectProject({ mcpClient, projectId: ctx.project.id })
+
+ const answer = await call({ mcpClient, name: AI_MODELS_TOOL })
+
+ expect(answer).not.toContain(SCOPED_PROVIDER)
+ })
+
+ it('shows a provider scoped to the selected project alone', async () => {
+ const ctx = await createTestContext(app)
+ await saveScopedProvider({ platformId: ctx.platform.id, projectScope: 'selected', projectIds: [ctx.project.id] })
+ const mcpClient = await connectAs({ ctx })
+ await selectProject({ mcpClient, projectId: ctx.project.id })
+
+ const answer = await call({ mcpClient, name: AI_MODELS_TOOL })
+
+ expect(answer).toContain(SCOPED_PROVIDER)
+ })
+
+ it('follows the selection when it moves to a project the provider excludes', async () => {
+ const ctx = await createTestContext(app)
+ const sibling = createMockProject({
+ platformId: ctx.platform.id,
+ ownerId: ctx.user.id,
+ displayName: `project-${apId()}`,
+ })
+ await db.save('project', sibling)
+ await saveScopedProvider({ platformId: ctx.platform.id, projectScope: 'selected', projectIds: [sibling.id] })
+ const mcpClient = await connectAs({ ctx })
+
+ await selectProject({ mcpClient, projectId: sibling.id })
+ expect(await call({ mcpClient, name: AI_MODELS_TOOL })).toContain(SCOPED_PROVIDER)
+
+ await selectProject({ mcpClient, projectId: ctx.project.id })
+ expect(await call({ mcpClient, name: AI_MODELS_TOOL })).not.toContain(SCOPED_PROVIDER)
+ })
+})
diff --git a/packages/server/api/test/integration/cloud/mcp/mcp-in-app-chat-access.test.ts b/packages/server/api/test/integration/cloud/mcp/mcp-in-app-chat-access.test.ts
new file mode 100644
index 00000000000..45dcc2e42f6
--- /dev/null
+++ b/packages/server/api/test/integration/cloud/mcp/mcp-in-app-chat-access.test.ts
@@ -0,0 +1,108 @@
+import { apId, Permission, RoleType } from '@activepieces/core-utils'
+import { FastifyInstance } from 'fastify'
+import { StatusCodes } from 'http-status-codes'
+import { afterAll, beforeAll, describe, expect, it } from 'vitest'
+import { mcpOAuthTokenService } from '../../../../src/app/mcp/oauth/token/mcp-oauth-token.service'
+import { db } from '../../../helpers/db'
+import { McpClient, mcpClientHelpers } from '../../../helpers/mcp-client'
+import { createMockProjectRole } from '../../../helpers/mocks'
+import { createMemberContext, createTestContext, TestContext } from '../../../helpers/test-context'
+import { setupTestEnvironment, teardownTestEnvironment } from '../../../helpers/test-setup'
+
+let app: FastifyInstance
+
+beforeAll(async () => {
+ app = await setupTestEnvironment()
+})
+
+afterAll(async () => {
+ await teardownTestEnvironment()
+})
+
+async function setup({ permissions }: { permissions: Permission[] }): Promise<{ owner: TestContext, member: TestContext }> {
+ const owner = await createTestContext(app, { plan: { agentsEnabled: true, chatEnabled: true } })
+ const role = createMockProjectRole({
+ platformId: owner.platform.id,
+ name: `custom-${apId()}`,
+ permissions,
+ type: RoleType.CUSTOM,
+ })
+ await db.save('project_role', role)
+ const member = await createMemberContext(app, owner, { projectRole: role.name })
+ return { owner, member }
+}
+
+async function startConversation({ ctx, projectId }: { ctx: TestContext, projectId: string }): Promise<string> {
+ const response = await ctx.post('/v1/agents/conversations', {})
+ expect(response.statusCode).toBe(StatusCodes.CREATED)
+ const conversationId = response.json().id
+ await db.update('agent_conversation', conversationId, { projectId })
+ return conversationId
+}
+
+async function chatClient({ ctx, conversationId }: { ctx: TestContext, conversationId: string }): Promise<McpClient> {
+ const accessToken = await mcpOAuthTokenService.issueInternalAccessToken({ userId: ctx.user.id, platformId: ctx.platform.id, projectId: null })
+ return { accessToken, endpoint: '/mcp/platform', conversationId }
+}
+
+describe('In-app AI Chat on the MCP server', () => {
+ it('runs a project tool for a member whose role lacks READ_MCP but grants the tool\'s permission', async () => {
+ const { owner, member } = await setup({ permissions: [Permission.READ_FLOW] })
+ const conversationId = await startConversation({ ctx: member, projectId: owner.project.id })
+
+ const text = await mcpClientHelpers.callTool({ app, mcpClient: await chatClient({ ctx: member, conversationId }), name: 'ap_list_flows' })
+
+ expect(text).toContain('✅')
+ expect(text).not.toContain(Permission.READ_MCP)
+ })
+
+ it('still denies a tool whose own permission the role does not grant', async () => {
+ const { owner, member } = await setup({ permissions: [Permission.READ_FLOW] })
+ const conversationId = await startConversation({ ctx: member, projectId: owner.project.id })
+
+ const text = await mcpClientHelpers.callTool({ app, mcpClient: await chatClient({ ctx: member, conversationId }), name: 'ap_create_flow', args: { flowName: 'Chat Flow' } })
+
+ expect(text).toContain('Permission denied')
+ expect(text).toContain(Permission.WRITE_FLOW)
+ })
+
+ it('keeps the READ_MCP gate on a project-scoped token from the /token route', async () => {
+ const { owner, member } = await setup({ permissions: [Permission.READ_FLOW] })
+ const accessToken = await mcpOAuthTokenService.issueInternalAccessToken({ userId: member.user.id, platformId: owner.platform.id, projectId: owner.project.id })
+
+ const text = await mcpClientHelpers.callTool({ app, mcpClient: { accessToken, endpoint: '/mcp' }, name: 'ap_list_flows' })
+
+ expect(text).toContain('Permission denied')
+ expect(text).toContain(Permission.READ_MCP)
+ })
+
+ it('gives no project access through a conversation that belongs to someone else', async () => {
+ const { owner, member } = await setup({ permissions: [Permission.READ_FLOW] })
+ const ownerConversationId = await startConversation({ ctx: owner, projectId: owner.project.id })
+
+ const text = await mcpClientHelpers.callTool({ app, mcpClient: await chatClient({ ctx: member, conversationId: ownerConversationId }), name: 'ap_list_flows' })
+
+ expect(text).not.toContain('✅')
+ expect(text).toContain('No project selected')
+ })
+
+ it('keeps the platform-wide tools gated when the conversation has no project', async () => {
+ const { member } = await setup({ permissions: [Permission.READ_FLOW] })
+ const response = await member.post('/v1/agents/conversations', {})
+ const conversationId = response.json().id
+
+ const text = await mcpClientHelpers.callTool({ app, mcpClient: await chatClient({ ctx: member, conversationId }), name: 'ap_set_project_context' })
+
+ expect(text).toContain('Permission denied')
+ expect(text).toContain(Permission.READ_MCP)
+ })
+
+ it('keeps working for a member whose role grants READ_MCP', async () => {
+ const { owner, member } = await setup({ permissions: [Permission.READ_FLOW, Permission.READ_MCP] })
+ const conversationId = await startConversation({ ctx: member, projectId: owner.project.id })
+
+ const text = await mcpClientHelpers.callTool({ app, mcpClient: await chatClient({ ctx: member, conversationId }), name: 'ap_list_flows' })
+
+ expect(text).toContain('✅')
+ })
+})
diff --git a/packages/server/api/test/integration/cloud/mcp/mcp-oauth-approve-access.test.ts b/packages/server/api/test/integration/cloud/mcp/mcp-oauth-approve-access.test.ts
new file mode 100644
index 00000000000..f8d3f48a79e
--- /dev/null
+++ b/packages/server/api/test/integration/cloud/mcp/mcp-oauth-approve-access.test.ts
@@ -0,0 +1,206 @@
+import { apId, Permission, RoleType } from '@activepieces/core-utils'
+import { DefaultProjectRole, PlatformRole, PrincipalType, UserIdentityProvider } from '@activepieces/shared'
+import { FastifyInstance } from 'fastify'
+import { afterAll, beforeAll, describe, expect, it } from 'vitest'
+import { generateMockToken } from '../../../helpers/auth'
+import { db } from '../../../helpers/db'
+import { MCP_OAUTH_REDIRECT_URI, mcpOAuthTestHelpers } from '../../../helpers/mcp-oauth'
+import { createMockProjectMember, createMockProjectRole, mockBasicUser } from '../../../helpers/mocks'
+import { createTestContext, TestContext } from '../../../helpers/test-context'
+import { setupTestEnvironment, teardownTestEnvironment } from '../../../helpers/test-setup'
+
+let app: FastifyInstance
+
+const PLATFORM_RESOURCE = 'https://cloud.activepieces.com/mcp/platform'
+
+beforeAll(async () => {
+ app = await setupTestEnvironment()
+})
+
+afterAll(async () => {
+ await teardownTestEnvironment()
+})
+
+async function createAuthRequestId(): Promise<string> {
+ const client = await mcpOAuthTestHelpers.registerClient({ app, tokenEndpointAuthMethod: 'none' })
+ const { challenge } = mcpOAuthTestHelpers.generatePkce()
+ const consent = await app.inject({
+ method: 'GET',
+ url: '/authorize?' + new URLSearchParams({
+ client_id: client.client_id,
+ redirect_uri: MCP_OAUTH_REDIRECT_URI,
+ response_type: 'code',
+ code_challenge: challenge,
+ code_challenge_method: 'S256',
+ scope: 'mcp',
+ resource: PLATFORM_RESOURCE,
+ }).toString(),
+ })
+ return new URL(String(consent.headers.location), MCP_OAUTH_REDIRECT_URI).searchParams.get('authRequestId') ?? ''
+}
+
+async function approveAs({ token, projectId }: { token: string, projectId?: string }) {
+ return app.inject({
+ method: 'POST',
+ url: '/api/v1/mcp-oauth/approve',
+ headers: { authorization: `Bearer ${token}` },
+ payload: {
+ authRequestId: await createAuthRequestId(),
+ ...(projectId ? { projectId } : {}),
+ },
+ })
+}
+
+async function addMember({ ctx, permissions, provider }: {
+ ctx: TestContext
+ permissions: Permission[]
+ provider?: UserIdentityProvider
+}): Promise<{ token: string }> {
+ const { mockUser } = await mockBasicUser({
+ userIdentity: { provider: provider ?? UserIdentityProvider.EMAIL, verified: true },
+ user: { platformId: ctx.platform.id, platformRole: PlatformRole.MEMBER },
+ })
+ const role = createMockProjectRole({
+ platformId: ctx.platform.id,
+ name: `role-${apId()}`,
+ permissions,
+ type: RoleType.CUSTOM,
+ })
+ await db.save('project_role', role)
+ await db.save('project_member', createMockProjectMember({
+ userId: mockUser.id,
+ platformId: ctx.platform.id,
+ projectId: ctx.project.id,
+ projectRoleId: role.id,
+ }))
+ const token = await generateMockToken({
+ id: mockUser.id,
+ type: PrincipalType.USER,
+ platform: { id: ctx.platform.id },
+ })
+ return { token }
+}
+
+describe('POST /v1/mcp-oauth/approve access control', () => {
+ it('lets a member holding READ_MCP authorize platform-wide', async () => {
+ const ctx = await createTestContext(app)
+ const { token } = await addMember({ ctx, permissions: [Permission.READ_FLOW, Permission.READ_MCP] })
+
+ const response = await approveAs({ token })
+
+ expect(response.statusCode).toBe(200)
+ })
+
+ it('refuses platform-wide authorization to a member holding READ_MCP nowhere', async () => {
+ const ctx = await createTestContext(app)
+ const { token } = await addMember({ ctx, permissions: [Permission.READ_FLOW] })
+
+ const response = await approveAs({ token })
+
+ expect(response.statusCode).toBe(403)
+ expect(response.json().error_description).toContain('any project')
+ })
+
+ it('refuses a project whose role lacks READ_MCP, which bare membership used to allow', async () => {
+ const ctx = await createTestContext(app)
+ const { token } = await addMember({ ctx, permissions: [Permission.READ_FLOW, Permission.WRITE_FLOW] })
+
+ const response = await approveAs({ token, projectId: ctx.project.id })
+
+ expect(response.statusCode).toBe(403)
+ expect(response.json().error_description).toContain('this project')
+ })
+
+ it('lets a member holding READ_MCP authorize their own project', async () => {
+ const ctx = await createTestContext(app)
+ const { token } = await addMember({ ctx, permissions: [Permission.READ_MCP] })
+
+ const response = await approveAs({ token, projectId: ctx.project.id })
+
+ expect(response.statusCode).toBe(200)
+ })
+
+ it('refuses an embedded user platform-wide authorization, even holding READ_MCP', async () => {
+ const ctx = await createTestContext(app)
+ const { token } = await addMember({
+ ctx,
+ permissions: [Permission.READ_FLOW, Permission.READ_MCP],
+ provider: UserIdentityProvider.JWT,
+ })
+
+ const response = await approveAs({ token })
+
+ expect(response.statusCode).toBe(403)
+ expect(response.json().error_description).toContain('specific project')
+ })
+
+ it('still lets an embedded user authorize their own project', async () => {
+ const ctx = await createTestContext(app)
+ const { token } = await addMember({
+ ctx,
+ permissions: [Permission.READ_MCP],
+ provider: UserIdentityProvider.JWT,
+ })
+
+ const response = await approveAs({ token, projectId: ctx.project.id })
+
+ expect(response.statusCode).toBe(200)
+ })
+
+ it('lets the platform admin authorize platform-wide', async () => {
+ const ctx = await createTestContext(app)
+
+ const response = await approveAs({ token: ctx.token })
+
+ expect(response.statusCode).toBe(200)
+ })
+
+ it('refuses a project the caller is not a member of', async () => {
+ const ctx = await createTestContext(app)
+ const other = await createTestContext(app)
+ const { token } = await addMember({ ctx, permissions: [Permission.READ_MCP] })
+
+ const response = await approveAs({ token, projectId: other.project.id })
+
+ expect(response.statusCode).toBe(403)
+ })
+
+ it('refuses a default-role member whose platform grants no project', async () => {
+ const ctx = await createTestContext(app)
+ const { mockUser } = await mockBasicUser({
+ user: { platformId: ctx.platform.id, platformRole: PlatformRole.MEMBER },
+ })
+ const token = await generateMockToken({
+ id: mockUser.id,
+ type: PrincipalType.USER,
+ platform: { id: ctx.platform.id },
+ })
+
+ const response = await approveAs({ token })
+
+ expect(response.statusCode).toBe(403)
+ })
+
+ it('lets a member on the default EDITOR role authorize platform-wide', async () => {
+ const ctx = await createTestContext(app)
+ const { mockUser } = await mockBasicUser({
+ user: { platformId: ctx.platform.id, platformRole: PlatformRole.MEMBER },
+ })
+ const editorRole = await db.findOneByOrFail<{ id: string }>('project_role', { name: DefaultProjectRole.EDITOR })
+ await db.save('project_member', createMockProjectMember({
+ userId: mockUser.id,
+ platformId: ctx.platform.id,
+ projectId: ctx.project.id,
+ projectRoleId: editorRole.id,
+ }))
+ const token = await generateMockToken({
+ id: mockUser.id,
+ type: PrincipalType.USER,
+ platform: { id: ctx.platform.id },
+ })
+
+ const response = await approveAs({ token })
+
+ expect(response.statusCode).toBe(200)
+ })
+})
diff --git a/packages/server/api/test/integration/cloud/mcp/mcp-rbac.test.ts b/packages/server/api/test/integration/cloud/mcp/mcp-rbac.test.ts
index 64ca79c3207..7c8e7a82835 100644
--- a/packages/server/api/test/integration/cloud/mcp/mcp-rbac.test.ts
+++ b/packages/server/api/test/integration/cloud/mcp/mcp-rbac.test.ts
@@ -1,11 +1,13 @@
-import { apId, Permission } from '@activepieces/core-utils'
-import { DefaultProjectRole, McpServerType, ProjectScopedMcpServer } from '@activepieces/shared'
+import { apId, Permission, RoleType } from '@activepieces/core-utils'
+import { DefaultProjectRole, McpServerType, PlatformRole, ProjectScopedMcpServer } from '@activepieces/shared'
import { FastifyBaseLogger, FastifyInstance } from 'fastify'
import { afterAll, beforeAll, describe, expect, it } from 'vitest'
-import { resolvePermissionChecker } from '../../../../src/app/mcp/mcp-permissions'
+import { resolveMcpPermissionChecker, resolvePermissionChecker } from '../../../../src/app/mcp/mcp-permissions'
import { apCreateFlowTool } from '../../../../src/app/mcp/tools/ap-create-flow'
import { apListFlowsTool } from '../../../../src/app/mcp/tools/ap-list-flows'
import { apSetupGuideTool } from '../../../../src/app/mcp/tools/ap-setup-guide'
+import { db } from '../../../helpers/db'
+import { createMockProjectRole, mockBasicUser } from '../../../helpers/mocks'
import { createMemberContext, createTestContext } from '../../../helpers/test-context'
import { setupTestEnvironment, teardownTestEnvironment } from '../../../helpers/test-setup'
@@ -45,7 +47,7 @@ describe('MCP Tool RBAC', () => {
const memberCtx = await createMemberContext(app, ctx, { projectRole: DefaultProjectRole.EDITOR })
const mcp = makeMcp(ctx.project.id)
- const checker = await resolvePermissionChecker({ userId: memberCtx.user.id, projectId: ctx.project.id, log: mockLog })
+ const checker = await resolveMcpPermissionChecker({ userId: memberCtx.user.id, projectId: ctx.project.id, log: mockLog })
const tool = apCreateFlowTool({ mcp, userId: memberCtx.user.id }, mockLog)
const execute = checker.wrapExecute({ execute: tool.execute, permission: tool.permission, toolTitle: tool.title })
const result = await execute({ flowName: 'Editor Flow' })
@@ -58,7 +60,7 @@ describe('MCP Tool RBAC', () => {
const ctx = await createTestContext(app)
const memberCtx = await createMemberContext(app, ctx, { projectRole: DefaultProjectRole.VIEWER })
- const checker = await resolvePermissionChecker({ userId: memberCtx.user.id, projectId: ctx.project.id, log: mockLog })
+ const checker = await resolveMcpPermissionChecker({ userId: memberCtx.user.id, projectId: ctx.project.id, log: mockLog })
const error = checker.check(Permission.WRITE_FLOW, 'ap_create_flow')
expect(error).not.toBeNull()
@@ -72,7 +74,7 @@ describe('MCP Tool RBAC', () => {
const memberCtx = await createMemberContext(app, ctx, { projectRole: DefaultProjectRole.VIEWER })
const mcp = makeMcp(ctx.project.id)
- const checker = await resolvePermissionChecker({ userId: memberCtx.user.id, projectId: ctx.project.id, log: mockLog })
+ const checker = await resolveMcpPermissionChecker({ userId: memberCtx.user.id, projectId: ctx.project.id, log: mockLog })
const tool = apListFlowsTool(mcp, mockLog)
const execute = checker.wrapExecute({ execute: tool.execute, permission: tool.permission, toolTitle: tool.title })
const result = await execute({})
@@ -84,7 +86,7 @@ describe('MCP Tool RBAC', () => {
const ctx = await createTestContext(app)
const memberCtx = await createMemberContext(app, ctx, { projectRole: DefaultProjectRole.VIEWER })
- const checker = await resolvePermissionChecker({ userId: memberCtx.user.id, projectId: ctx.project.id, log: mockLog })
+ const checker = await resolveMcpPermissionChecker({ userId: memberCtx.user.id, projectId: ctx.project.id, log: mockLog })
const error = checker.check(Permission.UPDATE_FLOW_STATUS, 'ap_lock_and_publish')
expect(error).not.toBeNull()
@@ -97,7 +99,7 @@ describe('MCP Tool RBAC', () => {
const memberCtx = await createMemberContext(app, ctx, { projectRole: DefaultProjectRole.VIEWER })
const mcp = makeMcp(ctx.project.id)
- const checker = await resolvePermissionChecker({ userId: memberCtx.user.id, projectId: ctx.project.id, log: mockLog })
+ const checker = await resolveMcpPermissionChecker({ userId: memberCtx.user.id, projectId: ctx.project.id, log: mockLog })
const tool = apSetupGuideTool(mcp, mockLog)
const error = checker.check(tool.permission, tool.title)
@@ -108,4 +110,94 @@ describe('MCP Tool RBAC', () => {
})
})
+ describe('READ_MCP is enforced on every tool call', () => {
+ async function createMemberWithPermissions(permissions: Permission[]) {
+ const ctx = await createTestContext(app)
+ const role = createMockProjectRole({
+ platformId: ctx.platform.id,
+ name: `custom-${apId()}`,
+ permissions,
+ type: RoleType.CUSTOM,
+ })
+ await db.save('project_role', role)
+ const member = await createMemberContext(app, ctx, { projectRole: role.name })
+ return { ctx, member }
+ }
+
+ it('denies a project tool when the role lacks READ_MCP, even though it grants that tool\'s permission', async () => {
+ const { ctx, member } = await createMemberWithPermissions([Permission.READ_FLOW])
+
+ const checker = await resolveMcpPermissionChecker({ userId: member.user.id, projectId: ctx.project.id, log: mockLog })
+ const error = checker.check(Permission.READ_FLOW, 'ap_list_flows')
+
+ expect(error).not.toBeNull()
+ expect(error!.isError).toBe(true)
+ expect(text(error!)).toContain(Permission.READ_MCP)
+ })
+
+ it('allows a project tool once the role grants READ_MCP', async () => {
+ const { ctx, member } = await createMemberWithPermissions([Permission.READ_FLOW, Permission.READ_MCP])
+
+ const checker = await resolveMcpPermissionChecker({ userId: member.user.id, projectId: ctx.project.id, log: mockLog })
+
+ expect(checker.check(Permission.READ_FLOW, 'ap_list_flows')).toBeNull()
+ })
+
+ it('denies piece-catalog tools too, since they read project connections and providers', async () => {
+ const { ctx, member } = await createMemberWithPermissions([Permission.READ_FLOW])
+
+ const checker = await resolveMcpPermissionChecker({ userId: member.user.id, projectId: ctx.project.id, log: mockLog })
+
+ expect(text(checker.check(undefined, 'ap_research_pieces')!)).toContain(Permission.READ_MCP)
+ expect(text(checker.check(undefined, 'ap_get_piece_props')!)).toContain(Permission.READ_MCP)
+ })
+
+ it('leaves the non-MCP checker alone, so agent permissions do not require READ_MCP', async () => {
+ const { ctx, member } = await createMemberWithPermissions([Permission.READ_FLOW, Permission.WRITE_AGENT])
+
+ const checker = await resolvePermissionChecker({ userId: member.user.id, projectId: ctx.project.id, log: mockLog })
+
+ expect(checker.check(Permission.READ_FLOW, '__name_flows_using_agent')).toBeNull()
+ expect(checker.check(Permission.WRITE_AGENT, '__move_agent_into_project')).toBeNull()
+ })
+ })
+
+ describe('when the user has no role in the project', () => {
+ async function createStrangerChecker() {
+ const ctx = await createTestContext(app)
+ const { mockUser: stranger } = await mockBasicUser({
+ user: { platformId: ctx.platform.id, platformRole: PlatformRole.MEMBER },
+ })
+ const checker = await resolveMcpPermissionChecker({ userId: stranger.id, projectId: ctx.project.id, log: mockLog })
+ return { ctx, checker }
+ }
+
+ it('denies project tools that declare no permission', async () => {
+ const { ctx, checker } = await createStrangerChecker()
+ const tool = apSetupGuideTool(makeMcp(ctx.project.id), mockLog)
+
+ const error = checker.check(tool.permission, tool.title)
+ expect(error).not.toBeNull()
+ expect(text(error!)).toContain('no role')
+
+ const execute = checker.wrapExecute({ execute: tool.execute, permission: tool.permission, toolTitle: tool.title })
+ expect(text(await execute({}))).toContain('Permission denied')
+ })
+
+ it('denies project tools that declare a permission', async () => {
+ const { checker } = await createStrangerChecker()
+
+ const error = checker.check(Permission.READ_FLOW, 'ap_list_flows')
+ expect(error).not.toBeNull()
+ expect(text(error!)).toContain('no role')
+ })
+
+ it('denies piece-catalog tools too, since they read project connections and providers', async () => {
+ const { checker } = await createStrangerChecker()
+
+ expect(text(checker.check(undefined, 'ap_research_pieces')!)).toContain('no role')
+ expect(text(checker.check(undefined, 'ap_list_ai_models')!)).toContain('no role')
+ })
+ })
+
})
diff --git a/packages/server/api/test/integration/cloud/mcp/mcp-reach-before-billing.test.ts b/packages/server/api/test/integration/cloud/mcp/mcp-reach-before-billing.test.ts
new file mode 100644
index 00000000000..97398c1f263
--- /dev/null
+++ b/packages/server/api/test/integration/cloud/mcp/mcp-reach-before-billing.test.ts
@@ -0,0 +1,100 @@
+import { ActivepiecesError, apId, ErrorCode, Permission, PlatformUsageMetric, RoleType } from '@activepieces/core-utils'
+import { DefaultProjectRole } from '@activepieces/shared'
+import { FastifyInstance } from 'fastify'
+import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest'
+import { db } from '../../../helpers/db'
+import { McpClient, mcpClientHelpers } from '../../../helpers/mcp-client'
+import { createMockProjectRole } from '../../../helpers/mocks'
+import { createMemberContext, createTestContext, TestContext } from '../../../helpers/test-context'
+import { setupTestEnvironment, teardownTestEnvironment } from '../../../helpers/test-setup'
+
+const { mockAssertCredits } = vi.hoisted(() => ({
+ mockAssertCredits: vi.fn(),
+}))
+
+vi.mock('../../../../src/app/platform/billing-provider', async (importOriginal) => {
+ const original = await importOriginal<typeof import('../../../../src/app/platform/billing-provider')>()
+ return { ...original, assertCreditsAndAppSumoNotExceeded: mockAssertCredits }
+})
+
+let app: FastifyInstance
+
+const SET_PROJECT_CONTEXT = 'ap_set_project_context'
+const PIECE_CATALOG_TOOL = 'ap_research_pieces'
+
+beforeAll(async () => {
+ app = await setupTestEnvironment()
+})
+
+afterAll(async () => {
+ await teardownTestEnvironment()
+})
+
+beforeEach(() => {
+ mockAssertCredits.mockReset()
+ mockAssertCredits.mockRejectedValue(new ActivepiecesError({
+ code: ErrorCode.QUOTA_EXCEEDED,
+ params: { metric: PlatformUsageMetric.AI_CREDITS },
+ }))
+})
+
+function connectAs({ ctx }: { ctx: TestContext }): Promise<McpClient> {
+ return mcpClientHelpers.connect({
+ app,
+ approve: (payload) => ctx.post('/v1/mcp-oauth/approve', payload),
+ })
+}
+
+function call({ mcpClient, name }: { mcpClient: McpClient, name: string }): Promise<string> {
+ return mcpClientHelpers.callTool({ app, mcpClient, name })
+}
+
+describe('a denied MCP call is refused before the platform is charged', () => {
+ it('refuses ap_set_project_context on reach, not on credits', async () => {
+ const ctx = await createTestContext(app)
+ const { member, role } = await createCustomRoleMember({ ctx })
+ const mcpClient = await connectAs({ ctx: member })
+
+ await db.update('project_role', role.id, { permissions: [Permission.READ_FLOW] })
+
+ const answer = await call({ mcpClient, name: SET_PROJECT_CONTEXT })
+
+ expect(answer).toContain(Permission.READ_MCP)
+ expect(answer).not.toContain('Out of credits')
+ })
+
+ it('refuses a piece-catalog tool on reach, not on credits', async () => {
+ const ctx = await createTestContext(app)
+ const { member, role } = await createCustomRoleMember({ ctx })
+ const mcpClient = await connectAs({ ctx: member })
+
+ await db.update('project_role', role.id, { permissions: [Permission.READ_FLOW] })
+
+ const answer = await call({ mcpClient, name: PIECE_CATALOG_TOOL })
+
+ expect(answer).toContain(Permission.READ_MCP)
+ expect(answer).not.toContain('Out of credits')
+ })
+
+ it('still refuses a member who does have reach on credits', async () => {
+ const ctx = await createTestContext(app)
+ const member = await createMemberContext(app, ctx, { projectRole: DefaultProjectRole.EDITOR })
+ const mcpClient = await connectAs({ ctx: member })
+
+ const answer = await call({ mcpClient, name: SET_PROJECT_CONTEXT })
+
+ expect(answer).toContain('Out of credits')
+ })
+})
+
+async function createCustomRoleMember({ ctx }: { ctx: TestContext }) {
+ const role = createMockProjectRole({
+ platformId: ctx.platform.id,
+ name: `role-${apId()}`,
+ permissions: [Permission.READ_FLOW, Permission.READ_MCP],
+ type: RoleType.CUSTOM,
+ })
+ await db.save('project_role', role)
+ const member = await createMemberContext(app, ctx, { projectRole: role.name })
+ return { member, role }
+}
diff --git a/packages/server/api/test/integration/ee/mcp/mcp-access-ee.test.ts b/packages/server/api/test/integration/ee/mcp/mcp-access-ee.test.ts
new file mode 100644
index 00000000000..2d67d3c6aca
--- /dev/null
+++ b/packages/server/api/test/integration/ee/mcp/mcp-access-ee.test.ts
@@ -0,0 +1,190 @@
+import { apId, Permission, RoleType } from '@activepieces/core-utils'
+import { DefaultProjectRole, PlatformRole, PrincipalType } from '@activepieces/shared'
+import { FastifyInstance } from 'fastify'
+import { afterAll, beforeAll, describe, expect, it } from 'vitest'
+import { mcpAccess } from '../../../../src/app/mcp/mcp-access'
+import { resolveMcpPermissionChecker } from '../../../../src/app/mcp/mcp-permissions'
+import { generateMockToken } from '../../../helpers/auth'
+import { db } from '../../../helpers/db'
+import { McpClient, mcpClientHelpers } from '../../../helpers/mcp-client'
+import { createMockProjectRole, mockBasicUser } from '../../../helpers/mocks'
+import { createMemberContext, createTestContext, TestContext } from '../../../helpers/test-context'
+import { setupTestEnvironment, teardownTestEnvironment } from '../../../helpers/test-setup'
+
+let app: FastifyInstance
+
+const LOCKED_TOOL = 'ap_list_flows'
+const PIECE_CATALOG_TOOL = 'ap_research_pieces'
+
+beforeAll(async () => {
+ app = await setupTestEnvironment()
+})
+
+afterAll(async () => {
+ await teardownTestEnvironment()
+})
+
+async function createCustomRoleMember({ ctx, permissions }: { ctx: TestContext, permissions: Permission[] }): Promise<TestContext> {
+ const role = createMockProjectRole({
+ platformId: ctx.platform.id,
+ name: `role-${apId()}`,
+ permissions,
+ type: RoleType.CUSTOM,
+ })
+ await db.save('project_role', role)
+ return createMemberContext(app, ctx, { projectRole: role.name })
+}
+
+function connectAs({ ctx }: { ctx: TestContext }): Promise<McpClient> {
+ return mcpClientHelpers.connect({
+ app,
+ approve: (payload) => ctx.post('/v1/mcp-oauth/approve', payload),
+ })
+}
+
+async function connectAsOperator({ ctx }: { ctx: TestContext }): Promise<McpClient> {
+ const { mockUser } = await mockBasicUser({
+ user: {
+ platformId: ctx.platform.id,
+ platformRole: PlatformRole.OPERATOR,
+ },
+ })
+ const token = await generateMockToken({
+ id: mockUser.id,
+ type: PrincipalType.USER,
+ platform: { id: ctx.platform.id },
+ })
+ return mcpClientHelpers.connect({
+ app,
+ approve: (payload) => app.inject({
+ method: 'POST',
+ url: '/api/v1/mcp-oauth/approve',
+ headers: { authorization: `Bearer ${token}` },
+ payload,
+ }),
+ })
+}
+
+describe('MCP access on enterprise edition', () => {
+ it('enforces READ_MCP on the checker, exactly as cloud does', async () => {
+ const ctx = await createTestContext(app)
+ const member = await createCustomRoleMember({ ctx, permissions: [Permission.READ_FLOW] })
+
+ const checker = await resolveMcpPermissionChecker({ userId: member.user.id, projectId: ctx.project.id, log: app.log })
+
+ expect(checker.check(Permission.READ_FLOW, LOCKED_TOOL)).not.toBeNull()
+ })
+
+ it('leaves a project out of the accessible list when its role lacks READ_MCP', async () => {
+ const ctx = await createTestContext(app)
+ const member = await createCustomRoleMember({ ctx, permissions: [Permission.READ_FLOW] })
+
+ const projects = await mcpAccess.listAccessibleProjects({ platformId: ctx.platform.id, userId: member.user.id, log: app.log })
+
+ expect(projects).toHaveLength(0)
+ })
+
+ it('refuses platform-wide authorization to a member holding READ_MCP nowhere', async () => {
+ const ctx = await createTestContext(app)
+ const member = await createCustomRoleMember({ ctx, permissions: [Permission.READ_FLOW] })
+
+ const response = await member.post('/v1/mcp-oauth/approve', { authRequestId: 'unused' })
+
+ expect(response.statusCode).toBe(403)
+ })
+
+ it('lets an EDITOR authorize platform-wide and run a read tool', async () => {
+ const ctx = await createTestContext(app)
+ const member = await createMemberContext(app, ctx, { projectRole: DefaultProjectRole.EDITOR })
+ const mcpClient = await connectAs({ ctx: member })
+
+ await mcpClientHelpers.callTool({ app, mcpClient, name: 'ap_set_project_context', args: { projectId: ctx.project.id } })
+ const listed = await mcpClientHelpers.callTool({ app, mcpClient, name: LOCKED_TOOL })
+
+ expect(listed).not.toContain('Permission denied')
+ })
+
+ it('lets a platform admin run a piece-catalog tool on the platform server', async () => {
+ const ctx = await createTestContext(app)
+ const mcpClient = await connectAs({ ctx })
+
+ const researched = await mcpClientHelpers.callTool({ app, mcpClient, name: PIECE_CATALOG_TOOL, args: { query: 'slack' } })
+
+ expect(researched).not.toContain('Permission denied')
+ })
+
+ it('lets an operator who belongs to no project reach the platform tools and any project', async () => {
+ const ctx = await createTestContext(app)
+ const mcpClient = await connectAsOperator({ ctx })
+
+ const researched = await mcpClientHelpers.callTool({ app, mcpClient, name: PIECE_CATALOG_TOOL, args: { query: 'slack' } })
+ const selected = await mcpClientHelpers.callTool({ app, mcpClient, name: 'ap_set_project_context', args: { projectId: ctx.project.id } })
+ const listed = await mcpClientHelpers.callTool({ app, mcpClient, name: LOCKED_TOOL })
+
+ expect(researched).not.toContain('Permission denied')
+ expect(selected).toContain('Project context set')
+ expect(listed).not.toContain('Permission denied')
+ })
+
+ it('denies a project already selected on the platform server once its role loses READ_MCP', async () => {
+ const ctx = await createTestContext(app)
+ const role = createMockProjectRole({
+ platformId: ctx.platform.id,
+ name: `role-${apId()}`,
+ permissions: [Permission.READ_MCP, Permission.READ_FLOW],
+ type: RoleType.CUSTOM,
+ })
+ await db.save('project_role', role)
+ const member = await createMemberContext(app, ctx, { projectRole: role.name })
+ const mcpClient = await connectAs({ ctx: member })
+ await mcpClientHelpers.callTool({ app, mcpClient, name: 'ap_set_project_context', args: { projectId: ctx.project.id } })
+
+ const before = await mcpClientHelpers.callTool({ app, mcpClient, name: LOCKED_TOOL })
+ await db.update('project_role', role.id, { permissions: [Permission.READ_FLOW] })
+ const after = await mcpClientHelpers.callTool({ app, mcpClient, name: LOCKED_TOOL })
+
+ expect(before).not.toContain('Permission denied')
+ expect(after).toContain(Permission.READ_MCP)
+ })
+
+ it('refuses a piece-catalog tool on an issued token once the role loses READ_MCP in every project', async () => {
+ const ctx = await createTestContext(app)
+ const role = createMockProjectRole({
+ platformId: ctx.platform.id,
+ name: `role-${apId()}`,
+ permissions: [Permission.READ_MCP, Permission.READ_FLOW],
+ type: RoleType.CUSTOM,
+ })
+ await db.save('project_role', role)
+ const member = await createMemberContext(app, ctx, { projectRole: role.name })
+ const mcpClient = await connectAs({ ctx: member })
+
+ const before = await mcpClientHelpers.callTool({ app, mcpClient, name: PIECE_CATALOG_TOOL, args: { query: 'slack' } })
+ await db.update('project_role', role.id, { permissions: [Permission.READ_FLOW] })
+ const after = await mcpClientHelpers.callTool({ app, mcpClient, name: PIECE_CATALOG_TOOL, args: { query: 'slack' } })
+
+ expect(before).not.toContain('Permission denied')
+ expect(after).toContain(Permission.READ_MCP)
+ })
+
+ it('lets a platform admin authorize a project of their own platform', async () => {
+ const ctx = await createTestContext(app)
+
+ const mcpClient = await mcpClientHelpers.connect({
+ app,
+ projectId: ctx.project.id,
+ approve: (payload) => ctx.post('/v1/mcp-oauth/approve', payload),
+ })
+
+ expect(mcpClient.accessToken).toBeTruthy()
+ })
+
+ it('refuses a platform admin a project that belongs to another platform', async () => {
+ const ctx = await createTestContext(app)
+ const otherCtx = await createTestContext(app)
+
+ const response = await ctx.post('/v1/mcp-oauth/approve', { authRequestId: 'unused', projectId: otherCtx.project.id })
+
+ expect(response.statusCode).toBe(403)
+ })
+})
diff --git a/packages/web/public/locales/en/translation.json b/packages/web/public/locales/en/translation.json
index 282f00ec960..052e85772f6 100644
--- a/packages/web/public/locales/en/translation.json
+++ b/packages/web/public/locales/en/translation.json
@@ -1029,6 +1029,7 @@
"This request has expired. Go back to {client} and start the connection again.": "This request has expired. Go back to {client} and start the connection again.",
"Signed in as {email}": "Signed in as {email}",
"Switch account": "Switch account",
+ "You do not have MCP access here. Pick another project, or ask a platform admin for access.": "You do not have MCP access here. Pick another project, or ask a platform admin for access.",
"Deny": "Deny",
"Authorize": "Authorize",
"Unknown app": "Unknown app",
diff --git a/packages/web/src/app/routes/mcp-authorize/index.tsx b/packages/web/src/app/routes/mcp-authorize/index.tsx
index b10c12f7d0c..0899896d4fd 100644
--- a/packages/web/src/app/routes/mcp-authorize/index.tsx
+++ b/packages/web/src/app/routes/mcp-authorize/index.tsx
@@ -1,6 +1,7 @@
import { SeekPage } from '@activepieces/core-utils';
import { ProjectType, ProjectWithLimits } from '@activepieces/shared';
import { useMutation, useQuery } from '@tanstack/react-query';
+import { StatusCodes } from 'http-status-codes';
import { t } from 'i18next';
import { jwtDecode } from 'jwt-decode';
import { CheckCircle, FolderKanban, Lock, Plug, Workflow } from 'lucide-react';
@@ -273,7 +274,7 @@ function McpAuthorizePage() {
'This request has expired. Go back to {client} and start the connection again.',
{ client: clientName },
)
- : t('Authorization failed. Please try again.')}
+ : authorizeFailureMessage(approveMutation.error)}
</div>
)}
@@ -331,6 +332,15 @@ function decodeJwtPayload(token: string | null): AuthRequestSummary {
}
}
+function authorizeFailureMessage(error: unknown): string {
+ if (api.isError(error) && error.response?.status === StatusCodes.FORBIDDEN) {
+ return t(
+ 'You do not have MCP access here. Pick another project, or ask a platform admin for access.',
+ );
+ }
+ return t('Authorization failed. Please try again.');
+}
+
type AuthRequestSummary = {
clientName: string;
isPlatformScoped: boolean;