@agent-native/dispatch 0.29.2 → 0.29.4

package/src/components/workspace-app-host.tsx

@@ -31,6 +31,7 @@ import { Link } from "react-router";
 import { isEmbedSessionExpiredMessage } from "../lib/embed-session-recovery";
 import {
   mergeChatFirstWorkspaceApps,
+  isWorkspaceSsoApp,
   navigateToWorkspaceApp,
   shouldOpenWorkspaceAppInTopWindow,
   workspaceAppDirectHref,
@@ -287,6 +288,7 @@ export function WorkspaceAppFrame({
     if (isDirectFallback) setEmbedError(null);
   }, [isDirectFallback, postThemeToFrame]);
   const workspaceSsoEnabled = useFeatureFlag(DISPATCH_WORKSPACE_SSO_FLAG.key);
+  const useWorkspaceSso = workspaceSsoEnabled && isWorkspaceSsoApp(app);
   const createEmbedSession = useActionMutation<
     EmbedSessionResult,
     EmbedSessionInput
@@ -320,6 +322,8 @@ export function WorkspaceAppFrame({
     return target.url ?? target.path ?? null;
   }, [app.path, app.url, embedPath]);
   const openInTopWindow = shouldOpenWorkspaceAppInTopWindow();
+  const topWindowSsoAttemptKey = `${app.id}\u0000${app.path ?? ""}\u0000${app.url ?? ""}\u0000${embedPath ?? ""}\u0000${embedAttempt}`;
+  const topWindowSsoAttemptedRef = useRef<string | null>(null);
   const embedInput = useMemo<EmbedSessionInput | null>(() => {
     if (embedPath !== undefined) {
       return buildChatFirstEmbedSessionInput(app.id, embedPath);
@@ -333,6 +337,10 @@ export function WorkspaceAppFrame({
   }, [app.id, app.path, app.url, appHref, embedPath]);
 
   useEffect(() => {
+    if (openInTopWindow && useWorkspaceSso && embedInput) {
+      setTopWindowNavigationFailed(false);
+      return;
+    }
     if (!openInTopWindow) {
       setTopWindowNavigationFailed(false);
       return;
@@ -349,26 +357,59 @@ export function WorkspaceAppFrame({
       didNavigate = false;
     }
     setTopWindowNavigationFailed(!didNavigate);
-  }, [navigateToTopWindow, openInTopWindow, topWindowHref]);
+  }, [
+    embedInput,
+    navigateToTopWindow,
+    openInTopWindow,
+    topWindowHref,
+    useWorkspaceSso,
+  ]);
 
   useEffect(() => {
-    if (!embedInput || (openInTopWindow && !topWindowNavigationFailed)) return;
+    const useTopWindowSso = openInTopWindow && useWorkspaceSso && !!embedInput;
+    if (
+      !embedInput ||
+      (openInTopWindow && !useWorkspaceSso && !topWindowNavigationFailed)
+    ) {
+      return;
+    }
+    if (
+      useTopWindowSso &&
+      topWindowSsoAttemptedRef.current === topWindowSsoAttemptKey
+    ) {
+      return;
+    }
+    if (useTopWindowSso) {
+      topWindowSsoAttemptedRef.current = topWindowSsoAttemptKey;
+    }
     let cancelled = false;
     setEmbedUrl(null);
     setEmbedError(null);
     setIsDirectFallback(false);
-    const createSession = workspaceSsoEnabled
+    const createSession = useWorkspaceSso
       ? createWorkspaceSsoEmbedSession
       : createEmbedSession;
     void createSession
       .mutateAsync(embedInput)
       .then((result) => {
-        if (!cancelled) setEmbedUrl(result.startUrl);
+        if (cancelled) return;
+        if (useTopWindowSso) {
+          let didNavigate = false;
+          try {
+            didNavigate = navigateToTopWindow(result.startUrl) !== false;
+          } catch {
+            didNavigate = false;
+          }
+          setTopWindowNavigationFailed(!didNavigate);
+          setEmbedUrl(didNavigate ? null : result.startUrl);
+          return;
+        }
+        setEmbedUrl(result.startUrl);
       })
       .catch((cause: unknown) => {
         if (cancelled) return;
         const error = cause instanceof Error ? cause : new Error(String(cause));
-        if (workspaceSsoEnabled) {
+        if (useWorkspaceSso) {
           // An SSO-enabled pane must never fall back to the child app's
           // unauthenticated shell. Keep the parent-owned retry surface in
           // place so a transient exchange failure cannot expose another
@@ -376,6 +417,7 @@ export function WorkspaceAppFrame({
           setIsDirectFallback(false);
           setEmbedUrl(null);
           setEmbedError(error);
+          if (useTopWindowSso) setTopWindowNavigationFailed(true);
           return;
         }
         setIsDirectFallback(true);
@@ -400,8 +442,10 @@ export function WorkspaceAppFrame({
     embedPath,
     embedAttempt,
     openInTopWindow,
+    navigateToTopWindow,
+    topWindowSsoAttemptKey,
     topWindowNavigationFailed,
-    workspaceSsoEnabled,
+    useWorkspaceSso,
   ]);
 
   useEffect(() => {
@@ -476,21 +520,52 @@ export function WorkspaceAppHost({
   const t = useT();
   const workspaceAppsQuery = useActionQuery<WorkspaceAppSummary[]>(
     "list-workspace-apps",
-    { includeAgentCards: false },
+    { includeAgentCards: false, includeArchived: true },
+  );
+  const workspaceApps = useMemo(
+    () => mergeChatFirstWorkspaceApps(workspaceAppsQuery.data),
+    [workspaceAppsQuery.data],
+  );
+  const visibleWorkspaceApps = useMemo(
+    () => workspaceApps.filter((item) => !item.archived),
+    [workspaceApps],
+  );
+  const workspaceAppIds = useMemo(
+    () => new Set(workspaceApps.map((item) => item.id.trim().toLowerCase())),
+    [workspaceApps],
+  );
+  const workspaceApp = useMemo(
+    () =>
+      visibleWorkspaceApps.find(
+        (item) => item.id.trim().toLowerCase() === appId?.trim().toLowerCase(),
+      ) ?? null,
+    [appId, visibleWorkspaceApps],
   );
   const grantedAppsQuery = useActionQuery<GrantedWorkspaceAppsResult>(
     "list_apps",
     {},
+    {
+      // Mounted workspace apps are already fully described by the workspace
+      // registry. Defer the broader MCP grant/discovery scan until that
+      // lookup misses; it is only needed for externally granted apps.
+      enabled: !workspaceAppsQuery.isLoading && !workspaceApp,
+    },
   );
   const apps = useMemo(() => {
     const merged = new Map<string, WorkspaceAppSummary>();
 
-    for (const app of mergeChatFirstWorkspaceApps(workspaceAppsQuery.data)) {
+    for (const app of visibleWorkspaceApps) {
       merged.set(app.id.trim().toLowerCase(), app);
     }
     for (const app of grantedAppsQuery.data?.apps ?? []) {
       const id = app.id.trim();
-      if (!id || merged.has(id.toLowerCase())) continue;
+      if (
+        !id ||
+        workspaceAppIds.has(id.toLowerCase()) ||
+        merged.has(id.toLowerCase())
+      ) {
+        continue;
+      }
       merged.set(id.toLowerCase(), {
         id,
         name: app.name.trim() || id,
@@ -501,7 +576,7 @@ export function WorkspaceAppHost({
     }
 
     return [...merged.values()];
-  }, [grantedAppsQuery.data?.apps, workspaceAppsQuery.data]);
+  }, [grantedAppsQuery.data?.apps, visibleWorkspaceApps, workspaceAppIds]);
   const app = useMemo(
     () =>
       apps.find(

package/src/lib/workspace-apps.spec.ts

@@ -3,9 +3,12 @@ import { describe, expect, it } from "vitest";
 import {
   isDefaultWorkspaceAppHiddenId,
   isDispatchWorkspaceAppId,
+  isPathMountedWorkspaceApp,
   isWorkspaceAppVisibleInDefaultLaunchers,
+  isWorkspaceSsoApp,
   mergeChatFirstWorkspaceApps,
   workspaceAppIdFromRoute,
+  workspaceAppDirectHref,
   workspaceAppRoute,
 } from "./workspace-apps";
 
@@ -31,6 +34,83 @@ describe("workspace app routes", () => {
     expect(isDispatchWorkspaceAppId("dispatch-tools")).toBe(false);
   });
 
+  it("requires canonical metadata before enabling workspace SSO", () => {
+    expect(
+      isWorkspaceSsoApp({
+        id: " Mail ",
+        path: "/",
+        url: "https://mail.agent-native.com",
+      }),
+    ).toBe(true);
+    expect(
+      isWorkspaceSsoApp({
+        id: "mail",
+        path: "/mail",
+        url: "https://agent-workspace.builder.io/mail",
+      }),
+    ).toBe(false);
+    expect(
+      isWorkspaceSsoApp({
+        id: "feedback-leaderboard",
+        path: "/feedback-leaderboard",
+        url: "https://agent-workspace.builder.io/feedback-leaderboard",
+      }),
+    ).toBe(false);
+  });
+
+  it("accepts the server eligibility projection for registered custom apps", () => {
+    expect(
+      isWorkspaceSsoApp({
+        id: "workspace-reports",
+        path: "/workspace-reports",
+        url: "https://reports.example.com/workspace-reports",
+        workspaceSso: true,
+      }),
+    ).toBe(true);
+    expect(
+      isWorkspaceSsoApp({
+        id: "workspace-reports",
+        path: "/workspace-reports",
+        url: "javascript:alert(1)",
+        workspaceSso: true,
+      }),
+    ).toBe(false);
+  });
+
+  it("keeps canonical loopback apps eligible outside production", () => {
+    expect(
+      isWorkspaceSsoApp({
+        id: "mail",
+        path: "/mail",
+        url: "http://localhost:8084",
+      }),
+    ).toBe(true);
+  });
+
+  it("identifies mounted apps and resolves their direct workspace href", () => {
+    const app = {
+      path: "/feedback-leaderboard",
+      url: "https://agent-workspace.builder.io/feedback-leaderboard/leaderboard",
+    };
+
+    expect(isPathMountedWorkspaceApp(app)).toBe(true);
+    expect(workspaceAppDirectHref(app, "/")).toBe(
+      "https://agent-workspace.builder.io/feedback-leaderboard/leaderboard",
+    );
+    expect(
+      isPathMountedWorkspaceApp({
+        path: "/",
+        url: "https://mail.agent-native.com",
+      }),
+    ).toBe(false);
+    expect(
+      isPathMountedWorkspaceApp({
+        path: "/",
+        url: "https://feedback.example.com",
+      }),
+    ).toBe(true);
+  });
+
   it("hides the generic chat starter and Dispatch from default launchers", () => {
     expect(isDefaultWorkspaceAppHiddenId(" Chat ")).toBe(true);
     expect(isWorkspaceAppVisibleInDefaultLaunchers({ id: "chat" })).toBe(false);

package/src/lib/workspace-apps.ts

@@ -2,7 +2,10 @@ import { CHAT_FIRST_DEFAULT_APP_IDS } from "@agent-native/core/client/chat-first
 import { isInBuilderFrame } from "@agent-native/core/client/host";
 import { withBuilderUtmTrackingParams } from "@agent-native/core/shared/builder-link-tracking";
 
-import { CANONICAL_WORKSPACE_SSO_APP_ORIGINS } from "../shared/workspace-sso";
+import {
+  CANONICAL_WORKSPACE_SSO_APP_ORIGINS,
+  isWorkspaceSsoAppUrl,
+} from "../shared/workspace-sso";
 
 export interface WorkspaceAppSummary {
   id: string;
@@ -28,17 +31,108 @@ export interface WorkspaceAppSummary {
   agentName?: string | null;
   agentSkillsCount?: number | null;
   archived?: boolean;
+  workspaceSso?: boolean;
 }
 
 interface WorkspaceAppHrefSource {
   path?: string | null;
   url?: string | null;
+  workspaceSso?: boolean;
 }
 
 export function isDispatchWorkspaceAppId(appId: string): boolean {
   return appId.trim().toLowerCase() === "dispatch";
 }
 
+function clientRuntimeEnvironment(): "production" | "development" {
+  const importMetaEnv = (
+    import.meta as unknown as {
+      env?: Record<string, string | boolean | undefined>;
+    }
+  ).env;
+  const processEnv = (
+    globalThis as typeof globalThis & {
+      process?: { env?: Record<string, string | boolean | undefined> };
+    }
+  ).process?.env;
+  const env = { ...processEnv, ...importMetaEnv };
+  if (
+    env.PROD === true ||
+    env.MODE === "production" ||
+    env.NODE_ENV === "production"
+  ) {
+    return "production";
+  }
+  if (
+    env.DEV === true ||
+    env.MODE === "development" ||
+    env.MODE === "test" ||
+    env.NODE_ENV === "development" ||
+    env.NODE_ENV === "test"
+  ) {
+    return "development";
+  }
+  return "production";
+}
+
+/**
+ * The workspace SSO action only accepts an exact registered app identity and
+ * origin. The catalog's boolean is a server-derived projection for custom
+ * registrations; the URL check keeps malformed metadata out of the action.
+ */
+export function isWorkspaceSsoApp(
+  app: WorkspaceAppHrefSource & { id: string },
+): boolean {
+  const rawUrl = app.url?.trim();
+  if (!rawUrl) return false;
+  try {
+    const url = new URL(rawUrl);
+    if (url.protocol !== "http:" && url.protocol !== "https:") return false;
+    if (app.workspaceSso === true) return true;
+    return isWorkspaceSsoAppUrl(
+      { id: app.id, url: rawUrl },
+      { nodeEnv: clientRuntimeEnvironment() },
+    );
+    // coercion-ok: malformed app metadata is not eligible for workspace SSO.
+  } catch {
+    return false;
+  }
+}
+
+function isCanonicalWorkspaceSsoOrigin(rawUrl: string): boolean {
+  try {
+    const origin = new URL(rawUrl).origin;
+    return Object.values(CANONICAL_WORKSPACE_SSO_APP_ORIGINS).some(
+      (canonicalOrigin) => canonicalOrigin === origin,
+    );
+  } catch {
+    // coercion-ok: malformed app metadata is not a canonical first-party app.
+    return false;
+  }
+}
+
+/**
+ * A mounted app URL leaves Dispatch's `/apps/:id` host route. Canonical
+ * first-party origins can stay inline even at `/`, while external published
+ * apps must open at their own origin regardless of their path.
+ */
+export function isPathMountedWorkspaceApp(
+  app: WorkspaceAppHrefSource,
+): boolean {
+  const rawUrl = app.url?.trim();
+  if (rawUrl) {
+    try {
+      const pathname = new URL(rawUrl).pathname.replace(/\/+$/, "") || "/";
+      return pathname !== "/" || !isCanonicalWorkspaceSsoOrigin(rawUrl);
+      // coercion-ok: invalid absolute URLs use the mounted path fallback.
+    } catch {
+      // Fall through to the mounted path for relative manifest values.
+    }
+  }
+  const path = app.path?.trim().replace(/\/+$/, "") || "/";
+  return path !== "/";
+}
+
 export function isDefaultWorkspaceAppHiddenId(appId: string): boolean {
   const normalized = appId.trim().toLowerCase();
   return normalized === "chat" || isDispatchWorkspaceAppId(normalized);

package/src/server/lib/app-creation-store.spec.ts

@@ -345,6 +345,49 @@ describe("listWorkspaceApps", () => {
     expect(apps.map((app) => app.id)).toEqual(["dispatch"]);
   });
 
+  it("projects exact custom SSO eligibility without exposing registry details", async () => {
+    stubNoPendingContext();
+    stubManifest([
+      { id: "dispatch", name: "Dispatch", path: "/dispatch" },
+      {
+        id: "workspace-reports",
+        name: "Workspace Reports",
+        path: "/workspace-reports",
+        url: "https://reports.example.com/workspace-reports",
+      },
+      {
+        id: "unregistered",
+        name: "Unregistered",
+        path: "/unregistered",
+        url: "https://unregistered.example.com",
+      },
+    ]);
+    vi.stubEnv(
+      "IDENTITY_SSO_APP_REGISTRY_JSON",
+      JSON.stringify([
+        {
+          appId: "workspace-reports",
+          clientId: "workspace-reports-client",
+          origin: "https://reports.example.com",
+          callbackPath: "/_agent-native/identity/callback",
+          capabilities: ["identity-sso"],
+        },
+      ]),
+    );
+
+    const apps = await runWithRequestContext(
+      { userEmail: "dev@example.test" },
+      () => listWorkspaceApps({ includeAgentCards: false }),
+    );
+
+    expect(apps.find((app) => app.id === "workspace-reports")).toMatchObject({
+      workspaceSso: true,
+    });
+    expect(apps.find((app) => app.id === "unregistered")).toMatchObject({
+      workspaceSso: false,
+    });
+  });
+
   it("filters workspace apps by audience", async () => {
     stubNoPendingContext();
     vi.stubEnv(

package/src/server/lib/app-creation-store.ts

@@ -17,6 +17,7 @@ import {
 import { getSetting, putSetting } from "@agent-native/core/settings";
 import { assertValidWorkspaceAppId } from "@agent-native/core/shared";
 
+import { isWorkspaceSsoAppUrl } from "../../shared/workspace-sso.js";
 import { identityKeyForIncoming } from "./dispatch-integrations.js";
 import {
   currentOrgId,
@@ -103,6 +104,8 @@ export interface WorkspaceAppSummary {
   agentName?: string | null;
   agentSkillsCount?: number | null;
   archived?: boolean;
+  /** Safe server-side eligibility projection for the workspace SSO action. */
+  workspaceSso?: boolean;
 }
 
 export interface ListWorkspaceAppsOptions {
@@ -1326,9 +1329,14 @@ async function applyArchivedAndPending(
       app,
       metadataSettings,
     );
-    return archivedSet.has(app.id)
-      ? { ...withMetadata, archived: true }
-      : withMetadata;
+    return {
+      ...withMetadata,
+      workspaceSso: isWorkspaceSsoAppUrl(withMetadata, {
+        nodeEnv: process.env.NODE_ENV,
+        registryRaw: process.env.IDENTITY_SSO_APP_REGISTRY_JSON,
+      }),
+      ...(archivedSet.has(app.id) ? { archived: true } : {}),
+    };
   });
   return options.includeArchived
     ? filterAppsByAudience(annotated, options.audience)

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

@@ -25,9 +25,8 @@ import {
 } from "@agent-native/core/server/agent-discovery";
 
 import {
-  CANONICAL_WORKSPACE_SSO_APP_ORIGINS,
   DISPATCH_WORKSPACE_SSO_FLAG,
-  parseWorkspaceSsoAppRegistrations,
+  isWorkspaceSsoAppUrl,
 } from "../../shared/workspace-sso.js";
 import {
   listWorkspaceApps,
@@ -465,17 +464,6 @@ function safeAppOrigin(app: DispatchMcpAccessibleApp): string | null {
   }
 }
 
-function isLoopbackOrigin(origin: string): boolean {
-  try {
-    const hostname = new URL(origin).hostname;
-    return ["localhost", "127.0.0.1", "::1"].includes(hostname);
-  } catch {
-    // coercion-ok: only a previously validated app origin reaches this helper;
-    // malformed values are ineligible for the loopback development exception.
-    return false;
-  }
-}
-
 function appBaseUrl(app: DispatchMcpAccessibleApp): string {
   return app.url.replace(/\/+$/, "");
 }
@@ -643,44 +631,13 @@ export async function resolveGrantedDispatchMcpApp(
   return match;
 }
 
-function workspaceSsoOriginForApp(appId: string): string | null {
-  const canonical =
-    CANONICAL_WORKSPACE_SSO_APP_ORIGINS[
-      appId as keyof typeof CANONICAL_WORKSPACE_SSO_APP_ORIGINS
-    ];
-  if (canonical) return canonical;
-  const custom = parseWorkspaceSsoAppRegistrations(
-    process.env.IDENTITY_SSO_APP_REGISTRY_JSON,
-  ).find((registration) => registration.appId === appId);
-  return custom?.origin ?? null;
-}
-
-function isWorkspaceSsoCanonicalApp(app: DispatchMcpAccessibleApp): boolean {
-  const origin = safeAppOrigin(app);
-  if (!origin) return false;
-  const registeredOrigin = workspaceSsoOriginForApp(app.id);
-  if (origin === registeredOrigin) return true;
-  // The built-in discovery table intentionally points at local dev ports when
-  // running outside production. Keep local development usable without ever
-  // weakening the production exact-origin check.
-  return process.env.NODE_ENV !== "production" && isLoopbackOrigin(origin)
-    ? Object.prototype.hasOwnProperty.call(
-        CANONICAL_WORKSPACE_SSO_APP_ORIGINS,
-        app.id,
-      )
-    : false;
-}
-
 async function isEligibleWorkspaceSsoApp(
   candidate: DispatchMcpAccessibleApp,
 ): Promise<boolean> {
-  const origin = safeAppOrigin(candidate);
-  if (!origin) return false;
-  if (isWorkspaceSsoCanonicalApp(candidate)) return true;
-
-  const customOrigin = workspaceSsoOriginForApp(candidate.id);
-  if (customOrigin === origin) return true;
-  return false;
+  return isWorkspaceSsoAppUrl(candidate, {
+    nodeEnv: process.env.NODE_ENV,
+    registryRaw: process.env.IDENTITY_SSO_APP_REGISTRY_JSON,
+  });
 }
 
 async function listWorkspaceSsoApps(): Promise<DispatchMcpAccessibleApp[]> {

package/src/shared/workspace-sso.ts

@@ -116,3 +116,58 @@ export function parseWorkspaceSsoAppRegistrations(
   }
   return registrations;
 }
+
+function appOrigin(rawUrl: unknown): string | null {
+  if (typeof rawUrl !== "string" || !rawUrl.trim()) return null;
+  try {
+    const url = new URL(rawUrl.trim());
+    return url.protocol === "http:" || url.protocol === "https:"
+      ? url.origin
+      : null;
+  } catch {
+    // coercion-ok: malformed app metadata is not eligible for workspace SSO.
+    return null;
+  }
+}
+
+function isLoopbackOrigin(origin: string): boolean {
+  try {
+    return LOCALHOST_HOSTS.has(new URL(origin).hostname);
+  } catch {
+    // coercion-ok: only a previously parsed origin reaches this helper.
+    return false;
+  }
+}
+
+/**
+ * Keep the server-side app catalog and the browser's action choice on the
+ * same exact-origin rules. `registryRaw` is deliberately supplied by the
+ * caller so this shared module never reads process or browser environment.
+ */
+export function isWorkspaceSsoAppUrl(
+  app: { id: string; url?: unknown },
+  options: { nodeEnv?: string; registryRaw?: unknown } = {},
+): boolean {
+  const origin = appOrigin(app.url);
+  if (!origin) return false;
+
+  const appId = app.id.trim().toLowerCase();
+  const canonicalOrigin =
+    CANONICAL_WORKSPACE_SSO_APP_ORIGINS[
+      appId as keyof typeof CANONICAL_WORKSPACE_SSO_APP_ORIGINS
+    ];
+  if (canonicalOrigin === origin) return true;
+
+  if (
+    options.nodeEnv !== "production" &&
+    canonicalOrigin &&
+    isLoopbackOrigin(origin)
+  ) {
+    return true;
+  }
+
+  return parseWorkspaceSsoAppRegistrations(options.registryRaw).some(
+    (registration) =>
+      registration.appId === appId && registration.origin === origin,
+  );
+}