db-mcp 1.1.1 → 3.0.0

package/dist/{http-VSB7DBJR.js → http-HWTUVFIA.js}

@@ -1,12 +1,14 @@
-import './chunk-4IA3DB5C.js';
-import { createModuleLogger, DbMcpError, ERROR_CODES } from './chunk-AOUL5SHS.js';
+import { createModuleLogger, DbMcpError, runWithAuthContext, ERROR_CODES, logger, SUPPORTED_SCOPES, scopesGrantToolAccess, InsufficientScopeError, hasAdminScope, hasReadScope, isOAuthError, BASE_SCOPES, AuthServerDiscoveryError, JwksFetchError, parseScopes, TokenExpiredError, InvalidSignatureError, InvalidTokenError, TokenMissingError } from './chunk-L552U3QS.js';
 import express from 'express';
 import { localhostHostValidation } from '@modelcontextprotocol/sdk/server/middleware/hostHeaderValidation.js';
 import cors from 'cors';
-import { randomUUID } from 'crypto';
+import rateLimit from 'express-rate-limit';
+import RedisStore from 'rate-limit-redis';
+import { createClient } from 'redis';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
-import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
+import { randomUUID } from 'crypto';
 import { isInitializeRequest } from '@modelcontextprotocol/sdk/types.js';
+import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
 import * as jose from 'jose';
 
 // src/auth/middleware/extraction.ts
@@ -27,155 +29,8 @@ function extractBearerToken(authHeader) {
   return token.length > 0 ? token : null;
 }
 
-// src/auth/errors.ts
-var OAuthError = class extends DbMcpError {
-  /** HTTP status code for this error */
-  httpStatus;
-  /** WWW-Authenticate header value */
-  wwwAuthenticate;
-  constructor(message, code, httpStatus, details, wwwAuthenticate) {
-    super(message, code, "authentication" /* AUTHENTICATION */, { details });
-    this.name = "OAuthError";
-    this.httpStatus = httpStatus;
-    this.wwwAuthenticate = wwwAuthenticate;
-  }
-};
-var TokenMissingError = class extends OAuthError {
-  constructor(realm = "db-mcp") {
-    super(
-      "No access token provided",
-      ERROR_CODES.AUTH.TOKEN_MISSING.full,
-      401,
-      void 0,
-      `Bearer realm="${realm}"`
-    );
-    this.name = "TokenMissingError";
-  }
-};
-var InvalidTokenError = class extends OAuthError {
-  constructor(message = "Invalid access token", details) {
-    super(
-      message,
-      ERROR_CODES.AUTH.TOKEN_INVALID.full,
-      401,
-      details,
-      'Bearer error="invalid_token"'
-    );
-    this.name = "InvalidTokenError";
-  }
-};
-var TokenExpiredError = class extends OAuthError {
-  constructor(expiredAt) {
-    super(
-      "Access token has expired",
-      ERROR_CODES.AUTH.TOKEN_EXPIRED.full,
-      401,
-      expiredAt ? { expiredAt: expiredAt.toISOString() } : void 0,
-      'Bearer error="invalid_token", error_description="Token has expired"'
-    );
-    this.name = "TokenExpiredError";
-  }
-};
-var InvalidSignatureError = class extends OAuthError {
-  constructor(message = "Token signature verification failed") {
-    super(
-      message,
-      ERROR_CODES.AUTH.SIGNATURE_INVALID.full,
-      401,
-      void 0,
-      'Bearer error="invalid_token", error_description="Signature verification failed"'
-    );
-    this.name = "InvalidSignatureError";
-  }
-};
-var AuthServerDiscoveryError = class extends OAuthError {
-  constructor(serverUrl, cause) {
-    super(
-      `Failed to discover authorization server metadata: ${serverUrl}`,
-      ERROR_CODES.AUTH.DISCOVERY_FAILED.full,
-      500,
-      {
-        serverUrl,
-        cause: cause?.message
-      }
-    );
-    this.name = "AuthServerDiscoveryError";
-  }
-};
-var JwksFetchError = class extends OAuthError {
-  constructor(jwksUri, cause) {
-    super(
-      `Failed to fetch JWKS: ${jwksUri}`,
-      ERROR_CODES.AUTH.JWKS_FETCH_FAILED.full,
-      500,
-      {
-        jwksUri,
-        cause: cause?.message
-      }
-    );
-    this.name = "JwksFetchError";
-  }
-};
-function isOAuthError(error) {
-  return error instanceof OAuthError;
-}
-
-// src/auth/scopes/constants.ts
-var SCOPES = {
-  /** Read-only access to all databases */
-  READ: "read",
-  /** Read and write access to all databases */
-  WRITE: "write",
-  /** Administrative access */
-  ADMIN: "admin"};
-var BASE_SCOPES = ["read", "write", "admin", "full"];
-var SCOPE_PATTERNS = {
-  /** Database-specific access pattern */
-  DATABASE: /^db:([a-zA-Z0-9_-]+)$/,
-  /** Table-specific access pattern */
-  TABLE: /^table:([a-zA-Z0-9_-]+):([a-zA-Z0-9_-]+)$/
-};
-var SUPPORTED_SCOPES = [
-  "read",
-  "write",
-  "admin",
-  "full",
-  "db:{database}",
-  "table:{database}:{table}"
-];
-function parseScopes(scopeString) {
-  return scopeString.split(/\s+/).map((s) => s.trim()).filter((s) => s.length > 0);
-}
-
-// src/auth/scopes/mapping.ts
-var TOOL_GROUP_SCOPES = {
-  core: SCOPES.READ,
-  json: SCOPES.READ,
-  text: SCOPES.READ,
-  stats: SCOPES.READ,
-  vector: SCOPES.READ,
-  geo: SCOPES.READ,
-  introspection: SCOPES.READ,
-  migration: SCOPES.WRITE,
-  admin: SCOPES.ADMIN,
-  codemode: SCOPES.ADMIN
-};
-var groupsForScope = (maxScope) => {
-  const hierarchy = {
-    read: 0,
-    write: 1,
-    admin: 2,
-    full: 3
-  };
-  const maxLevel = hierarchy[maxScope];
-  return Object.entries(TOOL_GROUP_SCOPES).filter(([, scope]) => hierarchy[scope] <= maxLevel).map(([group]) => group);
-};
-groupsForScope(SCOPES.READ);
-groupsForScope(SCOPES.WRITE);
-groupsForScope(SCOPES.ADMIN);
-
 // src/auth/middleware/express-auth.ts
