@adrata/adrata-mcp 1.0.0

package/toolsets/revenue/sloan-tools.js

@@ -0,0 +1,81 @@
+// ---------------------------------------------------------------------------
+// Sloan (AI executive assistant) tools — Wave 3 chat-native management suite.
+//
+// Thin first-class wrappers over the SAME governed AI-CRM tool dispatcher the
+// Adrata chat uses (POST /api/v1/ai-crm-tools/execute), so MCP/CLI users get
+// exact parity with chat: sloan_status (read), sloan_handoff (write),
+// configure_sloan (write; action 'check' is a read-only prerequisites
+// checklist). Server-side gates apply identically: configure_sloan mutations
+// are admin/manager-only, writes require approved=true + a reason and accept
+// an idempotency key — same two-step confirmation contract as
+// adrata_ai_tool_execute.
+//
+// NOTE: every Sloan tool (including approve_sloan_draft / reject_sloan_draft,
+// which have no dedicated wrapper here) is ALSO callable through the generic
+// `adrata_ai_tool_execute` passthrough — these wrappers exist for
+// discoverability and typed schemas, not because new plumbing was needed.
+// ---------------------------------------------------------------------------
+
+/**
+ * Register the Sloan EA tools.
+ *
+ * @param {object}   server        - McpServer instance
+ * @param {object}   z             - zod
+ * @param {Function} executeAiCrmTool - the shared dispatcher-execute helper
+ * @param {Function} okFn          - the ok() response helper
+ */
+export function registerSloanTools(server, z, executeAiCrmTool, okFn) {
+  server.tool(
+    'sloan_status',
+    "What Sloan (the AI executive assistant) is doing: follow-up objective counts by state, work due soon, drafts awaiting approval, and recent events. Scope 'me' (default) shows your objectives; 'workspace' (managers only) shows every seller. Filter to one prospect with personId/companyId/recipientEmail.",
+    {
+      scope: z.enum(['me', 'workspace']).optional().describe("'me' (default) or 'workspace' (manager/admin only)"),
+      userId: z.string().optional().describe("View one seller's Sloan activity (manager/admin only)"),
+      personId: z.string().optional().describe('Filter to objectives for this CRM person'),
+      companyId: z.string().optional().describe('Filter to objectives for this CRM company'),
+      recipientEmail: z.string().optional().describe('Filter to objectives whose recipient email contains this text'),
+      rangeHours: z.number().optional().describe('Window for due-soon/recent events (default 24, max 2160)'),
+    },
+    async (args) => okFn(await executeAiCrmTool('sloan_status', args)),
+  );
+
+  server.tool(
+    'sloan_handoff',
+    "Hand a prospect to Sloan (the AI executive assistant): creates a follow-up objective so Sloan pursues the meeting goal in the seller's autonomy mode (DraftOnly by default — every email waits for approval). GOVERNED WRITE: pass approved=true with a reason (and ideally an idempotencyKey); without approval the dispatcher returns the confirmation contract instead of writing.",
+    {
+      personId: z.string().optional().describe('CRM person id of the prospect (preferred)'),
+      email: z.string().optional().describe('Prospect email when no personId is known'),
+      name: z.string().optional().describe('Prospect full name (resolved against workspace people)'),
+      meetingGoal: z.string().optional().describe("What Sloan should book, e.g. 'Book a 30-min security review'"),
+      timezone: z.string().optional().describe('Prospect IANA timezone, if known'),
+      autonomyMode: z
+        .enum(['draft_only', 'approve_first_send', 'approve_all_replies', 'auto_high_confidence', 'full_auto'])
+        .optional()
+        .describe("Optional; may only LOWER autonomy versus the seller's configured mode"),
+      idempotencyKey: z.string().optional().describe('Idempotency key for the write'),
+      approved: z.boolean().optional().describe('Explicit user approval for this write'),
+      reason: z.string().optional().describe('Audit reason for this write'),
+    },
+    async ({ approved, reason, ...args }) =>
+      okFn(await executeAiCrmTool('sloan_handoff', args, { approved, reason })),
+  );
+
+  server.tool(
+    'configure_sloan',
+    "Configure Sloan for the workspace. action 'check' (default) is READ-ONLY: a prerequisites checklist (workspace flag, server kill-switch, connected Sloan mailbox, operational scheduling provider). Actions 'enable'/'disable' toggle the sloan.ea_loop flag and 'set_autonomy' sets a seller's default autonomy mode — admin/manager-gated server-side; pass approved=true with a reason for mutations.",
+    {
+      action: z.enum(['check', 'enable', 'disable', 'set_autonomy']).optional().describe("Default 'check' (read-only)"),
+      autonomyMode: z
+        .enum(['draft_only', 'approve_first_send', 'approve_all_replies', 'auto_high_confidence', 'full_auto'])
+        .optional()
+        .describe("Required for 'set_autonomy'"),
+      userId: z.string().optional().describe("For 'set_autonomy': target seller (defaults to the caller)"),
+      autoInherit: z.boolean().optional().describe('Optionally set sloan.auto_inherit alongside enable/disable (ignored if absent in this build)'),
+      idempotencyKey: z.string().optional().describe('Idempotency key for mutations'),
+      approved: z.boolean().optional().describe('Explicit user approval (mutations only)'),
+      reason: z.string().optional().describe('Audit reason (mutations only)'),
+    },
+    async ({ approved, reason, ...args }) =>
+      okFn(await executeAiCrmTool('configure_sloan', args, { approved, reason })),
+  );
+}

