@nebutra/mcp 0.1.3 → 2.0.0

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # @nebutra/mcp
 
+## 2.0.0
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @nebutra/ui@2.0.0
+  - @nebutra/capability-kit@2.0.0
+  - @nebutra/errors@2.0.0
+  - @nebutra/event-log@2.0.0
+  - @nebutra/trace-store@2.0.0
+
 ## 0.1.3
 
 ### Patch Changes

package/bin/nebutra-mcp.js

@@ -1,5 +1,28 @@
 #!/usr/bin/env node
-import { startContextServer } from "../src/server/contextServer.js";
+// Committed bin entry for `nebutra-mcp` (the stdio context server).
+//
+// pnpm links bins before any lifecycle script or build runs, so package.json#bin
+// must point at a file that exists in a fresh checkout — dist/ does not. This
+// file exists at link time and hands off to the tsup output once it is built.
+// Guarded by tests/architecture/workspace-bin-stubs.test.ts.
+import { existsSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
 
-// Starts the stdio MCP server for Cursor / Windsurf.
-startContextServer();
+const entry = resolve(dirname(fileURLToPath(import.meta.url)), "../dist/server/contextServer.js");
+
+if (!existsSync(entry)) {
+  process.stderr.write(
+    [
+      `nebutra-mcp: built entry not found at ${entry}`,
+      "The package has not been built yet. Run `pnpm --filter @nebutra/mcp build` and retry.",
+      "",
+    ].join("\n"),
+  );
+  process.exit(1);
+}
+
+// contextServer.js starts the server only when process.argv[1] ends with
+// "contextServer.js", so make argv identical to a direct `node dist/server/… `.
+process.argv[1] = entry;
+await import(pathToFileURL(entry).href);

package/bin/nebutra-tool-protocol.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+// Committed bin entry for `nebutra-tool-protocol`.
+//
+// pnpm links bins before any lifecycle script or build runs, so package.json#bin
+// must point at a file that exists in a fresh checkout — dist/ does not. This
+// file exists at link time and hands off to the tsup output once it is built.
+// Guarded by tests/architecture/workspace-bin-stubs.test.ts.
+import { existsSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const entry = resolve(dirname(fileURLToPath(import.meta.url)), "../dist/cli.js");
+
+if (!existsSync(entry)) {
+  process.stderr.write(
+    [
+      `nebutra-tool-protocol: built entry not found at ${entry}`,
+      "The package has not been built yet. Run `pnpm --filter @nebutra/mcp build` and retry.",
+      "",
+    ].join("\n"),
+  );
+  process.exit(1);
+}
+
+// Keep argv identical to a direct `node dist/cli.js …` invocation.
+process.argv[1] = entry;
+await import(pathToFileURL(entry).href);

package/dist/{chunk-25TNKUCR.js → chunk-7A2G4AGA.js}

@@ -541,83 +541,6 @@ var McpHost = class {
 var toolConsentStore = new InMemoryToolConsentStore();
 var mcpHost = new McpHost({ consent: toolConsentStore });
 
-// src/middleware/mcpMiddleware.ts
-function createRateLimitMiddleware(options) {
-  const requests = /* @__PURE__ */ new Map();
-  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 / 1e3}s`,
-        duration: 0
-      };
-    }
-    return next();
-  };
-}
-function createAuditMiddleware(options) {
-  return async (ctx, next) => {
-    const result = await next();
-    const entry = {
-      timestamp: (/* @__PURE__ */ 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;
-    Promise.resolve(options.onLog(entry)).catch(console.error);
-    return result;
-  };
-}
-function createAccessControlMiddleware(options) {
-  return async (ctx, next) => {
-    if (options.blockedTools?.includes(ctx.toolName)) {
-      return {
-        success: false,
-        error: `Tool ${ctx.toolName} is blocked`,
-        duration: 0
-      };
-    }
-    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();
-  };
-}
-function composeMCPMiddleware(middlewares) {
-  return async (ctx, finalNext) => {
-    let index = -1;
-    const dispatch = async (i) => {
-      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);
-  };
-}
-
 // src/server/uiAgentServer.ts
 import {
   loadAgentComponentContract,
@@ -856,10 +779,6 @@ export {
   McpHost,
   toolConsentStore,
   mcpHost,
-  createRateLimitMiddleware,
-  createAuditMiddleware,
-  createAccessControlMiddleware,
-  composeMCPMiddleware,
   INTERNAL_SERVERS,
   registerInternalServers,
   getInternalServerIds,

package/dist/chunk-EMIF5K3P.js

@@ -0,0 +1,83 @@
+// src/middleware/mcpMiddleware.ts
+function createRateLimitMiddleware(options) {
+  const requests = /* @__PURE__ */ new Map();
+  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 / 1e3}s`,
+        duration: 0
+      };
+    }
+    return next();
+  };
+}
+function createAuditMiddleware(options) {
+  return async (ctx, next) => {
+    const result = await next();
+    const entry = {
+      timestamp: (/* @__PURE__ */ 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;
+    Promise.resolve(options.onLog(entry)).catch(console.error);
+    return result;
+  };
+}
+function createAccessControlMiddleware(options) {
+  return async (ctx, next) => {
+    if (options.blockedTools?.includes(ctx.toolName)) {
+      return {
+        success: false,
+        error: `Tool ${ctx.toolName} is blocked`,
+        duration: 0
+      };
+    }
+    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();
+  };
+}
+function composeMCPMiddleware(middlewares) {
+  return async (ctx, finalNext) => {
+    let index = -1;
+    const dispatch = async (i) => {
+      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);
+  };
+}
+
+export {
+  createRateLimitMiddleware,
+  createAuditMiddleware,
+  createAccessControlMiddleware,
+  composeMCPMiddleware
+};

package/dist/cli.js

@@ -1,7 +1,8 @@
 import {
   McpHost,
   readToolDebug
-} from "./chunk-25TNKUCR.js";
+} from "./chunk-7A2G4AGA.js";
+import "./chunk-EMIF5K3P.js";
 import {
   createContextServerHandlers
 } from "./chunk-YMTQFRV2.js";

package/dist/index-BD_aLZKz.d.ts

@@ -0,0 +1,158 @@
+import { z } from 'zod';
+
+declare const ToolParameterSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        string: "string";
+        number: "number";
+        boolean: "boolean";
+        object: "object";
+        array: "array";
+    }>;
+    description: z.ZodOptional<z.ZodString>;
+    required: z.ZodOptional<z.ZodBoolean>;
+    default: z.ZodOptional<z.ZodAny>;
+}, z.core.$strip>;
+declare const ToolDefinitionSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        type: z.ZodEnum<{
+            string: "string";
+            number: "number";
+            boolean: "boolean";
+            object: "object";
+            array: "array";
+        }>;
+        description: z.ZodOptional<z.ZodString>;
+        required: z.ZodOptional<z.ZodBoolean>;
+        default: z.ZodOptional<z.ZodAny>;
+    }, z.core.$strip>>>;
+    returns: z.ZodOptional<z.ZodString>;
+    allowedPlans: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    allowedTenants: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    requiredPermissions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+type ToolParameter = z.infer<typeof ToolParameterSchema>;
+type ToolDefinition = z.infer<typeof ToolDefinitionSchema>;
+interface MCPRequest {
+    id: string;
+    method: string;
+    params?: Record<string, unknown>;
+}
+interface MCPResponse {
+    id: string;
+    result?: unknown;
+    error?: MCPError;
+}
+interface MCPError {
+    code: number;
+    message: string;
+    data?: unknown;
+}
+interface MCPContext {
+    requestId: string;
+    tenantId?: string;
+    userId?: string;
+    plan?: string;
+    permissions?: string[];
+    metadata?: Record<string, unknown>;
+}
+interface ToolExecutionRequest {
+    tool: string;
+    arguments: Record<string, unknown>;
+    context: MCPContext;
+}
+interface ToolExecutionResult {
+    success: boolean;
+    result?: unknown;
+    error?: string;
+    duration: number;
+    tokensUsed?: number;
+}
+interface MCPServerManifest {
+    name: string;
+    version: string;
+    scopes: string[];
+    homepage?: string;
+}
+interface MCPServerConfig {
+    id: string;
+    name: string;
+    description: string;
+    endpoint: string;
+    transport: "http" | "websocket" | "stdio" | "local";
+    manifest?: MCPServerManifest;
+    tools: ToolDefinition[];
+    handlers?: Record<string, MCPToolHandler>;
+    authentication?: {
+        type: "bearer" | "api-key" | "none";
+        headerName?: string;
+    };
+    rateLimit?: {
+        maxRequests: number;
+        windowMs: number;
+    };
+    allowedPlans?: string[];
+    allowedTenants?: string[];
+}
+type MCPToolHandler = (args: Record<string, unknown>, context: MCPContext) => unknown | Promise<unknown>;
+interface SmitheryServerInfo {
+    qualifiedName: string;
+    displayName: string;
+    description: string;
+    homepage?: string;
+    useCount?: number;
+    isDeployed?: boolean;
+}
+interface SmitheryConfig {
+    apiKey?: string;
+    baseUrl: string;
+    defaultServers?: string[];
+}
+
+/**
+ * MCP Middleware for rate limiting, audit logging, and access control
+ */
+interface MCPMiddlewareContext extends MCPContext {
+    toolName: string;
+    arguments: Record<string, unknown>;
+}
+type MCPMiddlewareNext = () => Promise<ToolExecutionResult>;
+type MCPMiddleware = (ctx: MCPMiddlewareContext, next: MCPMiddlewareNext) => Promise<ToolExecutionResult>;
+/**
+ * Rate limiting middleware for MCP calls
+ */
+declare function createRateLimitMiddleware(options: {
+    maxRequests: number;
+    windowMs: number;
+}): MCPMiddleware;
+/**
+ * Audit logging middleware
+ */
+declare function createAuditMiddleware(options: {
+    onLog: (entry: AuditLogEntry) => void | Promise<void>;
+}): MCPMiddleware;
+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
+ */
+declare function createAccessControlMiddleware(options: {
+    blockedTools?: string[];
+    allowedTools?: string[];
+}): MCPMiddleware;
+/**
+ * Compose multiple middlewares
+ */
+declare function composeMCPMiddleware(middlewares: MCPMiddleware[]): MCPMiddleware;
+
+export { type AuditLogEntry as A, type MCPServerConfig as M, type SmitheryConfig as S, type ToolDefinition as T, type MCPContext as a, type ToolExecutionResult as b, type MCPServerManifest as c, type MCPToolHandler as d, type MCPError as e, type MCPMiddleware as f, type MCPMiddlewareContext as g, type MCPRequest as h, type MCPResponse as i, type SmitheryServerInfo as j, ToolDefinitionSchema as k, type ToolExecutionRequest as l, type ToolParameter as m, ToolParameterSchema as n, composeMCPMiddleware as o, createAccessControlMiddleware as p, createAuditMiddleware as q, createRateLimitMiddleware as r, type MCPMiddlewareNext as s };

