@nebutra/mcp 0.1.3 → 0.1.4

package/src/middleware/mcpMiddleware.ts

@@ -1,150 +0,0 @@
-import type { MCPContext, ToolExecutionResult } from "../types";
-
-/**
- * MCP Middleware for rate limiting, audit logging, and access control
- */
-
-export interface MCPMiddlewareContext extends MCPContext {
-  toolName: string;
-  arguments: Record<string, unknown>;
-}
-
-export type MCPMiddlewareNext = () => Promise<ToolExecutionResult>;
-
-export type MCPMiddleware = (
-  ctx: MCPMiddlewareContext,
-  next: MCPMiddlewareNext,
-) => Promise<ToolExecutionResult>;
-
-/**
- * Rate limiting middleware for MCP calls
- */
-export function createRateLimitMiddleware(options: {
-  maxRequests: number;
-  windowMs: number;
-}): MCPMiddleware {
-  const requests = new Map<string, { count: number; resetAt: number }>();
-
-  return async (ctx, next) => {
-    const key = `${ctx.tenantId || "anon"}:${ctx.userId || "anon"}`;
-    const now = Date.now();
-
-    let record = requests.get(key);
-    if (!record || now > record.resetAt) {
-      record = { count: 0, resetAt: now + options.windowMs };
-      requests.set(key, record);
-    }
-
-    record.count++;
-
-    if (record.count > options.maxRequests) {
-      return {
-        success: false,
-        error: `MCP rate limit exceeded. Max ${options.maxRequests} requests per ${options.windowMs / 1000}s`,
-        duration: 0,
-      };
-    }
-
-    return next();
-  };
-}
-
-/**
- * Audit logging middleware
- */
-export function createAuditMiddleware(options: {
-  onLog: (entry: AuditLogEntry) => void | Promise<void>;
-}): MCPMiddleware {
-  return async (ctx, next) => {
-    const result = await next();
-
-    const entry: AuditLogEntry = {
-      timestamp: new Date().toISOString(),
-      requestId: ctx.requestId,
-      toolName: ctx.toolName,
-      arguments: ctx.arguments,
-      success: result.success,
-      duration: result.duration,
-    };
-
-    if (ctx.tenantId) entry.tenantId = ctx.tenantId;
-    if (ctx.userId) entry.userId = ctx.userId;
-    if (result.error) entry.error = result.error;
-
-    // Don't block on audit logging
-    Promise.resolve(options.onLog(entry)).catch(console.error);
-
-    return result;
-  };
-}
-
-export interface AuditLogEntry {
-  timestamp: string;
-  requestId: string;
-  tenantId?: string;
-  userId?: string;
-  toolName: string;
-  arguments: Record<string, unknown>;
-  success: boolean;
-  duration: number;
-  error?: string;
-}
-
-/**
- * Tool access control middleware
- */
-export function createAccessControlMiddleware(options: {
-  blockedTools?: string[];
-  allowedTools?: string[];
-}): MCPMiddleware {
-  return async (ctx, next) => {
-    // Check blocked list
-    if (options.blockedTools?.includes(ctx.toolName)) {
-      return {
-        success: false,
-        error: `Tool ${ctx.toolName} is blocked`,
-        duration: 0,
-      };
-    }
-
-    // Check allowed list (if specified)
-    if (
-      options.allowedTools &&
-      options.allowedTools.length > 0 &&
-      !options.allowedTools.includes(ctx.toolName)
-    ) {
-      return {
-        success: false,
-        error: `Tool ${ctx.toolName} is not in allowed list`,
-        duration: 0,
-      };
-    }
-
-    return next();
-  };
-}
-
-/**
- * Compose multiple middlewares
- */
-export function composeMCPMiddleware(middlewares: MCPMiddleware[]): MCPMiddleware {
-  return async (ctx, finalNext) => {
-    let index = -1;
-
-    const dispatch = async (i: number): Promise<ToolExecutionResult> => {
-      if (i <= index) {
-        throw new Error("next() called multiple times");
-      }
-      index = i;
-
-      const middleware = middlewares[i];
-      if (!middleware) {
-        return finalNext();
-      }
-
-      return middleware(ctx, () => dispatch(i + 1));
-    };
-
-    return dispatch(0);
-  };
-}

package/src/registry/index.ts

@@ -1 +0,0 @@
-export { MCPServerRegistry, serverRegistry } from "./serverRegistry";

package/src/registry/serverRegistry.ts

