skybridge 0.0.0-dev.89f68f1 → 0.0.0-dev.89f9a0f

package/dist/server/server.js

@@ -6,9 +6,15 @@ 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 { warnOnLargeToolOutput } from "../context-warnings.js";
+import { authToSecuritySchemes, evaluateSecuritySchemes, inBandChallengeResult, } from "./auth/security-schemes.js";
+import { setupOAuth } from "./auth/setup.js";
 import { createApp } from "./express.js";
+import { hostFromUserAgent } from "./host.js";
 import { createMiddlewareEntry } from "./metric.js";
-import { buildMiddlewareChain, getHandlerMaps } from "./middleware.js";
+import { buildMiddlewareChain, captureToolError, getHandlerMaps, } from "./middleware.js";
+import { resolveServerOrigin } from "./requestOrigin.js";
+import { discoverSkills, registerSkills, SKILLS_EXTENSION_KEY, } from "./skills.js";
 import { templateHelper } from "./templateHelper.js";
 const mergeWithUnion = (target, source) => {
     return mergeWith(target, source, (targetVal, sourceVal) => {
@@ -17,6 +23,20 @@ const mergeWithUnion = (target, source) => {
         }
     });
 };
+const SKILLS_DIR = "src/skills";
+/**
+ * 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
@@ -90,6 +110,47 @@ let pendingBuildManifest = null;
 export function __setBuildManifest(manifest) {
     pendingBuildManifest = manifest;
 }
+let pendingSkillsManifest = null;
+export function __setSkillsManifest(manifest) {
+    pendingSkillsManifest = manifest;
+}
+// Pure and `this`-free so it can run inside the `super(...)` call, before `this`
+// exists — the capability must be present for the `initialize` response.
+function withSkillsCapability(options, skybridgeOptions) {
+    if (!skybridgeOptions?.skills) {
+        return options;
+    }
+    return {
+        ...options,
+        capabilities: {
+            ...options?.capabilities,
+            extensions: {
+                ...options?.capabilities?.extensions,
+                [SKILLS_EXTENSION_KEY]: { directoryRead: true },
+            },
+        },
+    };
+}
+// Collapses registerTool's two overloads into a single { config, cb } shape.
+//   registerTool("greet", { description }, handler)
+//     -> { config: { name: "greet", description }, cb: handler }
+//   registerTool({ name: "greet", description }, handler)
+//     -> { config: { name: "greet", description }, cb: handler }
+function normalizeRegisterToolArgs(args) {
+    if (typeof args[0] === "string") {
+        return {
+            config: {
+                name: args[0],
+                ...args[1],
+            },
+            cb: args[2],
+        };
+    }
+    return {
+        config: args[0],
+        cb: args[1],
+    };
+}
 export class McpServer extends McpServerBaseOmitted {
     /**
      * The underlying Express app. Use this to extend the HTTP server with
@@ -121,12 +182,20 @@ export class McpServer extends McpServerBaseOmitted {
     viteManifest = null;
     serverInfo;
     serverOptions;
+    oauthEnabled = false;
+    resolveResourceMetadataUrl;
+    securitySchemesByTool = new Map();
     constructor(serverInfo, options, skybridgeOptions) {
-        super(serverInfo, options);
+        const mergedOptions = withSkillsCapability(options, skybridgeOptions);
+        super(serverInfo, mergedOptions);
         this.serverInfo = serverInfo;
-        this.serverOptions = options;
+        this.serverOptions = mergedOptions;
         this.express = express();
         this.express.use(express.json(skybridgeOptions?.json));
+        if (skybridgeOptions?.oauth) {
+            this.oauthEnabled = true;
+            this.resolveResourceMetadataUrl = setupOAuth(this.express, skybridgeOptions.oauth, this.securitySchemesByTool);
+        }
         // 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.
@@ -136,6 +205,19 @@ export class McpServer extends McpServerBaseOmitted {
             this.setViteManifest(pendingBuildManifest);
             pendingBuildManifest = null;
         }
+        this.setupSkills(Boolean(skybridgeOptions?.skills));
+    }
+    setupSkills(enabled) {
+        const manifest = pendingSkillsManifest;
+        pendingSkillsManifest = null;
+        if (!enabled) {
+            return;
+        }
+        const skills = manifest ?? discoverSkills(SKILLS_DIR);
+        if (skills.length === 0) {
+            console.warn(`skybridge: the "skills" option is enabled but no skills were found in "${SKILLS_DIR}". Add a <name>/SKILL.md there, or remove the option.`);
+        }
+        registerSkills(this, skills);
     }
     use(pathOrHandler, ...handlers) {
         // Branching is load-bearing: Express's `app.use` overloads can't be
@@ -231,7 +313,7 @@ export class McpServer extends McpServerBaseOmitted {
                     const result = (await next());
                     for (const content of result.contents ?? []) {
                         if (typeof content.uri === "string" &&
-                            stripQuery(content.uri) === path) {
+                            stripQuery(content.uri) === stripQuery(canonical)) {
                             content.uri = requested;
                         }
                     }
@@ -244,16 +326,33 @@ export class McpServer extends McpServerBaseOmitted {
                 }
             },
         };
+        // ChatGPT reads `securitySchemes` at the tool descriptor top level (SEP-1488,
+        // still Draft), but the SDK's registerTool strips unknown top-level fields, so
+        // it's stashed in `_meta` at registration. This restores it to the top level
+        // on tools/list output. Remove once SEP-1488 lands and the SDK preserves it.
+        //   { name: "checkout", _meta: { securitySchemes: [{ type: "oauth2" }] } }
+        //     -> { name: "checkout", _meta: {…}, securitySchemes: [{ type: "oauth2" }] }
+        const toolsListSecuritySchemesEntry = {
+            filter: "tools/list",
+            handler: async (_req, _extra, next) => {
+                const result = (await next());
+                for (const tool of result.tools) {
+                    const schemes = tool._meta?.securitySchemes;
+                    if (schemes && !("securitySchemes" in tool)) {
+                        tool.securitySchemes = schemes;
+                    }
+                }
+                return result;
+            },
+        };
         const monitoringEntry = createMiddlewareEntry();
         const entries = [
             ...(monitoringEntry ? [monitoringEntry] : []),
             viewListMetaEntry,
             viewReadResolveEntry,
+            toolsListSecuritySchemesEntry,
             ...this.mcpMiddlewareEntries,
         ];
-        if (entries.length === 0) {
-            return;
-        }
         const { requestHandlers, notificationHandlers } = getHandlerMaps(this.server);
         const instrumentMap = (map, isNotification) => {
             for (const [method, handler] of map) {
@@ -376,28 +475,13 @@ export class McpServer extends McpServerBaseOmitted {
             const val = headers[key];
             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 isClaude = hostFromUserAgent(header("user-agent")) === "claude";
+        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);
@@ -418,114 +502,77 @@ export class McpServer extends McpServerBaseOmitted {
                 .slice(0, 32);
             contentMetaOverrides = { domain: `${hash}.claudemcpcontent.com` };
         }
-        return { serverUrl, connectDomains, contentMetaOverrides };
+        return { serverUrl, assetsBasePath, connectDomains, contentMetaOverrides };
     }
     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;
@@ -540,19 +587,24 @@ export class McpServer extends McpServerBaseOmitted {
         };
         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 { serverUrl, assetsBasePath } = 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 html = isProduction
                 ? templateHelper.renderProduction({
                     hostType,
-                    serverUrl,
+                    serverUrl: viewBase,
                     viewFile: this.lookupViewFile(view.component),
                     styleFile: this.lookupDistFile("style.css") ?? "",
                 })
                 : templateHelper.renderDevelopment({
                     hostType,
-                    serverUrl,
+                    serverUrl: viewBase,
                     viewName: view.component,
                 });
             return {
@@ -562,9 +614,34 @@ export class McpServer extends McpServerBaseOmitted {
             };
         });
     }
-    wrapHandler(cb, { attachViewUUID }) {
+    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);
+    }
+    decorateToolHandler(cb, { attachViewUUID, securitySchemes, toolName, }) {
         return async (args, extra) => {
-            const result = await cb(args, extra);
+            const toolExtra = extra ?? args;
+            if (this.oauthEnabled) {
+                const failure = evaluateSecuritySchemes(securitySchemes, toolExtra?.authInfo);
+                if (failure) {
+                    const headers = toolExtra?.requestInfo?.headers ?? {};
+                    const header = (key) => {
+                        const value = headers[key];
+                        return Array.isArray(value) ? value[0] : value;
+                    };
+                    return inBandChallengeResult(failure, this.resolveResourceMetadataUrl?.(header));
+                }
+            }
+            let result;
+            try {
+                result = await cb(args, extra);
+            }
+            catch (error) {
+                captureToolError(toolExtra, error);
+                throw error;
+            }
+            warnOnLargeToolOutput(result, toolName);
             return {
                 ...result,
                 content: normalizeContent(result.content),
@@ -628,14 +705,19 @@ export class McpServer extends McpServerBaseOmitted {
     }
     registerTool(...args) {
         const baseFn = McpServerBase.prototype.registerTool;
-        if (typeof args[0] === "string") {
-            baseFn.call(this, args[0], args[1], args[2]);
-            return this;
+        const { config, cb } = normalizeRegisterToolArgs(args);
+        const { name, view, auth, securitySchemes: rawSecuritySchemes, _meta: userToolMeta, ...toolFields } = config;
+        const authNeedsProvider = auth !== undefined &&
+            (!auth.allowsAnonymous || Boolean(auth.scopes?.length));
+        if (rawSecuritySchemes === undefined &&
+            authNeedsProvider &&
+            !this.oauthEnabled) {
+            throw new Error(`Tool "${name}" sets \`auth: ${JSON.stringify(auth)}\` but the server has no \`oauth\` provider configured.`);
         }
-        const config = args[0];
-        const cb = args[1];
-        const { name, view, securitySchemes, _meta: userToolMeta, ...toolFields } = config;
+        const securitySchemes = rawSecuritySchemes ??
+            (auth && this.oauthEnabled ? authToSecuritySchemes(auth) : undefined);
         const toolMeta = { ...userToolMeta };
+        this.securitySchemesByTool.set(name, securitySchemes);
         if (securitySchemes) {
             // SEP-1488 puts `securitySchemes` at the top level of the tool
             // descriptor, but the SDK's `registerTool` drops unknown top-level
@@ -648,7 +730,11 @@ export class McpServer extends McpServerBaseOmitted {
             this.enforceOneToolPerView(view.component, name);
             this.registerViewResources(name, view, toolMeta);
         }
-        const wrappedCb = this.wrapHandler(cb, { attachViewUUID: Boolean(view) });
+        const wrappedCb = this.decorateToolHandler(cb, {
+            attachViewUUID: Boolean(view),
+            securitySchemes,
+            toolName: name,
+        });
         baseFn.call(this, name, { ...toolFields, _meta: toolMeta }, wrappedCb);
         return this;
     }