package/dist/index.d.ts

@@ -1,116 +1,8 @@
-import { z } from 'zod';
+import { M as MCPServerConfig, T as ToolDefinition, a as MCPContext, b as ToolExecutionResult, c as MCPServerManifest, d as MCPToolHandler } from './index-BD_aLZKz.js';
+export { A as AuditLogEntry, e as MCPError, f as MCPMiddleware, g as MCPMiddlewareContext, h as MCPRequest, i as MCPResponse, S as SmitheryConfig, j as SmitheryServerInfo, k as ToolDefinitionSchema, l as ToolExecutionRequest, m as ToolParameter, n as ToolParameterSchema, o as composeMCPMiddleware, p as createAccessControlMiddleware, q as createAuditMiddleware, r as createRateLimitMiddleware } from './index-BD_aLZKz.js';
 import { EventLog } from '@nebutra/event-log';
 import { TraceStore } from '@nebutra/trace-store';
-
-declare const ToolParameterSchema: z.ZodObject<{
-    type: z.ZodEnum<{
-        string: "string";
-        number: "number";
-        boolean: "boolean";
-        object: "object";
-        array: "array";
-    }>;
-    description: z.ZodOptional<z.ZodString>;
-    required: z.ZodOptional<z.ZodBoolean>;
-    default: z.ZodOptional<z.ZodAny>;
-}, z.core.$strip>;
-declare const ToolDefinitionSchema: z.ZodObject<{
-    name: z.ZodString;
-    description: z.ZodString;
-    parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-        type: z.ZodEnum<{
-            string: "string";
-            number: "number";
-            boolean: "boolean";
-            object: "object";
-            array: "array";
-        }>;
-        description: z.ZodOptional<z.ZodString>;
-        required: z.ZodOptional<z.ZodBoolean>;
-        default: z.ZodOptional<z.ZodAny>;
-    }, z.core.$strip>>>;
-    returns: z.ZodOptional<z.ZodString>;
-    allowedPlans: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    allowedTenants: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    requiredPermissions: z.ZodOptional<z.ZodArray<z.ZodString>>;
-}, z.core.$strip>;
-type ToolParameter = z.infer<typeof ToolParameterSchema>;
-type ToolDefinition = z.infer<typeof ToolDefinitionSchema>;
-interface MCPRequest {
-    id: string;
-    method: string;
-    params?: Record<string, unknown>;
-}
-interface MCPResponse {
-    id: string;
-    result?: unknown;
-    error?: MCPError;
-}
-interface MCPError {
-    code: number;
-    message: string;
-    data?: unknown;
-}
-interface MCPContext {
-    requestId: string;
-    tenantId?: string;
-    userId?: string;
-    plan?: string;
-    permissions?: string[];
-    metadata?: Record<string, unknown>;
-}
-interface ToolExecutionRequest {
-    tool: string;
-    arguments: Record<string, unknown>;
-    context: MCPContext;
-}
-interface ToolExecutionResult {
-    success: boolean;
-    result?: unknown;
-    error?: string;
-    duration: number;
-    tokensUsed?: number;
-}
-interface MCPServerManifest {
-    name: string;
-    version: string;
-    scopes: string[];
-    homepage?: string;
-}
-interface MCPServerConfig {
-    id: string;
-    name: string;
-    description: string;
-    endpoint: string;
-    transport: "http" | "websocket" | "stdio" | "local";
-    manifest?: MCPServerManifest;
-    tools: ToolDefinition[];
-    handlers?: Record<string, MCPToolHandler>;
-    authentication?: {
-        type: "bearer" | "api-key" | "none";
-        headerName?: string;
-    };
-    rateLimit?: {
-        maxRequests: number;
-        windowMs: number;
-    };
-    allowedPlans?: string[];
-    allowedTenants?: string[];
-}
-type MCPToolHandler = (args: Record<string, unknown>, context: MCPContext) => unknown | Promise<unknown>;
-interface SmitheryServerInfo {
-    qualifiedName: string;
-    displayName: string;
-    description: string;
-    homepage?: string;
-    useCount?: number;
-    isDeployed?: boolean;
-}
-interface SmitheryConfig {
-    apiKey?: string;
-    baseUrl: string;
-    defaultServers?: string[];
-}
+import 'zod';
 
 /**
  * Registry for MCP servers and their tools
@@ -329,51 +221,6 @@ declare class McpHost {
 declare const toolConsentStore: InMemoryToolConsentStore;
 declare const mcpHost: McpHost;
 
-/**
- * MCP Middleware for rate limiting, audit logging, and access control
- */
-interface MCPMiddlewareContext extends MCPContext {
-    toolName: string;
-    arguments: Record<string, unknown>;
-}
-type MCPMiddlewareNext = () => Promise<ToolExecutionResult>;
-type MCPMiddleware = (ctx: MCPMiddlewareContext, next: MCPMiddlewareNext) => Promise<ToolExecutionResult>;
-/**
- * Rate limiting middleware for MCP calls
- */
-declare function createRateLimitMiddleware(options: {
-    maxRequests: number;
-    windowMs: number;
-}): MCPMiddleware;
-/**
- * Audit logging middleware
- */
-declare function createAuditMiddleware(options: {
-    onLog: (entry: AuditLogEntry) => void | Promise<void>;
-}): MCPMiddleware;
-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
- */
-declare function createAccessControlMiddleware(options: {
-    blockedTools?: string[];
-    allowedTools?: string[];
-}): MCPMiddleware;
-/**
- * Compose multiple middlewares
- */
-declare function composeMCPMiddleware(middlewares: MCPMiddleware[]): MCPMiddleware;
-
 /**
  * Register internal Nebutra services as MCP servers
  * These wrap our existing microservices with MCP-compatible interfaces
@@ -388,4 +235,4 @@ declare function registerInternalServers(): void;
  */
 declare function getInternalServerIds(): string[];
 
