skybridge 0.0.0-dev.93c6a1f → 0.0.0-dev.93dffd6

package/dist/server/server.js

@@ -2,11 +2,17 @@ import crypto from "node:crypto";
 import { readFileSync } from "node:fs";
 import http from "node:http";
 import path from "node:path";
-import { McpServer as McpServerBase, } from "@modelcontextprotocol/sdk/server/mcp.js";
+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 { authToSecuritySchemes, evaluateSecuritySchemes, wwwAuthenticateHeader, } 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 { resolveServerOrigin } from "./requestOrigin.js";
 import { templateHelper } from "./templateHelper.js";
 const mergeWithUnion = (target, source) => {
     return mergeWith(target, source, (targetVal, sourceVal) => {
@@ -15,23 +21,169 @@ const mergeWithUnion = (target, source) => {
         }
     });
 };
-export class McpServer extends McpServerBase {
+/**
+ * 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;
+ * `undefined` produces `[]`. Mostly used internally — exported so consumers
+ * who build content lazily can apply the same normalization.
+ */
+export function normalizeContent(content) {
+    if (content === undefined) {
+        return [];
+    }
+    if (typeof content === "string") {
+        return [{ type: "text", text: content }];
+    }
+    if (Array.isArray(content)) {
+        return content;
+    }
+    return [content];
+}
+const McpServerBaseOmitted = McpServerBase;
+/**
+ * The Skybridge server. Extends the MCP SDK's `McpServer` with a typed tool
+ * registry, view resources, an embedded Express app, and protocol-level
+ * middleware. Construct it with the same `Implementation` info you would pass
+ * to the SDK, chain {@link McpServer.registerTool} calls to declare tools,
+ * then call {@link McpServer.run} to start the HTTP server.
+ *
+ * The `TTools` generic accumulates each registered tool's input/output/meta
+ * shape, so `typeof server` carries enough information for view-side helpers
+ * like {@link generateHelpers} to produce fully-typed hooks.
+ *
+ * @typeParam TTools - Accumulated tool registry. Filled in by `registerTool`
+ * chaining; you almost never set this manually.
+ *
+ * @example
+ * ```ts
+ * const server = new McpServer({ name: "my-app", version: "1.0.0" }, {})
+ *   .registerTool({
+ *     name: "search",
+ *     inputSchema: { query: z.string() },
+ *     view: { component: "search" },
+ *   }, async ({ query }) => ({ content: `Results for ${query}` }));
+ *
+ * await server.run();
+ * export type AppType = typeof server;
+ * ```
+ *
+ * @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;
+}
+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
+     * custom routes, middleware, or settings — e.g.
+     * `server.express.get("/health", ...)`.
+     *
+     * `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.
+     *
+     * Note: Alpic Cloud only routes traffic to `/mcp` — custom routes work
+     * locally and on self-hosted deployments.
+     */
     express;
-    customMiddleware = [];
     customErrorMiddleware = [];
     mcpMiddlewareEntries = [];
     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;
+    oauthEnabled = false;
+    resolveResourceMetadataUrl;
+    securitySchemesByTool = new Map();
+    constructor(serverInfo, options, skybridgeOptions) {
+        super(serverInfo, options);
+        this.serverInfo = serverInfo;
+        this.serverOptions = options;
+        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.
+        // 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
+        // resolved against a `string | RequestHandler` union, so we narrow.
         if (typeof pathOrHandler === "string") {
-            this.customMiddleware.push({
-                path: pathOrHandler,
-                handlers,
-            });
+            this.express.use(pathOrHandler, ...handlers);
         }
         else {
-            this.customMiddleware.push({
-                handlers: [pathOrHandler, ...handlers],
-            });
+            this.express.use(pathOrHandler, ...handlers);
         }
         return this;
     }
@@ -75,15 +227,84 @@ export class McpServer extends McpServerBase {
             return;
         }
         this.mcpMiddlewareApplied = true;
+        // Surface view-resource _meta on `resources/list` (per ext-apps spec:
+        // hosts/checkers read CSP & domain at list time before fetching content).
+        const viewListMetaEntry = {
+            filter: "resources/list",
+            handler: async (_req, extra, next) => {
+                const result = (await next());
+                for (const resource of result.resources) {
+                    const builder = this.viewMetaBuilders.get(resource.uri);
+                    if (!builder) {
+                        continue;
+                    }
+                    const meta = builder(extra);
+                    resource._meta = {
+                        ...(resource._meta ?? {}),
+                        ...meta,
+                    };
+                }
+                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 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, ...this.mcpMiddlewareEntries]
-            : this.mcpMiddlewareEntries;
-        if (entries.length === 0) {
-            return;
-        }
+        const entries = [
+            ...(monitoringEntry ? [monitoringEntry] : []),
+            viewListMetaEntry,
+            viewReadResolveEntry,
+            toolsListSecuritySchemesEntry,
+            ...this.mcpMiddlewareEntries,
+        ];
         const { requestHandlers, notificationHandlers } = getHandlerMaps(this.server);
-        // Wrap existing handlers and proxy future .set() for lazy SDK registration
         const instrumentMap = (map, isNotification) => {
             for (const [method, handler] of map) {
                 map.set(method, buildMiddlewareChain(method, isNotification, handler, entries));
@@ -94,212 +315,373 @@ export class McpServer extends McpServerBase {
         instrumentMap(requestHandlers, false);
         instrumentMap(notificationHandlers, true);
     }
+    /**
+     * Connect to an MCP transport (override of the SDK's `connect`). Use this
+     * when you're embedding Skybridge in a host that already manages its own
+     * transport (e.g. stdio for desktop apps); for HTTP, prefer {@link McpServer.run}
+     * which sets the transport up for you. Locks in any middleware registered
+     * via {@link McpServer.mcpMiddleware} — further calls to that method will
+     * throw afterwards.
+     */
     async connect(transport) {
         this.applyMcpMiddleware();
-        return super.connect(transport);
+        return McpServerBase.prototype.connect.call(this, transport);
     }
+    /**
+     * Per-request stateless connect. The SDK's `Protocol` only allows one
+     * transport per instance, so we can't reuse this `McpServer` across
+     * concurrent requests. The SDK's idiomatic fix is a `() => McpServer`
+     * factory, but that would break Skybridge's singleton API — so instead
+     * we build a fresh underlying `Server` per request and share the main
+     * server's handler maps by reference. The cast is unavoidable: there's
+     * no public API to inject handler maps. `getHandlerMaps` validates the
+     * read side and fails fast on SDK field renames.
+     */
+    async connectStatelessTransport(transport) {
+        this.applyMcpMiddleware();
+        const { requestHandlers, notificationHandlers } = getHandlerMaps(this.server);
+        const fresh = new SdkServer(this.serverInfo, this.serverOptions);
+        const target = fresh;
+        target._requestHandlers = requestHandlers;
+        target._notificationHandlers = notificationHandlers;
+        await fresh.connect(transport);
+    }
+    /**
+     * Start the HTTP server. Listens on `process.env.__PORT` (default `3000`),
+     * mounts the `/mcp` route, applies any custom Express middleware registered
+     * via {@link McpServer.use} / {@link McpServer.useOnError}, and locks in
+     * any MCP middleware registered via {@link McpServer.mcpMiddleware}.
+     *
+     * 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();
-        const httpServer = http.createServer();
-        if (!this.express) {
-            this.express = await createApp({
+        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,
-                customMiddleware: this.customMiddleware,
                 errorMiddleware: this.customErrorMiddleware,
             });
+            return this.express;
         }
+        const httpServer = http.createServer();
+        await createApp({
+            mcpServer: this,
+            httpServer,
+            errorMiddleware: this.customErrorMiddleware,
+        });
         httpServer.on("request", this.express);
-        return new Promise((resolve, reject) => {
+        const port = parseInt(process.env.__PORT ?? "3000", 10);
+        await new Promise((resolve, reject) => {
             httpServer.on("error", (error) => {
                 console.error("Failed to start server:", error);
                 reject(error);
             });
-            const port = parseInt(process.env.__PORT ?? "3000", 10);
             httpServer.listen(port, () => {
                 resolve();
             });
         });
+        // On workerd, bridge the Node http server to a Workers fetch handler.
+        // The specifier is held in a variable to sidestep tsc's module resolution
+        // (`cloudflare:node` only exists under wrangler/workerd).
+        if (typeof navigator !== "undefined" &&
+            navigator.userAgent === "Cloudflare-Workers") {
+            const cloudflareNode = "cloudflare:node";
+            const { httpServerHandler } = await import(cloudflareNode);
+            return httpServerHandler({ port });
+        }
+        const shutdown = () => {
+            // Drop both handlers so a second signal falls through to Node's default
+            // (force-quit on a second Ctrl+C while drain is hanging).
+            process.off("SIGTERM", shutdown);
+            process.off("SIGINT", shutdown);
+            httpServer.close(() => process.exit(0));
+            // Force exit if connections don't drain in time so the port is still
+            // released promptly (e.g. for nodemon restarts).
+            setTimeout(() => process.exit(0), 3000).unref();
+        };
+        process.on("SIGTERM", shutdown);
+        process.on("SIGINT", shutdown);
+        return undefined;
     }
-    registerWidget(name, resourceConfig, toolConfig, toolCallback) {
-        const userMeta = resourceConfig._meta;
-        const toolMeta = {
-            ...toolConfig._meta,
+    enforceOneToolPerView(component, toolName) {
+        const existingTool = this.claimedViews.get(component);
+        if (existingTool) {
+            throw new Error(`skybridge: view "${component}" is already used by tool "${existingTool}". Tool "${toolName}" cannot also reference it — each view backs exactly one tool.`);
+        }
+        this.claimedViews.set(component, toolName);
+    }
+    resolveViewRequestContext(extra) {
+        const isProduction = process.env.NODE_ENV === "production";
+        const headers = extra?.requestInfo?.headers || {};
+        const header = (key) => {
+            const val = headers[key];
+            return Array.isArray(val) ? val[0] : val;
         };
-        if (!resourceConfig.hosts || resourceConfig.hosts.includes("apps-sdk")) {
-            const widgetConfig = {
-                hostType: "apps-sdk",
-                uri: `ui://widgets/apps-sdk/${name}.html`,
-                mimeType: "text/html+skybridge",
-                buildContentMeta: ({ resourceDomains, connectDomains, domain }, overrides) => {
-                    const userUi = userMeta?.ui;
-                    const userCsp = userUi?.csp;
-                    const defaults = {
-                        "openai/widgetCSP": {
-                            resource_domains: resourceDomains,
-                            connect_domains: connectDomains,
-                        },
-                        "openai/widgetDomain": domain,
-                        "openai/widgetDescription": resourceConfig.description,
-                    };
-                    const fromUi = {
-                        "openai/widgetCSP": {
-                            resource_domains: userCsp?.resourceDomains,
-                            connect_domains: userCsp?.connectDomains,
-                            frame_domains: userCsp?.frameDomains,
-                            redirect_domains: userCsp?.redirectDomains,
-                        },
-                        "openai/widgetDomain": userUi?.domain,
-                        "openai/widgetPrefersBorder": userUi?.prefersBorder,
-                    };
-                    const directOpenaiKeys = Object.fromEntries(Object.entries(userMeta ?? {}).filter(([key]) => key.startsWith("openai/")));
-                    return mergeWithUnion(mergeWithUnion(mergeWithUnion(defaults, fromUi), directOpenaiKeys), { "openai/widgetDomain": overrides.domain });
-                },
-            };
-            this.registerWidgetResource({
-                name,
-                widgetConfig,
-                resourceConfig,
-            });
-            toolMeta["openai/outputTemplate"] = widgetConfig.uri;
+        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);
+            wsUrl.protocol = wsUrl.protocol === "https:" ? "wss:" : "ws:";
+            connectDomains.push(wsUrl.origin);
         }
-        if (!resourceConfig.hosts || resourceConfig.hosts.includes("mcp-app")) {
-            const widgetConfig = {
-                hostType: "mcp-app",
-                uri: `ui://widgets/ext-apps/${name}.html`,
-                mimeType: "text/html;profile=mcp-app",
-                buildContentMeta: ({ resourceDomains, connectDomains, domain }, overrides) => {
-                    const defaults = {
-                        ui: {
-                            csp: {
-                                resourceDomains,
-                                connectDomains,
-                            },
-                            domain,
-                        },
-                    };
-                    return mergeWithUnion(defaults, {
-                        ui: { ...userMeta?.ui, ...overrides },
-                    });
-                },
-            };
-            this.registerWidgetResource({
-                name,
-                widgetConfig,
-                resourceConfig,
-            });
-            // @ts-expect-error - For backwards compatibility with Claude current implementation of the specs
-            toolMeta["ui/resourceUri"] = widgetConfig.uri;
-            toolMeta.ui = { resourceUri: widgetConfig.uri };
+        let contentMetaOverrides = {};
+        if (isClaude) {
+            const pathname = extra?.requestInfo?.url?.pathname ?? "";
+            const rawUrl = header("x-alpic-forwarded-url") ?? `${serverUrl}${pathname}`;
+            // Strip a lone trailing slash so the hash matches the connector URL
+            // as registered with Claude (which has no trailing slash on bare origins).
+            const url = rawUrl.endsWith("/") ? rawUrl.slice(0, -1) : rawUrl;
+            const hash = crypto
+                .createHash("sha256")
+                .update(url)
+                .digest("hex")
+                .slice(0, 32);
+            contentMetaOverrides = { domain: `${hash}.claudemcpcontent.com` };
         }
-        const wrappedToolCallback = async (args, extra) => {
-            const result = await toolCallback(args, extra);
-            return {
-                ...result,
-                _meta: {
-                    ...result._meta,
-                    viewUUID: crypto.randomUUID(),
-                },
-            };
-        };
-        this.registerTool(name, {
-            ...toolConfig,
-            _meta: toolMeta,
-        }, wrappedToolCallback);
-        return this;
+        return { serverUrl, assetsBasePath, connectDomains, contentMetaOverrides };
     }
-    registerTool(name, config, cb) {
-        super.registerTool(name, config, cb);
-        return this;
+    registerViewResources(toolName, view, toolMeta) {
+        // 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);
+        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 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,
+                            }),
+                        },
+                    },
+                };
+                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 };
     }
-    registerWidgetResource({ name, widgetConfig, resourceConfig, }) {
-        const { hostType, uri: widgetUri, mimeType, buildContentMeta, } = widgetConfig;
-        this.registerResource(name, widgetUri, { ...resourceConfig, _meta: resourceConfig._meta }, async (uri, extra) => {
+    registerViewResource({ name, viewResource, view, }) {
+        const { hostType, uri: viewUri, mimeType, buildContentMeta } = viewResource;
+        const buildMeta = (extra) => {
+            const { serverUrl, connectDomains, contentMetaOverrides } = this.resolveViewRequestContext(extra);
+            return buildContentMeta({
+                resourceDomains: [serverUrl],
+                connectDomains,
+                domain: serverUrl,
+                baseUriDomains: [serverUrl],
+            }, 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 isClaude = extra?.requestInfo?.headers?.["user-agent"] === "Claude-User";
-            const headers = extra?.requestInfo?.headers || {};
-            const header = (key) => {
-                const val = headers[key];
-                return Array.isArray(val) ? val[0] : val;
-            };
-            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, 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,
-                    widgetFile: this.lookupDistFileWithIndexFallback(`src/widgets/${name}`),
-                    styleFile: this.lookupDistFile("style.css"),
+                    serverUrl: viewBase,
+                    viewFile: this.lookupViewFile(view.component),
+                    styleFile: this.lookupDistFile("style.css") ?? "",
                 })
                 : templateHelper.renderDevelopment({
                     hostType,
-                    serverUrl,
-                    widgetName: name,
+                    serverUrl: viewBase,
+                    viewName: view.component,
                 });
-            const connectDomains = [serverUrl];
-            if (!isProduction) {
-                const wsUrl = new URL(serverUrl);
-                wsUrl.protocol = wsUrl.protocol === "https:" ? "wss:" : "ws:";
-                connectDomains.push(wsUrl.origin);
-            }
-            let contentMetaOverrides = {};
-            if (isClaude) {
-                const pathname = extra?.requestInfo?.url?.pathname ?? "";
-                const rawUrl = header("x-alpic-forwarded-url") ?? `${serverUrl}${pathname}`;
-                // Strip a lone trailing slash so the hash matches the connector URL
-                // as registered with Claude (which has no trailing slash on bare origins).
-                const url = rawUrl.endsWith("/") ? rawUrl.slice(0, -1) : rawUrl;
-                const hash = crypto
-                    .createHash("sha256")
-                    .update(url)
-                    .digest("hex")
-                    .slice(0, 32);
-                contentMetaOverrides = { domain: `${hash}.claudemcpcontent.com` };
-            }
-            const contentMeta = buildContentMeta({
-                resourceDomains: [serverUrl],
-                connectDomains,
-                domain: serverUrl,
-                baseUriDomains: [serverUrl],
-            }, contentMetaOverrides);
             return {
                 contents: [
-                    { uri: uri.href, mimeType, text: html, _meta: contentMeta },
+                    { uri: uri.href, mimeType, text: html, _meta: buildMeta(extra) },
                 ],
             };
         });
     }
+    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, }) {
+        return async (args, extra) => {
+            if (this.oauthEnabled) {
+                const failure = evaluateSecuritySchemes(securitySchemes, extra.authInfo);
+                if (failure) {
+                    const headers = extra?.requestInfo?.headers ?? {};
+                    const header = (key) => {
+                        const value = headers[key];
+                        return Array.isArray(value) ? value[0] : value;
+                    };
+                    const challenge = wwwAuthenticateHeader(failure, this.resolveResourceMetadataUrl?.(header));
+                    return {
+                        isError: true,
+                        content: [{ type: "text", text: failure.description }],
+                        _meta: { "mcp/www_authenticate": [challenge] },
+                    };
+                }
+            }
+            const result = await cb(args, extra);
+            return {
+                ...result,
+                content: normalizeContent(result.content),
+                ...(attachViewUUID && {
+                    _meta: {
+                        ...result._meta,
+                        viewUUID: crypto.randomUUID(),
+                    },
+                }),
+            };
+        };
+    }
+    computeViewVersionParam(viewName) {
+        if (process.env.NODE_ENV !== "production") {
+            return "";
+        }
+        try {
+            const viewFile = this.lookupViewFile(viewName);
+            const styleFile = this.lookupDistFile("style.css") ?? "";
+            const hash = crypto
+                .createHash("sha256")
+                .update(viewFile)
+                .update("\0")
+                .update(styleFile)
+                .digest("hex")
+                .slice(0, 8);
+            return `?v=${hash}`;
+        }
+        catch {
+            return "";
+        }
+    }
+    lookupViewFile(viewName) {
+        const manifest = this.readManifest();
+        for (const entry of Object.values(manifest)) {
+            if (entry?.isEntry && entry.name === viewName && entry.file) {
+                return entry.file;
+            }
+        }
+        throw new Error(`View "${viewName}" not found in Vite manifest. Did the build complete successfully? Look for an entry with name "${viewName}" in dist/assets/.vite/manifest.json.`);
+    }
     lookupDistFile(key) {
         const manifest = this.readManifest();
         return manifest[key]?.file;
     }
-    lookupDistFileWithIndexFallback(basePath) {
-        const manifest = this.readManifest();
-        const flatFileKey = `${basePath}.tsx`;
-        const indexFileKey = `${basePath}/index.tsx`;
-        return manifest[flatFileKey]?.file ?? manifest[indexFileKey]?.file;
+    /**
+     * Inject the Vite manifest as a value rather than letting `readManifest()`
+     * load it from disk. Required for runtimes without a usable filesystem
+     * (Cloudflare Workers, etc.) — the user's `skybridge build` emits the
+     * manifest as a JS module which the entry imports and passes here.
+     */
+    setViteManifest(manifest) {
+        this.viteManifest = manifest;
+        return this;
     }
     readManifest() {
+        if (this.viteManifest) {
+            return this.viteManifest;
+        }
         return JSON.parse(readFileSync(path.join(process.cwd(), "dist", "assets", ".vite", "manifest.json"), "utf-8"));
     }
+    registerTool(...args) {
+        const baseFn = McpServerBase.prototype.registerTool;
+        const { config, cb } = normalizeRegisterToolArgs(args);
+        const { name, view, auth, securitySchemes: rawSecuritySchemes, _meta: userToolMeta, ...toolFields } = config;
+        const authNeedsProvider = auth !== undefined && (!auth.public || 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 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
+            // fields, so the canonical spot isn't reachable without intercepting
+            // `tools/list`. Use the `_meta` back-compat mirror documented in the
+            // Apps SDK reference until SEP-1488 lands in the spec.
+            toolMeta.securitySchemes = securitySchemes;
+        }
+        if (view) {
+            this.enforceOneToolPerView(view.component, name);
+            this.registerViewResources(name, view, toolMeta);
+        }
+        const wrappedCb = this.decorateToolHandler(cb, {
+            attachViewUUID: Boolean(view),
+            securitySchemes,
+        });
+        baseFn.call(this, name, { ...toolFields, _meta: toolMeta }, wrappedCb);
+        return this;
+    }
 }
 //# sourceMappingURL=server.js.map