@agent-native/dispatch 0.40.40 → 0.40.41-beta-dispatch-embed-01a15dc9-20261027050558

package/src/server/lib/mcp-gateway.spec.ts

@@ -18,12 +18,14 @@ const mocks = vi.hoisted(() => ({
     return `/_agent-native/embed/start?ticket=${encodeURIComponent(ticket)}`;
   }),
   managerStart: vi.fn(),
+  managerGetConnectErrorStatus: vi.fn(),
   managerStop: vi.fn(),
   managerCallTool: vi.fn(),
   managerConstructor: vi.fn(),
   a2aConstructor: vi.fn(),
   a2aSend: vi.fn(),
   a2aGetTask: vi.fn(),
+  signA2AOrgMemberDelegationToken: vi.fn(),
   signA2AOrganizationToken: vi.fn(),
   signA2AToken: vi.fn(),
   canonicalA2AAudience: vi.fn((url: string) => url.replace(/\/+$/, "")),
@@ -88,6 +90,7 @@ vi.mock("@agent-native/core/a2a", async (importOriginal) => {
       }
     },
     signA2AOrganizationToken: mocks.signA2AOrganizationToken,
+    signA2AOrgMemberDelegationToken: mocks.signA2AOrgMemberDelegationToken,
     signA2AToken: mocks.signA2AToken,
     getGlobalA2ASecret: () => process.env.A2A_SECRET?.trim(),
     canonicalA2AAudience: mocks.canonicalA2AAudience,
@@ -111,6 +114,10 @@ vi.mock("@agent-native/core/mcp-client", () => ({
       return mocks.managerStart();
     }
 
+    getConnectErrorStatus(serverId: string) {
+      return mocks.managerGetConnectErrorStatus(serverId);
+    }
+
     stop() {
       return mocks.managerStop();
     }
@@ -165,6 +172,7 @@ beforeEach(() => {
   mocks.a2aSend.mockReset();
   mocks.a2aGetTask.mockReset();
   mocks.signA2AOrganizationToken.mockReset();
+  mocks.signA2AOrgMemberDelegationToken.mockReset();
   mocks.signA2AToken.mockReset();
   mocks.discoverAgents.mockResolvedValue([analyticsAgent]);
   mocks.getBuiltinAgents.mockReturnValue([]);
@@ -177,6 +185,7 @@ beforeEach(() => {
     expiresAt: 12345,
   });
   mocks.managerStart.mockResolvedValue(undefined);
+  mocks.managerGetConnectErrorStatus.mockReturnValue(undefined);
   mocks.managerStop.mockResolvedValue(undefined);
   mocks.managerCallTool.mockResolvedValue({
     structuredContent: {
@@ -194,9 +203,11 @@ beforeEach(() => {
     },
   });
   mocks.signA2AToken.mockResolvedValue("signed-token");
+  mocks.signA2AOrgMemberDelegationToken.mockResolvedValue("org-member-token");
   mocks.signA2AOrganizationToken.mockResolvedValue("signed-token");
   mocks.getOrgA2ASecret.mockResolvedValue(null);
   mocks.getOrgDomain.mockResolvedValue(null);
+  vi.stubEnv("A2A_SECRET", "");
   mocks.isFeatureFlagEnabled.mockResolvedValue(true);
 });
 
@@ -1575,6 +1586,228 @@ describe("createGrantedDispatchMcpEmbedSession", () => {
     expect(mocks.managerConstructor).toHaveBeenCalled();
   });
 
+  it.each([
+    [
+      "workspace-sso",
+      "gateway mount path",
+      "https://beta.agent-workspace.builder.io/dispatch",
+      "",
+    ],
+    [
+      "dispatch-grant",
+      "gateway mount path",
+      "https://beta.agent-workspace.builder.io/dispatch",
+      "",
+    ],
+    [
+      "workspace-sso",
+      "APP_BASE_PATH",
+      "https://beta.agent-workspace.builder.io",
+      "/dispatch",
+    ],
+    [
+      "dispatch-grant",
+      "APP_BASE_PATH",
+      "https://beta.agent-workspace.builder.io",
+      "/dispatch",
+    ],
+  ] as const)(
+    "uses the mounted Workspace MCP endpoint and audience for %s embeds with %s",
+    async (route, _mountConfig, gatewayUrl, appBasePath) => {
+      vi.stubEnv("A2A_SECRET", "test-a2a-secret");
+      vi.stubEnv("WORKSPACE_GATEWAY_URL", gatewayUrl);
+      vi.stubEnv("APP_BASE_PATH", appBasePath);
+      vi.stubEnv("VITE_APP_BASE_PATH", "");
+      vi.stubEnv(
+        "IDENTITY_SSO_APP_REGISTRY_JSON",
+        JSON.stringify([
+          {
+            appId: "customer-ticket-triage",
+            clientId: "workspace-client",
+            origin: "https://beta.agent-workspace.builder.io",
+            callbackPath: "/_agent-native/identity/callback",
+            capabilities: ["identity-sso"],
+          },
+        ]),
+      );
+      const workspaceApp = {
+        id: "customer-ticket-triage",
+        name: "Customer Ticket Triage",
+        description: "Triage customer tickets",
+        path: "/customer-ticket-triage",
+        url: "https://beta.agent-workspace.builder.io/dispatch/apps/customer-ticket-triage",
+        isDispatch: false,
+      };
+      mocks.listWorkspaceApps.mockResolvedValue([workspaceApp]);
+      mocks.discoverAgents.mockResolvedValue([
+        {
+          id: workspaceApp.id,
+          name: workspaceApp.name,
+          description: workspaceApp.description,
+          url: workspaceApp.url,
+          color: "#14B8A6",
+        },
+      ]);
+      mocks.managerCallTool.mockResolvedValueOnce({
+        structuredContent: {
+          startUrl:
+            "https://beta.agent-workspace.builder.io/dispatch/_agent-native/embed/start?ticket=remote",
+        },
+      });
+
+      const result = await runWithRequestContext(
+        {
+          userEmail: "owner@example.test",
+          requestOrigin: "https://beta.dispatch.agent-native.com",
+        },
+        () =>
+          route === "workspace-sso"
+            ? createWorkspaceSsoEmbedSession({
+                app: workspaceApp.id,
+                path: "/triage",
+                chrome: "minimal",
+              })
+            : createGrantedDispatchMcpEmbedSession({
+                app: workspaceApp.id,
+                path: "/triage",
+                chrome: "minimal",
+              }),
+      );
+
+      expect(mocks.managerConstructor).toHaveBeenCalledWith(
+        expect.objectContaining({
+          servers: {
+            target: expect.objectContaining({
+              url: "https://beta.agent-workspace.builder.io/dispatch/mcp",
+              headers: { Authorization: "Bearer signed-token" },
+            }),
+          },
+        }),
+      );
+      expect(mocks.signA2AToken).toHaveBeenCalledWith(
+        "owner@example.test",
+        undefined,
+        undefined,
+        expect.objectContaining({
+          audience: "https://beta.agent-workspace.builder.io/dispatch/mcp",
+          preferGlobalSecret: true,
+        }),
+      );
+      expect(mocks.managerCallTool).toHaveBeenCalledWith(
+        "mcp__target__create_embed_session",
+        {
+          url: "https://beta.agent-workspace.builder.io/dispatch/apps/customer-ticket-triage/triage",
+          chrome: "minimal",
+        },
+      );
+      expect(result.startUrl).toBe(
+        "https://beta.agent-workspace.builder.io/dispatch/_agent-native/embed/start?ticket=remote",
+      );
+
+      mocks.managerCallTool.mockResolvedValueOnce({
+        structuredContent: {
+          startUrl:
+            "https://beta.agent-workspace.builder.io/dispatch/apps/customer-ticket-triage/_agent-native/embed/start?ticket=sibling",
+        },
+      });
+      await expect(
+        runWithRequestContext(
+          {
+            userEmail: "owner@example.test",
+            requestOrigin: "https://beta.dispatch.agent-native.com",
+          },
+          () =>
+            route === "workspace-sso"
+              ? createWorkspaceSsoEmbedSession({
+                  app: workspaceApp.id,
+                  path: "/",
+                  chrome: "minimal",
+                })
+              : createGrantedDispatchMcpEmbedSession({
+                  app: workspaceApp.id,
+                  path: "/",
+                  chrome: "minimal",
+                }),
+        ),
+      ).rejects.toThrow(/invalid embed start URL/);
+    },
+  );
+
+  it("does not fall back when the configured Workspace gateway URL is invalid", async () => {
+    vi.stubEnv("WORKSPACE_GATEWAY_URL", "not-a-url");
+    mocks.listWorkspaceApps.mockResolvedValue([
+      {
+        id: "customer-ticket-triage",
+        name: "Customer Ticket Triage",
+        description: "Triage customer tickets",
+        path: "/customer-ticket-triage",
+        url: "https://beta.agent-workspace.builder.io/dispatch/apps/customer-ticket-triage",
+        isDispatch: false,
+      },
+    ]);
+
+    await expect(
+      runWithRequestContext(
+        {
+          userEmail: "owner@example.test",
+          requestOrigin: "https://beta.dispatch.agent-native.com",
+        },
+        () =>
+          createWorkspaceSsoEmbedSession({
+            app: "customer-ticket-triage",
+            path: "/",
+            chrome: "minimal",
+          }),
+      ),
+    ).rejects.toThrow();
+    expect(mocks.managerConstructor).not.toHaveBeenCalled();
+  });
+
+  it("rejects unsupported Workspace gateway schemes before beta projection", async () => {
+    vi.stubEnv("A2A_SECRET", "test-a2a-secret");
+    vi.stubEnv(
+      "WORKSPACE_GATEWAY_URL",
+      "ftp://agent-workspace.builder.io/dispatch",
+    );
+    vi.stubEnv("APP_BASE_PATH", "");
+    vi.stubEnv("VITE_APP_BASE_PATH", "");
+    const workspaceApp = {
+      id: "customer-ticket-triage",
+      name: "Customer Ticket Triage",
+      description: "Triage customer tickets",
+      path: "/customer-ticket-triage",
+      url: "https://beta.agent-workspace.builder.io/dispatch/apps/customer-ticket-triage",
+      isDispatch: false,
+    };
+    mocks.listWorkspaceApps.mockResolvedValue([workspaceApp]);
+    mocks.discoverAgents.mockResolvedValue([
+      {
+        id: workspaceApp.id,
+        name: workspaceApp.name,
+        description: workspaceApp.description,
+        url: workspaceApp.url,
+        color: "#14B8A6",
+      },
+    ]);
+
+    await expect(
+      runWithRequestContext(
+        {
+          userEmail: "owner@example.test",
+          requestOrigin: "https://beta.dispatch.agent-native.com",
+        },
+        () =>
+          createGrantedDispatchMcpEmbedSession({
+            app: workspaceApp.id,
+            path: "/",
+            chrome: "minimal",
+          }),
+      ),
+    ).rejects.toThrow("WORKSPACE_GATEWAY_URL must use http or https.");
+    expect(mocks.signA2AToken).not.toHaveBeenCalled();
+    expect(mocks.managerConstructor).not.toHaveBeenCalled();
+  });
+
   it("rejects beta workspace SSO apps on the production lane", async () => {
     mocks.discoverAgents.mockResolvedValue([]);
     mocks.listWorkspaceApps.mockResolvedValue([
@@ -2015,7 +2248,9 @@ describe("createGrantedDispatchMcpEmbedSession", () => {
     });
   });
 
-  it("binds the authenticated MCP caller token to the org ID", async () => {
+  it("does not send the source app's local org ID to the target", async () => {
+    mocks.getOrgDomain.mockResolvedValue("builder.io");
+
     await runWithRequestContext(
       {
         userEmail: "owner@example.test",
@@ -2037,11 +2272,10 @@ describe("createGrantedDispatchMcpEmbedSession", () => {
         expiresIn: "5m",
         audience: "http://localhost:8086/mcp",
         preferGlobalSecret: true,
-        extraClaims: { org_id: "org-1" },
       },
     );
     expect(mocks.signA2AOrganizationToken).not.toHaveBeenCalled();
-    expect(mocks.getOrgDomain).not.toHaveBeenCalled();
+    expect(mocks.getOrgDomain).toHaveBeenCalledWith("org-1");
     expect(mocks.getOrgA2ASecret).not.toHaveBeenCalled();
     expect(mocks.managerConstructor).toHaveBeenCalledWith(
       expect.objectContaining({
@@ -2054,11 +2288,139 @@ describe("createGrantedDispatchMcpEmbedSession", () => {
     );
   });
 
-  it("requires A2A_SECRET when an organization-only credential cannot assert user identity", async () => {
+  it("uses a user delegation token when only the org secret is configured", async () => {
     vi.stubEnv("A2A_SECRET", "");
     mocks.getOrgDomain.mockResolvedValue("builder.io");
     mocks.getOrgA2ASecret.mockResolvedValue("org-specific-secret");
 
+    const result = await runWithRequestContext(
+      {
+        userEmail: "owner@example.test",
+        orgId: "org-1",
+        requestOrigin: "http://localhost:8092",
+      },
+      () =>
+        createGrantedDispatchMcpEmbedSession({
+          app: "analytics",
+          path: "/dashboards",
+        }),
+    );
+
+    expect(mocks.signA2AToken).not.toHaveBeenCalled();
+    expect(mocks.signA2AOrgMemberDelegationToken).toHaveBeenCalledWith(
+      "owner@example.test",
+      "builder.io",
+      "org-specific-secret",
+      "http://localhost:8086/mcp",
+    );
+    expect(mocks.signA2AOrganizationToken).not.toHaveBeenCalled();
+    expect(result.startUrl).toBe(
+      "http://localhost:8086/_agent-native/embed/start?ticket=remote",
+    );
+    expect(mocks.managerConstructor).toHaveBeenCalledWith(
+      expect.objectContaining({
+        servers: {
+          target: expect.objectContaining({
+            headers: { Authorization: "Bearer org-member-token" },
+          }),
+        },
+      }),
+    );
+  });
+
+  it("tries org-member delegation after a deployment-token auth rejection", async () => {
+    mocks.getOrgDomain.mockResolvedValue("builder.io");
+    mocks.getOrgA2ASecret.mockResolvedValue("org-specific-secret");
+    mocks.signA2AToken.mockResolvedValue("deployment-user-token");
+    mocks.signA2AOrgMemberDelegationToken.mockResolvedValue("org-member-token");
+    mocks.managerGetConnectErrorStatus.mockReturnValueOnce(401);
+
+    const result = await runWithRequestContext(
+      {
+        userEmail: "owner@example.test",
+        orgId: "org-1",
+        requestOrigin: "http://localhost:8092",
+      },
+      () =>
+        createGrantedDispatchMcpEmbedSession({
+          app: "analytics",
+          path: "/dashboards",
+        }),
+    );
+
+    expect(result.startUrl).toBe(
+      "http://localhost:8086/_agent-native/embed/start?ticket=remote",
+    );
+    expect(mocks.managerConstructor).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining({
+        servers: {
+          target: expect.objectContaining({
+            headers: { Authorization: "Bearer deployment-user-token" },
+          }),
+        },
+      }),
+    );
+    expect(mocks.managerConstructor).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({
+        servers: {
+          target: expect.objectContaining({
+            headers: { Authorization: "Bearer org-member-token" },
+          }),
+        },
+      }),
+    );
+    expect(mocks.managerCallTool).toHaveBeenCalledTimes(1);
+    expect(mocks.signA2AOrgMemberDelegationToken).toHaveBeenCalledWith(
+      "owner@example.test",
+      "builder.io",
+      "org-specific-secret",
+      "http://localhost:8086/mcp",
+    );
+  });
+
+  it("uses member delegation when the org secret matches the source deployment secret", async () => {
+    vi.stubEnv("A2A_SECRET", "source-deployment-secret");
+    mocks.getOrgDomain.mockResolvedValue("builder.io");
+    mocks.getOrgA2ASecret.mockResolvedValue("source-deployment-secret");
+    mocks.managerGetConnectErrorStatus.mockReturnValueOnce(401);
+
+    const result = await runWithRequestContext(
+      {
+        userEmail: "owner@example.test",
+        orgId: "org-1",
+        requestOrigin: "http://localhost:8092",
+      },
+      () =>
+        createGrantedDispatchMcpEmbedSession({
+          app: "analytics",
+          path: "/dashboards",
+        }),
+    );
+
+    expect(result.startUrl).toBe(
+      "http://localhost:8086/_agent-native/embed/start?ticket=remote",
+    );
+    expect(mocks.managerConstructor).toHaveBeenCalledTimes(2);
+    expect(mocks.signA2AOrgMemberDelegationToken).toHaveBeenCalledWith(
+      "owner@example.test",
+      "builder.io",
+      "source-deployment-secret",
+      "http://localhost:8086/mcp",
+    );
+  });
+
+  it("does not treat a bare status number in an error message as an auth refusal", async () => {
+    vi.stubEnv("A2A_SECRET", "source-deployment-secret");
+    mocks.getOrgDomain.mockResolvedValue("builder.io");
+    mocks.getOrgA2ASecret.mockResolvedValue("org-specific-secret");
+    mocks.managerStart.mockRejectedValueOnce(
+      new Error(
+        "MCP response body mentions reference 403 from an unrelated request",
+      ),
+    );
+
     await expect(
       runWithRequestContext(
         {
@@ -2072,13 +2434,38 @@ describe("createGrantedDispatchMcpEmbedSession", () => {
             path: "/dashboards",
           }),
       ),
-    ).rejects.toThrow(
-      /require A2A_SECRET to preserve the authenticated user identity/,
+    ).rejects.toThrow(/reference 403 from an unrelated request/);
+
+    expect(mocks.managerConstructor).toHaveBeenCalledTimes(1);
+    expect(mocks.signA2AOrgMemberDelegationToken).not.toHaveBeenCalled();
+    expect(mocks.getOrgA2ASecret).not.toHaveBeenCalled();
+  });
+
+  it("does not retry an action-level authorization error with member delegation", async () => {
+    mocks.getOrgDomain.mockResolvedValue("builder.io");
+    mocks.getOrgA2ASecret.mockResolvedValue("org-specific-secret");
+    mocks.managerCallTool.mockRejectedValueOnce(
+      Object.assign(new Error("Forbidden"), { status: 403 }),
     );
 
-    expect(mocks.signA2AToken).not.toHaveBeenCalled();
-    expect(mocks.signA2AOrganizationToken).not.toHaveBeenCalled();
-    expect(mocks.managerConstructor).not.toHaveBeenCalled();
+    await expect(
+      runWithRequestContext(
+        {
+          userEmail: "owner@example.test",
+          orgId: "org-1",
+          requestOrigin: "http://localhost:8092",
+        },
+        () =>
+          createGrantedDispatchMcpEmbedSession({
+            app: "analytics",
+            path: "/dashboards",
+          }),
+      ),
+    ).rejects.toThrow("Forbidden");
+
+    expect(mocks.managerConstructor).toHaveBeenCalledTimes(1);
+    expect(mocks.signA2AOrgMemberDelegationToken).not.toHaveBeenCalled();
+    expect(mocks.getOrgA2ASecret).not.toHaveBeenCalled();
   });
 
   it("does not retry an authenticated-caller error with an org principal", async () => {