-export { type AuditLogEntry, INTERNAL_SERVERS, InMemoryToolConsentStore, MCPClient, type MCPContext, type MCPError, type MCPMiddleware, type MCPMiddlewareContext, type MCPRequest, type MCPResponse, type MCPServerConfig, type MCPServerManifest, MCPServerRegistry, type MCPToolHandler, McpHost, type SmitheryConfig, type SmitheryServerInfo, type ToolConsentGrant, type ToolConsentStore, type ToolDebugEntry, type ToolDefinition, ToolDefinitionSchema, type ToolExecutionRequest, type ToolExecutionResult, type ToolParameter, ToolParameterSchema, appendToolDebug, composeMCPMiddleware, createAccessControlMiddleware, createAuditMiddleware, createRateLimitMiddleware, getInternalServerIds, mcpClient, mcpHost, readToolDebug, registerInternalServers, serverRegistry, toolConsentStore, toolDebugPath };
+export { INTERNAL_SERVERS, InMemoryToolConsentStore, MCPClient, MCPContext, MCPServerConfig, MCPServerManifest, MCPServerRegistry, MCPToolHandler, McpHost, type ToolConsentGrant, type ToolConsentStore, type ToolDebugEntry, ToolDefinition, ToolExecutionResult, appendToolDebug, getInternalServerIds, mcpClient, mcpHost, readToolDebug, registerInternalServers, serverRegistry, toolConsentStore, toolDebugPath };

