fix(gateway): authorize plugin methods from attached registry (#94343)

wangmiao0668000666 · web-flow · commit 27f702d68fab · 2026-06-19T11:56:24.000+01:00
Authorize plugin gateway methods against the exact registry attached to dispatch, preserving fallback behavior for dynamic methods and deleting one-off repro scripts. Fixes #92044. Co-authored-by: wangmiao0668000666 <wang.miao86@xydigit.com>
diff --git a/src/gateway/method-scopes.ts b/src/gateway/method-scopes.ts
@@ -175,6 +175,17 @@ export function authorizeOperatorScopesForMethod(
     return missingScope ? { allowed: false, missingScope } : { allowed: true };
   }
   const requiredScope = resolveRequiredOperatorScopeForMethod(method) ?? ADMIN_SCOPE;
+  return authorizeOperatorScopesForRequiredScope(requiredScope, scopes);
+}
+
+/** Checks a method registry's already-resolved static scope against presented operator scopes. */
+export function authorizeOperatorScopesForRequiredScope(
+  requiredScope: OperatorScope,
+  scopes: readonly string[],
+): { allowed: true } | { allowed: false; missingScope: OperatorScope } {
+  if (scopes.includes(ADMIN_SCOPE)) {
+    return { allowed: true };
+  }
   if (requiredScope === READ_SCOPE) {
     if (scopes.includes(READ_SCOPE) || scopes.includes(WRITE_SCOPE)) {
       return { allowed: true };
diff --git a/src/gateway/server-methods.authorization.test.ts b/src/gateway/server-methods.authorization.test.ts
@@ -0,0 +1,65 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { createEmptyPluginRegistry } from "../plugins/registry-empty.js";
+import { setActivePluginRegistry } from "../plugins/runtime.js";
+import {
+  createGatewayMethodRegistry,
+  createPluginGatewayMethodDescriptor,
+} from "./methods/registry.js";
+import { handleGatewayRequest } from "./server-methods.js";
+import type { GatewayRequestHandler } from "./server-methods/types.js";
+
+const METHOD = "workboard.cards.dispatch";
+
+afterEach(() => {
+  setActivePluginRegistry(createEmptyPluginRegistry());
+});
+
+describe("gateway method authorization", () => {
+  async function dispatch(scopes: string[]) {
+    const handler: GatewayRequestHandler = ({ respond }) => respond(true, { ok: true });
+    const methodRegistry = createGatewayMethodRegistry([
+      createPluginGatewayMethodDescriptor({
+        pluginId: "workboard",
+        name: METHOD,
+        handler,
+        scope: "operator.write",
+      }),
+    ]);
+    const respond = vi.fn();
+
+    // Reproduce a request whose attached dispatch registry is newer than the global runtime state.
+    setActivePluginRegistry(createEmptyPluginRegistry());
+    await handleGatewayRequest({
+      req: { type: "req", id: "req-1", method: METHOD },
+      respond,
+      client: {
+        connId: "conn-1",
+        connect: {
+          role: "operator",
+          scopes,
+          client: { id: "test", version: "1", platform: "test", mode: "test" },
+          minProtocol: 1,
+          maxProtocol: 1,
+        },
+      } as Parameters<typeof handleGatewayRequest>[0]["client"],
+      isWebchatConnect: () => false,
+      context: { logGateway: { warn: vi.fn() } } as unknown as Parameters<
+        typeof handleGatewayRequest
+      >[0]["context"],
+      methodRegistry,
+    });
+    return respond;
+  }
+
+  it("authorizes from the attached registry used for dispatch", async () => {
+    const allowed = await dispatch(["operator.write"]);
+    const denied = await dispatch(["operator.read"]);
+
+    expect(allowed).toHaveBeenCalledWith(true, { ok: true });
+    expect(denied).toHaveBeenCalledWith(
+      false,
+      undefined,
+      expect.objectContaining({ message: "missing scope: operator.write" }),
+    );
+  });
+});
diff --git a/src/gateway/server-methods.ts b/src/gateway/server-methods.ts
@@ -9,7 +9,11 @@ import { getPluginRegistryState } from "../plugins/runtime-state.js";
 import { withPluginRuntimeGatewayRequestScope } from "../plugins/runtime/gateway-request-scope.js";
 import { formatControlPlaneActor, resolveControlPlaneActor } from "./control-plane-audit.js";
 import { consumeControlPlaneWriteBudget } from "./control-plane-rate-limit.js";
-import { ADMIN_SCOPE, authorizeOperatorScopesForMethod } from "./method-scopes.js";
+import {
+  ADMIN_SCOPE,
+  authorizeOperatorScopesForMethod,
+  authorizeOperatorScopesForRequiredScope,
+} from "./method-scopes.js";
 import {
   createCoreGatewayMethodDescriptors,
   createGatewayMethodDescriptorsFromHandlers,
@@ -18,6 +22,7 @@ import {
   isCoreGatewayMethodClassified,
   type GatewayMethodRegistry,
 } from "./methods/registry.js";
+import { isOperatorScope } from "./operator-scopes.js";
 import { isRoleAuthorizedForMethod, parseGatewayRole } from "./role-policy.js";
 import type {
   GatewayRequestHandler,
@@ -226,6 +231,7 @@ function authorizeGatewayMethod(
   method: string,
   client: GatewayRequestOptions["client"],
   params: unknown,
+  methodRegistry: GatewayMethodRegistry,
 ) {
   // Pre-connect and health requests are allowed through; role/scope checks require the
   // authenticated connect metadata established by the gateway handshake.
@@ -250,7 +256,10 @@ function authorizeGatewayMethod(
   if (scopes.includes(ADMIN_SCOPE)) {
     return null;
   }
-  const scopeAuth = authorizeOperatorScopesForMethod(method, scopes, params);
+  const registeredScope = methodRegistry.getScope(method);
+  const scopeAuth = isOperatorScope(registeredScope)
+    ? authorizeOperatorScopesForRequiredScope(registeredScope, scopes)
+    : authorizeOperatorScopesForMethod(method, scopes, params);
   if (!scopeAuth.allowed) {
     return errorShape(ErrorCodes.INVALID_REQUEST, `missing scope: ${scopeAuth.missingScope}`);
   }
@@ -632,7 +641,7 @@ export async function handleGatewayRequest(
   const { req, respond, client, isWebchatConnect, context } = opts;
   const methodRegistry =
     opts.methodRegistry ?? createRequestGatewayMethodRegistry(opts.extraHandlers);
-  const authError = authorizeGatewayMethod(req.method, client, req.params);
+  const authError = authorizeGatewayMethod(req.method, client, req.params, methodRegistry);
   if (authError) {
     respond(false, undefined, authError);
     return;
