@ferrlabs/mcp-core 8.2.1 → 9.0.0

package/dist/transports/__tests__/http-host.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=http-host.test.d.ts.map

package/dist/transports/__tests__/http-host.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-host.test.d.ts","sourceRoot":"","sources":["../../../src/transports/__tests__/http-host.test.ts"],"names":[],"mappings":""}

package/dist/transports/__tests__/http-host.test.js

@@ -0,0 +1,78 @@
+import { describe, it, expect } from 'vitest';
+import { hostnameOf, isHostAllowed, resolvePublicEndpoint } from '../http-host.js';
+describe('hostnameOf', () => {
+    it.each([
+        ['[::1]:3000', '[::1]'],
+        ['[::1]', '[::1]'],
+        ['localhost:3000', 'localhost'],
+        ['localhost', 'localhost'],
+        ['MCP.ferrlabs.com:443', 'mcp.ferrlabs.com'],
+    ])('reads %s as %s', (header, expected) => {
+        expect(hostnameOf(header)).toBe(expected);
+    });
+    it.each(['', '[::1', 'a b', 'evil.test/x', 'user@host', 'host:port'])('rejects the malformed header %j', (header) => {
+        expect(hostnameOf(header)).toBeUndefined();
+    });
+});
+describe('isHostAllowed', () => {
+    it('matches an IPv6 Host against the same IPv6 entry only', () => {
+        expect(isHostAllowed('[::1]:3000', ['[::1]'])).toBe(true);
+        expect(isHostAllowed('[::2]:3000', ['[::1]'])).toBe(false);
+        expect(isHostAllowed('[::1]:3000', ['localhost'])).toBe(false);
+    });
+    it('does not let a malformed header collapse into a matching token', () => {
+        expect(isHostAllowed('[', ['['])).toBe(false);
+        expect(isHostAllowed('[::1', ['[::1]'])).toBe(false);
+    });
+    it('rejects everything when the allowlist is empty', () => {
+        expect(isHostAllowed('mcp.ferrlabs.com', [])).toBe(false);
+    });
+    it('rejects a missing Host header', () => {
+        expect(isHostAllowed(undefined, ['mcp.ferrlabs.com'])).toBe(false);
+    });
+});
+describe('resolvePublicEndpoint', () => {
+    const bindAll = { bindHost: '0.0.0.0', port: 3000 };
+    it('uses the public URL origin and allows only its host by default', () => {
+        expect(resolvePublicEndpoint({
+            ...bindAll,
+            publicUrl: 'https://mcp.ferrlabs.com/',
+            allowedHosts: [],
+        })).toEqual({ publicUrl: 'https://mcp.ferrlabs.com', allowedHosts: ['mcp.ferrlabs.com'] });
+    });
+    it('normalises explicit allowlist entries, ports and brackets included', () => {
+        expect(resolvePublicEndpoint({
+            ...bindAll,
+            publicUrl: 'https://mcp.ferrlabs.com',
+            allowedHosts: ['MCP.ferrlabs.com:443', '[::1]:3000'],
+        }).allowedHosts).toEqual(['mcp.ferrlabs.com', '[::1]']);
+    });
+    it('defaults to a loopback URL and loopback hosts when bound to loopback', () => {
+        expect(resolvePublicEndpoint({
+            publicUrl: undefined,
+            allowedHosts: [],
+            bindHost: '127.0.0.1',
+            port: 4000,
+        })).toEqual({
+            publicUrl: 'http://127.0.0.1:4000',
+            allowedHosts: ['127.0.0.1', 'localhost', '[::1]'],
+        });
+    });
+    it('refuses a non-loopback bind without a public URL', () => {
+        expect(() => resolvePublicEndpoint({
+            ...bindAll,
+            publicUrl: undefined,
+            allowedHosts: ['mcp.ferrlabs.com'],
+        })).toThrow(/FERRLABS_MCP_PUBLIC_URL/);
+    });
+    it('refuses a public URL that is not http or https', () => {
+        expect(() => resolvePublicEndpoint({ ...bindAll, publicUrl: 'ftp://mcp.ferrlabs.com', allowedHosts: [] })).toThrow(/http or https/);
+    });
+    it('refuses a malformed allowlist entry instead of dropping it', () => {
+        expect(() => resolvePublicEndpoint({
+            ...bindAll,
+            publicUrl: 'https://mcp.ferrlabs.com',
+            allowedHosts: ['a b'],
+        })).toThrow(/invalid entry/);
+    });
+});

