@ferrlabs/mcp 5.1.1 → 5.2.1

package/dist/auth/__tests__/context.test.d.ts

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

package/dist/auth/__tests__/context.test.d.ts.map

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

package/dist/auth/__tests__/context.test.js

@@ -0,0 +1,29 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+describe('per-request bearer token takes precedence over env/persisted', () => {
+    beforeEach(() => {
+        delete process.env.FERRLABS_API_TOKEN;
+        delete process.env.FERRFLOW_API_TOKEN;
+        process.env.FERRLABS_MCP_NO_PERSIST = '1';
+        process.env.FERRLABS_MCP_NO_OAUTH = '1';
+    });
+    it('returns the bearer from AuthContext when set', async () => {
+        const { runWithAuthContext } = await import('../context.js');
+        const { getToken } = await import('../index.js');
+        const result = await runWithAuthContext({ bearerToken: 'fl_req_token' }, () => getToken());
+        expect(result).toBe('fl_req_token');
+    });
+    it('bearer from context wins over FERRLABS_API_TOKEN env', async () => {
+        process.env.FERRLABS_API_TOKEN = 'fl_env';
+        const { runWithAuthContext } = await import('../context.js');
+        const { getToken } = await import('../index.js');
+        const result = await runWithAuthContext({ bearerToken: 'fl_req' }, () => getToken());
+        expect(result).toBe('fl_req');
+    });
+    it('falls back to env when context has no bearer', async () => {
+        process.env.FERRLABS_API_TOKEN = 'fl_env_only';
+        const { runWithAuthContext } = await import('../context.js');
+        const { getToken } = await import('../index.js');
+        const result = await runWithAuthContext({}, () => getToken());
+        expect(result).toBe('fl_env_only');
+    });
+});

package/dist/auth/context.d.ts

@@ -0,0 +1,9 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+interface AuthContext {
+    bearerToken?: string;
+}
+export declare const authContext: AsyncLocalStorage<AuthContext>;
+export declare function runWithAuthContext<T>(ctx: AuthContext, fn: () => Promise<T>): Promise<T>;
+export declare function getRequestBearerToken(): string | undefined;
+export {};
+//# sourceMappingURL=context.d.ts.map

package/dist/auth/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/auth/context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAErD,UAAU,WAAW;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,eAAO,MAAM,WAAW,gCAAuC,CAAC;AAEhE,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,GAAG,EAAE,WAAW,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAExF;AAED,wBAAgB,qBAAqB,IAAI,MAAM,GAAG,SAAS,CAE1D"}

package/dist/auth/context.js

@@ -0,0 +1,8 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+export const authContext = new AsyncLocalStorage();
+export function runWithAuthContext(ctx, fn) {
+    return authContext.run(ctx, fn);
+}
+export function getRequestBearerToken() {
+    return authContext.getStore()?.bearerToken;
+}

package/dist/auth/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/auth/index.ts"],"names":[],"mappings":"AAMA,wBAAsB,QAAQ,IAAI,OAAO,CAAC,MAAM,CAAC,CAgChD;AAED,wBAAgB,yBAAyB,IAAI,IAAI,CAGhD"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/auth/index.ts"],"names":[],"mappings":"AAOA,wBAAsB,QAAQ,IAAI,OAAO,CAAC,MAAM,CAAC,CAuChD;AAED,wBAAgB,yBAAyB,IAAI,IAAI,CAGhD"}

package/dist/auth/index.js

@@ -1,8 +1,15 @@
 import { readPersistedToken, writePersistedToken } from './persistence.js';
 import { runLoopbackOauthFlow } from './oauth.js';
