@agent-native/dispatch 0.27.9 → 0.27.10

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.");
   }