-var logger = createModuleLogger("AUTH");
+var logger2 = createModuleLogger("AUTH");
 function isPublicPath(path, publicPaths) {
   if (path.startsWith("/.well-known/")) {
     return true;
@@ -198,8 +53,9 @@ function createAuthMiddleware(config) {
   return async (req, res, next) => {
     const requestId = crypto.randomUUID();
     req.requestId = requestId;
+    res.setHeader("X-Request-ID", requestId);
     if (isPublicPath(req.path, publicPaths)) {
-      logger.info(`Public path accessed: ${req.path}`, {
+      logger2.info(`Public path accessed: ${req.path}`, {
         code: "AUTH_PUBLIC_PATH",
         requestId,
         path: req.path
@@ -210,7 +66,7 @@ function createAuthMiddleware(config) {
     const token = extractBearerToken(req.headers.authorization);
     if (!token) {
       const error = new TokenMissingError(resourceServer.getResourceUri());
-      logger.warning("No access token provided", {
+      logger2.warning("No access token provided", {
         code: ERROR_CODES.AUTH.TOKEN_MISSING.full,
         requestId,
         path: req.path
@@ -225,7 +81,7 @@ function createAuthMiddleware(config) {
     }
     const result = await tokenValidator.validate(token);
     if (!result.valid) {
-      logger.warning(
+      logger2.warning(
         `Token validation failed: ${result.error ?? "Unknown error"}`,
         {
           code: result.errorCode ?? ERROR_CODES.AUTH.TOKEN_INVALID.full,
@@ -236,11 +92,14 @@ function createAuthMiddleware(config) {
       res.status(401);
       res.setHeader(
         "WWW-Authenticate",
-        resourceServer.getWWWAuthenticateHeader("invalid_token", result.error)
+        resourceServer.getWWWAuthenticateHeader(
+          "invalid_token",
+          "Token validation failed"
+        )
       );
       res.json({
         error: "invalid_token",
-        error_description: result.error
+        error_description: "Token validation failed"
       });
       return;
     }
@@ -251,7 +110,7 @@ function createAuthMiddleware(config) {
     }
     req.auth = claims;
     req.accessToken = token;
-    logger.info(`Request authenticated: ${claims.sub}`, {
+    logger2.info(`Request authenticated: ${claims.sub}`, {
       code: "AUTH_SUCCESS",
       requestId,
       sub: claims.sub,
@@ -289,18 +148,9 @@ var JSONRPC_INTERNAL_ERROR = -32603;
 var HTTP_REQUEST_TIMEOUT_MS = 12e4;
 var HTTP_KEEP_ALIVE_TIMEOUT_MS = 65e3;
 var HTTP_HEADERS_TIMEOUT_MS = 66e3;
-function getClientIp(req, trustProxy) {
-  if (trustProxy) {
-    const forwarded = req.headers["x-forwarded-for"];
-    if (typeof forwarded === "string") {
-      const firstIp = forwarded.split(",")[0]?.trim();
-      if (firstIp) return firstIp;
-    }
-  }
-  return req.ip ?? req.socket.remoteAddress ?? "unknown";
-}
 function setupSecurityHeaders(state) {
   if (!state.app) return;
+  state.app.disable("x-powered-by");
   state.app.use((_req, res, next) => {
     res.setHeader("X-Content-Type-Options", "nosniff");
     res.setHeader("X-Frame-Options", "DENY");
@@ -314,8 +164,12 @@ function setupSecurityHeaders(state) {
       "camera=(), microphone=(), geolocation=()"
     );
     res.setHeader("Referrer-Policy", "no-referrer");
+    res.setHeader("X-Permitted-Cross-Domain-Policies", "none");
     if (state.config.enableHSTS) {
-      const maxAge = state.config.hstsMaxAge ?? DEFAULT_HSTS_MAX_AGE;
+      const maxAge = Math.max(
+        state.config.hstsMaxAge ?? DEFAULT_HSTS_MAX_AGE,
+        31536e3
+      );
       res.setHeader(
         "Strict-Transport-Security",
         `max-age=${String(maxAge)}; includeSubDomains`
@@ -328,13 +182,15 @@ function matchesCorsOrigin(origin, pattern) {
   if (pattern === "*") return true;
   if (pattern.startsWith("*.")) {
     const domain = pattern.slice(1);
+    const isLocalDev = origin === "http://localhost" || origin.startsWith("http://localhost:") || origin === "http://127.0.0.1" || origin.startsWith("http://127.0.0.1:") || origin === "http://[::1]" || origin.startsWith("http://[::1]:");
+    if (!isLocalDev && !origin.startsWith("https://")) return false;
     return origin.endsWith(domain) && origin.length > domain.length;
   }
   return origin === pattern;
 }
 function setupCors(state) {
   if (!state.app) return;
-  const corsOrigins = state.config.corsOrigins ?? ["*"];
+  const corsOrigins = state.config.corsOrigins ?? [];
   const isWildcard = corsOrigins.includes("*");
   state.app.use((req, res, next) => {
     const origin = req.headers.origin;
@@ -365,41 +221,41 @@ function setupCors(state) {
 function setupRateLimiting(state) {
   if (!state.app) return;
   const windowMs = DEFAULT_RATE_LIMIT_WINDOW_MS;
-  const maxRequests = process.env["MCP_RATE_LIMIT_MAX"] ? parseInt(process.env["MCP_RATE_LIMIT_MAX"], 10) : DEFAULT_RATE_LIMIT_MAX;
-  const trustProxy = state.config.trustProxy ?? false;
-  state.rateLimitCleanupTimer = setInterval(() => {
-    const now = Date.now();
-    for (const [ip, entry] of state.rateLimitMap) {
-      if (now >= entry.resetAt) {
-        state.rateLimitMap.delete(ip);
-      }
-    }
-  }, windowMs);
-  state.rateLimitCleanupTimer.unref();
-  state.app.use((req, res, next) => {
-    if (req.path === "/health") {
-      next();
-      return;
-    }
-    const ip = getClientIp(req, trustProxy);
-    const now = Date.now();
-    let entry = state.rateLimitMap.get(ip);
-    if (!entry || now >= entry.resetAt) {
-      entry = { count: 0, resetAt: now + windowMs };
-      state.rateLimitMap.set(ip, entry);
-    }
-    entry.count++;
-    if (entry.count > maxRequests) {
-      const retryAfter = Math.ceil((entry.resetAt - now) / 1e3);
-      res.setHeader("Retry-After", String(retryAfter));
-      res.status(429).json({
-        error: "Too Many Requests",
-        retryAfter
+  const parsedMax = process.env["MCP_RATE_LIMIT_MAX"] ? parseInt(process.env["MCP_RATE_LIMIT_MAX"], 10) : DEFAULT_RATE_LIMIT_MAX;
+  const safeParsedMax = Number.isNaN(parsedMax) ? DEFAULT_RATE_LIMIT_MAX : parsedMax;
+  const maxRequests = Math.max(1, Math.min(safeParsedMax, 1e4));
+  let store;
+  if (process.env["REDIS_URL"]) {
+    const redisClient = createClient({ url: process.env["REDIS_URL"] });
+    redisClient.connect().catch((err) => {
+      logger.error("Redis connection failed", {
+        error: err instanceof Error ? err : new Error(String(err))
+      });
+    });
+    store = new RedisStore({
+      sendCommand: (...args) => redisClient.sendCommand(args)
+    });
+    logger.info("Configured RedisStore for rate limiting", { module: "HTTP" });
+  } else if (process.env["NODE_ENV"] === "production") {
+    logger.error(
+      "CRITICAL SECURITY WARNING: Using default in-memory rate limit store in production. In multi-instance deployments, rate limits will not be synchronized across instances (leading to amplification attacks). Configure REDIS_URL for production clusters or ensure your proxy handles rate limiting.",
+      { module: "HTTP" }
+    );
+  }
+  const limiter = rateLimit({
+    windowMs,
+    max: maxRequests,
+    standardHeaders: true,
+    legacyHeaders: false,
+    ...store ? { store } : {},
+    skip: (req) => req.path === "/health",
+    handler: (_req, res, _next, options) => {
+      res.status(options.statusCode).json({
+        error: "Too Many Requests"
       });
-      return;
     }
-    next();
   });
+  state.app.use(limiter);
 }
 
 // src/transports/http/type-adapters.ts
@@ -410,8 +266,8 @@ function asServerResponse(res) {
   return res;
 }
 
-// src/transports/http/session.ts
-var logger3 = createModuleLogger("HTTP");
+// src/transports/http/sessions/stateless.ts
+var logger4 = createModuleLogger("HTTP");
 async function setupStatelessEndpoints(state) {
   if (!state.app || !state.mcpServer) {
     throw new DbMcpError(
@@ -424,14 +280,14 @@ async function setupStatelessEndpoints(state) {
     enableJsonResponse: true
   });
   state.statelessTransport.onclose ??= () => {
-    logger3.debug("Stateless transport closed", {
+    logger4.debug("Stateless transport closed", {
       code: "HTTP_STATELESS_CLOSE"
     });
   };
   await state.mcpServer.connect(
     state.statelessTransport
   );
-  logger3.info("Stateless transport connected", { code: "HTTP_STATELESS" });
+  logger4.info("Stateless transport connected", { code: "HTTP_STATELESS" });
   state.app.post("/mcp", (req, res) => {
     if (!state.statelessTransport) {
       res.status(500).json({ error: "Transport not initialized" });
@@ -457,6 +313,47 @@ async function setupStatelessEndpoints(state) {
     res.status(204).end();
   });
 }
+
+// src/transports/http/sessions/mutex.ts
+var Mutex = class {
+  queue = [];
+  locked = false;
+  async acquire() {
+    return new Promise((resolve) => {
+      const lock = () => {
+        this.locked = true;
+        resolve(() => {
+          this.locked = false;
+          if (this.queue.length > 0) {
+            const next = this.queue.shift();
+            next?.();
+          }
+        });
+      };
+      if (this.locked) {
+        this.queue.push(lock);
+      } else {
+        lock();
+      }
+    });
+  }
+};
+
+// src/transports/http/sessions/stateful.ts
+var logger5 = createModuleLogger("HTTP");
+var connectionMutex = new Mutex();
+function verifySessionOwner(state, sessionId, reqAuthSub) {
+  const owner = state.sessionOwners.get(sessionId);
+  if (owner !== void 0 && owner !== reqAuthSub) {
+    return false;
+  }
+  return true;
+}
+function isValidSessionId(id) {
+  if (!id) return false;
+  if (id.length !== 36) return false;
+  return /^[0-9a-fA-F-]{36}$/.test(id);
+}
 function setupStatefulEndpoints(state) {
   if (!state.app || !state.mcpServer) {
     throw new DbMcpError(
@@ -468,6 +365,17 @@ function setupStatefulEndpoints(state) {
   const server = state.mcpServer;
   state.app.post("/mcp", (req, res) => {
     const sessionId = req.headers["mcp-session-id"];
+    if (sessionId !== void 0 && !isValidSessionId(sessionId)) {
+      res.status(400).json({
+        jsonrpc: "2.0",
+        error: {
+          code: JSONRPC_SERVER_ERROR,
+          message: "Bad Request: Invalid session ID format"
+        },
+        id: null
+      });
+      return;
+    }
     if (sessionId && state.sseTransports.has(sessionId)) {
       res.status(400).json({
         jsonrpc: "2.0",
@@ -491,39 +399,96 @@ function setupStatefulEndpoints(state) {
     void (async () => {
       try {
         let httpTransport;
-        if (sessionId && state.transports.has(sessionId)) {
-          httpTransport = state.transports.get(sessionId);
+        const existingTransport = sessionId ? state.transports.get(sessionId) : void 0;
+        if (typeof sessionId === "string" && existingTransport !== void 0) {
+          if (!verifySessionOwner(state, sessionId, req.auth?.sub)) {
+            res.status(403).json({
+              jsonrpc: "2.0",
+              error: {
+                code: JSONRPC_SERVER_ERROR,
+                message: "Forbidden: session belongs to a different client"
+              },
+              id: null
+            });
+            return;
+          }
+          httpTransport = existingTransport;
         } else if (sessionId === void 0 && isNewSessionRequest(req.body)) {
+          const maxSessions = state.config.maxSessions ?? 1e3;
+          if (state.transports.size >= maxSessions) {
+            res.status(429).json({
+              jsonrpc: "2.0",
+              error: {
+                code: JSONRPC_SERVER_ERROR,
+                message: "Too Many Requests: Maximum number of concurrent sessions reached"
+              },
+              id: null
+            });
+            return;
+          }
           const newTransport = new StreamableHTTPServerTransport({
             sessionIdGenerator: () => randomUUID(),
             onsessioninitialized: (sid) => {
-              logger3.info("HTTP session initialized", {
+              logger5.info("HTTP session initialized", {
                 code: "HTTP_SESSION_INIT",
                 sessionId: sid
               });
               state.transports.set(sid, newTransport);
+              state.sessionOwners.set(sid, req.auth?.sub);
             }
           });
           newTransport.onclose = () => {
             const sid = newTransport.sessionId;
             if (sid !== void 0 && state.transports.has(sid)) {
-              logger3.info("HTTP transport closed", {
+              logger5.info("HTTP transport closed", {
                 code: "HTTP_SESSION_CLOSE",
                 sessionId: sid
               });
               state.transports.delete(sid);
+              state.sessionOwners.delete(sid);
             }
           };
-          try {
-            await server.connect(
-              newTransport
-            );
-          } catch {
-            await server.close();
-            await server.connect(
-              newTransport
-            );
-          }
+          await connectionMutex.acquire().then(async (release) => {
+            try {
+              if (server.server.transport) {
+                const oldTransport = server.server.transport;
+                logger5.info("Captured oldTransport in /mcp", {
+                  hasOldTransport: oldTransport !== void 0,
+                  hasOnclose: oldTransport.onclose !== void 0
+                });
+                try {
+                  await Promise.race([
+                    server.close(),
+                    new Promise(
+                      (_, reject) => setTimeout(
+                        () => reject(new Error("server.close timeout")),
+                        2e3
+                      )
+                    )
+                  ]);
+                  logger5.info("server.close() succeeded in /mcp");
+                } catch (closeErr) {
+                  logger5.error("server.close() failed or timed out in /mcp", {
+                    error: closeErr instanceof Error ? closeErr : new Error(String(closeErr))
+                  });
+                }
+                if (server.server.transport === oldTransport && oldTransport.onclose !== void 0) {
+                  logger5.info(
+                    "Manually invoking oldTransport.onclose() to clear Protocol state in /mcp"
+                  );
+                  oldTransport.onclose();
+                }
+                delete oldTransport.onclose;
+              }
+              logger5.info("Attempting server.connect(newTransport)");
+              await server.connect(
+                newTransport
+              );
+              logger5.info("server.connect succeeded in /mcp");
+            } finally {
+              release();
+            }
+          });
           await newTransport.handleRequest(
             asIncoming(req),
             asServerResponse(res),
@@ -549,7 +514,7 @@ function setupStatefulEndpoints(state) {
           );
         }
       } catch (error) {
-        logger3.error("Error handling MCP request", {
+        logger5.error("Error handling MCP request", {
           code: ERROR_CODES.SERVER.TRANSPORT_ERROR.full,
           error: error instanceof Error ? error : void 0
         });
@@ -568,44 +533,62 @@ function setupStatefulEndpoints(state) {
   });
   state.app.get("/mcp", (req, res) => {
     const sessionId = req.headers["mcp-session-id"];
-    if (sessionId === void 0 || !state.transports.has(sessionId)) {
+    if (sessionId === void 0 || !isValidSessionId(sessionId)) {
+      res.status(400).send("Invalid or missing session ID");
+      return;
+    }
+    const httpTransport = state.transports.get(sessionId);
+    if (httpTransport === void 0) {
       res.status(400).send("Invalid or missing session ID");
       return;
     }
+    if (!verifySessionOwner(state, sessionId, req.auth?.sub)) {
+      res.status(403).send("Forbidden: session belongs to a different client");
+      return;
+    }
     const lastEventId = req.headers["last-event-id"];
     if (lastEventId !== void 0) {
-      logger3.debug("Client reconnecting with Last-Event-ID", {
+      logger5.debug("Client reconnecting with Last-Event-ID", {
         code: "HTTP_SSE_RECONNECT",
         sessionId,
         lastEventId
       });
     }
-    const httpTransport = state.transports.get(sessionId);
     if (httpTransport !== void 0) {
       void httpTransport.handleRequest(asIncoming(req), asServerResponse(res));
     }
   });
   state.app.delete("/mcp", (req, res) => {
     const sessionId = req.headers["mcp-session-id"];
-    if (sessionId === void 0 || !state.transports.has(sessionId)) {
+    if (sessionId === void 0 || !isValidSessionId(sessionId)) {
+      res.status(400).send("Invalid or missing session ID");
+      return;
+    }
+    const httpTransport = state.transports.get(sessionId);
+    if (httpTransport === void 0) {
       res.status(400).send("Invalid or missing session ID");
       return;
     }
-    logger3.info("Session termination requested", {
+    if (!verifySessionOwner(state, sessionId, req.auth?.sub)) {
+      res.status(403).send("Forbidden: session belongs to a different client");
+      return;
+    }
+    logger5.info("Session termination requested", {
       code: "HTTP_SESSION_DELETE",
       sessionId
     });
-    const httpTransport = state.transports.get(sessionId);
     if (httpTransport !== void 0) {
       void httpTransport.handleRequest(asIncoming(req), asServerResponse(res));
     }
   });
 }
+var logger6 = createModuleLogger("HTTP");
+var connectionMutex2 = new Mutex();
 function setupLegacySSEEndpoints(state) {
   if (!state.app || !state.mcpServer) return;
   const server = state.mcpServer;
   state.app.get("/sse", (req, res) => {
-    logger3.info("Legacy SSE connection requested", {
+    logger6.info("Legacy SSE connection requested", {
       code: "SSE_CONNECT"
     });
     const sseTransport = new SSEServerTransport(
@@ -615,25 +598,63 @@ function setupLegacySSEEndpoints(state) {
     void (async () => {
       try {
         state.sseTransports.set(sseTransport.sessionId, sseTransport);
+        state.sessionOwners.set(sseTransport.sessionId, req.auth?.sub);
         sseTransport.onclose = () => {
-          logger3.info("Legacy SSE transport closed", {
+          logger6.info("Legacy SSE transport closed", {
             code: "SSE_CLOSE",
             sessionId: sseTransport.sessionId
           });
           state.sseTransports.delete(sseTransport.sessionId);
+          state.sessionOwners.delete(sseTransport.sessionId);
         };
-        try {
-          await server.connect(
-            sseTransport
-          );
-        } catch {
-          await server.close();
-          await server.connect(
-            sseTransport
-          );
-        }
+        const origSend = sseTransport.send.bind(sseTransport);
+        sseTransport.send = async (message) => {
+          logger6.debug("SSE SEND", {
+            sessionId: sseTransport.sessionId
+          });
+          return origSend(message);
+        };
+        await connectionMutex2.acquire().then(async (release) => {
+          try {
+            if (server.server.transport) {
+              const oldTransport = server.server.transport;
+              logger6.info("Captured oldTransport", {
+                hasOldTransport: oldTransport !== void 0,
+                hasOnclose: oldTransport.onclose !== void 0
+              });
+              try {
+                await Promise.race([
+                  server.close(),
+                  new Promise(
+                    (_, reject) => setTimeout(
+                      () => reject(new Error("server.close timeout")),
+                      2e3
+                    )
+                  )
+                ]);
+                logger6.info("server.close() succeeded");
+              } catch (closeErr) {
+                logger6.error("server.close() failed or timed out", {
+                  error: closeErr instanceof Error ? closeErr : new Error(String(closeErr))
+                });
+              }
+              if (server.server.transport === oldTransport && oldTransport.onclose !== void 0) {
+                logger6.info(
+                  "Manually invoking oldTransport.onclose() to clear Protocol state"
+                );
+                oldTransport.onclose();
+              }
+              delete oldTransport.onclose;
+            }
+            logger6.info("Attempting server.connect(sseTransport)");
+            await server.connect(sseTransport);
+            logger6.info("server.connect succeeded");
+          } finally {
+            release();
+          }
+        });
       } catch (error) {
-        logger3.error("Error starting SSE transport", {
+        logger6.error("Error starting SSE transport", {
           code: ERROR_CODES.SERVER.TRANSPORT_ERROR.full,
           error: error instanceof Error ? error : void 0
         });
@@ -644,6 +665,7 @@ function setupLegacySSEEndpoints(state) {
     })();
     req.on("close", () => {
       state.sseTransports.delete(sseTransport.sessionId);
+      state.sessionOwners.delete(sseTransport.sessionId);
     });
   });
   state.app.post("/messages", (req, res) => {
@@ -671,16 +693,33 @@ function setupLegacySSEEndpoints(state) {
       });
       return;
     }
+    if (!verifySessionOwner(state, sessionId, req.auth?.sub)) {
+      res.status(403).json({
+        jsonrpc: "2.0",
+        error: {
+          code: JSONRPC_SERVER_ERROR,
+          message: "Forbidden: session belongs to a different client"
+        },
+        id: null
+      });
+      return;
+    }
     void sseTransport.handlePostMessage(
       asIncoming(req),
       asServerResponse(res),
       req.body
-    );
+    ).then(() => {
+      logger6.info("handlePostMessage completed", { sessionId });
+    }).catch((e) => {
+      logger6.error("handlePostMessage error", {
+        error: e instanceof Error ? e : new Error(String(e))
+      });
+    });
   });
 }
 
 // src/auth/oauth-resource-server.ts
-var logger4 = createModuleLogger("AUTH");
+var logger7 = createModuleLogger("AUTH");
 var OAuthResourceServer = class {
   config;
   metadata = null;
@@ -691,7 +730,7 @@ var OAuthResourceServer = class {
       scopesSupported: config.scopesSupported.length > 0 ? config.scopesSupported : [...SUPPORTED_SCOPES],
       bearerMethodsSupported: config.bearerMethodsSupported ?? ["header"]
     };
-    logger4.info(
+    logger7.info(
       `OAuth Resource Server initialized for: ${this.config.resource}`,
       { code: "AUTH_INIT" }
     );
@@ -729,7 +768,7 @@ var OAuthResourceServer = class {
       res.setHeader("Content-Type", "application/json");
       res.setHeader("Cache-Control", "public, max-age=3600");
       res.json(metadata);
-      logger4.info("Protected Resource Metadata served", {
+      logger7.info("Protected Resource Metadata served", {
         code: "AUTH_METADATA_SERVED"
       });
     };
@@ -747,7 +786,8 @@ var OAuthResourceServer = class {
       parts.push(`error="${error}"`);
     }
     if (errorDescription) {
-      parts.push(`error_description="${errorDescription}"`);
+      const safe = errorDescription.replace(/"/g, "'").substring(0, 200);
+      parts.push(`error_description="${safe}"`);
     }
     return parts.join(", ");
   }
@@ -780,12 +820,6 @@ var OAuthResourceServer = class {
     if (this.config.scopesSupported.includes(scope)) {
       return true;
     }
-    if (SCOPE_PATTERNS.DATABASE.test(scope)) {
-      return true;
-    }
-    if (SCOPE_PATTERNS.TABLE.test(scope)) {
-      return true;
-    }
     return false;
   }
   /**
@@ -803,7 +837,7 @@ var OAuthResourceServer = class {
 };
 
 // src/auth/authorization-server-discovery.ts
-var logger5 = createModuleLogger("AUTH");
+var logger8 = createModuleLogger("AUTH");
 var AuthorizationServerDiscovery = class {
   authServerUrl;
   cacheTtl;
@@ -814,7 +848,16 @@ var AuthorizationServerDiscovery = class {
     this.authServerUrl = config.authServerUrl.replace(/\/+$/, "");
     this.cacheTtl = config.cacheTtl ?? 3600;
     this.timeout = config.timeout ?? 5e3;
-    logger5.info(
+    if (!this.authServerUrl.startsWith("https://") && process.env["NODE_ENV"] !== "development" && process.env["NODE_ENV"] !== "test") {
+      const url = new URL(this.authServerUrl);
+      const isLocalDev = url.hostname === "localhost" || url.hostname === "127.0.0.1" || url.hostname === "[::1]";
+      if (!isLocalDev) {
+        throw new Error(
+          `Security: Authorization server URL must use HTTPS in production. Got: ${this.authServerUrl}. Set NODE_ENV=development to allow HTTP for local testing.`
+        );
+      }
+    }
+    logger8.info(
       `Authorization Server Discovery initialized for: ${this.authServerUrl}`,
       { code: "AUTH_INIT" }
     );
@@ -830,13 +873,13 @@ var AuthorizationServerDiscovery = class {
    */
   async discover() {
     if (this.cachedMetadata && Date.now() < this.cacheExpiry) {
-      logger5.info("Using cached authorization server metadata", {
+      logger8.info("Using cached authorization server metadata", {
         code: "AUTH_CACHE_HIT"
       });
       return this.cachedMetadata;
     }
     const metadataUrl = `${this.authServerUrl}/.well-known/oauth-authorization-server`;
-    logger5.info(`Fetching authorization server metadata from: ${metadataUrl}`, {
+    logger8.info(`Fetching authorization server metadata from: ${metadataUrl}`, {
       code: "AUTH_DISCOVERY"
     });
     try {
@@ -861,14 +904,14 @@ var AuthorizationServerDiscovery = class {
       this.validateMetadata(metadata);
       this.cachedMetadata = metadata;
       this.cacheExpiry = Date.now() + this.cacheTtl * 1e3;
-      logger5.info(
+      logger8.info(
         `Authorization server metadata cached for ${String(this.cacheTtl)}s`,
         { code: "AUTH_DISCOVERY_SUCCESS" }
       );
       return metadata;
     } catch (error) {
       const cause = error instanceof Error ? error : new Error(String(error));
-      logger5.error(
+      logger8.error(
         `Failed to discover authorization server: ${this.authServerUrl}`,
         {
           code: ERROR_CODES.AUTH.DISCOVERY_FAILED.full,
@@ -898,11 +941,22 @@ var AuthorizationServerDiscovery = class {
         "validation" /* VALIDATION */
       );
     }
+    try {
+      new URL(metadata.issuer);
+      new URL(metadata.token_endpoint);
+    } catch {
+      throw new DbMcpError(
+        "Invalid URL format in metadata fields",
+        "AUTH_DISCOVERY_INVALID",
+        "validation" /* VALIDATION */
+      );
+    }
     const expectedIssuer = this.authServerUrl;
     if (metadata.issuer !== expectedIssuer) {
-      logger5.warning(
-        `Issuer mismatch: expected ${expectedIssuer}, got ${metadata.issuer}`,
-        { code: "AUTH_ISSUER_MISMATCH" }
+      throw new DbMcpError(
+        `Issuer validation failed. Per RFC 8414 \xA73.3, the issuer MUST be identical to the authorization server URL.`,
+        "AUTH_ISSUER_MISMATCH",
+        "validation" /* VALIDATION */
       );
     }
   }
@@ -980,7 +1034,7 @@ var AuthorizationServerDiscovery = class {
   clearCache() {
     this.cachedMetadata = null;
     this.cacheExpiry = 0;
-    logger5.info("Authorization server metadata cache cleared", {
+    logger8.info("Authorization server metadata cache cleared", {
       code: "AUTH_CACHE_CLEARED"
     });
   }
@@ -997,23 +1051,43 @@ var AuthorizationServerDiscovery = class {
     return this.authServerUrl;
   }
 };
-var logger6 = createModuleLogger("AUTH");
-var TokenValidator = class {
+var logger9 = createModuleLogger("AUTH");
+var TokenValidator = class _TokenValidator {
+  /** Default algorithms accepted when none are explicitly configured */
+  static DEFAULT_ALGORITHMS = [
+    "RS256",
+    "RS384",
+    "RS512",
+    "ES256",
+    "ES384",
+    "ES512"
+  ];
   /** Resolved configuration with all defaults applied */
   jwksUri;
   issuer;
   audience;
   clockTolerance;
   jwksCacheTtl;
+  algorithms;
   jwks = null;
   jwksExpiry = 0;
   constructor(config) {
+    if (config.jwksUri && !config.jwksUri.startsWith("https://") && process.env["ALLOW_HTTP_JWKS"] !== "true") {
+      const url = new URL(config.jwksUri);
+      const isLocalDev = url.hostname === "localhost" || url.hostname === "127.0.0.1";
+      if (!isLocalDev) {
+        throw new Error(
+          `Security: JWKS URI must use HTTPS in production. Got: ${config.jwksUri}. Set ALLOW_HTTP_JWKS=true to allow HTTP for local testing.`
+        );
+      }
+    }
     this.jwksUri = config.jwksUri;
     this.issuer = config.issuer;
     this.audience = config.audience;
-    this.clockTolerance = config.clockTolerance ?? 60;
+    this.clockTolerance = config.clockTolerance ?? 30;
     this.jwksCacheTtl = config.jwksCacheTtl ?? 3600;
-    logger6.info(`Token Validator initialized for issuer: ${this.issuer}`, {
+    this.algorithms = config.algorithms ?? _TokenValidator.DEFAULT_ALGORITHMS;
+    logger9.info(`Token Validator initialized for issuer: ${this.issuer}`, {
       code: "AUTH_INIT"
     });
   }
@@ -1029,10 +1103,11 @@ var TokenValidator = class {
       const { payload } = await jose.jwtVerify(token, jwks, {
         issuer: this.issuer,
         audience: this.audience,
-        clockTolerance: this.clockTolerance
+        clockTolerance: this.clockTolerance,
+        algorithms: this.algorithms
       });
       const claims = this.extractClaims(payload);
-      logger6.info(`Token validated for subject: ${claims.sub}`, {
+      logger9.info(`Token validated for subject: ${claims.sub}`, {
         code: "AUTH_TOKEN_VALID",
         sub: claims.sub,
         scopes: claims.scopes.length,
@@ -1053,7 +1128,7 @@ var TokenValidator = class {
     if (this.jwks && Date.now() < this.jwksExpiry) {
       return this.jwks;
     }
-    logger6.info(`Fetching JWKS from: ${this.jwksUri}`, {
+    logger9.debug(`Fetching JWKS from: ${this.jwksUri}`, {
       code: "AUTH_JWKS_FETCH"
     });
     try {
@@ -1063,13 +1138,13 @@ var TokenValidator = class {
         cacheMaxAge: this.jwksCacheTtl * 1e3
       });
       this.jwksExpiry = Date.now() + this.jwksCacheTtl * 1e3;
-      logger6.info(`JWKS cached for ${String(this.jwksCacheTtl)}s`, {
+      logger9.info(`JWKS cached for ${String(this.jwksCacheTtl)}s`, {
         code: "AUTH_JWKS_CACHED"
       });
       return this.jwks;
     } catch (error) {
       const cause = error instanceof Error ? error : new Error(String(error));
-      logger6.error(`Failed to fetch JWKS: ${this.jwksUri}`, {
+      logger9.error(`Failed to fetch JWKS: ${this.jwksUri}`, {
         code: ERROR_CODES.AUTH.JWKS_FETCH_FAILED.full,
         error: cause
       });
@@ -1092,18 +1167,25 @@ var TokenValidator = class {
         (s) => typeof s === "string"
       );
     }
+    const safePayload = {};
+    for (const key of Object.keys(payload)) {
+      if (key !== "__proto__" && key !== "constructor" && key !== "prototype" && key !== "valueOf" && key !== "toString" && key !== "hasOwnProperty") {
+        safePayload[key] = payload[key];
+      }
+    }
     return {
-      sub: payload.sub ?? "unknown",
+      // Include all other claims (prototype-polluting keys filtered above)
+      ...safePayload,
+      // Explicitly set authoritative fields last to prevent override via safePayload
+      sub: safePayload.sub ?? "unknown",
       scopes,
-      exp: payload.exp ?? 0,
-      iat: payload.iat ?? 0,
-      iss: payload.iss,
-      aud: payload.aud,
-      nbf: payload.nbf ?? void 0,
-      jti: payload.jti,
-      client_id: payload["client_id"],
-      // Include all other claims
-      ...payload
+      exp: safePayload.exp ?? 0,
+      iat: safePayload.iat ?? 0,
+      iss: safePayload.iss,
+      aud: safePayload.aud,
+      nbf: safePayload.nbf ?? void 0,
+      jti: safePayload.jti,
+      client_id: safePayload["client_id"]
     };
   }
   /**
@@ -1111,7 +1193,7 @@ var TokenValidator = class {
    */
   handleValidationError(error) {
     if (error instanceof jose.errors.JWTExpired) {
-      logger6.warning("Token has expired", {
+      logger9.warning("Token has expired", {
         code: ERROR_CODES.AUTH.TOKEN_EXPIRED.full,
         error
       });
@@ -1122,18 +1204,18 @@ var TokenValidator = class {
       };
     }
     if (error instanceof jose.errors.JWTClaimValidationFailed) {
-      logger6.warning(`Token claim validation failed: ${error.message}`, {
+      logger9.warning(`Token claim validation failed: ${error.message}`, {
         code: ERROR_CODES.AUTH.TOKEN_INVALID.full,
         error
       });
       return {
         valid: false,
-        error: `Token claim validation failed: ${error.message}`,
+        error: "Token claim validation failed",
         errorCode: ERROR_CODES.AUTH.TOKEN_INVALID.full
       };
     }
     if (error instanceof jose.errors.JWSSignatureVerificationFailed) {
-      logger6.warning("Token signature verification failed", {
+      logger9.warning("Token signature verification failed", {
         code: ERROR_CODES.AUTH.SIGNATURE_INVALID.full,
         error
       });
@@ -1144,7 +1226,7 @@ var TokenValidator = class {
       };
     }
     if (error instanceof jose.errors.JWKSNoMatchingKey) {
-      logger6.warning("No matching key found in JWKS", {
+      logger9.warning("No matching key found in JWKS", {
         code: ERROR_CODES.AUTH.TOKEN_INVALID.full,
         error
       });
@@ -1155,13 +1237,13 @@ var TokenValidator = class {
       };
     }
     const message = error instanceof Error ? error.message : String(error);
-    logger6.error(`Token validation failed: ${message}`, {
+    logger9.error(`Token validation failed: ${message}`, {
       code: ERROR_CODES.AUTH.TOKEN_INVALID.full,
       error: error instanceof Error ? error : void 0
     });
     return {
       valid: false,
-      error: `Token validation failed: ${message}`,
+      error: "Token validation failed",
       errorCode: ERROR_CODES.AUTH.TOKEN_INVALID.full
     };
   }
@@ -1172,7 +1254,7 @@ var TokenValidator = class {
     this.jwks = null;
     this.jwksExpiry = 0;
     this.getJwks();
-    logger6.info("JWKS cache refreshed", { code: "AUTH_JWKS_REFRESHED" });
+    logger9.info("JWKS cache refreshed", { code: "AUTH_JWKS_REFRESHED" });
   }
   /**
    * Clear the JWKS cache
@@ -1180,7 +1262,7 @@ var TokenValidator = class {
   clearCache() {
     this.jwks = null;
     this.jwksExpiry = 0;
-    logger6.info("Token validator cache cleared", {
+    logger9.info("Token validator cache cleared", {
       code: "AUTH_CACHE_CLEARED"
     });
   }
@@ -1199,8 +1281,15 @@ var TokenValidator = class {
 };
 
 // src/transports/http/oauth.ts
-var logger7 = createModuleLogger("HTTP");
+var logger10 = createModuleLogger("HTTP");
 function applyAuthMiddleware(state) {
+  const corsOrigins = state.config.corsOrigins ?? [];
+  const isPubliclyExposed = state.config.oauth.enabled || state.config.noAuthEnforcement;
+  if (corsOrigins.includes("*") && isPubliclyExposed) {
+    throw new Error(
+      "Security: CORS wildcard origin ('*') is forbidden when authentication is enabled or enforcement is explicitly disabled. Configure explicit origins via --cors-origins for production deployments."
+    );
+  }
   if (state.config.oauth.enabled && state.tokenValidator && state.resourceServer && state.app) {
     const authMiddleware = createAuthMiddleware({
       tokenValidator: state.tokenValidator,
@@ -1208,56 +1297,148 @@ function applyAuthMiddleware(state) {
       publicPaths: ["/health", ...state.config.oauth.publicPaths ?? []]
     });
     state.app.use(authMiddleware);
-  } else if (state.config.authToken && state.app) {
-    state.app.use(createSimpleBearerAuth(state.config.authToken));
-    logger7.info("Simple bearer token authentication enabled", {
-      code: "AUTH_BEARER_ENABLED"
-    });
   } else if (state.app) {
-    logger7.warning(
-      "No authentication configured for HTTP transport. Set --auth-token or --oauth-enabled for production deployments.",
+    logger10.warning(
+      "No authentication configured for HTTP transport. Set --oauth-enabled for production deployments.",
       { code: "AUTH_NONE" }
     );
   }
 }
-function createSimpleBearerAuth(expectedToken) {
-  const publicPaths = ["/health", "/", "/.well-known"];
-  return (req, res, next) => {
-    if (publicPaths.some((p) => req.path === p || req.path.startsWith(`${p}/`))) {
+function applyScopeEnforcementMiddleware(state) {
+  if (!state.app) return;
+  state.app.use((req, res, next) => {
+    const body = req.body;
+    if (req.method !== "POST") {
       next();
       return;
     }
-    const authHeader = req.headers.authorization;
-    if (!authHeader?.startsWith("Bearer ")) {
-      res.status(401);
-      res.setHeader("WWW-Authenticate", 'Bearer realm="db-mcp"');
-      res.json({
-        error: "unauthorized",
-        error_description: "Bearer token required"
+    const contentType = req.headers["content-type"]?.split(";")[0]?.trim();
+    if (contentType !== "application/json") {
+      res.status(400).json({
+        error: "invalid_request",
+        error_description: "Content-Type must be exactly application/json"
       });
       return;
     }
-    const token = authHeader.slice(7);
-    if (token !== expectedToken) {
-      logger7.warning("Invalid bearer token rejected", {
-        code: "AUTH_BEARER_REJECTED"
-      });
-      res.status(401);
-      res.setHeader(
-        "WWW-Authenticate",
-        'Bearer realm="db-mcp", error="invalid_token"'
-      );
-      res.json({
-        error: "unauthorized",
-        error_description: "Invalid bearer token"
+    if (Array.isArray(body)) {
+      res.status(400).json({
+        error: "invalid_request",
+        error_description: "Batch JSON-RPC requests are not supported"
       });
       return;
     }
+    if (!req.auth) {
+      next();
+      return;
+    }
+    const rpcMethod = body?.method;
+    if (rpcMethod === "tools/list") {
+      const originalJson = res.json;
+      const scopes = req.auth.scopes;
+      const isRecord = (val) => typeof val === "object" && val !== null && !Array.isArray(val);
+      res.json = function(data) {
+        if (isRecord(data) && isRecord(data["result"]) && Array.isArray(data["result"]["tools"])) {
+          data["result"]["tools"] = data["result"]["tools"].filter(
+            (tool) => {
+              if (isRecord(tool) && typeof tool["name"] === "string") {
+                return scopesGrantToolAccess(scopes, tool["name"]);
+              }
+              return false;
+            }
+          );
+        }
+        return originalJson.call(this, data);
+      };
+      next();
+      return;
+    }
+    if (rpcMethod === "tools/call") {
+      const toolName = body?.params?.name;
+      if (!toolName) {
+        next();
+        return;
+      }
+      const hasAccess = scopesGrantToolAccess(req.auth.scopes, toolName);
+      if (!hasAccess) {
+        const error = new InsufficientScopeError(
+          `Tool access: ${toolName}`,
+          req.auth.scopes
+        );
+        logger10.warning(`Insufficient scope for tool: ${toolName}`, {
+          code: ERROR_CODES.AUTH.SCOPE_DENIED.full,
+          toolName,
+          providedScopes: req.auth.scopes
+        });
+        res.status(error.httpStatus);
+        if (error.wwwAuthenticate) {
+          res.setHeader("WWW-Authenticate", error.wwwAuthenticate);
+        }
+        res.json({
+          error: "insufficient_scope",
+          error_description: `Access to tool '${toolName}' denied`,
+          tool: toolName
+        });
+        return;
+      }
+    } else if (rpcMethod === "resources/read") {
+      const resourceUri = body?.params?.uri ?? "";
+      const requiredScope = resourceUri.startsWith("sqlite://audit") ? "admin" : "read";
+      const hasAccess = requiredScope === "admin" ? hasAdminScope(req.auth.scopes) : hasReadScope(req.auth.scopes);
+      if (!hasAccess) {
+        const error = new InsufficientScopeError(
+          `Resource access: ${resourceUri}`,
+          req.auth.scopes
+        );
+        logger10.warning(`Insufficient scope for resource: ${resourceUri}`, {
+          code: ERROR_CODES.AUTH.SCOPE_DENIED.full,
+          resourceUri,
+          requiredScope,
+          providedScopes: req.auth.scopes
+        });
+        res.status(error.httpStatus);
+        if (error.wwwAuthenticate) {
+          res.setHeader("WWW-Authenticate", error.wwwAuthenticate);
+        }
+        res.json({
+          error: "insufficient_scope",
+          error_description: `Access to resource '${resourceUri}' requires '${requiredScope}' scope`
+        });
+        return;
+      }
+    } else if (rpcMethod === "prompts/get") {
+      const hasAccess = hasReadScope(req.auth.scopes);
+      if (!hasAccess) {
+        const promptName = body?.params?.name ?? "unknown";
+        const error = new InsufficientScopeError(
+          `Prompt access: ${promptName}`,
+          req.auth.scopes
+        );
+        logger10.warning(`Insufficient scope for prompt: ${promptName}`, {
+          code: ERROR_CODES.AUTH.SCOPE_DENIED.full,
+          promptName,
+          providedScopes: req.auth.scopes
+        });
+        res.status(error.httpStatus);
+        if (error.wwwAuthenticate) {
+          res.setHeader("WWW-Authenticate", error.wwwAuthenticate);
+        }
+        res.json({
+          error: "insufficient_scope",
+          error_description: `Access to prompt '${promptName}' requires 'read' scope`
+        });
+        return;
+      }
+    }
     next();
-  };
+  });
 }
 async function setupOAuth(state, resourceUri) {
-  logger7.info("Setting up OAuth 2.1...", { code: "HTTP_OAUTH_SETUP" });
+  logger10.info("Setting up OAuth 2.1...", { code: "HTTP_OAUTH_SETUP" });
+  if (state.config.oauth.enabled && !state.config.oauth.audience) {
+    throw new Error(
+      "Security: OAuth audience must be explicitly configured when OAuth is enabled."
+    );
+  }
   state.resourceServer = new OAuthResourceServer({
     resource: resourceUri,
     authorizationServers: [state.config.oauth.authorizationServerUrl],
@@ -1278,25 +1459,25 @@ async function setupOAuth(state, resourceUri) {
       audience: state.config.oauth.audience,
       clockTolerance: state.config.oauth.clockTolerance
     });
-    logger7.info("OAuth 2.1 setup complete", { code: "HTTP_OAUTH_READY" });
+    logger10.info("OAuth 2.1 setup complete", { code: "HTTP_OAUTH_READY" });
   } catch (error) {
-    logger7.warning(
+    logger10.warning(
       "Authorization server discovery failed. OAuth validation disabled.",
       {
         code: ERROR_CODES.AUTH.DISCOVERY_FAILED.full,
         error: error instanceof Error ? error : void 0
       }
     );
-    if (!state.config.oauth.jwksUri) {
-      logger7.error(
-        "No JWKS URI available. Please provide oauth.jwksUri in config.",
+    if (!state.config.oauth.jwksUri || !state.config.oauth.issuer) {
+      logger10.error(
+        "OAuth discovery failed and explicit jwksUri/issuer were not provided. Hard failing to prevent spoofed token acceptance.",
         { code: ERROR_CODES.AUTH.DISCOVERY_FAILED.full }
       );
       throw error;
     }
     state.tokenValidator = new TokenValidator({
       jwksUri: state.config.oauth.jwksUri,
-      issuer: state.config.oauth.issuer ?? state.config.oauth.authorizationServerUrl,
+      issuer: state.config.oauth.issuer,
       audience: state.config.oauth.audience,
       clockTolerance: state.config.oauth.clockTolerance
     });
@@ -1304,7 +1485,7 @@ async function setupOAuth(state, resourceUri) {
 }
 
 // src/transports/http/transport.ts
-var logger8 = createModuleLogger("HTTP");
+var logger11 = createModuleLogger("HTTP");
 var HttpTransport = class {
   /** Internal state shared with session/middleware/oauth modules */
   state;
@@ -1312,7 +1493,7 @@ var HttpTransport = class {
     this.state = {
       config: {
         ...config,
-        host: config.host ?? "0.0.0.0",
+        host: config.host ?? "127.0.0.1",
         stateless: config.stateless ?? false,
         enableHSTS: config.enableHSTS ?? process.env["MCP_ENABLE_HSTS"] === "true"
       },
@@ -1320,13 +1501,12 @@ var HttpTransport = class {
       httpServer: null,
       transports: /* @__PURE__ */ new Map(),
       sseTransports: /* @__PURE__ */ new Map(),
+      sessionOwners: /* @__PURE__ */ new Map(),
       statelessTransport: null,
       resourceServer: null,
       authServerDiscovery: null,
       tokenValidator: null,
-      mcpServer: null,
-      rateLimitMap: /* @__PURE__ */ new Map(),
-      rateLimitCleanupTimer: null
+      mcpServer: null
     };
   }
   /**
@@ -1338,13 +1518,25 @@ var HttpTransport = class {
    * @param server - The MCP server instance
    */
   async initialize(server) {
-    logger8.info("Initializing HTTP transport...", {
+    logger11.info("Initializing HTTP transport...", {
       code: "HTTP_INIT",
       stateless: this.state.config.stateless
     });
     this.state.mcpServer = server;
     this.state.app = express();
     this.state.app.use(localhostHostValidation());
+    if (this.state.config.trustedProxyIps !== void 0) {
+      if (Array.isArray(this.state.config.trustedProxyIps) && this.state.config.trustedProxyIps.length === 0) {
+        throw new DbMcpError(
+          "trustedProxyIps cannot be an empty array if specified",
+          "CONFIG_ERROR",
+          "config" /* CONFIGURATION */
+        );
+      }
+      this.state.app.set("trust proxy", this.state.config.trustedProxyIps);
+    } else {
+      this.state.app.set("trust proxy", false);
+    }
     setupSecurityHeaders(this.state);
     setupCors(this.state);
     setupRateLimiting(this.state);
@@ -1353,17 +1545,32 @@ var HttpTransport = class {
       express.json({ limit: maxBodyBytes })
     );
     const resourceUri = this.state.config.resourceUri ?? `http://localhost:${String(this.state.config.port)}`;
+    if (!this.state.config.oauth.enabled && !this.state.config.noAuthEnforcement) {
+      throw new DbMcpError(
+        "HTTP transport is enabled without authentication. You must configure OAuth (--oauth-enabled) or explicitly bypass this check with --no-auth-enforcement.",
+        "AUTH_REQUIRED",
+        "config" /* CONFIGURATION */
+      );
+    }
     if (this.state.config.oauth.enabled) {
+      if (resourceUri.startsWith("http://") && !resourceUri.includes("localhost") && !resourceUri.includes("127.0.0.1")) {
+        logger11.warning(
+          "Security Warning (F09): OAuth is enabled but resource URI is not using HTTPS. A TLS-terminating reverse proxy is required in production."
+        );
+      }
       await setupOAuth(this.state, resourceUri);
     }
-    this.state.app.get("/health", (_req, res) => {
-      res.json({
+    this.state.app.get("/health", (req, res) => {
+      const response = {
         status: "healthy",
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        oauth: this.state.config.oauth.enabled,
-        mode: this.state.config.stateless ? "stateless" : "stateful",
-        activeSessions: this.state.transports.size
-      });
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      if (req.auth) {
+        response["oauth"] = this.state.config.oauth.enabled;
+        response["mode"] = this.state.config.stateless ? "stateless" : "stateful";
+        response["activeSessions"] = this.state.transports.size;
+      }
+      res.json(response);
     });
     this.state.app.get("/", (_req, res) => {
       res.json({
@@ -1382,6 +1589,31 @@ var HttpTransport = class {
       });
     });
     applyAuthMiddleware(this.state);
+    applyScopeEnforcementMiddleware(this.state);
+    const oauthEnabled = this.state.config.oauth?.enabled ?? false;
+    let lastNoAuthWarning = 0;
+    this.state.app.use((req, _res, next) => {
+      const implicitAdmin = !req.auth && !oauthEnabled;
+      if (implicitAdmin) {
+        const now = Date.now();
+        if (now - lastNoAuthWarning > 6e4) {
+          logger11.warning(
+            "No-auth mode is granting implicit 'admin' scope. This is expected for local dev but dangerous in production.",
+            { module: "HTTP", ip: req.ip }
+          );
+          lastNoAuthWarning = now;
+        }
+      }
+      const authCtx = {
+        authenticated: !!req.auth || !oauthEnabled,
+        claims: req.auth,
+        scopes: req.auth?.scopes ?? (implicitAdmin ? ["admin"] : []),
+        clientIp: req.ip
+      };
+      runWithAuthContext(authCtx, () => {
+        next();
+      });
+    });
     if (this.state.config.stateless) {
       await setupStatelessEndpoints(this.state);
     } else {
@@ -1394,7 +1626,7 @@ var HttpTransport = class {
     this.state.app.use((_req, res) => {
       res.status(404).json({ error: "Not found" });
     });
-    logger8.info("HTTP transport initialized", {
+    logger11.info("HTTP transport initialized", {
       code: "HTTP_INIT_COMPLETE",
       port: this.state.config.port,
       oauth: this.state.config.oauth.enabled,
@@ -1417,15 +1649,15 @@ var HttpTransport = class {
       try {
         this.state.httpServer = this.state.app?.listen(
           this.state.config.port,
-          this.state.config.host ?? "0.0.0.0",
+          this.state.config.host ?? "127.0.0.1",
           () => {
             if (this.state.httpServer) {
               this.state.httpServer.setTimeout(HTTP_REQUEST_TIMEOUT_MS);
               this.state.httpServer.keepAliveTimeout = HTTP_KEEP_ALIVE_TIMEOUT_MS;
               this.state.httpServer.headersTimeout = HTTP_HEADERS_TIMEOUT_MS;
             }
-            logger8.info(
-              `HTTP server listening on ${this.state.config.host ?? "0.0.0.0"}:${String(this.state.config.port)}`,
+            logger11.info(
+              `HTTP server listening on ${this.state.config.host ?? "127.0.0.1"}:${String(this.state.config.port)}`,
               {
                 code: "HTTP_SERVER_STARTED",
                 mode: this.state.config.stateless ? "stateless" : "stateful"
@@ -1435,7 +1667,7 @@ var HttpTransport = class {
           }
         ) ?? null;
         this.state.httpServer?.on("error", (error) => {
-          logger8.error("Failed to start HTTP server", {
+          logger11.error("Failed to start HTTP server", {
             code: ERROR_CODES.SERVER.START_FAILED.full,
             error
           });
@@ -1450,19 +1682,15 @@ var HttpTransport = class {
    * Stop the server and close all active sessions
    */
   async stop() {
-    if (this.state.rateLimitCleanupTimer) {
-      clearInterval(this.state.rateLimitCleanupTimer);
-      this.state.rateLimitCleanupTimer = null;
-    }
     for (const [sessionId, transport] of this.state.transports) {
       try {
-        logger8.debug("Closing transport", {
+        logger11.debug("Closing transport", {
           code: "HTTP_SESSION_CLEANUP",
           sessionId
         });
         await transport.close();
       } catch (error) {
-        logger8.error("Error closing transport", {
+        logger11.error("Error closing transport", {
           code: ERROR_CODES.SERVER.SHUTDOWN_FAILED.full,
           sessionId,
           error: error instanceof Error ? error : void 0
@@ -1470,15 +1698,16 @@ var HttpTransport = class {
       }
     }
     this.state.transports.clear();
+    this.state.sessionOwners.clear();
     for (const [sessionId, transport] of this.state.sseTransports) {
       try {
-        logger8.debug("Closing SSE transport", {
+        logger11.debug("Closing SSE transport", {
           code: "SSE_SESSION_CLEANUP",
           sessionId
         });
         await transport.close();
       } catch (error) {
-        logger8.error("Error closing SSE transport", {
+        logger11.error("Error closing SSE transport", {
           code: ERROR_CODES.SERVER.SHUTDOWN_FAILED.full,
           sessionId,
           error: error instanceof Error ? error : void 0
@@ -1490,7 +1719,7 @@ var HttpTransport = class {
       try {
         await this.state.statelessTransport.close();
       } catch (error) {
-        logger8.error("Error closing stateless transport", {
+        logger11.error("Error closing stateless transport", {
           code: ERROR_CODES.SERVER.SHUTDOWN_FAILED.full,
           error: error instanceof Error ? error : void 0
         });
@@ -1503,13 +1732,13 @@ var HttpTransport = class {
       }
       this.state.httpServer.close((error) => {
         if (error) {
-          logger8.error("Error stopping HTTP server", {
+          logger11.error("Error stopping HTTP server", {
             code: ERROR_CODES.SERVER.SHUTDOWN_FAILED.full,
             error
           });
           reject(error);
         } else {
-          logger8.info("HTTP server stopped", { code: "HTTP_SERVER_STOPPED" });
+          logger11.info("HTTP server stopped", { code: "HTTP_SERVER_STOPPED" });
           resolve();
         }
       });