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

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

@@ -3,12 +3,14 @@ import {
   canonicalA2AAudience,
   extractA2APersistedMutationReceipts,
   getGlobalA2ASecret,
+  signA2AOrgMemberDelegationToken,
   signA2AOrganizationToken,
   signA2AToken,
   stripA2APersistedArtifactMarkers,
   type A2APersistedMutationReceipt,
   type Task,
 } from "@agent-native/core/a2a";
+import { getAppConfig } from "@agent-native/core/app-config";
 import { isFeatureFlagEnabled } from "@agent-native/core/feature-flags";
 import {
   buildMcpToolName,
@@ -19,6 +21,7 @@ import {
   buildDeepLink,
   buildEmbedStartPath,
   createEmbedSessionTicket,
+  getConfiguredAppBasePath,
   getRequestContext,
   getRequestOrgId,
   getRequestUserEmail,
@@ -28,6 +31,7 @@ import {
   getBuiltinAgents,
   type DiscoveredAgent,
 } from "@agent-native/core/server/agent-discovery";
+import { EMBED_START_PATH } from "@agent-native/core/shared";
 
 import { DESKTOP_WORKSPACE_SSO_FLAG } from "../../shared/feature-flags.js";
 import {
@@ -79,6 +83,7 @@ export interface DispatchMcpAccessibleApp {
   description: string;
   url: string;
   homeUrl?: string;
+  mcpUrl?: string;
   color: string;
   granted: boolean;
 }
@@ -581,14 +586,73 @@ function appHomeBaseUrl(app: DispatchMcpAccessibleApp): string {
   return appBaseUrl(app);
 }
 
+function workspaceGatewayMcpUrl(appUrl: string): string | undefined {
+  const configuredGateway = getAppConfig().workspace.gatewayUrl?.trim();
+  if (!configuredGateway) return undefined;
+
+  let configuredUrl: URL;
+  try {
+    configuredUrl = new URL(configuredGateway);
+  } catch {
+    throw new Error(
+      "WORKSPACE_GATEWAY_URL must be a valid absolute HTTP(S) URL.",
+    );
+  }
+  if (
+    configuredUrl.protocol !== "http:" &&
+    configuredUrl.protocol !== "https:"
+  ) {
+    throw new Error("WORKSPACE_GATEWAY_URL must use http or https.");
+  }
+
+  const gateway = new URL(projectEnvironmentUrl(configuredUrl.toString()));
+  if (gateway.protocol !== "http:" && gateway.protocol !== "https:") {
+    throw new Error("WORKSPACE_GATEWAY_URL must use http or https.");
+  }
+  const target = new URL(appUrl);
+  if (gateway.origin !== target.origin) return undefined;
+  const configuredBasePath = getConfiguredAppBasePath();
+  const gatewayPath = gateway.pathname.replace(/\/+$/, "");
+  const basePath =
+    configuredBasePath &&
+    gatewayPath !== configuredBasePath &&
+    !gatewayPath.startsWith(`${configuredBasePath}/`)
+      ? `${configuredBasePath}${gatewayPath}`
+      : gatewayPath;
+  gateway.pathname = `${basePath}/mcp`;
+  gateway.search = "";
+  gateway.hash = "";
+  return gateway.toString().replace(/\/$/, "");
+}
+
+function appMcpUrl(app: DispatchMcpAccessibleApp): string {
+  const explicit = app.mcpUrl?.trim();
+  return (
+    explicit?.replace(/\/+$/, "") ??
+    workspaceGatewayMcpUrl(app.url) ??
+    `${appHomeBaseUrl(app)}/mcp`
+  );
+}
+
+function appMcpBaseUrl(app: DispatchMcpAccessibleApp): string {
+  const url = new URL(appMcpUrl(app));
+  url.pathname = url.pathname.replace(/\/mcp\/?$/, "") || "/";
+  url.search = "";
+  url.hash = "";
+  return url.toString().replace(/\/$/, "");
+}
+
 function resolveGrantedAppEmbedStartUrl(
   app: DispatchMcpAccessibleApp,
   startUrl: string,
 ): string {
   try {
-    const baseUrl = appHomeBaseUrl(app);
+    const baseUrl = appMcpBaseUrl(app);
     const resolved = new URL(startUrl, `${baseUrl}/`);
-    if (!appMatchesUrlPath(app, resolved)) {
+    const base = new URL(baseUrl);
+    const basePath = base.pathname.replace(/\/+$/, "");
+    const expectedPath = `${basePath}${EMBED_START_PATH}`;
+    if (resolved.origin !== base.origin || resolved.pathname !== expectedPath) {
       throw new Error(
         "Target app returned an embed start URL outside the granted app.",
       );
@@ -763,11 +827,13 @@ async function listWorkspaceSsoApps(): Promise<DispatchMcpAccessibleApp[]> {
   }
   for (const app of mountedApps) {
     if (app.isDispatch || !app.url) continue;
+    const mcpUrl = workspaceGatewayMcpUrl(app.url);
     candidatesById.set(app.id, {
       id: app.id,
       name: app.name,
       description: app.description,
       url: app.url,
+      ...(mcpUrl ? { mcpUrl } : {}),
       color: DISPATCH_COLOR,
       granted: true,
     });
@@ -1104,14 +1170,16 @@ function isRetryableTargetMcpError(error: unknown): boolean {
 }
 
 function targetMcpErrorStatus(error: unknown): number | undefined {
+  const status = httpStatusFromError(error);
+  if (status !== undefined) return status;
   const message =
     error instanceof Error
       ? error.message
       : typeof error === "string"
         ? error
         : safeJson(error);
-  const status = message.match(/\b([45]\d{2})\b/)?.[1];
-  return status ? Number(status) : undefined;
+  const matchedStatus = message.match(/\b([45]\d{2})\b/)?.[1];
+  return matchedStatus ? Number(matchedStatus) : undefined;
 }
 
 function targetMcpRequestDetails(input: {
@@ -1132,6 +1200,22 @@ function targetMcpConnectTimeout(deadline: number): number {
   return Math.max(1000, budget);
 }
 
+class TargetMcpAuthenticationRejectedError extends Error {
+  readonly status?: number;
+
+  constructor(cause: unknown) {
+    super("Target MCP authentication was rejected", { cause });
+    this.name = "TargetMcpAuthenticationRejectedError";
+    const status = httpStatusFromError(cause) ?? targetMcpErrorStatus(cause);
+    if (status !== undefined) this.status = status;
+  }
+}
+
+function isTargetMcpAuthenticationRejected(error: unknown): boolean {
+  const status = httpStatusFromError(error);
+  return status === 401 || status === 403;
+}
+
 function targetMcpRetryDelay(attempt: number): number {
   const base =
     TARGET_EMBED_SESSION_RETRY_BASE_MS * Math.pow(2, Math.max(0, attempt - 1));
@@ -1152,7 +1236,7 @@ async function callTargetCreateEmbedSession(input: {
         servers: {
           [serverId]: {
             type: "http",
-            url: `${appHomeBaseUrl(input.app)}/mcp`,
+            url: appMcpUrl(input.app),
             headers: {
               Authorization: `Bearer ${input.token}`,
             },
@@ -1161,8 +1245,17 @@ async function callTargetCreateEmbedSession(input: {
       },
       { connectTimeoutMs: targetMcpConnectTimeout(deadline) },
     );
+    let connected = false;
     try {
       await manager.start();
+      const connectErrorStatus = manager.getConnectErrorStatus(serverId);
+      if (connectErrorStatus === 401 || connectErrorStatus === 403) {
+        const error = Object.assign(new Error(`HTTP ${connectErrorStatus}`), {
+          status: connectErrorStatus,
+        });
+        throw new TargetMcpAuthenticationRejectedError(error);
+      }
+      connected = true;
       return await manager.callTool(
         buildMcpToolName(serverId, "create_embed_session"),
         {
@@ -1171,6 +1264,13 @@ async function callTargetCreateEmbedSession(input: {
         },
       );
     } catch (error) {
+      if (
+        !connected &&
+        !(error instanceof TargetMcpAuthenticationRejectedError) &&
+        isTargetMcpAuthenticationRejected(error)
+      ) {
+        throw new TargetMcpAuthenticationRejectedError(error);
+      }
       if (
         attempt >= TARGET_EMBED_SESSION_ATTEMPTS ||
         !isRetryableTargetMcpError(error) ||
@@ -1187,23 +1287,60 @@ async function callTargetCreateEmbedSession(input: {
   }
 }
 
-async function createTargetMcpUserToken(input: {
+type TargetMcpCredential = {
+  strategy: "deployment-user" | "org-member-delegation";
+  token: string;
+};
+
+async function createTargetMcpUserCredentials(input: {
   ownerEmail: string;
   orgId?: string;
   target: DispatchMcpAccessibleApp;
-}): Promise<string> {
-  if (!getGlobalA2ASecret()) {
+}): Promise<{
+  credentials: TargetMcpCredential[];
+  loadOrgMemberCredential: () => Promise<TargetMcpCredential | undefined>;
+}> {
+  const audience = canonicalA2AAudience(appMcpUrl(input.target));
+  const orgDomain = input.orgId
+    ? (await getOrgDomain(input.orgId))?.trim().toLowerCase() || undefined
+    : undefined;
+  const credentials: TargetMcpCredential[] = [];
+  if (getGlobalA2ASecret()) {
+    credentials.push({
+      strategy: "deployment-user",
+      token: await signA2AToken(input.ownerEmail, undefined, undefined, {
+        expiresIn: "5m",
+        audience,
+        preferGlobalSecret: true,
+      }),
+    });
+  }
+
+  const loadOrgMemberCredential = async () => {
+    if (!input.orgId || !orgDomain) return undefined;
+    const orgSecret = await getOrgA2ASecret(input.orgId);
+    if (!orgSecret) return undefined;
+    return {
+      strategy: "org-member-delegation" as const,
+      token: await signA2AOrgMemberDelegationToken(
+        input.ownerEmail,
+        orgDomain,
+        orgSecret,
+        audience,
+      ),
+    };
+  };
+
+  if (credentials.length === 0) {
+    const orgMemberCredential = await loadOrgMemberCredential();
+    if (orgMemberCredential) credentials.push(orgMemberCredential);
+  }
+  if (credentials.length === 0) {
     throw new Error(
-      "Cross-app embed sessions require A2A_SECRET to preserve the authenticated user identity; an organization-only A2A credential cannot create a user-owned session.",
+      "Cross-app embed sessions require a deployment A2A secret or an organization secret with member delegation enabled on the target.",
     );
   }
-  const audience = canonicalA2AAudience(`${appHomeBaseUrl(input.target)}/mcp`);
-  return signA2AToken(input.ownerEmail, undefined, undefined, {
-    expiresIn: "5m",
-    audience,
-    preferGlobalSecret: true,
-    ...(input.orgId ? { extraClaims: { org_id: input.orgId } } : {}),
-  });
+  return { credentials, loadOrgMemberCredential };
 }
 
 async function resolveEmbedTarget(
@@ -1363,45 +1500,72 @@ async function createEmbedSessionForResolvedApp(input: {
     });
   }
 
-  const targetToken = await createTargetMcpUserToken({
+  const targetCredentials = await createTargetMcpUserCredentials({
     ownerEmail,
-    orgId,
+    ...(orgId !== undefined ? { orgId } : {}),
     target: target.app,
   });
   const targetDetails = targetMcpRequestDetails({
     app: target.app,
     url: target.url,
   });
-  let parsed: {
-    startUrl?: string;
-    targetPath?: string;
-    expiresAt?: number;
-  };
-  console.info("[dispatch] workspace embed target request", {
-    ...targetDetails,
-    authStrategy: "user-identity",
-  });
-  try {
-    const result = await callTargetCreateEmbedSession({
-      app: target.app,
-      token: targetToken,
-      url: target.url,
-      chrome,
-    });
-    parsed = parseMcpToolTextResult(result) as {
-      startUrl?: string;
-      targetPath?: string;
-      expiresAt?: number;
-    };
-  } catch (error) {
-    console.warn("[dispatch] workspace embed target response", {
+  let parsed:
+    | {
+        startUrl?: string;
+        targetPath?: string;
+        expiresAt?: number;
+      }
+    | undefined;
+  const credentials = [...targetCredentials.credentials];
+  for (const [index, credential] of credentials.entries()) {
+    console.info("[dispatch] workspace embed target request", {
       ...targetDetails,
-      authStrategy: "user-identity",
-      status: targetMcpErrorStatus(error),
-      category: isRetryableTargetMcpError(error) ? "transient" : "permanent",
+      authStrategy: credential.strategy,
     });
-    throw error;
+    try {
+      const result = await callTargetCreateEmbedSession({
+        app: target.app,
+        token: credential.token,
+        url: target.url,
+        ...(chrome !== undefined ? { chrome } : {}),
+      });
+      parsed = parseMcpToolTextResult(result) as {
+        startUrl?: string;
+        targetPath?: string;
+        expiresAt?: number;
+      };
+      break;
+    } catch (error) {
+      if (
+        error instanceof TargetMcpAuthenticationRejectedError &&
+        credential.strategy === "deployment-user" &&
+        index === credentials.length - 1
+      ) {
+        const orgMemberCredential =
+          await targetCredentials.loadOrgMemberCredential();
+        if (orgMemberCredential) credentials.push(orgMemberCredential);
+      }
+      if (
+        error instanceof TargetMcpAuthenticationRejectedError &&
+        index < credentials.length - 1
+      ) {
+        console.warn("[dispatch] workspace embed auth candidate rejected", {
+          ...targetDetails,
+          authStrategy: credential.strategy,
+          status: targetMcpErrorStatus(error),
+        });
+        continue;
+      }
+      console.warn("[dispatch] workspace embed target response", {
+        ...targetDetails,
+        authStrategy: credential.strategy,
+        status: targetMcpErrorStatus(error),
+        category: isRetryableTargetMcpError(error) ? "transient" : "permanent",
+      });
+      throw error;
+    }
   }
+  if (!parsed) throw 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.");
   }

package/src/shared/workspace-app-route.ts

@@ -0,0 +1,3 @@
+export function workspaceAppRoute(appId: string): string {
+  return `/apps/${encodeURIComponent(appId)}`;
+}