@rigour-labs/mcp 6.1.1 → 6.2.0

package/dist/gateway/runtime.d.ts

@@ -0,0 +1,19 @@
+import type { CallToolResult, Tool } from '@modelcontextprotocol/sdk/types.js';
+import type { GatewayControlConfig } from '@rigour-labs/core';
+export interface GatewayTool extends Tool {
+    name: string;
+}
+export declare class DownstreamRegistry {
+    private readonly config;
+    private readonly cwd;
+    private readonly connected;
+    constructor(config: GatewayControlConfig, cwd: string);
+    connect(): Promise<void>;
+    listTools(): Promise<GatewayTool[]>;
+    call(serverName: string, toolName: string, args: Record<string, unknown>): Promise<CallToolResult>;
+    close(): Promise<void>;
+}
+export declare function splitGatewayTool(name: string, configuredServers: string[]): {
+    server: string;
+    tool: string;
+} | null;

package/dist/gateway/runtime.js

@@ -0,0 +1,81 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { getDefaultEnvironment, StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+function exposedSchema(schema) {
+    const properties = schema.properties && typeof schema.properties === 'object' ? schema.properties : {};
+    return {
+        ...schema,
+        properties: {
+            ...properties,
+            _rigourCapability: {
+                type: 'string',
+                description: 'One-use capability id issued by the Rigour control plane',
+            },
+        },
+    };
+}
+export class DownstreamRegistry {
+    config;
+    cwd;
+    connected = new Map();
+    constructor(config, cwd) {
+        this.config = config;
+        this.cwd = cwd;
+    }
+    async connect() {
+        try {
+            for (const [name, serverConfig] of Object.entries(this.config.servers)) {
+                const client = new Client({ name: 'rigour-mcp-gateway', version: '1.0.0' });
+                const transport = new StdioClientTransport({
+                    command: serverConfig.command,
+                    args: serverConfig.args,
+                    env: { ...getDefaultEnvironment(), ...serverConfig.env },
+                    cwd: this.cwd,
+                    stderr: 'inherit',
+                });
+                await client.connect(transport);
+                this.connected.set(name, { client, transport, config: serverConfig });
+            }
+        }
+        catch (error) {
+            await this.close();
+            throw error;
+        }
+    }
+    async listTools() {
+        const tools = [];
+        for (const [serverName, downstream] of this.connected) {
+            const listed = await downstream.client.listTools();
+            for (const tool of listed.tools) {
+                if (!downstream.config.allow.includes('*') && !downstream.config.allow.includes(tool.name))
+                    continue;
+                tools.push({
+                    ...tool,
+                    name: `${serverName}__${tool.name}`,
+                    description: `[via Rigour:${serverName}] ${tool.description ?? tool.name}`,
+                    inputSchema: exposedSchema(tool.inputSchema),
+                });
+            }
+        }
+        return tools;
+    }
+    async call(serverName, toolName, args) {
+        const downstream = this.connected.get(serverName);
+        if (!downstream)
+            throw new Error(`Unknown downstream MCP server: ${serverName}`);
+        if (!downstream.config.allow.includes('*') && !downstream.config.allow.includes(toolName)) {
+            throw new Error(`Tool ${serverName}__${toolName} is not allowed by the trusted gateway configuration`);
+        }
+        return downstream.client.callTool({ name: toolName, arguments: args });
+    }
+    async close() {
+        await Promise.allSettled([...this.connected.values()].map(({ client }) => client.close()));
+        this.connected.clear();
+    }
+}
+export function splitGatewayTool(name, configuredServers) {
+    const server = configuredServers.find((candidate) => name.startsWith(`${candidate}__`));
+    if (!server)
+        return null;
+    const tool = name.slice(server.length + 2);
+    return tool ? { server, tool } : null;
+}

package/dist/gateway/server.d.ts

@@ -0,0 +1 @@
+export declare function runGatewayServer(cwd: string): Promise<void>;

package/dist/gateway/server.js

@@ -0,0 +1,125 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { appendExecutionReceipt, consumeTrustedGrant, getGatewayPolicyHash, loadGatewayConfig, normalizeMcpAction, } from '@rigour-labs/core';
+import { DownstreamRegistry, splitGatewayTool } from './runtime.js';
+function denied(message) {
+    return { isError: true, content: [{ type: 'text', text: `Rigour denied this action: ${message}` }] };
+}
+function failed(message) {
+    return { isError: true, content: [{ type: 'text', text: message }] };
+}
+function authorize(cwd, config, capabilityId, resource) {
+    if (!capabilityId)
+        return { ok: false, reason: 'Explicit capability is required' };
+    return consumeTrustedGrant(cwd, {
+        id: capabilityId,
+        subjectId: config.agentId,
+        taskId: config.taskId,
+        action: 'mcp.call',
+        resource,
+    });
+}
+function prepareCall(request, context) {
+    const target = splitGatewayTool(request.params.name, Object.keys(context.config.servers));
+    const rawArgs = (request.params.arguments ?? {});
+    const capabilityId = typeof rawArgs._rigourCapability === 'string' ? rawArgs._rigourCapability : undefined;
+    const args = { ...rawArgs };
+    delete args._rigourCapability;
+    const actionTarget = target ?? { server: 'gateway', tool: request.params.name };
+    const action = normalizeMcpAction({
+        actorId: context.config.agentId,
+        taskId: context.config.taskId,
+        server: actionTarget.server,
+        tool: actionTarget.tool,
+        args,
+    });
+    return { target, args, capabilityId, action };
+}
+function toolIsAllowed(context, target) {
+    const allowed = context.config.servers[target.server].allow;
+    return allowed.includes('*') || allowed.includes(target.tool);
+}
+function authorizationDecision(config, authorization) {
+    const mustDeny = config.mode === 'enforce' && !authorization.ok;
+    return {
+        mustDeny,
+        decision: (mustDeny ? 'deny' : 'allow'),
+        simulatedDecision: config.mode === 'observe' && !authorization.ok ? 'deny' : undefined,
+        reason: authorization.ok
+            ? authorization.reason
+            : config.mode === 'observe'
+                ? `Observe mode: would deny because ${authorization.reason}`
+                : authorization.reason,
+    };
+}
+async function recordDenial(context, input) {
+    await appendExecutionReceipt(context.cwd, {
+        action: input.action,
+        mode: context.config.mode,
+        decision: 'deny',
+        reason: input.reason,
+        capabilityId: input.capabilityId,
+        policyHash: context.policyHash,
+        outcome: 'denied',
+    });
+    return denied(input.reason);
+}
+async function handleGatewayCall(request, context) {
+    const { target, args, capabilityId, action } = prepareCall(request, context);
+    if (!target)
+        return recordDenial(context, { action, capabilityId, reason: `Unknown gateway tool ${request.params.name}` });
+    if (!toolIsAllowed(context, target)) {
+        return recordDenial(context, {
+            action, capabilityId, reason: `Tool ${request.params.name} is not allowed by the trusted gateway configuration`,
+        });
+    }
+    const authorization = await authorize(context.cwd, context.config, capabilityId, action.resource);
+    const { mustDeny, decision, simulatedDecision, reason } = authorizationDecision(context.config, authorization);
+    if (mustDeny)
+        return recordDenial(context, { action, capabilityId, reason });
+    let result;
+    try {
+        result = await context.downstream.call(target.server, target.tool, args);
+    }
+    catch (error) {
+        const failure = `${reason}; downstream failed before returning a result: ${error?.message ?? String(error)}`;
+        await appendExecutionReceipt(context.cwd, {
+            action, mode: context.config.mode, decision, simulatedDecision, reason: failure,
+            capabilityId, policyHash: context.policyHash, outcome: 'failed',
+        });
+        return failed(failure);
+    }
+    try {
+        const outcome = result.isError ? 'failed' : 'forwarded';
+        const receipt = await appendExecutionReceipt(context.cwd, {
+            action, mode: context.config.mode, decision, simulatedDecision,
+            reason: result.isError ? `${reason}; downstream returned an error result` : reason,
+            capabilityId, policyHash: context.policyHash, outcome,
+        });
+        return { ...result, _meta: { ...(result._meta ?? {}), rigourReceiptId: receipt.id } };
+    }
+    catch (error) {
+        return failed(`Downstream action returned, but Rigour could not record its receipt: ${error?.message ?? String(error)}. Treat the external outcome as unknown and inspect the downstream system.`);
+    }
+}
+export async function runGatewayServer(cwd) {
+    const config = await loadGatewayConfig(cwd);
+    if (!config)
+        throw new Error('Gateway is not configured. Run `rigour firewall gateway-configure --config <file>`.');
+    const downstream = new DownstreamRegistry(config, cwd);
+    await downstream.connect();
+    const server = new Server({ name: 'rigour-mcp-gateway', version: '1.0.0' }, { capabilities: { tools: {} } });
+    const policyHash = getGatewayPolicyHash(cwd, config);
+    const context = { cwd, config, downstream, policyHash };
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: await downstream.listTools() }));
+    server.setRequestHandler(CallToolRequestSchema, async (request) => handleGatewayCall(request, context));
+    const shutdown = async () => {
+        await downstream.close();
+        await server.close();
+    };
+    process.once('SIGINT', shutdown);
+    process.once('SIGTERM', shutdown);
+    await server.connect(new StdioServerTransport());
+    console.error(`Rigour MCP gateway running in ${config.mode} mode for ${Object.keys(config.servers).length} downstream server(s)`);
+}

