lael-labs/executor

apps/cloud/src/engine/execution-stack.ts+20−1

@@ -43,8 +43,13 @@ import { · 42 unmodified lines
43	collectTables,	43	collectTables,
44	} from "@executor-js/api/server";	44	} from "@executor-js/api/server";
45	import { googleCatalogOAuthScopesForPreset } from "@executor-js/plugin-openapi/providers/google";	45	import { googleCatalogOAuthScopesForPreset } from "@executor-js/plugin-openapi/providers/google";
		46	import { slackMcpUserScopes } from "@executor-js/react/lib/slack-mcp-oauth";
46	import { makeDynamicWorkerExecutor } from "@executor-js/runtime-dynamic-worker";	47	import { makeDynamicWorkerExecutor } from "@executor-js/runtime-dynamic-worker";
47	import type { AnyPlugin, FirstPartyOAuthClientConfig } from "@executor-js/sdk";	48	import {
		49	IntegrationSlug,
		50	type AnyPlugin,
		51	type FirstPartyOAuthClientConfig,
		52	} from "@executor-js/sdk";
48		53
49	import executorConfig from "../../executor.config";	54	import executorConfig from "../../executor.config";
50	import { DbService } from "../db/db";	55	import { DbService } from "../db/db";
@@ -136,6 +141,20 @@ const cloudFirstPartyOAuthClients = (): readonly FirstPartyOAuthClientConfig[] = · 85 unmodified lines
136	},	141	},
137	]	142	]
138	: []),	143	: []),
		144	...(env.FIRST_PARTY_SLACK_CLIENT_ID && env.FIRST_PARTY_SLACK_CLIENT_SECRET
		145	? [
		146	{
		147	name: "slack",
		148	authorizationUrl: "https://slack.com/oauth/v2_user/authorize",
		149	tokenUrl: "https://slack.com/api/oauth.v2.user.access",
		150	resource: "https://mcp.slack.com",
		151	clientId: env.FIRST_PARTY_SLACK_CLIENT_ID,
		152	clientSecret: env.FIRST_PARTY_SLACK_CLIENT_SECRET,
		153	integrations: [IntegrationSlug.make("slack")],
		154	allowedScopes: slackMcpUserScopes,
		155	},
		156	]
		157	: []),
139	];	158	];
140		159
141	export const CloudHostConfig: Layer.Layer<HostConfig> = Layer.sync(HostConfig, () => ({	160	export const CloudHostConfig: Layer.Layer<HostConfig> = Layer.sync(HostConfig, () => ({

apps/cloud/src/env-augment.d.ts+2−0

@@ -67,6 +67,8 @@ declare global { · 66 unmodified lines
67	FIRST_PARTY_GITHUB_TOKEN_URL?: string;	67	FIRST_PARTY_GITHUB_TOKEN_URL?: string;
68	FIRST_PARTY_GOOGLE_CLIENT_ID?: string;	68	FIRST_PARTY_GOOGLE_CLIENT_ID?: string;
69	FIRST_PARTY_GOOGLE_CLIENT_SECRET?: string;	69	FIRST_PARTY_GOOGLE_CLIENT_SECRET?: string;
		70	FIRST_PARTY_SLACK_CLIENT_ID?: string;
		71	FIRST_PARTY_SLACK_CLIENT_SECRET?: string;
70		72
71	// Billing	73	// Billing
72	AUTUMN_SECRET_KEY?: string;	74	AUTUMN_SECRET_KEY?: string;

packages/core/sdk/src/oauth-client.ts+8−2

   readonly clientId: string;
   /** Literal secret from host env. Empty string for a public/PKCE client. */
   readonly clientSecret: string;
+  /** RFC 8707 protected resource for MCP-style providers. Required when the
+   *  integration discovers its OAuth scopes from resource metadata. */
+  readonly resource?: string | null;
   /** Integrations this app is intended for, used by pickers to rank it as the
    *  exact-match default for those integrations. Endpoint-host matching still
    *  applies when omitted. */
   readonly integrations?: readonly IntegrationSlug[];
   /** OAuth scopes this deployment permits the app to request. Omit to allow
-   *  every scope declared by a matching integration. When present, OAuth start
+   *  every scope declared by a matching integration. For declared scopes,
-   *  and completion fail unless every requested scope belongs to this set. */
+   *  start and completion fail unless every requested scope belongs to this
+   *  set. For MCP-style discovery, the provider's advertised scope catalog is
+   *  capped to this set because it may include capabilities the registered app
+   *  was not approved for. */
   readonly allowedScopes?: readonly string[];
 }

packages/core/sdk/src/oauth-first-party.test.ts+6−1

         const { executor } = yield* makeTestWorkspaceHarness({
           plugins,
           firstPartyOAuthClients: [
-            { ...firstPartyClientFor(server), allowedScopes: ["openid", "read"] },
+            {
+              ...firstPartyClientFor(server),
+              resource: server.resourceUrl,
+              allowedScopes: ["openid", "read"],
+            },
           ],
         });
         yield* executor.acme.seed();
           allowedScopes: ["openid", "read"],
         });
         expect(firstParty.clientId).toBe("test-client");
+        expect(firstParty.resource).toBe(server.resourceUrl);
         expect("clientSecret" in firstParty).toBe(false);
       }),
     ),

packages/core/sdk/src/oauth-scope-union.test.ts+46−0

@@ -11,6 +11,7 @@ import { · 10 unmodified lines
11	ToolName,	11	ToolName,
12	} from "./ids";	12	} from "./ids";
13	import type { AuthMethodDescriptor } from "./integration";	13	import type { AuthMethodDescriptor } from "./integration";
		14	import { firstPartyOAuthClientSlug } from "./oauth-client";
