@mongoosejs/studio 0.5.14 → 0.6.0

package/backend/sandbox/createScriptDb.js

@@ -4,6 +4,19 @@ const omitNullish = require('../helpers/omitNullish');
 
 const wrappedCollections = new WeakSet();
 
+// Read preference only applies to reads, so it is injected for these methods
+// only. Applying it to a write would be meaningless at best and rejected by the
+// driver at worst.
+const readMethods = new Set([
+  'aggregate',
+  'countDocuments',
+  'distinct',
+  'estimatedDocumentCount',
+  'find',
+  'findOne',
+  'listIndexes'
+]);
+
 const collectionMethodOptionsIndex = new Map([
   ['aggregate', 1],
   ['bulkWrite', 1],
@@ -48,10 +61,13 @@ function createScriptDb(db, options = {}) {
   }
 
   let dryRunSession = null;
-  const getSession = () => dryRunSession;
-  const getMaxTimeMS = () => options.maxTimeMS;
-  cloneModels(sourceConnection, scriptConnection, getSession, getMaxTimeMS);
-  wrapCollectionAccessors(scriptConnection, getSession, getMaxTimeMS);
+  const getOperationOptions = () => ({
+    session: dryRunSession,
+    maxTimeMS: options.maxTimeMS,
+    readPreference: options.readPreference
+  });
+  cloneModels(sourceConnection, scriptConnection, getOperationOptions);
+  wrapCollectionAccessors(scriptConnection, getOperationOptions);
 
   const originalDebug = sourceConnection.options?.debug;
   scriptConnection.set('debug', function() {
@@ -79,14 +95,14 @@ function createScriptDb(db, options = {}) {
   };
 }
 
-function cloneModels(sourceConnection, scriptConnection, getSession, getMaxTimeMS) {
+function cloneModels(sourceConnection, scriptConnection, getOperationOptions) {
   for (const Model of Object.values(sourceConnection.models ?? {})) {
     if (Model?.schema == null || typeof scriptConnection.model !== 'function') {
       continue;
     }
 
     const ClonedModel = scriptConnection.model(Model.modelName, Model.schema, getCollectionName(Model));
-    wrapModelCollections(ClonedModel, getSession, getMaxTimeMS);
+    wrapModelCollections(ClonedModel, getOperationOptions);
   }
 }
 
@@ -94,13 +110,13 @@ function getCollectionName(Model) {
   return Model.collection?.collectionName ?? Model.collection?.name ?? Model.$__collection?.collectionName;
 }
 
-function wrapModelCollections(Model, getSession, getMaxTimeMS) {
+function wrapModelCollections(Model, getOperationOptions) {
   const collection = Model?.collection ?? Model?.$__collection;
   if (collection == null) {
     return;
   }
 
-  const wrappedCollection = wrapCollection(collection, getSession, getMaxTimeMS);
+  const wrappedCollection = wrapCollection(collection, getOperationOptions);
   Model.collection = wrappedCollection;
   Model.$__collection = wrappedCollection;
 
@@ -119,7 +135,7 @@ function setModelCollectionSymbols(target, collection) {
   }
 }
 
-function wrapCollectionAccessors(scriptConnection, getSession, getMaxTimeMS) {
+function wrapCollectionAccessors(scriptConnection, getOperationOptions) {
   const wrappedCollectionCache = new WeakMap();
 
   const nativeDb = scriptConnection.db;
@@ -136,19 +152,19 @@ function wrapCollectionAccessors(scriptConnection, getSession, getMaxTimeMS) {
           collection.collection = originalDbCollection.call(nativeDb, collection.name);
         }
       }
-      return getOrCreateWrappedCollection(wrappedCollectionCache, collection, getSession, getMaxTimeMS);
+      return getOrCreateWrappedCollection(wrappedCollectionCache, collection, getOperationOptions);
     };
   }
 
   if (originalDbCollection != null) {
     nativeDb.collection = function() {
       const collection = originalDbCollection.apply(this, arguments);
-      return getOrCreateWrappedCollection(wrappedCollectionCache, collection, getSession, getMaxTimeMS);
+      return getOrCreateWrappedCollection(wrappedCollectionCache, collection, getOperationOptions);
     };
   }
 }
 
-function getOrCreateWrappedCollection(cache, collection, getSession, getMaxTimeMS) {
+function getOrCreateWrappedCollection(cache, collection, getOperationOptions) {
   if (collection == null || (typeof collection !== 'object' && typeof collection !== 'function')) {
     return collection;
   }
@@ -158,12 +174,12 @@ function getOrCreateWrappedCollection(cache, collection, getSession, getMaxTimeM
   if (cache.has(collection)) {
     return cache.get(collection);
   }
-  const wrapped = wrapCollection(collection, getSession, getMaxTimeMS);
+  const wrapped = wrapCollection(collection, getOperationOptions);
   cache.set(collection, wrapped);
   return wrapped;
 }
 
-function wrapCollection(collection, getSession, getMaxTimeMS) {
+function wrapCollection(collection, getOperationOptions) {
   if (wrappedCollections.has(collection)) {
     return collection;
   }
@@ -176,20 +192,20 @@ function wrapCollection(collection, getSession, getMaxTimeMS) {
     }
 
     wrapped[methodName] = function() {
-      const args = addOperationOptions(
-        Array.from(arguments),
-        optionsIndex,
-        getSession(),
-        getMaxTimeMS()
-      );
+      const { session, maxTimeMS, readPreference } = getOperationOptions();
+      const args = addOperationOptions(Array.from(arguments), optionsIndex, {
+        session,
+        maxTimeMS,
+        readPreference: readMethods.has(methodName) ? readPreference : null
+      });
       return method.apply(collection, args);
     };
   }
   return wrapped;
 }
 
-function addOperationOptions(args, optionsIndex, session, maxTimeMS) {
-  if (session == null && maxTimeMS == null) {
+function addOperationOptions(args, optionsIndex, { session, maxTimeMS, readPreference }) {
+  if (session == null && maxTimeMS == null && readPreference == null) {
     return args;
   }
 
@@ -203,7 +219,7 @@ function addOperationOptions(args, optionsIndex, session, maxTimeMS) {
     if (session != null) {
       throw new Error('Cannot run dry run on script where options arg is a non-object');
     }
-    throw new Error('Cannot apply maxTimeMS to script where options arg is a non-object');
+    throw new Error('Cannot apply Studio operation options to script where options arg is a non-object');
   }
 
   if (session != null && options?.session != null) {
@@ -213,6 +229,7 @@ function addOperationOptions(args, optionsIndex, session, maxTimeMS) {
   args[optionsIndex] = omitNullish({
     ...(options ?? {}),
     maxTimeMS: maxTimeMS ?? options?.maxTimeMS,
+    readPreference: readPreference ?? options?.readPreference,
     session: session ?? options?.session
   });
   return args;

package/backend/util/archetypeToZodSchema.js

@@ -0,0 +1,74 @@
+'use strict';
+
+const Archetype = require('archetype');
+const mongoose = require('mongoose');
+const z = require('zod/v4');
+
+module.exports = function archetypeToZodSchema(paramsType) {
+  if (paramsType?.schema?.json == null) {
+    throw new Error('Expected a compiled Archetype params type');
+  }
+
+  return objectToZodSchema(paramsType.schema.json());
+};
+
+function objectToZodSchema(definition) {
+  return z.object(Object.fromEntries(
+    Object.entries(definition).map(([path, options]) => [path, pathToZodSchema(options)])
+  ));
+}
+
+function pathToZodSchema(options) {
+  if (options == null || typeof options !== 'object' || Array.isArray(options)) {
+    options = { $type: options };
+  } else if (!Object.prototype.hasOwnProperty.call(options, '$type')) {
+    options = { $type: Object, $schema: options };
+  }
+
+  let schema = typeToZodSchema(options.$type, options.$schema);
+  if (Array.isArray(options.$enum) && options.$enum.length > 0) {
+    schema = z.union(options.$enum.map(value => z.literal(value)));
+  }
+  if (typeof options.$validate === 'function') {
+    schema = schema.refine(value => {
+      try {
+        options.$validate(value, options);
+        return true;
+      } catch (_) {
+        return false;
+      }
+    });
+  }
+  if (!options.$required || options.$default !== undefined) {
+    schema = schema.optional();
+  }
+  if (options.$default !== undefined && typeof options.$default !== 'function') {
+    schema = schema.meta({ default: options.$default });
+  }
+  return schema;
+}
+
+function typeToZodSchema(type, nestedSchema) {
+  if (Array.isArray(type)) {
+    return z.array(typeToZodSchema(type[0]));
+  }
+  if (type === Archetype.Any) {
+    return z.unknown();
+  }
+  if (type === 'string' || type === String) {
+    return z.string();
+  }
+  if (type === 'number' || type === Number) {
+    return z.number();
+  }
+  if (type === 'boolean' || type === Boolean) {
+    return z.boolean();
+  }
+  if (type === Date || type === mongoose.Types.ObjectId) {
+    return z.string();
+  }
+  if (type === Object) {
+    return nestedSchema ? objectToZodSchema(nestedSchema) : z.record(z.string(), z.unknown());
+  }
+  return z.unknown();
+}

package/docs/mcp-oauth.md

@@ -0,0 +1,106 @@
+# MCP OAuth
+
+Mongoose Studio lets a user connect an MCP client, such as ChatGPT or Claude, to a Studio deployment using OAuth 2.1.
+The client never receives MongoDB credentials, a connection string, or the workspace API key.
+It receives a short-lived access token that only works against one Studio deployment and only does what the user approved.
+
+## Who does what
+
+The Studio deployment in your application is the OAuth *protected resource*.
+The Mongoose Studio mothership is the OAuth *authorization server*.
+
+Studio therefore never issues, stores, or validates MCP tokens by itself.
+It publishes metadata that tells clients where the authorization server is, and it asks the authorization server to resolve each incoming token.
+
+## The flow
+
+1. The user adds the Studio MCP URL, for example `https://app.example.com/studio/mcp`, to ChatGPT or Claude.
+2. The client calls the MCP endpoint with no token and gets a `401` with a `WWW-Authenticate: Bearer resource_metadata="..."` header.
+3. The client fetches that protected resource metadata document from Studio, which names the authorization server and the resource identifier.
+4. The client fetches the authorization server metadata, registers itself dynamically, and opens the Studio authorization page in a browser.
+5. The user signs in to Mongoose Studio if necessary, reviews the access being delegated, adjusts it if they have a choice, and authorizes.
+6. The authorization server redirects back to the client with a single-use authorization code.
+7. The client exchanges the code plus its PKCE verifier for a short-lived access token and a refresh token.
+8. On every MCP request, Studio asks the authorization server to resolve the access token, and runs the request under the policy it returns.
+
+Authorization Code with PKCE (`S256`) is required, and there are no client secrets: MCP clients are public clients.
+Access tokens live 15 minutes.
+Refresh tokens live 30 days and rotate on every use, so a user does not have to reconnect the client regularly.
+
+## Authorization grants
+
+Approving the authorization page creates an `MCPOAuthGrant` on the mothership.
+The grant records who delegated the access, the workspace and Studio deployment it applies to, which OAuth client it was issued to, and the capabilities that were approved:
+
+```javascript
+{
+  userId,
+  workspaceId,
+  resource,       // canonical URL of the Studio MCP endpoint, the environment being accessed
+  oauthClientId,
+  oauthClientName,
+  capabilities: {
+    read: true,
+    write: false,
+    readPreference: 'secondary',
+    maxTimeMS: 5000,
+    collections: '*'
+  },
+  lastUsedAt,
+  revokedAt
+}
+```
+
+A Studio workspace is the organization and project unit, and `resource` identifies the individual deployment, so a grant is scoped to exactly one database environment.
+
+Access tokens are opaque references to a grant, not copies of it.
+Nothing about the policy is embedded in the token, which is what makes the following true:
+
+- Revoking a grant, or revoking the client's refresh token, stops the client immediately.
+- Editing a grant changes what the client may do on its next request, without issuing a new credential.
+- Changing the user's workspace roles or the workspace MCP policy changes what the client may do, again on its next request.
+
+## Effective authorization
+
+The access delegated to an MCP client is the intersection of four things:
+
+1. The workspace `mcpPolicy`.
+2. The member's `mcpPolicy`.
+3. The member's Studio roles.
+4. The capabilities on the grant.
+
+Every layer can only take access away.
+A read-only user cannot delegate write access, a user capped at secondary reads cannot delegate primary reads, and a user capped at 5 seconds cannot delegate 30 seconds.
+The authorization page only offers options that are valid reductions of what the user already has, and the server intersects the request again before storing it, so a tampered request cannot widen a grant.
+
+Studio enforces the resolved policy per request:
+
+- `write: false` downgrades the request's roles, so write actions are neither offered as MCP tools nor callable.
+- `maxTimeMS` and `readPreference` travel as request params, set from the grant by trusted middleware, and every Studio action applies them to its MongoDB operations, including operations inside dashboard and document scripts.
+
+The Studio action tree is built once, with one set of options, so these limits are per request rather than per mount.
+They can only narrow what the host application already allows: `maxTimeMS` is capped by the `maxTimeMS` option when one is configured, and a read preference is resolved to whichever of the configured and requested values is more restrictive.
+`maxTimeMS` and `readPreference` are also reserved MCP params, so they are not offered to MCP clients as tool inputs and a client cannot name them itself.
+
+## Configuration
+
+The Mongoose Studio side needs a Pro API key and its own externally reachable URL, since the resource identifier is that URL.
+Set `publicUrl` to the URL where Mongoose Studio is mounted:
+
+```javascript
+app.use('/studio', await studio('/studio/api', mongoose, {
+  apiKey: process.env.MONGOOSE_STUDIO_API_KEY,
+  publicUrl: 'https://app.example.com/studio'
+}));
+```
+
+Pass `mcp: false` to serve Studio without an MCP endpoint at all.
+Neither the endpoint nor its protected resource metadata is then mounted, so there is nothing for an MCP client to discover.
+Without an API key, the MCP endpoint follows the normal localhost or `bindIp` restrictions and does not mount OAuth protected resource metadata.
+
+Mongoose Studio registers that URL with the authorization server the first time a client asks for its protected resource metadata, which is how an OAuth `resource` parameter is mapped back to a workspace.
+It advertises the configured mothership's origin in `authorization_servers`, keeping authentication with the same service Mongoose Studio already uses.
+
+Browser based MCP clients, claude.ai among them, run discovery from the page rather than from a server.
+Studio therefore serves the MCP endpoint and its metadata with CORS, and exposes `WWW-Authenticate` via `Access-Control-Expose-Headers`.
+Without that last header a browser hides the challenge from the client, and the client cannot find the authorization server at all.

package/eslint.config.js

@@ -13,6 +13,7 @@ module.exports = defineConfig([
       sourceType: 'commonjs',
       globals: {
         fetch: true,
+        URL: true,
         setTimeout: true,
         process: true,
         console: true,

package/eval/agent/run.js

@@ -161,7 +161,7 @@ async function executeFinalCode(conn, trace) {
   if (!trace.finalCode) {
     return;
   }
-  const sandbox = createSandbox({ db: conn });
+  const sandbox = createSandbox(conn, {});
   try {
     trace.output = await sandbox.runScript({ script: trace.finalCode });
     trace.logs = sandbox.getLogs();

package/express.js

@@ -3,6 +3,8 @@
 const Backend = require('./backend');
 const express = require('express');
 const frontend = require('./frontend');
+const mcp = require('./backend/mcp');
+const mothership = require('./backend/integrations/mothership');
 const isBindIPConnection = require('./backend/helpers/isBindIPConnection');
 const isLocalhostConnection = require('./backend/helpers/isLocalhostConnection');
 const normalizeBindIPOption = require('./backend/helpers/normalizeBindIPOption');
@@ -10,10 +12,14 @@ const { toRoute, objectRouter } = require('extrovert');
 const { defaultMothershipURL } = require('./constants');
 
 const jsonParser = express.json();
+const MCP_ACCESS_TOKEN_PREFIX = 'mcp_at_';
 
 module.exports = async function mongooseStudioExpressApp(apiUrl, conn, options) {
   const router = express.Router();
   options = options ? { changeStream: true, ...options } : { changeStream: true };
+  if (options.mcp !== false && options.apiKey && !options.publicUrl) {
+    throw new Error('Mongoose Studio requires the publicUrl option when MCP is enabled with an API key');
+  }
   const hasBindIpOption = Object.prototype.hasOwnProperty.call(options, 'bindIp');
   const bindIp = normalizeBindIPOption(options.bindIp);
 
@@ -38,6 +44,7 @@ module.exports = async function mongooseStudioExpressApp(apiUrl, conn, options)
       })
       .then(res => res.json()));
   }
+  options.workspace = workspace;
 
   if (!workspace && bindIp !== null) {
     router.use((req, res, next) => {
@@ -54,49 +61,56 @@ module.exports = async function mongooseStudioExpressApp(apiUrl, conn, options)
   const backend = Backend(conn, options.studioConnection, options);
   delete backend.services;
 
-  router.use(
-    '/api',
-    function authorize(req, res, next) {
-      if (!workspace) {
-        next();
-        return;
+  function authorizeRequest(req, res, next) {
+    if (!workspace) {
+      next();
+      return;
+    }
+    const authorizationHeader = req.headers.authorization;
+    if (!authorizationHeader) {
+      res.setHeader('WWW-Authenticate', 'Bearer');
+      return res.status(401).json({ message: 'Not authorized' });
+    }
+    const authorization = authorizationHeader.replace(/^Bearer\s+/i, '');
+    const params = {
+      method: 'POST',
+      body: JSON.stringify({ workspaceId: workspace._id }),
+      headers: {
+        'Authorization': authorization,
+        'Content-Type': 'application/json'
       }
-      const authorization = req.headers.authorization;
-      const params = {
-        method: 'POST',
-        body: JSON.stringify({ workspaceId: workspace._id }),
-        headers: {
-          'Authorization': authorization,
-          'Content-Type': 'application/json'
+    };
+    fetch(`${mothershipUrl}/me`, params)
+      .then(response => {
+        if (response.status < 200 || response.status >= 400) {
+          return response.json().then(data => {
+            throw new Error(`Mongoose Studio API Key Error ${response.status}: ${require('util').inspect(data)}`);
+          });
         }
-      };
-      fetch(`${mothershipUrl}/me`, params)
-        .then(response => {
-          if (response.status < 200 || response.status >= 400) {
-            return response.json().then(data => {
-              throw new Error(`Mongoose Studio API Key Error ${response.status}: ${require('util').inspect(data)}`);
-            });
-          }
-          return response;
-        })
-        .then(res => res.json())
-        .then(({ user, roles }) => {
-          if (!user || !roles) {
-            return res.status(403).json({ message: 'Not authorized' });
-          }
-          req._internals = req._internals || {};
-          req._internals.authorization = authorization;
-          req._internals.initiatedById = user._id;
-          req._internals.roles = roles;
-          req._internals.$workspaceId = workspace._id;
-          req._internals.initiatedBy = user;
-
-          next();
-        })
-        .catch(err => {
-          return res.status(500).json({ message: err.message });
-        });
-    },
+        return response;
+      })
+      .then(res => res.json())
+      .then(({ user, roles }) => {
+        if (!user || !roles) {
+          return res.status(403).json({ message: 'Not authorized' });
+        }
+        req._internals = req._internals || {};
+        req._internals.authorization = authorization;
+        req._internals.initiatedById = user._id;
+        req._internals.roles = roles;
+        req._internals.$workspaceId = workspace._id;
+        req._internals.initiatedBy = user;
+
+        next();
+      })
+      .catch(err => {
+        return res.status(500).json({ message: err.message });
+      });
+  }
+
+  router.use(
+    '/api',
+    authorizeRequest,
     function parseJson(req, res, next) {
       if (req.body !== undefined || req.readable === false) {
         return next();
@@ -106,6 +120,110 @@ module.exports = async function mongooseStudioExpressApp(apiUrl, conn, options)
     objectRouter(backend, toRoute)
   );
 
+  // MCP clients (ChatGPT, Claude, ...) authenticate with OAuth access tokens
+  // issued by the mothership. Mongoose Studio is the protected resource: it publishes the
+  // metadata that points clients at the authorization server, and resolves each
+  // token to its current grant before handling the request.
+  const mcpEnabled = options.mcp !== false;
+  const registeredMCPResources = new Set();
+  const mcpAuthorizationServerUrl = new URL(mothershipUrl).origin;
+  const mcpResource = workspace ? canonicalize(`${options.publicUrl.replace(/\/+$/, '')}/mcp`) : null;
+
+  async function registerMCPResource(resource) {
+    if (registeredMCPResources.has(resource)) {
+      return;
+    }
+    try {
+      await mothership.Workspace.registerMCPResource({ apiKey: options.apiKey, resource }, options);
+      registeredMCPResources.add(resource);
+    } catch (err) {
+      // Not fatal: metadata is still worth serving, and the next request retries.
+      console.warn(`[MONGOOSE STUDIO] Could not register MCP resource ${resource}: ${err.message}`);
+    }
+  }
+
+  function mcpChallenge({ error, description } = {}) {
+    // A client may go straight to the authorization server without requesting
+    // metadata first, so register the resource when sending the challenge too.
+    registerMCPResource(mcpResource).catch(() => {});
+    const metadataUrl = `${mcpResource.replace(/\/mcp$/, '')}/.well-known/oauth-protected-resource`;
+    const parts = [`Bearer resource_metadata="${metadataUrl}"`];
+    if (error) {
+      parts.push(`error="${error}"`);
+    }
+    if (description) {
+      parts.push(`error_description="${`${description}`.replace(/"/g, '')}"`);
+    }
+    return parts.join(', ');
+  }
+
+  async function serveProtectedResourceMetadata(req, res, next) {
+    try {
+      await registerMCPResource(mcpResource);
+      res.setHeader('Cache-Control', 'no-store');
+      res.json({
+        resource: mcpResource,
+        authorization_servers: [mcpAuthorizationServerUrl],
+        scopes_supported: ['mcp'],
+        bearer_methods_supported: ['header'],
+        resource_documentation: 'https://mongoosestudio.app/docs/'
+      });
+    } catch (err) {
+      next(err);
+    }
+  }
+
+  if (mcpEnabled && workspace) {
+    // Browser based MCP clients discover and connect cross-origin, so both the
+    // metadata and the MCP endpoint itself need CORS, including a preflight.
+    router.use('/.well-known/oauth-protected-resource', mcpCors);
+    router.get('/.well-known/oauth-protected-resource', serveProtectedResourceMetadata);
+    router.get('/.well-known/oauth-protected-resource/mcp', serveProtectedResourceMetadata);
+  }
+  if (mcpEnabled) {
+    router.use('/mcp', mcpCors, authorizeMCPRequest, jsonParser, mcp(backend));
+  }
+
+  function authorizeMCPRequest(req, res, next) {
+    if (!workspace) {
+      return authorizeRequest(req, res, next);
+    }
+    const token = `${req.headers.authorization || ''}`.replace(/^Bearer\s+/i, '').trim();
+    if (!token) {
+      res.setHeader('WWW-Authenticate', mcpChallenge());
+      return res.status(401).json({ message: 'Not authorized' });
+    }
+    if (!token.startsWith(MCP_ACCESS_TOKEN_PREFIX)) {
+      // A Studio session token, for example the Studio UI talking to its own
+      // MCP endpoint. Fall back to the regular Studio authorization path.
+      return authorizeRequest(req, res, next);
+    }
+
+    mothership.MCPOAuthToken.introspectMCPAccessToken({ apiKey: options.apiKey, token, resource: mcpResource }, options).
+      then(({ user, permissions }) => {
+        req._internals = req._internals || {};
+        req._internals.authorization = token;
+        req._internals.initiatedById = user._id;
+        req._internals.roles = permissions.roles;
+        req._internals.$workspaceId = workspace._id;
+        req._internals.initiatedBy = user;
+        // The limits from the grant, applied to every operation this request
+        // runs. `maxTimeMS` is still capped by the host application's own
+        // `maxTimeMS` option, and a read preference can only be narrowed.
+        req._internals.maxTimeMS = permissions.maxTimeMS;
+        req._internals.readPreference = permissions.readPreference;
+
+        next();
+      }).
+      catch(err => {
+        if (err.status === 401 || err.status === 403) {
+          res.setHeader('WWW-Authenticate', mcpChallenge({ error: 'invalid_token', description: err.message }));
+          return res.status(401).json({ message: err.message });
+        }
+        return res.status(500).json({ message: err.message });
+      });
+  }
+
   const { config } = await frontend(apiUrl, false, options, workspace);
   config.enableTaskVisualizer = options.enableTaskVisualizer;
   router.get('/config.js', function (req, res) {
@@ -121,3 +239,27 @@ module.exports = async function mongooseStudioExpressApp(apiUrl, conn, options)
 
   return router;
 }
+
+function mcpCors(req, res, next) {
+  res.setHeader('Access-Control-Allow-Origin', req.headers.origin || '*');
+  res.setHeader('Vary', 'Origin');
+  res.setHeader('Access-Control-Allow-Methods', 'GET, POST, DELETE, OPTIONS');
+  res.setHeader('Access-Control-Allow-Headers', 'Authorization, Content-Type, Mcp-Protocol-Version, Mcp-Session-Id, Last-Event-ID');
+  res.setHeader('Access-Control-Expose-Headers', 'WWW-Authenticate, Mcp-Session-Id, Mcp-Protocol-Version');
+  res.setHeader('Access-Control-Max-Age', '86400');
+
+  if (req.method === 'OPTIONS') {
+    return res.status(204).end();
+  }
+  next();
+}
+
+function canonicalize(resource) {
+  const url = new URL(resource);
+  url.hash = '';
+  url.search = '';
+  if (url.pathname.length > 1 && url.pathname.endsWith('/')) {
+    url.pathname = url.pathname.replace(/\/+$/, '');
+  }
+  return url.toString();
+}

package/frontend/index.js

@@ -32,9 +32,12 @@ module.exports = async function frontend(apiUrl, isLambda, options, workspace) {
   }
 
   const { apiKey, ...workspaceData } = workspace || {};
+  const workspaceBaseUrl = workspace?.baseUrl?.replace(/\/+$/, '');
   const config = {
     baseURL: apiUrl,
     isLambda,
+    mcp: options?.mcp !== false,
+    mcpUrl: workspaceBaseUrl ? `${workspaceBaseUrl}/mcp` : null,
     mothershipUrl: apiKey ? mothershipUrl : null,
     workspace: workspaceData
   };