@@ -1,165 +0,0 @@
-import type { MCPContext, MCPServerConfig, ToolDefinition } from "../types";
-
-/**
- * Registry for MCP servers and their tools
- * Handles server registration, discovery, and access control
- */
-export class MCPServerRegistry {
-  private servers: Map<string, MCPServerConfig> = new Map();
-  private toolIndex: Map<string, string> = new Map(); // tool name -> server id
-
-  /**
-   * Register an MCP server
-   */
-  register(config: MCPServerConfig): void {
-    this.servers.set(config.id, config);
-
-    // Index tools for quick lookup
-    for (const tool of config.tools) {
-      const qualifiedName = `${config.id}:${tool.name}`;
-      this.toolIndex.set(qualifiedName, config.id);
-      // Also allow short name if unique
-      if (!this.toolIndex.has(tool.name)) {
-        this.toolIndex.set(tool.name, config.id);
-      }
-    }
-  }
-
-  /**
-   * Unregister an MCP server
-   */
-  unregister(serverId: string): boolean {
-    const server = this.servers.get(serverId);
-    if (!server) return false;
-
-    // Remove tool index entries
-    for (const tool of server.tools) {
-      const qualifiedName = `${serverId}:${tool.name}`;
-      this.toolIndex.delete(qualifiedName);
-      // Only remove short name if it points to this server
-      if (this.toolIndex.get(tool.name) === serverId) {
-        this.toolIndex.delete(tool.name);
-      }
-    }
-
-    this.servers.delete(serverId);
-    return true;
-  }
-
-  /**
-   * Get server by ID
-   */
-  getServer(serverId: string): MCPServerConfig | undefined {
-    return this.servers.get(serverId);
-  }
-
-  /**
-   * Find server by tool name
-   */
-  findServerByTool(toolName: string): MCPServerConfig | undefined {
-    const serverId = this.toolIndex.get(toolName);
-    if (!serverId) return undefined;
-    return this.servers.get(serverId);
-  }
-
-  /**
-   * Get all registered servers
-   */
-  getAllServers(): MCPServerConfig[] {
-    return Array.from(this.servers.values());
-  }
-
-  /**
-   * Get all available tools
-   */
-  getAllTools(): Array<ToolDefinition & { serverId: string }> {
-    const tools: Array<ToolDefinition & { serverId: string }> = [];
-    for (const server of this.servers.values()) {
-      for (const tool of server.tools) {
-        tools.push({ ...tool, serverId: server.id });
-      }
-    }
-    return tools;
-  }
-
-  /**
-   * Check if a context has access to a server
-   */
-  canAccess(serverId: string, context: MCPContext): boolean {
-    const server = this.servers.get(serverId);
-    if (!server) return false;
-
-    // Check plan restrictions
-    if (server.allowedPlans && server.allowedPlans.length > 0) {
-      if (!context.plan || !server.allowedPlans.includes(context.plan)) {
-        return false;
-      }
-    }
-
-    // Check tenant restrictions
-    if (server.allowedTenants && server.allowedTenants.length > 0) {
-      if (!context.tenantId || !server.allowedTenants.includes(context.tenantId)) {
-        return false;
-      }
-    }
-
-    return true;
-  }
-
-  /**
-   * Check whether a context can execute a specific tool. Tool-level policy
-   * narrows the server policy and supports tenant, plan, and permission gates.
-   */
-  canAccessTool(toolName: string, context: MCPContext): boolean {
-    const server = this.findServerByTool(toolName);
-    if (!server || !this.canAccess(server.id, context)) return false;
-
-    const tool = this.findTool(server, toolName);
-    if (!tool) return false;
-
-    if (tool.allowedPlans && tool.allowedPlans.length > 0) {
-      if (!context.plan || !tool.allowedPlans.includes(context.plan)) return false;
-    }
-
-    if (tool.allowedTenants && tool.allowedTenants.length > 0) {
-      if (!context.tenantId || !tool.allowedTenants.includes(context.tenantId)) return false;
-    }
-
-    if (tool.requiredPermissions && tool.requiredPermissions.length > 0) {
-      const permissions = new Set(context.permissions ?? []);
-      if (!tool.requiredPermissions.every((permission) => permissions.has(permission))) {
-        return false;
-      }
-    }
-
-    return true;
-  }
-
-  /**
-   * Get tools accessible by a context
-   */
-  getAccessibleTools(context: MCPContext): Array<ToolDefinition & { serverId: string }> {
-    const tools: Array<ToolDefinition & { serverId: string }> = [];
-
-    for (const server of this.servers.values()) {
-      if (this.canAccess(server.id, context)) {
-        for (const tool of server.tools) {
-          if (this.canAccessTool(`${server.id}:${tool.name}`, context)) {
-            tools.push({ ...tool, serverId: server.id });
-          }
-        }
-      }
-    }
-
-    return tools;
-  }
-
-  private findTool(server: MCPServerConfig, toolName: string): ToolDefinition | undefined {
-    return server.tools.find(
-      (tool) => tool.name === toolName || `${server.id}:${tool.name}` === toolName,
-    );
-  }
-}
-
-// Global registry instance
-export const serverRegistry = new MCPServerRegistry();

