skybridge 0.0.0-dev.f40327b → 0.0.0-dev.f40afe0

package/dist/server/server.js

@@ -6,9 +6,11 @@ import { Server as SdkServer, } from "@modelcontextprotocol/sdk/server/index.js"
 import { McpServer as McpServerBase } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { mergeWith, union } from "es-toolkit";
 import express, {} from "express";
+import { setupOAuth } from "./auth/setup.js";
 import { createApp } from "./express.js";
 import { createMiddlewareEntry } from "./metric.js";
 import { buildMiddlewareChain, getHandlerMaps } from "./middleware.js";
+import { resolveServerOrigin } from "./requestOrigin.js";
 import { templateHelper } from "./templateHelper.js";
 const mergeWithUnion = (target, source) => {
     return mergeWith(target, source, (targetVal, sourceVal) => {
@@ -17,6 +19,28 @@ const mergeWithUnion = (target, source) => {
         }
     });
 };
+/**
+ * Normalize an `x-forwarded-prefix` value into a leading-slash, no-trailing-slash
+ * path. Takes the first hop of a comma-separated proxy chain.
+ * "/v1/", "v1", "/v1, /internal" → "/v1"; "", "/", undefined → "".
+ */
+function normalizeForwardedPrefix(raw) {
+    const firstHop = raw?.split(",")[0]?.trim() ?? "";
+    const trimmed = firstHop.replace(/\/+$/, "");
+    if (trimmed === "") {
+        return "";
+    }
+    return trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+}
+/**
+ * Drop the query string from a `ui://` view URI, leaving the bare path. The
+ * `?v=` cache key is the only query we append, so a plain split is enough and
+ * sidesteps `URL` normalization quirks on the non-special `ui:` scheme.
+ */
+function stripQuery(uri) {
+    const queryIndex = uri.indexOf("?");
+    return queryIndex === -1 ? uri : uri.slice(0, queryIndex);
+}
 /**
  * Coerce a tool handler's return value into an MCP `content` array. Strings
  * become a single `TextContent`; a single block is wrapped in an array;
@@ -65,13 +89,31 @@ const McpServerBaseOmitted = McpServerBase;
  *
  * @see https://docs.skybridge.tech/api-reference/mcp-server
  */