package/dist/index.js

@@ -467,6 +467,13 @@ server.setRequestHandler(GetPromptRequestSchema, async (request) => {
 });
 // ─── Start ────────────────────────────────────────────────────────
 async function main() {
+    if (process.argv.includes('--gateway')) {
+        const repoFlag = process.argv.indexOf('--repo');
+        const cwd = repoFlag >= 0 && process.argv[repoFlag + 1] ? process.argv[repoFlag + 1] : process.cwd();
+        const { runGatewayServer } = await import('./gateway/server.js');
+        await runGatewayServer(cwd);
+        return;
+    }
     const transport = new StdioServerTransport();
     await server.connect(transport);
     console.error("Rigour MCP server v4.0.0 running on stdio");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rigour-labs/mcp",
-  "version": "6.1.1",
+  "version": "6.2.0",
   "description": "MCP server + live dashboard for AI code governance — OWASP LLM Top 10 (10/10), real-time MCP App UI, 25+ security patterns, Bayesian learning Brain, hallucinated import detection, multi-agent governance. Works with Claude, Cursor, VS Code, ChatGPT, Goose, Windsurf. Industry presets for HIPAA, SOC2, FedRAMP.",
   "license": "MIT",
   "homepage": "https://rigour.run",
@@ -62,7 +62,7 @@
     "execa": "^8.0.1",
     "fs-extra": "^11.4.0",
     "yaml": "^2.8.2",
-    "@rigour-labs/core": "6.1.1"
+    "@rigour-labs/core": "6.2.0"
   },
   "devDependencies": {
     "@types/node": "^25.0.3",