package/dist/index.js

@@ -7,10 +7,6 @@ import {
   ToolDefinitionSchema,
   ToolParameterSchema,
   appendToolDebug,
-  composeMCPMiddleware,
-  createAccessControlMiddleware,
-  createAuditMiddleware,
-  createRateLimitMiddleware,
   getInternalServerIds,
   mcpClient,
   mcpHost,
@@ -19,7 +15,13 @@ import {
   serverRegistry,
   toolConsentStore,
   toolDebugPath
-} from "./chunk-25TNKUCR.js";
+} from "./chunk-7A2G4AGA.js";
+import {
+  composeMCPMiddleware,
+  createAccessControlMiddleware,
+  createAuditMiddleware,
+  createRateLimitMiddleware
+} from "./chunk-EMIF5K3P.js";
 export {
   INTERNAL_SERVERS,
   InMemoryToolConsentStore,

package/dist/middleware/index.d.ts

@@ -0,0 +1,2 @@
+export { A as AuditLogEntry, f as MCPMiddleware, g as MCPMiddlewareContext, s as MCPMiddlewareNext, o as composeMCPMiddleware, p as createAccessControlMiddleware, q as createAuditMiddleware, r as createRateLimitMiddleware } from '../index-BD_aLZKz.js';
+import 'zod';

package/dist/middleware/index.js

@@ -0,0 +1,12 @@
+import {
+  composeMCPMiddleware,
+  createAccessControlMiddleware,
+  createAuditMiddleware,
+  createRateLimitMiddleware
+} from "../chunk-EMIF5K3P.js";
+export {
+  composeMCPMiddleware,
+  createAccessControlMiddleware,
+  createAuditMiddleware,
+  createRateLimitMiddleware
+};