@agent-native/dispatch 0.27.8 → 0.27.10

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

@@ -942,13 +942,18 @@ describe("createGrantedDispatchMcpEmbedSession", () => {
     expect(mocks.managerConstructor).toHaveBeenCalled();
   });
 
-  it("allows custom mounted workspace apps from the live workspace registry", async () => {
+  it("excludes path-mounted apps from SSO while retaining canonical apps", async () => {
     vi.stubEnv("WORKSPACE_GATEWAY_URL", "https://agent-workspace.builder.io");
-    mocks.discoverAgents.mockResolvedValue([]);
+    mocks.discoverAgents.mockResolvedValue([
+      {
+        ...analyticsAgent,
+        url: "https://analytics.agent-native.com",
+      },
+    ]);
     mocks.managerCallTool.mockResolvedValueOnce({
       structuredContent: {
         startUrl:
-          "https://agent-workspace.builder.io/atlas/_agent-native/embed/start?ticket=remote",
+          "https://analytics.agent-native.com/_agent-native/embed/start?ticket=remote",
       },
     });
     mocks.listWorkspaceApps.mockResolvedValue([
@@ -965,6 +970,20 @@ describe("createGrantedDispatchMcpEmbedSession", () => {
       },
     ]);
 
+    await expect(
+      runWithRequestContext(
+        {
+          userEmail: "owner@example.test",
+          requestOrigin: "https://dispatch.agent-native.com",
+        },
+        () =>
+          createWorkspaceSsoEmbedSession({
+            app: "atlas",
+            path: "/",
+          }),
+      ),
+    ).rejects.toThrow(/not registered/);
+
     const result = await runWithRequestContext(
       {
         userEmail: "owner@example.test",
@@ -972,23 +991,13 @@ describe("createGrantedDispatchMcpEmbedSession", () => {
       },
       () =>
         createWorkspaceSsoEmbedSession({
-          app: "atlas",
-          path: "/",
+          app: "analytics",
+          path: "/overview",
         }),
     );
 
-    expect(result).toMatchObject({
-      app: "atlas",
-      startUrl:
-        "https://agent-workspace.builder.io/atlas/_agent-native/embed/start?ticket=remote",
-    });
-    expect(mocks.managerConstructor).toHaveBeenCalledWith({
-      servers: {
-        target: expect.objectContaining({
-          url: "https://agent-workspace.builder.io/atlas/mcp",
-        }),
-      },
-    });
+    expect(result.app).toBe("analytics");
+    expect(mocks.managerConstructor).toHaveBeenCalled();
   });
 
   it("allows an exact custom registry entry and rejects an unregistered external app", async () => {
@@ -1263,6 +1272,74 @@ describe("createGrantedDispatchMcpEmbedSession", () => {
     );
   });
 
+  it("falls back to the shared A2A secret when the target rejects org signing", async () => {
+    vi.stubEnv("A2A_SECRET", "shared-secret");
+    mocks.getOrgDomain.mockResolvedValue("builder.io");
+    mocks.getOrgA2ASecret.mockResolvedValue("org-specific-secret");
+    mocks.signA2AToken
+      .mockResolvedValueOnce("org-signed-token")
+      .mockResolvedValueOnce("global-signed-token");
+    mocks.managerCallTool
+      .mockRejectedValueOnce(
+        new Error(
+          'MCP server "target" is not connected: HTTP 401 Unauthorized',
+        ),
+      )
+      .mockResolvedValueOnce({
+        structuredContent: {
+          startUrl:
+            "http://localhost:8086/_agent-native/embed/start?ticket=remote",
+        },
+      });
+
+    const result = await runWithRequestContext(
+      {
+        userEmail: "owner@example.test",
+        orgId: "org-1",
+        requestOrigin: "http://localhost:8092",
+      },
+      () =>
+        createGrantedDispatchMcpEmbedSession({
+          app: "analytics",
+          path: "/dashboards",
+        }),
+    );
+
+    expect(result).toMatchObject({ app: "analytics" });
+    expect(mocks.managerConstructor).toHaveBeenCalledTimes(2);
+    expect(mocks.managerConstructor).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining({
+        servers: {
+          target: expect.objectContaining({
+            headers: { Authorization: "Bearer org-signed-token" },
+          }),
+        },
+      }),
+    );
+    expect(mocks.managerConstructor).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({
+        servers: {
+          target: expect.objectContaining({
+            headers: { Authorization: "Bearer global-signed-token" },
+          }),
+        },
+      }),
+    );
+    expect(mocks.signA2AToken).toHaveBeenNthCalledWith(
+      2,
+      "owner@example.test",
+      "builder.io",
+      undefined,
+      {
+        expiresIn: "5m",
+        audience: "http://localhost:8086",
+        preferGlobalSecret: true,
+      },
+    );
+  });
+
   it("falls back to the shared A2A secret when no org secret is available", async () => {
     mocks.getOrgDomain.mockResolvedValue("builder.io");
     mocks.getOrgA2ASecret.mockResolvedValue(null);

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

@@ -626,17 +626,6 @@ function workspaceSsoOriginForApp(appId: string): string | null {
   return custom?.origin ?? null;
 }
 
-function workspaceSsoGatewayOrigin(): string | null {
-  const configured = process.env.WORKSPACE_GATEWAY_URL?.trim();
-  if (!configured) return null;
-  try {
-    return new URL(configured).origin;
-  } catch {
-    // coercion-ok: malformed deployment configuration is not a trusted origin.
-    return null;
-  }
-}
-
 function isWorkspaceSsoCanonicalApp(app: DispatchMcpAccessibleApp): boolean {
   const origin = safeAppOrigin(app);
   if (!origin) return false;
@@ -653,17 +642,8 @@ function isWorkspaceSsoCanonicalApp(app: DispatchMcpAccessibleApp): boolean {
     : false;
 }
 
-function sameWorkspaceApp(
-  candidate: DispatchMcpAccessibleApp,
-  mounted: WorkspaceAppSummary,
-): boolean {
-  if (candidate.id !== mounted.id || !mounted.url) return false;
-  return candidate.url.replace(/\/+$/, "") === mounted.url.replace(/\/+$/, "");
-}
-
 async function isEligibleWorkspaceSsoApp(
   candidate: DispatchMcpAccessibleApp,
-  mountedApps: WorkspaceAppSummary[],
 ): Promise<boolean> {
   const origin = safeAppOrigin(candidate);
   if (!origin) return false;
@@ -671,18 +651,7 @@ async function isEligibleWorkspaceSsoApp(
 
   const customOrigin = workspaceSsoOriginForApp(candidate.id);
   if (customOrigin === origin) return true;
-
-  const dispatchOrigin = safeAppOrigin({
-    id: DISPATCH_APP_ID,
-    name: DISPATCH_NAME,
-    description: DISPATCH_DESCRIPTION,
-    url: dispatchSelfBaseUrl(),
-    color: DISPATCH_COLOR,
-    granted: true,
-  });
-  const trustedMountedOrigin = workspaceSsoGatewayOrigin() ?? dispatchOrigin;
-  if (origin !== trustedMountedOrigin) return false;
-  return mountedApps.some((mounted) => sameWorkspaceApp(candidate, mounted));
+  return false;
 }
 
 async function listWorkspaceSsoApps(): Promise<DispatchMcpAccessibleApp[]> {
@@ -702,8 +671,8 @@ async function listWorkspaceSsoApps(): Promise<DispatchMcpAccessibleApp[]> {
     });
   }
   // The hosted Dispatch database is separate from the shared Workspace
-  // database. Overlay the live mounted registry so custom apps are eligible
-  // without copying a stale app list into Dispatch configuration.
+  // database. Overlay the live mounted registry so custom apps remain
+  // discoverable without copying a stale app list into Dispatch configuration.
   for (const app of mountedApps) {
     if (app.isDispatch || !app.url) continue;
     candidatesById.set(app.id, {
@@ -718,7 +687,7 @@ async function listWorkspaceSsoApps(): Promise<DispatchMcpAccessibleApp[]> {
   const candidates = [...candidatesById.values()];
   const eligible = [] as DispatchMcpAccessibleApp[];
   for (const candidate of candidates) {
-    if (await isEligibleWorkspaceSsoApp(candidate, mountedApps)) {
+    if (await isEligibleWorkspaceSsoApp(candidate)) {
       eligible.push(candidate);
     }
   }
@@ -975,6 +944,46 @@ function isRetryableTargetMcpError(error: unknown): boolean {
   );
 }
 
+function isTargetMcpAuthError(error: unknown): boolean {
+  const message =
+    error instanceof Error
+      ? error.message
+      : typeof error === "string"
+        ? error
+        : String(error ?? "");
+  return /\b401\b|\b403\b|unauthorized|forbidden|invalid(?: or expired)? (?:a2a )?token|authentication required/i.test(
+    message,
+  );
+}
+
+function targetMcpErrorStatus(error: unknown): number | undefined {
+  const message =
+    error instanceof Error
+      ? error.message
+      : typeof error === "string"
+        ? error
+        : String(error ?? "");
+  const status = message.match(/\b([45]\d{2})\b/)?.[1];
+  return status ? Number(status) : undefined;
+}
+
+type TargetMcpTokenAttempt = {
+  token: string;
+  strategy: "org" | "global";
+};
+
+function targetMcpRequestDetails(input: {
+  app: DispatchMcpAccessibleApp;
+  url: string;
+}): { app: string; targetOrigin: string; targetPath: string } {
+  const targetUrl = new URL(input.url);
+  return {
+    app: input.app.id,
+    targetOrigin: targetUrl.origin,
+    targetPath: targetUrl.pathname,
+  };
+}
+
 function targetMcpRetryDelay(attempt: number): number {
   const base =
     TARGET_EMBED_SESSION_RETRY_BASE_MS * Math.pow(2, Math.max(0, attempt - 1));
@@ -1025,6 +1034,58 @@ async function callTargetCreateEmbedSession(input: {
   }
 }
 
+async function createTargetMcpTokenAttempts(input: {
+  ownerEmail: string;
+  orgDomain?: string;
+  orgSecret?: string;
+  target: DispatchMcpAccessibleApp;
+}): Promise<TargetMcpTokenAttempt[]> {
+  const attempts: TargetMcpTokenAttempt[] = [];
+  const addAttempt = async (tokenInput: {
+    strategy: TargetMcpTokenAttempt["strategy"];
+    secret?: string;
+    preferGlobalSecret: boolean;
+  }) => {
+    const token = await signA2AToken(
+      input.ownerEmail,
+      input.orgDomain,
+      tokenInput.secret,
+      {
+        expiresIn: "5m",
+        audience: canonicalA2AAudience(appBaseUrl(input.target)),
+        preferGlobalSecret: tokenInput.preferGlobalSecret,
+      },
+    );
+    if (!attempts.some((attempt) => attempt.token === token)) {
+      attempts.push({ token, strategy: tokenInput.strategy });
+    }
+  };
+
+  if (input.orgDomain && input.orgSecret) {
+    await addAttempt({
+      strategy: "org",
+      secret: input.orgSecret,
+      preferGlobalSecret: false,
+    });
+    // A target app may not have the org secret synced yet. The shared secret
+    // is a bounded compatibility fallback, used only after the target rejects
+    // the org-signed request and never after a non-authentication failure.
+    if (process.env.A2A_SECRET?.trim()) {
+      await addAttempt({
+        strategy: "global",
+        preferGlobalSecret: true,
+      });
+    }
+  } else {
+    await addAttempt({
+      strategy: "global",
+      preferGlobalSecret: true,
+    });
+  }
+
+  return attempts;
+}
+
 async function resolveEmbedTarget(
   input: {
     app?: string;
@@ -1192,43 +1253,93 @@ async function createEmbedSessionForResolvedApp(input: {
     typeof orgSecret === "string" && orgSecret.trim().length > 0;
   const usableOrgDomain =
     typeof orgDomain === "string" && orgDomain.trim().length > 0;
-  const useOrgSigning = usableOrgDomain && usableOrgSecret;
   const signedOrgDomain = usableOrgDomain ? orgDomain.trim() : undefined;
-  const token = await signA2AToken(
+  const tokenAttempts = await createTargetMcpTokenAttempts({
     ownerEmail,
-    signedOrgDomain,
-    useOrgSigning ? orgSecret.trim() : undefined,
-    {
-      expiresIn: "5m",
-      audience: canonicalA2AAudience(appBaseUrl(target.app)),
-      // Prefer the synced org A2A secret when present because first-party
-      // production apps do not have to share the same deployment env secret.
-      // Fall back to the global A2A_SECRET for orgs that have not synced yet.
-      preferGlobalSecret: !useOrgSigning,
-    },
-  );
-
-  const result = await callTargetCreateEmbedSession({
+    orgDomain: signedOrgDomain,
+    orgSecret: usableOrgSecret ? orgSecret.trim() : undefined,
+    target: target.app,
+  });
+  const targetDetails = targetMcpRequestDetails({
     app: target.app,
-    token,
     url: target.url,
-    chrome,
   });
-  const parsed = parseMcpToolTextResult(result) as {
+  let parsed: {
     startUrl?: string;
     targetPath?: string;
     expiresAt?: number;
-  };
+  } | null = null;
+  let lastError: unknown;
+  for (
+    let attemptIndex = 0;
+    attemptIndex < tokenAttempts.length;
+    attemptIndex++
+  ) {
+    const tokenAttempt = tokenAttempts[attemptIndex];
+    console.info("[dispatch] workspace embed target request", {
+      ...targetDetails,
+      authStrategy: tokenAttempt.strategy,
+      attempt: attemptIndex + 1,
+      attempts: tokenAttempts.length,
+    });
+    try {
+      const result = await callTargetCreateEmbedSession({
+        app: target.app,
+        token: tokenAttempt.token,
+        url: target.url,
+        chrome,
+      });
+      parsed = parseMcpToolTextResult(result) as {
+        startUrl?: string;
+        targetPath?: string;
+        expiresAt?: number;
+      };
+      break;
+    } catch (error) {
+      lastError = error;
+      console.warn("[dispatch] workspace embed target response", {
+        ...targetDetails,
+        authStrategy: tokenAttempt.strategy,
+        attempt: attemptIndex + 1,
+        status: targetMcpErrorStatus(error),
+        category: isTargetMcpAuthError(error)
+          ? "authentication"
+          : isRetryableTargetMcpError(error)
+            ? "transient"
+            : "permanent",
+      });
+      if (
+        !isTargetMcpAuthError(error) ||
+        attemptIndex >= tokenAttempts.length - 1
+      ) {
+        throw error;
+      }
+    }
+  }
+  if (!parsed) {
+    throw lastError instanceof Error
+      ? lastError
+      : new Error("Target app did not return an embed session.");
+  }
   if (!parsed.startUrl) {
     throw new Error("Target app did not return an embed start URL.");
   }
+  const startUrl = resolveGrantedAppEmbedStartUrl(target.app, parsed.startUrl);
+  const startUrlDetails = new URL(startUrl);
+  console.info("[dispatch] workspace embed target minted session", {
+    ...targetDetails,
+    startPath: startUrlDetails.pathname,
+    returnedTicket: startUrlDetails.searchParams.has("ticket"),
+    returnedTargetPath: typeof parsed.targetPath === "string",
+    returnedExpiry: typeof parsed.expiresAt === "number",
+  });
   const output: {
     startUrl: string;
     targetPath?: string;
     expiresAt?: number;
     app: string;
   } = {
-    startUrl: resolveGrantedAppEmbedStartUrl(target.app, parsed.startUrl),
+    startUrl,
     app: target.app.id,
   };
   if (parsed.targetPath) output.targetPath = parsed.targetPath;
@@ -1248,13 +1359,31 @@ export async function createWorkspaceSsoEmbedSession(input: {
   app: string;
 }> {
   const ownerEmail = getRequestUserEmail();
-  if (!ownerEmail) throw new Error("no authenticated user");
+  if (!ownerEmail) {
+    console.warn("[dispatch] workspace embed mint rejected", {
+      phase: "dispatch-auth",
+      requestedApp: input.app ?? null,
+      hasPath: typeof input.path === "string",
+      hasUrl: typeof input.url === "string",
+      ownerResolved: false,
+      orgResolved: Boolean(getRequestOrgId()),
+    });
+    throw new Error("no authenticated user");
+  }
   const enabled = await isFeatureFlagEnabled(DISPATCH_WORKSPACE_SSO_FLAG, {
     userEmail: ownerEmail,
     userKey: ownerEmail,
     orgId: getRequestOrgId(),
   });
   if (!enabled) {
+    console.warn("[dispatch] workspace embed mint rejected", {
+      phase: "feature-flag",
+      requestedApp: input.app ?? null,
+      hasPath: typeof input.path === "string",
+      hasUrl: typeof input.url === "string",
+      ownerResolved: true,
+      orgResolved: Boolean(getRequestOrgId()),
+    });
     throw new Error("Dispatch workspace sign-in is not enabled.");
   }