+import { getRequestBearerToken } from './context.js';
 let cached = null;
 let inFlight = null;
 export async function getToken() {
+    const perRequest = getRequestBearerToken();
+    if (perRequest)
+        return perRequest;
+    if (process.env.FERRLABS_MCP_MODE === 'http') {
+        throw new Error('Bearer token required. Send `Authorization: Bearer fl_...` on each request.');
+    }
     if (cached)
         return cached;
     const envToken = process.env.FERRLABS_API_TOKEN ?? process.env.FERRFLOW_API_TOKEN;

package/dist/index.js

@@ -1,23 +1,20 @@
 #!/usr/bin/env node
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { registerStatsTools } from './tools/stats.js';
-import { registerTokenTools } from './tools/tokens.js';
-import { registerOrgsTools } from './tools/orgs.js';
-import { registerVaultsTools } from './tools/vaults.js';
-import { registerIssuesTools } from './tools/issues.js';
-import { registerSubscriptionsTools } from './tools/subscriptions.js';
-import { registerDocsTools } from './tools/docs.js';
-const server = new McpServer({
-    name: 'ferrlabs',
-    version: '4.0.0',
+import { startStdioServer } from './transports/stdio.js';
+import { startHttpServer } from './transports/http.js';
+async function main() {
+    const mode = process.env.FERRLABS_MCP_MODE ?? (process.argv.includes('--http') ? 'http' : 'stdio');
+    if (mode === 'http') {
+        const port = Number(process.env.PORT ?? '3000');
+        await startHttpServer({
+            port,
+            host: process.env.HOST,
+            stateless: process.env.FERRLABS_MCP_STATEFUL !== '1',
+        });
+        return;
+    }
+    await startStdioServer();
+}
+main().catch((err) => {
+    console.error('ferrlabs-mcp fatal:', err instanceof Error ? err.message : err);
+    process.exit(1);
 });
-registerStatsTools(server);
-registerTokenTools(server);
-registerOrgsTools(server);
-registerVaultsTools(server);
-registerIssuesTools(server);
-registerSubscriptionsTools(server);
-registerDocsTools(server);
-const { StdioServerTransport } = await import('@modelcontextprotocol/sdk/server/stdio.js');
-const transport = new StdioServerTransport();
-await server.connect(transport);

package/dist/server.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function createMcpServer(): McpServer;
+//# sourceMappingURL=server.d.ts.map

package/dist/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAWpE,wBAAgB,eAAe,IAAI,SAAS,CAU3C"}

package/dist/server.js

@@ -0,0 +1,20 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { registerStatsTools } from './tools/stats.js';
+import { registerTokenTools } from './tools/tokens.js';
+import { registerOrgsTools } from './tools/orgs.js';
+import { registerVaultsTools } from './tools/vaults.js';
+import { registerIssuesTools } from './tools/issues.js';
+import { registerSubscriptionsTools } from './tools/subscriptions.js';
+import { registerDocsTools } from './tools/docs.js';
+const VERSION = '5.1.1';
+export function createMcpServer() {
+    const server = new McpServer({ name: 'ferrlabs', version: VERSION });
+    registerStatsTools(server);
+    registerTokenTools(server);
+    registerOrgsTools(server);
+    registerVaultsTools(server);
+    registerIssuesTools(server);
+    registerSubscriptionsTools(server);
+    registerDocsTools(server);
+    return server;
+}

package/dist/transports/http.d.ts

@@ -0,0 +1,7 @@
+export interface HttpServerOptions {
+    port: number;
+    host?: string;
+    stateless?: boolean;
+}
+export declare function startHttpServer(opts: HttpServerOptions): Promise<void>;
+//# sourceMappingURL=http.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../../src/transports/http.ts"],"names":[],"mappings":"AAaA,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAoBD,wBAAsB,eAAe,CAAC,IAAI,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CA0D5E"}

package/dist/transports/http.js

@@ -0,0 +1,89 @@
+import { createServer } from 'node:http';
+import { randomUUID } from 'node:crypto';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { createMcpServer } from '../server.js';
+import { runWithAuthContext } from '../auth/context.js';
+function extractBearer(req) {
+    const header = req.headers['authorization'];
+    if (typeof header !== 'string')
+        return undefined;
+    const match = /^Bearer\s+(.+)$/i.exec(header);
+    return match?.[1];
+}
+async function readJsonBody(req) {
+    if (req.method !== 'POST')
+        return undefined;
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        req.on('data', (c) => chunks.push(c));
+        req.on('end', () => {
+            const raw = Buffer.concat(chunks).toString('utf8');
+            if (!raw)
+                return resolve(undefined);
+            try {
+                resolve(JSON.parse(raw));
+            }
+            catch (err) {
+                reject(err);
+            }
+        });
+        req.on('error', reject);
+    });
+}
+export async function startHttpServer(opts) {
+    const { port, host = '0.0.0.0', stateless = true } = opts;
+    const transports = new Map();
+    async function handleMcpRequest(req, res) {
+        const sessionId = req.headers['mcp-session-id'] ?? undefined;
+        let transport = sessionId ? transports.get(sessionId) : undefined;
+        if (!transport) {
+            transport = new StreamableHTTPServerTransport({
+                sessionIdGenerator: stateless ? undefined : randomUUID,
+                onsessioninitialized: stateless
+                    ? undefined
+                    : (newSessionId) => {
+                        if (transport)
+                            transports.set(newSessionId, transport);
+                    },
+            });
+            transport.onclose = () => {
+                if (sessionId)
+                    transports.delete(sessionId);
+            };
+            const server = createMcpServer();
+            await server.connect(transport);
+        }
+        const body = await readJsonBody(req);
+        const bearerToken = extractBearer(req);
+        await runWithAuthContext({ bearerToken }, () => transport.handleRequest(req, res, body));
+    }
+    const httpServer = createServer((req, res) => {
+        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 (url === '/mcp' || url.startsWith('/mcp?')) {
+            handleMcpRequest(req, res).catch((err) => {
+                if (!res.headersSent) {
+                    res.writeHead(500, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: err instanceof Error ? err.message : String(err) }));
+                }
+                else {
+                    res.end();
+                }
+            });
+            return;
+        }
+        res.writeHead(404, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Not found' }));
+    });
+    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`);
+            resolve();
+        });
+    });
+}

package/dist/transports/stdio.d.ts

@@ -0,0 +1,2 @@
+export declare function startStdioServer(): Promise<void>;
+//# sourceMappingURL=stdio.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"stdio.d.ts","sourceRoot":"","sources":["../../src/transports/stdio.ts"],"names":[],"mappings":"AAGA,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC,CAItD"}

package/dist/transports/stdio.js

@@ -0,0 +1,7 @@
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { createMcpServer } from '../server.js';
+export async function startStdioServer() {
+    const server = createMcpServer();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}

package/package.json

@@ -50,7 +50,7 @@
     "url": "https://github.com/FerrLabs/MCP.git"
   },
   "type": "module",
-  "version": "5.1.1",
+  "version": "5.2.1",
   "scripts": {
     "build": "tsc",
     "ci:local": "pnpm typecheck && pnpm test && pnpm build",