package/transport-http.js

@@ -0,0 +1,505 @@
+/**
+ * Streamable HTTP transport for the Adrata MCP Server.
+ *
+ * Uses the @modelcontextprotocol/sdk built-in StreamableHTTPServerTransport
+ * which supports both direct JSON-RPC responses and SSE streaming via a
+ * single POST /mcp endpoint (Streamable HTTP spec).
+ *
+ * Environment:
+ *   ADRATA_MCP_PORT         - HTTP port (default 3100)
+ *   ADRATA_MCP_CORS_ORIGINS - Comma-separated allowed origins (default '*')
+ *   ADRATA_MCP_REQUIRE_AUTH - Require Bearer auth for /mcp (default true)
+ *
+ * Auth:
+ *   Authorization header is validated through the same tier system used by
+ *   the stdio transport. Each connection gets an isolated session via the
+ *   SDK's built-in session management.
+ */
+
+import http from 'node:http';
+import crypto from 'node:crypto';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { authenticate } from './access/auth.js';
+import { getCorsHeaders, isOriginAllowed, checkTransportSecurity, isIpAllowed, checkRateLimit, rateLimitResponse as buildRateLimitResponse } from './security.js';
+import { protectedResourceMetadata, validateTokenAudience } from './access/resource-metadata.js';
+
+const PROTECTED_RESOURCE_METADATA_PATH = '/.well-known/oauth-protected-resource';
+
+const PORT = parseInt(process.env.ADRATA_MCP_PORT || '3100', 10);
+const CORS_ORIGINS = process.env.ADRATA_MCP_CORS_ORIGINS || '*';
+const REQUIRE_HTTP_AUTH = process.env.ADRATA_MCP_REQUIRE_AUTH !== 'false';
+const TRUST_PROXY = process.env.ADRATA_MCP_TRUST_PROXY === 'true';
+const MAX_BODY_BYTES = parsePositiveInt(process.env.ADRATA_MCP_MAX_BODY_BYTES, 1024 * 1024);
+const MAX_SESSIONS = parsePositiveInt(process.env.ADRATA_MCP_MAX_SESSIONS, 1000);
+const SESSION_IDLE_MS = parsePositiveInt(process.env.ADRATA_MCP_SESSION_IDLE_MS, 30 * 60 * 1000);
+const TOKEN_VALIDATION_TTL_MS = parsePositiveInt(process.env.ADRATA_MCP_TOKEN_VALIDATION_TTL_MS, 60_000);
+const TOKEN_VALIDATION_TIMEOUT_MS = parsePositiveInt(process.env.ADRATA_MCP_TOKEN_VALIDATION_TIMEOUT_MS, 5_000);
+// Session bindings only need to remain stable for this process lifetime. A
+// keyed fingerprint avoids exposing a reusable verifier for bearer tokens.
+const AUTHORIZATION_FINGERPRINT_KEY = crypto.randomBytes(32);
+
+function parsePositiveInt(value, fallback) {
+  const parsed = Number.parseInt(value || '', 10);
+  return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : fallback;
+}
+
+// ---------------------------------------------------------------------------
+// Per-session transport management
+// ---------------------------------------------------------------------------
+// Each client session gets its own StreamableHTTPServerTransport instance,
+// keyed by the session ID returned in the Mcp-Session-Id header. The MCP
+// server is connected to each transport independently so sessions are fully
+// isolated.
+//
+// For initialization requests (no session ID), we create a new transport,
+// connect it to the server, and let the SDK assign a session ID.
+// ---------------------------------------------------------------------------
+
+/** @type {Map<string, { transport: StreamableHTTPServerTransport, principal: string, lastSeenAt: number }>} */
+const sessions = new Map();
+const validatedPrincipals = new Map();
+
+function principalFingerprint(req) {
+  const authorization = req.headers['authorization'] || '';
+  return crypto
+    .createHmac('sha256', AUTHORIZATION_FINGERPRINT_KEY)
+    .update(authorization)
+    .digest('hex');
+}
+
+async function validateHostedBearer(auth, token, principal) {
+  const cachedUntil = validatedPrincipals.get(principal) || 0;
+  if (cachedUntil > Date.now()) return true;
+
+  const apiBase = auth.apiUrl || process.env.ADRATA_API_URL || 'https://api.adrata.com';
+  const validationPath = process.env.ADRATA_MCP_TOKEN_VALIDATION_PATH || '/api/v1/capabilities/workspace';
+  const validationUrl = new URL(validationPath, apiBase);
+
+  try {
+    const response = await fetch(validationUrl, {
+      headers: { Authorization: `Bearer ${token}`, Accept: 'application/json' },
+      signal: AbortSignal.timeout(TOKEN_VALIDATION_TIMEOUT_MS),
+    });
+    if (!response.ok) return false;
+    if (validatedPrincipals.size >= MAX_SESSIONS) {
+      const oldest = validatedPrincipals.keys().next().value;
+      if (oldest) validatedPrincipals.delete(oldest);
+    }
+    validatedPrincipals.set(principal, Date.now() + TOKEN_VALIDATION_TTL_MS);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function forwardedHeader(req, name) {
+  return TRUST_PROXY ? req.headers[name] : undefined;
+}
+
+function requestProtocol(req) {
+  const forwarded = forwardedHeader(req, 'x-forwarded-proto');
+  return (typeof forwarded === 'string' ? forwarded.split(',').at(-1)?.trim() : null)
+    || (req.socket.encrypted ? 'https' : 'http');
+}
+
+function clientAddress(req) {
+  const forwarded = forwardedHeader(req, 'x-forwarded-for');
+  // A trusted ALB appends the address it observed. Use the right-most value so
+  // an attacker-supplied leading X-Forwarded-For value cannot bypass policy.
+  return (typeof forwarded === 'string' ? forwarded.split(',').at(-1)?.trim() : null)
+    || req.socket.remoteAddress
+    || 'unknown';
+}
+
+// ---------------------------------------------------------------------------
+// Auth from Authorization header
+// ---------------------------------------------------------------------------
+
+/**
+ * Extract auth context from request headers. Falls back to env-based auth
+ * if no Authorization header is present (preserves existing behavior).
+ */
+function authenticateRequest(req) {
+  const authHeader = req.headers['authorization'] || '';
+
+  if (authHeader.startsWith('Bearer ')) {
+    const token = authHeader.slice(7);
+    // Treat a bearer token in the header the same as ADRATA_OAUTH_TOKEN
+    // (enterprise tier) for the duration of this request.
+    const saved = process.env.ADRATA_OAUTH_TOKEN;
+    process.env.ADRATA_OAUTH_TOKEN = token;
+    const auth = authenticate();
+    // Restore env to avoid leaking across requests
+    if (saved !== undefined) {
+      process.env.ADRATA_OAUTH_TOKEN = saved;
+    } else {
+      delete process.env.ADRATA_OAUTH_TOKEN;
+    }
+    return auth;
+  }
+
+  if (authHeader.startsWith('ApiKey ')) {
+    const key = authHeader.slice(7);
+    const saved = process.env.ADRATA_API_KEY;
+    process.env.ADRATA_API_KEY = key;
+    const auth = authenticate();
+    if (saved !== undefined) {
+      process.env.ADRATA_API_KEY = saved;
+    } else {
+      delete process.env.ADRATA_API_KEY;
+    }
+    return auth;
+  }
+
+  // Fall back to environment-based auth
+  return authenticate();
+}
+
+function hasHostedBearerAuth(req) {
+  const authHeader = req.headers['authorization'] || '';
+  return typeof authHeader === 'string' && authHeader.startsWith('Bearer ');
+}
+
+function bearerToken(req) {
+  const authHeader = req.headers['authorization'] || '';
+  return authHeader.startsWith('Bearer ') ? authHeader.slice(7) : '';
+}
+
+/** The absolute URL of THIS resource server's RFC 9728 metadata document. */
+function resourceMetadataUrl(req) {
+  const proto = requestProtocol(req);
+  const host = req.headers.host || `localhost:${PORT}`;
+  return `${proto}://${host}${PROTECTED_RESOURCE_METADATA_PATH}`;
+}
+
+function writeJson(res, statusCode, body, headers = {}) {
+  res.writeHead(statusCode, { 'Content-Type': 'application/json', ...headers });
+  res.end(JSON.stringify(body));
+}
+
+/**
+ * RFC 9728 §5.1 challenge: a 401 that points the client at this resource's
+ * protected-resource-metadata so it can discover the authorization server.
+ * `error` is an RFC 6750 code — `invalid_token` when a token was rejected
+ * (e.g. wrong audience), otherwise a bare challenge.
+ */
+function writeUnauthorized(res, req, { error, description } = {}) {
+  const metadataUrl = req ? resourceMetadataUrl(req) : `https://api.adrata.com${PROTECTED_RESOURCE_METADATA_PATH}`;
+  let challenge = `Bearer realm="adrata-mcp", resource_metadata="${metadataUrl}"`;
+  if (error) challenge += `, error="${error}"`;
+  if (description) challenge += `, error_description="${description}"`;
+  writeJson(
+    res,
+    401,
+    {
+      error: error || 'unauthorized',
+      message: description || 'Bearer token authentication is required for hosted Adrata MCP.',
+    },
+    { 'WWW-Authenticate': challenge },
+  );
+}
+
+// ---------------------------------------------------------------------------
+// CORS helpers
+// ---------------------------------------------------------------------------
+
+function setCorsHeaders(res, req) {
+  const origin = req.headers['origin'] || '';
+
+  // Apply security headers (HSTS, X-Content-Type-Options, etc.)
+  const securityHeaders = getCorsHeaders(origin);
+  for (const [key, value] of Object.entries(securityHeaders)) {
+    res.setHeader(key, value);
+  }
+
+  // Standard CORS handling (falls back to env config if security module allows)
+  if (CORS_ORIGINS === '*' && isOriginAllowed(origin)) {
+    res.setHeader('Access-Control-Allow-Origin', origin || '*');
+  } else if (CORS_ORIGINS !== '*') {
+    const allowed = CORS_ORIGINS.split(',').map(o => o.trim());
+    if (allowed.includes(origin)) {
+      res.setHeader('Access-Control-Allow-Origin', origin);
+    }
+  }
+  res.setHeader('Access-Control-Allow-Methods', 'GET, POST, DELETE, OPTIONS');
+  res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization, Mcp-Session-Id, X-API-Key');
+  res.setHeader('Access-Control-Expose-Headers', 'Mcp-Session-Id');
+  res.setHeader('Access-Control-Max-Age', '86400');
+}
+
+// ---------------------------------------------------------------------------
+// Request body reader
+// ---------------------------------------------------------------------------
+
+function readBody(req, maxBytes = MAX_BODY_BYTES) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let size = 0;
+    let exceeded = false;
+    req.on('data', (chunk) => {
+      if (exceeded) return;
+      size += chunk.length;
+      if (size > maxBytes) {
+        exceeded = true;
+        const error = new Error('Request body too large');
+        error.code = 'BODY_TOO_LARGE';
+        reject(error);
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on('end', () => {
+      if (!exceeded) resolve(Buffer.concat(chunks).toString('utf-8'));
+    });
+    req.on('error', reject);
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Start HTTP transport
+// ---------------------------------------------------------------------------
+
+/**
+ * Start the Streamable HTTP server and return a cleanup function.
+ *
+ * @param {import('@modelcontextprotocol/sdk/server/mcp.js').McpServer} mcpServer
+ *   The shared MCP server instance (same one used by stdio).
+ * @returns {Promise<http.Server>}
+ */
+export async function startHttpTransport(mcpServer, options = {}) {
+  const runWithAuthContext = options.runWithAuthContext || ((auth, fn) => fn());
+
+  const httpServer = http.createServer(async (req, res) => {
+    const url = new URL(req.url, `http://${req.headers.host || 'localhost'}`);
+    const pathname = url.pathname;
+
+    // CORS preflight
+    if (req.method === 'OPTIONS') {
+      setCorsHeaders(res, req);
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+
+    if (pathname === '/health') {
+      setCorsHeaders(res, req);
+      writeJson(res, 200, { status: 'ok' });
+      return;
+    }
+
+    // RFC 9728 OAuth 2.0 Protected Resource Metadata — public, unauthenticated.
+    // Served at the base path and the MCP-scoped suffix so clients that append
+    // the resource path segment (per the 2025 MCP spec) also resolve it.
+    if (pathname === PROTECTED_RESOURCE_METADATA_PATH
+      || pathname === `${PROTECTED_RESOURCE_METADATA_PATH}/mcp`) {
+      setCorsHeaders(res, req);
+      if (req.method !== 'GET') {
+        writeJson(res, 405, { error: 'Method not allowed. Use GET.' });
+        return;
+      }
+      writeJson(res, 200, protectedResourceMetadata(resourceMetadataUrl(req)));
+      return;
+    }
+
+    // Transport security: reject HTTP in production (require TLS)
+    const proto = requestProtocol(req);
+    const transportCheck = checkTransportSecurity(`${proto}://${req.headers.host}`);
+    if (!transportCheck.secure) {
+      writeJson(res, 403, { error: transportCheck.warning });
+      return;
+    }
+
+    // IP allowlisting (enterprise feature)
+    const clientIp = clientAddress(req);
+    if (!isIpAllowed(clientIp)) {
+      writeJson(res, 403, { error: 'IP address not in allowlist.' });
+      return;
+    }
+
+    // Only handle /mcp
+    if (pathname !== '/mcp') {
+      setCorsHeaders(res, req);
+      writeJson(res, 404, { error: 'Not found. Use POST /mcp for JSON-RPC calls.' });
+      return;
+    }
+
+    setCorsHeaders(res, req);
+
+    // Validate auth
+    if (REQUIRE_HTTP_AUTH && !hasHostedBearerAuth(req)) {
+      writeUnauthorized(res, req);
+      return;
+    }
+
+    // RFC 8707 audience binding / no-token-passthrough: a bearer token minted
+    // for a different audience (another resource or client) MUST NOT be
+    // accepted here. This is enforced before we touch the tier system so a
+    // cross-audience token can never reach a tool or the upstream API.
+    const presentedToken = bearerToken(req);
+    if (presentedToken) {
+      const audCheck = validateTokenAudience(presentedToken);
+      if (!audCheck.valid) {
+        writeUnauthorized(res, req, {
+          error: 'invalid_token',
+          description: audCheck.reason === 'audience_mismatch'
+            ? 'Access token audience does not match this MCP resource.'
+            : 'Access token is not valid for this MCP resource.',
+        });
+        return;
+      }
+    }
+
+    const auth = authenticateRequest(req);
+    if (REQUIRE_HTTP_AUTH && !auth.authenticated) {
+      writeUnauthorized(res, req);
+      return;
+    }
+
+    const principal = principalFingerprint(req);
+    auth.securityPrincipal = principal;
+    if (presentedToken && !(await validateHostedBearer(auth, presentedToken, principal))) {
+      writeUnauthorized(res, req, {
+        error: 'invalid_token',
+        description: 'Access token could not be validated by the Adrata authorization boundary.',
+      });
+      return;
+    }
+
+    // Attach auth info for the SDK's authInfo passthrough
+    req.auth = { tier: auth.tier, authenticated: auth.authenticated };
+
+    const sessionId = req.headers['mcp-session-id'];
+
+    if (sessionId && sessions.has(sessionId)) {
+      const session = sessions.get(sessionId);
+      if (session.principal !== principal) {
+        writeJson(res, 403, { error: 'MCP session belongs to a different authenticated principal.' });
+        return;
+      }
+      session.lastSeenAt = Date.now();
+    }
+
+    if (req.method === 'POST') {
+      // Read and parse body
+      let body;
+      try {
+        const raw = await readBody(req);
+        body = JSON.parse(raw);
+      } catch (error) {
+        if (error?.code === 'BODY_TOO_LARGE') {
+          if (!res.headersSent) writeJson(res, 413, { error: `Request body exceeds ${MAX_BODY_BYTES} bytes.` });
+          return;
+        }
+        writeJson(res, 400, { jsonrpc: '2.0', error: { code: -32700, message: 'Parse error' }, id: null });
+        return;
+      }
+
+      // Check if this is an initialization request (method: 'initialize')
+      const isInit = Array.isArray(body)
+        ? body.some(msg => msg.method === 'initialize')
+        : body.method === 'initialize';
+
+      let transport;
+
+      if (isInit) {
+        if (sessions.size >= MAX_SESSIONS) {
+          writeJson(res, 503, { error: 'MCP session capacity reached. Retry later.' });
+          return;
+        }
+        // Create a new transport for this session
+        transport = new StreamableHTTPServerTransport({
+          sessionIdGenerator: () => crypto.randomUUID(),
+        });
+
+        // When transport closes, clean up the session
+        transport.onclose = () => {
+          const sid = transport.sessionId;
+          if (sid) sessions.delete(sid);
+        };
+
+        // Connect the MCP server to this transport
+        await runWithAuthContext(auth, () => mcpServer.connect(transport));
+
+        // Handle the request (the SDK will set the session ID during init)
+        await runWithAuthContext(auth, () => transport.handleRequest(req, res, body));
+
+        // Store the session after initialization
+        const sid = transport.sessionId;
+        if (sid) {
+          sessions.set(sid, { transport, principal, lastSeenAt: Date.now() });
+        }
+      } else if (sessionId && sessions.has(sessionId)) {
+        // Existing session
+        transport = sessions.get(sessionId).transport;
+        await runWithAuthContext(auth, () => transport.handleRequest(req, res, body));
+      } else {
+        // No session ID or unknown session for a non-init request
+        writeJson(res, 400, {
+          jsonrpc: '2.0',
+          error: { code: -32600, message: 'Bad Request: missing or invalid session. Send an initialize request first.' },
+          id: null,
+        });
+      }
+    } else if (req.method === 'GET') {
+      // GET /mcp opens a standalone SSE stream for server-initiated notifications
+      if (sessionId && sessions.has(sessionId)) {
+        const transport = sessions.get(sessionId).transport;
+        await runWithAuthContext(auth, () => transport.handleRequest(req, res));
+      } else {
+        writeJson(res, 400, { error: 'Missing or invalid Mcp-Session-Id header.' });
+      }
+    } else if (req.method === 'DELETE') {
+      // DELETE /mcp terminates a session
+      if (sessionId && sessions.has(sessionId)) {
+        const transport = sessions.get(sessionId).transport;
+        await transport.close();
+        sessions.delete(sessionId);
+        res.writeHead(204);
+        res.end();
+      } else {
+        writeJson(res, 404, { error: 'Session not found.' });
+      }
+    } else {
+      writeJson(res, 405, { error: 'Method not allowed.' });
+    }
+  });
+
+  const sessionCleanup = setInterval(() => {
+    const cutoff = Date.now() - SESSION_IDLE_MS;
+    for (const [sessionId, session] of sessions) {
+      if (session.lastSeenAt < cutoff) {
+        sessions.delete(sessionId);
+        session.transport.close().catch(() => {});
+      }
+    }
+  }, Math.min(SESSION_IDLE_MS, 60_000));
+  sessionCleanup.unref?.();
+
+  httpServer.on('close', () => {
+    clearInterval(sessionCleanup);
+    for (const session of sessions.values()) session.transport.close().catch(() => {});
+    sessions.clear();
+    validatedPrincipals.clear();
+  });
+
+  httpServer.requestTimeout = 30_000;
+  httpServer.headersTimeout = 15_000;
+  httpServer.keepAliveTimeout = 5_000;
+
+  return new Promise((resolve) => {
+    httpServer.listen(PORT, () => {
+      console.error(`Adrata MCP HTTP transport listening on http://localhost:${PORT}/mcp`);
+      console.error(`CORS origins: ${CORS_ORIGINS}`);
+      console.error(`Active sessions: ${sessions.size}`);
+      resolve(httpServer);
+    });
+  });
+}
+
+export const _test = {
+  clientAddress,
+  requestProtocol,
+  principalFingerprint,
+  readBody,
+  validateHostedBearer,
+};