package/src/server/contextServer.ts

@@ -1,211 +0,0 @@
-#!/usr/bin/env node
-
-import fs from "node:fs";
-import path from "node:path";
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import {
-  CallToolRequestSchema,
-  ListResourcesRequestSchema,
-  ListToolsRequestSchema,
-  ReadResourceRequestSchema,
-} from "@modelcontextprotocol/sdk/types.js";
-
-/**
- * Nebutra MCP Context Server
- * Exposes core project files and state to Cursor / Windsurf allowing AI Agents
- * to instantly understand the Nebutra-Sailor application structure and routing logic.
- */
-class NebutraContextServer {
-  private server: Server;
-  private projectRoot: string;
-
-  constructor(projectRoot?: string) {
-    this.projectRoot = projectRoot || process.cwd();
-
-    this.server = new Server(
-      {
-        name: "@nebutra/context-server",
-        version: "0.1.0",
-      },
-      {
-        capabilities: {
-          resources: {},
-          tools: {},
-        },
-      },
-    );
-
-    this.setupResourceHandlers();
-    this.setupToolHandlers();
-
-    this.server.onerror = (_error) => {};
-  }
-
-  private setupResourceHandlers() {
-    const handlers = createContextServerHandlers(this.projectRoot);
-
-    this.server.setRequestHandler(ListResourcesRequestSchema, async () => handlers.listResources());
-
-    this.server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
-      return handlers.readResource(request.params);
-    });
-  }
-
-  private setupToolHandlers() {
-    const handlers = createContextServerHandlers(this.projectRoot);
-
-    this.server.setRequestHandler(ListToolsRequestSchema, async () => handlers.listTools());
-
-    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-      return handlers.callTool(request.params);
-    });
-  }
-
-  async run() {
-    const transport = new StdioServerTransport();
-    await this.server.connect(transport);
-  }
-}
-
-const RESOURCE_MAP = {
-  "file:///nebutra.config.json": {
-    relativePath: "nebutra.config.json",
-    name: "Nebutra Configuration",
-    mimeType: "application/json",
-    description:
-      "Global configurations for the Nebutra template including enabled features (auth, payments, i18n, db).",
-  },
-  "file:///prisma/schema.prisma": {
-    relativePath: "packages/platform/db/prisma/schema.prisma",
-    name: "Database Schema Overview",
-    mimeType: "text/plain",
-    description: "The core Prisma schema defining the database tables and relationships.",
-  },
-} as const;
-
-export function createContextServerHandlers(projectRoot: string) {
-  return {
-    async listResources() {
-      return {
-        resources: Object.entries(RESOURCE_MAP).map(([uri, resource]) => ({
-          uri,
-          name: resource.name,
-          mimeType: resource.mimeType,
-          description: resource.description,
-        })),
-      };
-    },
-
-    async readResource({ uri }: { uri: string }) {
-      const resource = RESOURCE_MAP[uri as keyof typeof RESOURCE_MAP];
-      if (!resource) {
-        throw new Error(`Resource not found: ${uri}`);
-      }
-
-      const filePath = path.join(projectRoot, resource.relativePath);
-      try {
-        const content = fs.readFileSync(filePath, "utf-8");
-        return {
-          contents: [
-            {
-              uri,
-              mimeType: resource.mimeType,
-              text: content,
-            },
-          ],
-        };
-      } catch {
-        throw new Error(`Failed to read the requested resource file at ${filePath}`);
-      }
-    },
-
-    async listTools() {
-      return {
-        tools: [
-          {
-            name: "get_project_structure",
-            description: "Returns a bounded app/package routing tree for the current project.",
-            inputSchema: {
-              type: "object",
-              properties: {},
-              required: [],
-            },
-          },
-        ],
-      };
-    },
-
-    async callTool({ name }: { name: string; arguments?: Record<string, unknown> | undefined }) {
-      if (name !== "get_project_structure") {
-        throw new Error(`Unknown tool: ${name}`);
-      }
-
-      try {
-        return {
-          content: [
-            {
-              type: "text",
-              text: getProjectStructure(projectRoot),
-            },
-          ],
-        };
-      } catch (error) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Error: ${error instanceof Error ? error.message : String(error)}`,
-            },
-          ],
-          isError: true,
-        };
-      }
-    },
-  };
-}
-
-function getProjectStructure(projectRoot: string): string {
-  const roots = ["apps", "packages", "backends"].filter((segment) =>
-    fs.existsSync(path.join(projectRoot, segment)),
-  );
-  if (roots.length === 0) return "No Nebutra workspace roots found.";
-
-  const entries: string[] = [];
-  for (const root of roots) {
-    walkProjectTree(path.join(projectRoot, root), root, entries, 4);
-  }
-  return entries.length > 0 ? entries.join("\n") : "No project entries found.";
-}
-
-function walkProjectTree(
-  absoluteDir: string,
-  relativeDir: string,
-  entries: string[],
-  depthRemaining: number,
-): void {
-  if (depthRemaining < 0 || entries.length >= 200) return;
-
-  entries.push(relativeDir);
-
-  for (const dirent of fs.readdirSync(absoluteDir, { withFileTypes: true })) {
-    if (!dirent.isDirectory()) continue;
-    if (dirent.name === "node_modules" || dirent.name.startsWith(".")) continue;
-    walkProjectTree(
-      path.join(absoluteDir, dirent.name),
-      path.join(relativeDir, dirent.name),
-      entries,
-      depthRemaining - 1,
-    );
-  }
-}
-
-// Export a factory or run directly if invoked as script
-export const startContextServer = () => {
-  const server = new NebutraContextServer();
-  server.run().catch(console.error);
-};
-
-if (process.argv[1]?.endsWith("contextServer.js") || process.argv[1]?.endsWith("nebutra-mcp")) {
-  startContextServer();
-}

package/src/server/index.ts

@@ -1,6 +0,0 @@
-export {
-  getInternalServerIds,
-  INTERNAL_SERVERS,
-  registerInternalServers,
-} from "./internalServers";
-export { createUiAgentMcpServer } from "./uiAgentServer";

package/src/server/internalServers.ts

@@ -1,72 +0,0 @@
-import { serverRegistry } from "../registry/serverRegistry";
-import type { MCPServerConfig } from "../types";
-import { createUiAgentMcpServer } from "./uiAgentServer";
-
-/**
- * Register internal Nebutra services as MCP servers
- * These wrap our existing microservices with MCP-compatible interfaces
- */
-
-export const INTERNAL_SERVERS: MCPServerConfig[] = [
-  createUiAgentMcpServer(),
-  // AI Service
-  {
-    id: "nebutra-ai",
-    name: "Nebutra AI Service",
-    description: "AI-powered text generation, embedding, and translation",
-    endpoint: process.env.AI_SERVICE_URL || "http://localhost:8001",
-    transport: "http",
-    tools: [
-      {
-        name: "generate_text",
-        description: "Generate text using LLM",
-        parameters: {
-          prompt: { type: "string", description: "Input prompt", required: true },
-          max_tokens: { type: "number", description: "Max tokens to generate", default: 1000 },
-          temperature: { type: "number", description: "Sampling temperature", default: 0.7 },
-        },
-        returns: "Generated text",
-      },
-      {
-        name: "create_embedding",
-        description: "Create vector embedding for text",
-        parameters: {
-          text: { type: "string", description: "Text to embed", required: true },
-          model: {
-            type: "string",
-            description: "Embedding model",
-            default: "text-embedding-3-small",
-          },
-        },
-        returns: "Vector embedding array",
-      },
-      {
-        name: "translate",
-        description: "Translate text between languages",
-        parameters: {
-          text: { type: "string", description: "Text to translate", required: true },
-          source: { type: "string", description: "Source language code", default: "en" },
-          target: { type: "string", description: "Target language code", required: true },
-        },
-        returns: "Translated text",
-      },
-    ],
-    rateLimit: { maxRequests: 100, windowMs: 60000 },
-  },
-];
-
-/**
- * Register all internal servers
- */
-export function registerInternalServers(): void {
-  for (const server of INTERNAL_SERVERS) {
-    serverRegistry.register(server);
-  }
-}
-
-/**
- * Get list of internal server IDs
- */
-export function getInternalServerIds(): string[] {
-  return INTERNAL_SERVERS.map((s) => s.id);
-}