+// Side channel populated by `dist/__entry.js` before user code is imported.
+// Set at module scope rather than passed through the constructor because the
+// wrapper has the manifest before the user's `new McpServer(...)` runs, and
+// threading it through every call site (including user templates) is exactly
+// the boilerplate this design is trying to hide.
+let pendingBuildManifest = null;
+/**
+ * Prime the build-time Vite manifest before user code constructs its
+ * `McpServer`. Called from the generated `dist/__entry.js`; not part of the
+ * user-facing API.
+ *
+ * @internal
+ */
+export function __setBuildManifest(manifest) {
+    pendingBuildManifest = manifest;
+}
 export class McpServer extends McpServerBaseOmitted {
     /**
      * The underlying Express app. Use this to extend the HTTP server with
      * custom routes, middleware, or settings — e.g.
      * `server.express.get("/health", ...)`.
      *
-     * `express.json()` is pre-applied. Register your handlers before `run()`;
+     * `express.json()` is pre-applied — tune it via the constructor's third
+     * argument, e.g. `new McpServer(info, {}, { json: { limit: "10mb" } })`.
+     * Register your handlers before `run()`;
      * after `run()`, dev-mode middleware, the `/mcp` route, and the default
      * error handler are appended in that order.
      *
@@ -84,15 +126,34 @@ export class McpServer extends McpServerBaseOmitted {
     mcpMiddlewareApplied = false;
     claimedViews = new Map();
     viewMetaBuilders = new Map();
+    /**
+     * Maps a view resource's query-less path to its canonical registered URI
+     * (the one carrying the `?v=` cache key). Lets `resources/read` resolve the
+     * underlying view no matter which version param the consumer sends, since
+     * the param is only a cache key, not part of the resource's identity.
+     */
+    viewUriByPath = new Map();
     viteManifest = null;
     serverInfo;
     serverOptions;
-    constructor(serverInfo, options) {
+    constructor(serverInfo, options, skybridgeOptions) {
         super(serverInfo, options);
         this.serverInfo = serverInfo;
         this.serverOptions = options;
         this.express = express();
-        this.express.use(express.json());
+        this.express.use(express.json(skybridgeOptions?.json));
+        if (skybridgeOptions?.oauth) {
+            setupOAuth(this.express, skybridgeOptions.oauth);
+        }
+        // Pick up the manifest if `dist/__entry.js` primed it before importing
+        // user code. Consume-once: clear after the first construction so a
+        // subsequent test that doesn't prime can't inherit stale state.
+        // Explicit `setViteManifest` calls still win because they happen after
+        // construction.
+        if (pendingBuildManifest) {
+            this.setViteManifest(pendingBuildManifest);
+            pendingBuildManifest = null;
+        }
     }
     use(pathOrHandler, ...handlers) {
         // Branching is load-bearing: Express's `app.use` overloads can't be
@@ -165,10 +226,47 @@ export class McpServer extends McpServerBaseOmitted {
                 return result;
             },
         };
+        // Resolve a view's `resources/read` by its query-less path so the
+        // underlying asset is served no matter the `?v=` value (stale cache key,
+        // no param, etc.). The version param is a cache-busting hint for external
+        // consumers; it must not gate resolution. We rewrite the lookup URI to the
+        // canonical registered one, then restore the requested URI on the response
+        // so the consumer-facing URI is never rewritten.
+        const viewReadResolveEntry = {
+            filter: "resources/read",
+            handler: async (req, _extra, next) => {
+                const requested = req.params.uri;
+                if (typeof requested !== "string") {
+                    return next();
+                }
+                const path = stripQuery(requested);
+                const canonical = this.viewUriByPath.get(path);
+                if (!canonical) {
+                    return next();
+                }
+                req.params.uri = canonical;
+                try {
+                    const result = (await next());
+                    for (const content of result.contents ?? []) {
+                        if (typeof content.uri === "string" &&
+                            stripQuery(content.uri) === stripQuery(canonical)) {
+                            content.uri = requested;
+                        }
+                    }
+                    return result;
+                }
+                finally {
+                    // Restore the shared request params so middleware outer to us never
+                    // observes the rewritten lookup URI after next() unwinds.
+                    req.params.uri = requested;
+                }
+            },
+        };
         const monitoringEntry = createMiddlewareEntry();
         const entries = [
             ...(monitoringEntry ? [monitoringEntry] : []),
             viewListMetaEntry,
+            viewReadResolveEntry,
             ...this.mcpMiddlewareEntries,
         ];
         if (entries.length === 0) {
@@ -224,10 +322,24 @@ export class McpServer extends McpServerBaseOmitted {
      *
      * On Cloudflare Workers / workerd, returns an object exposing `fetch` so
      * the runtime can bridge incoming requests to the Node HTTP server. On
+     * Vercel (`VERCEL === "1"`), returns the Express app directly so the
+     * serverless function entry can call it as a `(req, res)` handler. On
      * Node, returns `undefined` once listening.
      */
     async run() {
         this.applyMcpMiddleware();
+        if (process.env.VERCEL === "1") {
+            // createApp only reads httpServer inside its dev-only branch
+            // (viewsDevServer); under VERCEL=1 + NODE_ENV=production it's a
+            // bare object passed to satisfy the required parameter.
+            const httpServer = http.createServer();
+            await createApp({
+                mcpServer: this,
+                httpServer,
+                errorMiddleware: this.customErrorMiddleware,
+            });
+            return this.express;
+        }
         const httpServer = http.createServer();
         await createApp({
             mcpServer: this,
@@ -283,27 +395,12 @@ export class McpServer extends McpServerBaseOmitted {
             return Array.isArray(val) ? val[0] : val;
         };
         const isClaude = header("user-agent") === "Claude-User";
-        let serverUrl;
-        const forwardedHost = header("x-forwarded-host");
-        const origin = header("origin");
-        const host = header("host");
-        if (forwardedHost) {
-            const proto = header("x-forwarded-proto") || "https";
-            serverUrl = `${proto}://${forwardedHost}`;
-        }
-        else if (origin) {
-            serverUrl = origin;
-        }
-        else if (host) {
-            const proto = ["127.0.0.1:", "localhost:"].some((p) => host.startsWith(p))
-                ? "http"
-                : "https";
-            serverUrl = `${proto}://${host}`;
-        }
-        else {
-            const devPort = process.env.__PORT || "3000";
-            serverUrl = `http://localhost:${devPort}`;
-        }
+        const serverUrl = resolveServerOrigin(header);
+        // Path prefix the proxy routed this request under (e.g. `foo.com/v1`). Read
+        // per-request so one process can serve many hosts/prefixes at once: the
+        // origin is recovered from x-forwarded-host, the prefix from
+        // x-forwarded-prefix. Empty when served at the origin root.
+        const assetsBasePath = normalizeForwardedPrefix(header("x-forwarded-prefix"));
         const connectDomains = [serverUrl];
         if (!isProduction) {
             const wsUrl = new URL(serverUrl);
@@ -324,114 +421,88 @@ export class McpServer extends McpServerBaseOmitted {
                 .slice(0, 32);
             contentMetaOverrides = { domain: `${hash}.claudemcpcontent.com` };
         }
-        return { serverUrl, connectDomains, contentMetaOverrides };
+        const serverHostname = new URL(serverUrl).hostname;
+        const isLocalhost = serverHostname === "localhost" ||
+            serverHostname === "127.0.0.1" ||
+            serverHostname === "[::1]";
+        const useBundledDevTemplate = !isProduction && !isLocalhost;
+        return {
+            serverUrl,
+            assetsBasePath,
+            connectDomains,
+            contentMetaOverrides,
+            useBundledDevTemplate,
+        };
     }
     registerViewResources(toolName, view, toolMeta) {
-        const hosts = view.hosts ?? ["apps-sdk", "mcp-app"];
         // Append a content-derived version param so hosts (e.g. ChatGPT) bust
         // their cache when the bundle changes, but keep the URI stable across
         // `tools/list` calls when the bundle hasn't changed.
         const versionParam = this.computeViewVersionParam(view.component);
-        if (hosts.includes("apps-sdk")) {
-            const viewResource = {
-                hostType: "apps-sdk",
-                uri: `ui://views/apps-sdk/${view.component}.html${versionParam}`,
-                mimeType: "text/html+skybridge",
-                buildContentMeta: ({ resourceDomains, connectDomains, domain }, overrides) => {
-                    const defaults = {
-                        "openai/widgetCSP": {
-                            resource_domains: resourceDomains,
-                            connect_domains: connectDomains,
-                        },
-                        "openai/widgetDomain": domain,
-                        "openai/widgetDescription": view.description,
-                    };
-                    const fromView = {
-                        "openai/widgetCSP": {
-                            resource_domains: view.csp?.resourceDomains,
-                            connect_domains: view.csp?.connectDomains,
-                            frame_domains: view.csp?.frameDomains,
-                            redirect_domains: view.csp?.redirectDomains,
-                        },
-                        "openai/widgetDomain": view.domain,
-                        "openai/widgetPrefersBorder": view.prefersBorder,
-                    };
-                    const base = mergeWithUnion(mergeWithUnion(defaults, fromView), {
-                        "openai/widgetDomain": overrides.domain,
-                    });
-                    if (view._meta) {
-                        return { ...base, ...view._meta };
-                    }
-                    return base;
-                },
-            };
-            this.registerViewResource({
-                name: toolName,
-                viewResource,
-                view,
-            });
-            toolMeta["openai/outputTemplate"] = viewResource.uri;
-        }
-        if (hosts.includes("mcp-app")) {
-            const viewResource = {
-                hostType: "mcp-app",
-                uri: `ui://views/ext-apps/${view.component}.html${versionParam}`,
-                mimeType: "text/html;profile=mcp-app",
-                buildContentMeta: ({ resourceDomains, connectDomains, domain, baseUriDomains }, overrides) => {
-                    const defaults = {
-                        ui: {
-                            csp: {
-                                resourceDomains,
-                                connectDomains,
-                                baseUriDomains,
-                            },
-                            domain,
+        const viewResource = {
+            hostType: "mcp-app",
+            uri: `ui://views/ext-apps/${view.component}.html${versionParam}`,
+            mimeType: "text/html;profile=mcp-app",
+            buildContentMeta: ({ resourceDomains, connectDomains, domain, baseUriDomains }, overrides) => {
+                const defaults = {
+                    ui: {
+                        csp: {
+                            resourceDomains,
+                            connectDomains,
+                            baseUriDomains,
                         },
-                    };
-                    const fromView = {
-                        ui: {
-                            ...(view.description && { description: view.description }),
-                            ...(view.prefersBorder !== undefined && {
-                                prefersBorder: view.prefersBorder,
+                        domain,
+                    },
+                };
+                const fromView = {
+                    ui: {
+                        ...(view.description && { description: view.description }),
+                        ...(view.prefersBorder !== undefined && {
+                            prefersBorder: view.prefersBorder,
+                        }),
+                        ...(view.domain && { domain: view.domain }),
+                        csp: {
+                            ...(view.csp?.resourceDomains && {
+                                resourceDomains: view.csp.resourceDomains,
+                            }),
+                            ...(view.csp?.connectDomains && {
+                                connectDomains: view.csp.connectDomains,
+                            }),
+                            ...(view.csp?.frameDomains && {
+                                frameDomains: view.csp.frameDomains,
+                            }),
+                            ...(view.csp?.baseUriDomains && {
+                                baseUriDomains: view.csp.baseUriDomains,
                             }),
-                            ...(view.domain && { domain: view.domain }),
-                            csp: {
-                                ...(view.csp?.resourceDomains && {
-                                    resourceDomains: view.csp.resourceDomains,
-                                }),
-                                ...(view.csp?.connectDomains && {
-                                    connectDomains: view.csp.connectDomains,
-                                }),
-                                ...(view.csp?.frameDomains && {
-                                    frameDomains: view.csp.frameDomains,
-                                }),
-                                ...(view.csp?.baseUriDomains && {
-                                    baseUriDomains: view.csp.baseUriDomains,
-                                }),
-                                ...(view.csp?.redirectDomains && {
-                                    redirectDomains: view.csp.redirectDomains,
-                                }),
-                            },
                         },
-                    };
-                    const base = mergeWithUnion(mergeWithUnion(defaults, fromView), {
-                        ui: overrides,
-                    });
-                    if (view._meta) {
-                        return { ...base, ...view._meta };
-                    }
-                    return base;
-                },
-            };
-            this.registerViewResource({
-                name: toolName,
-                viewResource,
-                view,
-            });
-            // @ts-expect-error - For backwards compatibility with Claude current implementation of the specs
-            toolMeta["ui/resourceUri"] = viewResource.uri;
-            toolMeta.ui = { ...toolMeta.ui, resourceUri: viewResource.uri };
-        }
+                    },
+                };
+                const ui = mergeWithUnion(mergeWithUnion(defaults, fromView), {
+                    ui: overrides,
+                });
+                const base = {
+                    ...ui,
+                    ...(view.description && {
+                        "openai/widgetDescription": view.description,
+                    }),
+                    ...(view.csp?.redirectDomains && {
+                        "openai/widgetCSP": { redirect_domains: view.csp.redirectDomains },
+                    }),
+                };
+                if (view._meta) {
+                    return { ...base, ...view._meta };
+                }
+                return base;
+            },
+        };
+        this.registerViewResource({ name: toolName, viewResource, view });
+        // Advertise via the MCP Apps standard pointer only — ChatGPT renders from
+        // ui.resourceUri (verified), and not emitting openai/outputTemplate lets us
+        // retire the legacy apps-sdk resource later. The legacy apps-sdk URL is still
+        // served (see registerViewResource) so already-published apps keep resolving.
+        // @ts-expect-error - For backwards compatibility with Claude current implementation of the specs
+        toolMeta["ui/resourceUri"] = viewResource.uri;
+        toolMeta.ui = { ...toolMeta.ui, resourceUri: viewResource.uri };
     }
     registerViewResource({ name, viewResource, view, }) {
         const { hostType, uri: viewUri, mimeType, buildContentMeta } = viewResource;
@@ -445,21 +516,41 @@ export class McpServer extends McpServerBaseOmitted {
             }, contentMetaOverrides);
         };
         this.viewMetaBuilders.set(viewUri, buildMeta);
+        this.viewUriByPath.set(stripQuery(viewUri), viewUri);
+        this.serveLegacyAppsSdkUrl(view.component, viewUri);
         this.registerResource(name, viewUri, { description: view.description }, async (uri, extra) => {
             const isProduction = process.env.NODE_ENV === "production";
-            const { serverUrl } = this.resolveViewRequestContext(extra);
-            const html = isProduction
-                ? templateHelper.renderProduction({
-                    hostType,
-                    serverUrl,
-                    viewFile: this.lookupViewFile(view.component),
-                    styleFile: this.lookupDistFile("style.css") ?? "",
-                })
-                : templateHelper.renderDevelopment({
-                    hostType,
-                    serverUrl,
-                    viewName: view.component,
-                });
+            const { serverUrl, assetsBasePath, useBundledDevTemplate } = this.resolveViewRequestContext(extra);
+            // The view resolves all assets (template imports + runtime lazy chunks
+            // via `window.skybridge.serverUrl`) against this base, so it carries the
+            // proxy path prefix. CSP domains in `buildMeta` stay the bare origin.
+            const viewBase = `${serverUrl}${assetsBasePath}`;
+            const renderBundled = () => templateHelper.renderProduction({
+                hostType,
+                serverUrl: viewBase,
+                viewFile: this.lookupViewFile(view.component),
+                styleFile: this.lookupDistFile("style.css") ?? "",
+            });
+            const renderUnbundled = () => templateHelper.renderDevelopment({
+                hostType,
+                serverUrl: viewBase,
+                viewName: view.component,
+            });
+            let html;
+            if (isProduction) {
+                html = renderBundled();
+            }
+            else if (useBundledDevTemplate) {
+                try {
+                    html = renderBundled();
+                }
+                catch {
+                    html = renderUnbundled();
+                }
+            }
+            else {
+                html = renderUnbundled();
+            }
             return {
                 contents: [
                     { uri: uri.href, mimeType, text: html, _meta: buildMeta(extra) },
@@ -467,6 +558,11 @@ export class McpServer extends McpServerBaseOmitted {
             };
         });
     }
+    serveLegacyAppsSdkUrl(component, canonicalUri) {
+        this.viewUriByPath.set(`ui://views/apps-sdk/${component}.html`, canonicalUri);
+        this.viewUriByPath.set(`ui://widgets/apps-sdk/${component}.html`, canonicalUri);
+        this.viewUriByPath.set(`ui://widgets/ext-apps/${component}.html`, canonicalUri);
+    }
     wrapHandler(cb, { attachViewUUID }) {
         return async (args, extra) => {
             const result = await cb(args, extra);