14	import { definePlugin, type IntegrationRecord } from "./plugin";	15	import { definePlugin, type IntegrationRecord } from "./plugin";
15	import { makeTestWorkspaceHarness, memoryCredentialsPlugin } from "./test-config";	16	import { makeTestWorkspaceHarness, memoryCredentialsPlugin } from "./test-config";
16	import { serveTestHttpApp } from "./testing";	17	import { serveTestHttpApp } from "./testing";
@@ -532,6 +533,51 @@ describe("oauth.start integration-driven scopes", () => { · 515 unmodified lines
532	),	533	),
533	);	534	);
534		535
		536	it.effect(
		537	"(i) a scope-limited first-party MCP app caps the provider's advertised scope catalog",
		538	() =>
		539	Effect.scoped(
		540	Effect.gen(function* () {
		541	const server = yield* serveMetadataServer({
		542	prm: { scopesSupported: ["read", "write", "admin"] },
		543	});
		544	const plugins = [
		545	memoryCredentialsPlugin(),
		546	makeMcpScopePlugin({ scopes: null }),
		547	] as const;
		548	const { executor } = yield* makeTestWorkspaceHarness({
		549	plugins,
		550	firstPartyOAuthClients: [
		551	{
		552	name: "acme",
		553	authorizationUrl: server.authorizationEndpoint,
		554	tokenUrl: server.tokenEndpoint,
		555	resource: server.mcpResourceUrl,
		556	clientId: "test-client",
		557	clientSecret: "test-secret",
		558	integrations: [INTEG],
		559	allowedScopes: ["read", "write"],
		560	},
		561	],
		562	});
		563	yield* executor.mcp.seed();
		564
		565	const started = yield* executor.oauth.start({
		566	owner: "org",
		567	client: firstPartyOAuthClientSlug("acme"),
		568	clientOwner: "org",
		569	name: ConnectionName.make("main"),
		570	integration: INTEG,
		571	template: TEMPLATE,
		572	});
		573	expect(started.status).toBe("redirect");
		574	if (started.status !== "redirect") return;
		575
		576	expect(scopesFromAuthorizeUrl(started.authorizationUrl)).toEqual(["read", "write"]);
		577	}),
		578	),
		579	);
		580