package/dist/transports/__tests__/http.test.js

@@ -1,5 +1,7 @@
-import { describe, it, expect } from 'vitest';
-import { unauthorizedChallenge, resolveAllowedOrigin, isHostAllowed, defaultBindHost, parseList, } from '../http.js';
+import { describe, it, expect, afterEach } from 'vitest';
+import { request } from 'node:http';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { unauthorizedChallenge, resolveAllowedOrigin, defaultBindHost, parseList, startHttpServer, } from '../http.js';
 describe('unauthorizedChallenge', () => {
     const metadataUrl = 'https://mcp.ferrvault.com/.well-known/oauth-protected-resource';
     it('returns an RFC 6749 §5.2 error body where `error` is a string', () => {
@@ -37,20 +39,6 @@ describe('resolveAllowedOrigin', () => {
         expect(resolveAllowedOrigin('https://app.ferrlabs.com', [])).toBeUndefined();
     });
 });
-describe('isHostAllowed', () => {
-    it('allows any host when no allowlist is configured', () => {
-        expect(isHostAllowed('anything.test', [])).toBe(true);
-    });
-    it('matches the host ignoring port and case', () => {
-        expect(isHostAllowed('MCP.ferrlabs.com:3000', ['mcp.ferrlabs.com'])).toBe(true);
-    });
-    it('rejects a host outside the allowlist (DNS-rebinding guard)', () => {
-        expect(isHostAllowed('attacker.test', ['mcp.ferrlabs.com'])).toBe(false);
-    });
-    it('rejects a missing host header when an allowlist is set', () => {
-        expect(isHostAllowed(undefined, ['mcp.ferrlabs.com'])).toBe(false);
-    });
-});
 describe('defaultBindHost', () => {
     it('defaults to loopback', () => {
         expect(defaultBindHost(undefined, false)).toBe('127.0.0.1');
@@ -70,3 +58,73 @@ describe('parseList', () => {
         expect(parseList(undefined)).toEqual([]);
     });
 });
+describe('startHttpServer', () => {
+    let server;
+    afterEach(async () => {
+        await new Promise((resolve) => (server ? server.close(() => resolve()) : resolve()));
+        server = undefined;
+    });
+    async function start() {
+        server = await startHttpServer({
+            port: 0,
+            host: '127.0.0.1',
+            publicUrl: 'https://mcp.ferrlabs.test',
+            createServer: () => new McpServer({ name: 'test', version: '0.0.0' }),
+        });
+        return server.address().port;
+    }
+    function get(port, path, headers) {
+        return new Promise((resolve, reject) => {
+            const req = request({ host: '127.0.0.1', port, path, method: 'GET', headers }, (res) => {
+                let body = '';
+                res.setEncoding('utf8');
+                res.on('data', (c) => (body += c));
+                res.on('end', () => resolve({
+                    status: res.statusCode ?? 0,
+                    body,
+                    wwwAuthenticate: res.headers['www-authenticate'],
+                }));
+            });
+            req.on('error', reject);
+            req.end();
+        });
+    }
+    it('advertises the configured public URL whatever X-Forwarded-Host says', async () => {
+        const port = await start();
+        const res = await get(port, '/.well-known/oauth-protected-resource', {
+            Host: 'mcp.ferrlabs.test',
+            'X-Forwarded-Host': 'attacker.test',
+            'X-Forwarded-Proto': 'http',
+        });
+        expect(res.status).toBe(200);
+        expect(JSON.parse(res.body).resource).toBe('https://mcp.ferrlabs.test');
+    });
+    it('points the 401 challenge at the configured public URL', async () => {
+        const port = await start();
+        const res = await get(port, '/mcp', {
+            Host: 'mcp.ferrlabs.test',
+            'X-Forwarded-Host': 'attacker.test',
+        });
+        expect(res.status).toBe(401);
+        expect(res.wwwAuthenticate).toContain('resource_metadata="https://mcp.ferrlabs.test/.well-known/oauth-protected-resource"');
+    });
+    it('rejects a Host outside the allowlist derived from the public URL', async () => {
+        const port = await start();
+        const res = await get(port, '/.well-known/oauth-protected-resource', {
+            Host: 'attacker.test',
+        });
+        expect(res.status).toBe(421);
+    });
+    it('answers health probes whatever the Host header, so kubelet probes on the pod IP pass', async () => {
+        const port = await start();
+        const res = await get(port, '/health', { Host: '10.42.0.17:3000' });
+        expect(res.status).toBe(200);
+    });
+    it('refuses to start on a non-loopback address without a public URL', async () => {
+        await expect(startHttpServer({
+            port: 0,
+            host: '0.0.0.0',
+            createServer: () => new McpServer({ name: 'test', version: '0.0.0' }),
+        })).rejects.toThrow(/FERRLABS_MCP_PUBLIC_URL/);
+    });
+});

package/dist/transports/http-host.d.ts

@@ -0,0 +1,17 @@
+export declare class HttpConfigError extends Error {
+    constructor(message: string);
+}
+export interface PublicEndpoint {
+    publicUrl: string;
+    allowedHosts: string[];
+}
+export declare function hostnameOf(hostHeader: string): string | undefined;
+export declare function isHostAllowed(hostHeader: string | undefined, allowedHosts: string[]): boolean;
+export declare function isLoopback(bindHost: string): boolean;
+export declare function resolvePublicEndpoint(opts: {
+    publicUrl: string | undefined;
+    allowedHosts: string[];
+    bindHost: string;
+    port: number;
+}): PublicEndpoint;
+//# sourceMappingURL=http-host.d.ts.map

package/dist/transports/http-host.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-host.d.ts","sourceRoot":"","sources":["../../src/transports/http-host.ts"],"names":[],"mappings":"AAEA,qBAAa,eAAgB,SAAQ,KAAK;IACxC,YAAY,OAAO,EAAE,MAAM,EAG1B;CACF;AAED,MAAM,WAAW,cAAc;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB;AAED,wBAAgB,UAAU,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAOjE;AAED,wBAAgB,aAAa,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,EAAE,YAAY,EAAE,MAAM,EAAE,GAAG,OAAO,CAI7F;AAED,wBAAgB,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAEpD;AAyBD,wBAAgB,qBAAqB,CAAC,IAAI,EAAE;IAC1C,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;CACd,GAAG,cAAc,CAqBjB"}

package/dist/transports/http-host.js

@@ -0,0 +1,65 @@
+const LOOPBACK_HOSTNAMES = ['127.0.0.1', 'localhost', '[::1]'];
+export class HttpConfigError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'HttpConfigError';
+    }
+}
+export function hostnameOf(hostHeader) {
+    if (hostHeader.length === 0 || /[\s/?#@\\]/.test(hostHeader))
+        return undefined;
+    try {
+        return new URL(`http://${hostHeader}`).hostname;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function isHostAllowed(hostHeader, allowedHosts) {
+    if (!hostHeader)
+        return false;
+    const hostname = hostnameOf(hostHeader);
+    return hostname !== undefined && allowedHosts.includes(hostname);
+}
+export function isLoopback(bindHost) {
+    return [...LOOPBACK_HOSTNAMES, '::1'].includes(bindHost);
+}
+function parsePublicUrl(raw) {
+    let url;
+    try {
+        url = new URL(raw);
+    }
+    catch {
+        throw new HttpConfigError(`FERRLABS_MCP_PUBLIC_URL is not a valid URL: ${raw}`);
+    }
+    if (url.protocol !== 'https:' && url.protocol !== 'http:') {
+        throw new HttpConfigError(`FERRLABS_MCP_PUBLIC_URL must be http or https, got ${url.protocol}`);
+    }
+    return url;
+}
+function parseAllowedHosts(entries) {
+    return entries.map((entry) => {
+        const hostname = hostnameOf(entry);
+        if (hostname === undefined) {
+            throw new HttpConfigError(`FERRLABS_MCP_ALLOWED_HOSTS has an invalid entry: ${entry}`);
+        }
+        return hostname;
+    });
+}
+export function resolvePublicEndpoint(opts) {
+    const explicitHosts = parseAllowedHosts(opts.allowedHosts);
+    if (opts.publicUrl) {
+        const url = parsePublicUrl(opts.publicUrl);
+        return {
+            publicUrl: url.origin,
+            allowedHosts: explicitHosts.length > 0 ? explicitHosts : [url.hostname],
+        };
+    }
+    if (isLoopback(opts.bindHost)) {
+        return {
+            publicUrl: `http://127.0.0.1:${opts.port}`,
+            allowedHosts: explicitHosts.length > 0 ? explicitHosts : LOOPBACK_HOSTNAMES,
+        };
+    }
+    throw new HttpConfigError(`The HTTP transport is bound to ${opts.bindHost}, so it needs FERRLABS_MCP_PUBLIC_URL, the URL clients reach it at (e.g. https://mcp.ferrlabs.com). It is advertised as the OAuth resource and its host becomes the default Host allowlist.`);
+}

package/dist/transports/http.d.ts

@@ -1,7 +1,7 @@
+import { type Server } from 'node:http';
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 export declare function parseList(raw: string | undefined): string[];
 export declare function resolveAllowedOrigin(requestOrigin: string | undefined, allowlist: string[]): string | undefined;
-export declare function isHostAllowed(hostHeader: string | undefined, allowedHosts: string[]): boolean;
 export declare function defaultBindHost(envHost: string | undefined, bindAll: boolean): string;
 export declare function unauthorizedChallenge(metadataUrl: string): {
     wwwAuthenticate: string;
@@ -11,6 +11,7 @@ export interface HttpServerOptions {
     port: number;
     host?: string;
     stateless?: boolean;
+    publicUrl?: string;
     createServer: () => McpServer;
     /**
      * URL of the OAuth 2.0 Authorization Server users authenticate against.
@@ -27,5 +28,5 @@ export interface HttpServerOptions {
      */
     authorizationServer?: string;
 }
-export declare function startHttpServer(opts: HttpServerOptions): Promise<void>;
+export declare function startHttpServer(opts: HttpServerOptions): Promise<Server>;
 //# sourceMappingURL=http.d.ts.map

package/dist/transports/http.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../../src/transports/http.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAYzE,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,EAAE,CAM3D;AAED,wBAAgB,oBAAoB,CAClC,aAAa,EAAE,MAAM,GAAG,SAAS,EACjC,SAAS,EAAE,MAAM,EAAE,GAClB,MAAM,GAAG,SAAS,CAGpB;AAED,wBAAgB,aAAa,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,EAAE,YAAY,EAAE,MAAM,EAAE,GAAG,OAAO,CAK7F;AAED,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,EAAE,OAAO,EAAE,OAAO,GAAG,MAAM,CAGrF;AAYD,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,MAAM,GAAG;IAC1D,eAAe,EAAE,MAAM,CAAC;IACxB,IAAI,EAAE,MAAM,CAAC;CACd,CAQA;AAED,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,YAAY,EAAE,MAAM,SAAS,CAAC;IAC9B;;;;;;;;;;;;OAYG;IACH,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAoCD,wBAAsB,eAAe,CAAC,IAAI,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CA+J5E"}
+{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../../src/transports/http.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,MAAM,EAEZ,MAAM,WAAW,CAAC;AAGnB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAazE,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,EAAE,CAM3D;AAED,wBAAgB,oBAAoB,CAClC,aAAa,EAAE,MAAM,GAAG,SAAS,EACjC,SAAS,EAAE,MAAM,EAAE,GAClB,MAAM,GAAG,SAAS,CAGpB;AAED,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,EAAE,OAAO,EAAE,OAAO,GAAG,MAAM,CAGrF;AAKD,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,MAAM,GAAG;IAC1D,eAAe,EAAE,MAAM,CAAC;IACxB,IAAI,EAAE,MAAM,CAAC;CACd,CAQA;AAED,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,SAAS,CAAC;IAC9B;;;;;;;;;;;;OAYG;IACH,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAoCD,wBAAsB,eAAe,CAAC,IAAI,EAAE,iBAAiB,GAAG,OAAO,CAAC,MAAM,CAAC,CAsK9E"}

package/dist/transports/http.js

@@ -2,6 +2,7 @@ import { createServer as createHttpServer, } from 'node:http';
 import { randomUUID } from 'node:crypto';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import { runWithAuthContext } from '../auth/context.js';
+import { isHostAllowed, resolvePublicEndpoint } from './http-host.js';
 const MAX_BODY_BYTES = 1_000_000;
 function extractBearer(req) {
     const header = req.headers['authorization'];
@@ -23,24 +24,11 @@ export function resolveAllowedOrigin(requestOrigin, allowlist) {
         return undefined;
     return allowlist.includes(requestOrigin) ? requestOrigin : undefined;
 }
-export function isHostAllowed(hostHeader, allowedHosts) {
-    if (allowedHosts.length === 0)
-        return true;
-    if (!hostHeader)
-        return false;
-    const host = hostHeader.split(':')[0].toLowerCase();
-    return allowedHosts.some((allowed) => allowed.split(':')[0].toLowerCase() === host);
-}
 export function defaultBindHost(envHost, bindAll) {
     if (envHost)
         return envHost;
     return bindAll ? '0.0.0.0' : '127.0.0.1';
 }
-function publicOrigin(req) {
-    const proto = req.headers['x-forwarded-proto']?.split(',')[0]?.trim() ?? 'https';
-    const host = req.headers['x-forwarded-host'] ?? req.headers.host ?? '';
-    return `${proto}://${host}`;
-}
 const UNAUTHORIZED_DESCRIPTION = 'Missing or invalid bearer token. Fetch the OAuth protected-resource metadata and run the authorization code + PKCE flow.';
 export function unauthorizedChallenge(metadataUrl) {
     return {
@@ -91,23 +79,26 @@ export async function startHttpServer(opts) {
     const bindAll = process.env.FERRLABS_MCP_BIND_ALL === '1';
     const host = defaultBindHost(opts.host, bindAll);
     const allowedOrigins = parseList(process.env.FERRLABS_MCP_ALLOWED_ORIGINS);
-    const allowedHosts = parseList(process.env.FERRLABS_MCP_ALLOWED_HOSTS);
+    const { publicUrl, allowedHosts } = resolvePublicEndpoint({
+        publicUrl: opts.publicUrl ?? process.env.FERRLABS_MCP_PUBLIC_URL,
+        allowedHosts: parseList(process.env.FERRLABS_MCP_ALLOWED_HOSTS),
+        bindHost: host,
+        port,
+    });
     const authServer = opts.authorizationServer ?? process.env.FERRLABS_AUTH_URL ?? 'https://api.ferrlabs.com';
     const transports = new Map();
-    function sendUnauthorized(req, res) {
-        const origin = publicOrigin(req);
-        const { wwwAuthenticate, body } = unauthorizedChallenge(`${origin}/.well-known/oauth-protected-resource`);
+    function sendUnauthorized(res) {
+        const { wwwAuthenticate, body } = unauthorizedChallenge(`${publicUrl}/.well-known/oauth-protected-resource`);
         res.writeHead(401, {
             'Content-Type': 'application/json',
             'WWW-Authenticate': wwwAuthenticate,
         });
         res.end(body);
     }
-    function sendResourceMetadata(req, res) {
-        const origin = publicOrigin(req);
+    function sendResourceMetadata(res) {
         res.writeHead(200, { 'Content-Type': 'application/json' });
         res.end(JSON.stringify({
-            resource: origin,
+            resource: publicUrl,
             authorization_servers: [authServer],
             bearer_methods_supported: ['header'],
             resource_documentation: 'https://ferrlabs.com',
@@ -116,7 +107,7 @@ export async function startHttpServer(opts) {
     async function handleMcpRequest(req, res) {
         const bearerToken = extractBearer(req);
         if (!bearerToken) {
-            sendUnauthorized(req, res);
+            sendUnauthorized(res);
             return;
         }
         const sessionId = req.headers['mcp-session-id'] ?? undefined;
@@ -189,19 +180,19 @@ export async function startHttpServer(opts) {
             res.end();
             return;
         }
-        if (!isHostAllowed(req.headers.host, allowedHosts)) {
-            res.writeHead(421, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ error: 'Host not allowed' }));
-            return;
-        }
         const url = req.url ?? '/';
         if (url === '/health' || url === '/livez' || url === '/readyz') {
             res.writeHead(200, { 'Content-Type': 'application/json' });
             res.end(JSON.stringify({ status: 'ok', service: 'ferrlabs-mcp' }));
             return;
         }
+        if (!isHostAllowed(req.headers.host, allowedHosts)) {
+            res.writeHead(421, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Host not allowed' }));
+            return;
+        }
         if (url === '/.well-known/oauth-protected-resource') {
-            sendResourceMetadata(req, res);
+            sendResourceMetadata(res);
             return;
         }
         if (url === '/mcp' || url.startsWith('/mcp?')) {
@@ -223,8 +214,9 @@ export async function startHttpServer(opts) {
     await new Promise((resolve, reject) => {
         httpServer.once('error', reject);
         httpServer.listen(port, host, () => {
-            console.error(`ferrlabs-mcp HTTP transport listening on http://${host}:${port}/mcp`);
+            console.error(`ferrlabs-mcp HTTP transport listening on http://${host}:${port}/mcp, advertised as ${publicUrl}`);
             resolve();
         });
     });
+    return httpServer;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ferrlabs/mcp-core",
-  "version": "8.2.1",
+  "version": "9.0.0",
   "description": "Shared core for FerrLabs MCP servers — auth, transports (stdio + Streamable HTTP), api-client, runner",
   "license": "MPL-2.0",
   "type": "module",