535	it.effect("(j) caps server-advertised resource scopes so the authorize URL stays bounded", () =>	581	it.effect("(j) caps server-advertised resource scopes so the authorize URL stays bounded", () =>
536	Effect.scoped(	582	Effect.scoped(
537	Effect.gen(function* () {	583	Effect.gen(function* () {

packages/core/sdk/src/oauth-service.ts+23−16

   readonly grant: OAuthGrant;
   readonly clientId: string;
   readonly clientSecret: string;
-  readonly resource: null;
+  readonly resource: string | null;
 } => ({
   slug: String(firstPartyOAuthClientSlug(config.name)),
   authorizationUrl: config.authorizationUrl,
   grant: "authorization_code",
   clientId: config.clientId,
   clientSecret: config.clientSecret,
-  resource: null,
+  resource: config.resource ?? null,
 });
 export const makeOAuthService = (deps: OAuthServiceDeps): OAuthService => {
         grant: "authorization_code",
         authorizationUrl: config.authorizationUrl,
         tokenUrl: config.tokenUrl,
-        resource: null,
+        resource: config.resource ?? null,
         clientId: config.clientId,
         origin: {
           kind: "first_party",
               }),
           ),
         );
+      const firstParty = firstPartyFlow ? firstPartyBySlug.get(String(input.client)) : undefined;
       const requestedScopes =
         scopePolicy.kind === "discover"
-          ? yield* discoverScopesForResource(client.resource).pipe(
+          ? yield* (() => {
-              Effect.mapError(
+              const discovered = discoverScopesForResource(client.resource).pipe(
-                (cause) =>
+                Effect.mapError(
-                  new OAuthStartError({
+                  (cause) =>
-                    // oxlint-disable-next-line executor/no-unknown-error-message -- boundary: OAuthDiscoveryError carries a typed `message` field
+                    new OAuthStartError({
-                    message: `Failed to discover OAuth scopes: ${cause.message}`,
+                      // oxlint-disable-next-line executor/no-unknown-error-message -- boundary: OAuthDiscoveryError carries a typed `message` field
-                  }),
+                      message: `Failed to discover OAuth scopes: ${cause.message}`,
-              ),
+                    }),
-            )
+                ),
+              );
+              if (firstParty?.allowedScopes === undefined) return discovered;
+              const allowed = new Set(firstParty.allowedScopes);
+              return discovered.pipe(
+                Effect.map((scopes) => scopes.filter((scope) => allowed.has(scope))),
+              );
+            })()
           : dedupeScopes(scopePolicy.scopes);
       // An explicitly scope-limited first-party app is an authorization
-      // boundary, not picker decoration. Endpoint matching can associate one
+      // boundary, not picker decoration. Endpoint matching and provider
-      // Google client with every Google API, so enforce the complete requested
+      // discovery can surface capabilities outside the registered app, so
-      // set here before persisting an OAuth session or redirecting the browser.
+      // enforce the complete requested set before persisting or redirecting.
       if (firstPartyFlow) {
-        const firstParty = firstPartyBySlug.get(String(input.client));
         if (
           firstParty !== undefined &&
           !firstPartyOAuthClientAllowsScopes(firstParty, requestedScopes)

packages/react/src/components/oauth-app-setup.ts+4−29

@@ -1,3 +1,7 @@
		1	import { slackMcpUserScopes } from "../lib/slack-mcp-oauth";
		2
		3	export { slackMcpUserScopes } from "../lib/slack-mcp-oauth";
		4
1	export interface OAuthAppSetup {	5	export interface OAuthAppSetup {
2	readonly id: string;	6	readonly id: string;
3	readonly title: string;	7	readonly title: string;
@@ -29,35 +33,6 @@ interface SlackManifest { · 25 unmodified lines
29	};	33	};
30	}	34	}
31		35
32	export const slackMcpUserScopes = [
33	"search:read.public",
34	"search:read.private",
35	"search:read.mpim",
36	"search:read.im",
37	"search:read.files",
38	"search:read.users",
39	"chat:write",
40	"channels:history",
41	"groups:history",
42	"mpim:history",
43	"im:history",
44	"canvases:read",
45	"canvases:write",
46	"users:read",
47	"users:read.email",
48	"reactions:write",
49	"reactions:read",
50	"emoji:read",
51	"files:read",
52	"channels:write",
53	"groups:write",
54	"im:write",
55	"mpim:write",
56	"channels:read",
57	"groups:read",
58	"mpim:read",
59	] as const;
60
61	const slackManifest = (callbackUrl: string): SlackManifest => ({	36	const slackManifest = (callbackUrl: string): SlackManifest => ({
62	display_information: { name: "Executor" },	37	display_information: { name: "Executor" },
63	oauth_config: {	38	oauth_config: {

packages/react/src/lib/slack-mcp-oauth.ts+32−0

@@ -0,0 +1,32 @@
	1	/** User scopes approved on Executor's Slack MCP OAuth app and embedded in the
	2	* BYO-app creation manifest. Cloud uses the same list as its first-party
	3	* discovery cap so Slack metadata cannot expand the requested grant beyond
	4	* the provider-side registration. */
	5	export const slackMcpUserScopes = [
	6	"search:read.public",
	7	"search:read.private",
	8	"search:read.mpim",
	9	"search:read.im",
	10	"search:read.files",
	11	"search:read.users",
	12	"chat:write",
	13	"channels:history",
	14	"groups:history",
	15	"mpim:history",
	16	"im:history",
	17	"canvases:read",
	18	"canvases:write",
	19	"users:read",
	20	"users:read.email",
	21	"reactions:write",
	22	"reactions:read",
	23	"emoji:read",
	24	"files:read",
	25	"channels:write",
	26	"groups:write",
	27	"im:write",
	28	"mpim:write",
	29	"channels:read",
	30	"groups:read",
	31	"mpim:read",
	32	] as const;