@burdenoff/mcp-libs 2026.1021.1 → 2026.1028.1

package/dist/core/index.js

@@ -1,3 +1,3 @@
-export { CircularDependencyError, DESTRUCTIVE_NAME_VERBS, McpAuthError, McpInternalError, McpUserError, MissingDependencyError, TOOL_NAME_LIMIT, buildContext, clientCredentialsFlow, createAuthStore, createConfigStore, createGqlClients, createLogger, createMcpServer, createProgress, errorResult, extractGqlErrorMessage, fetchWorkspaces, inferDestructiveHint, inferReadOnlyHint, issueWorkspaceToken, jsonResult, mcpPromptName, mcpResourceUri, mcpToolName, pollDeviceTokenOnce, registerTool, sortModules, startDeviceCodeFlow, textResult, toServerCapabilities, unionCapabilities, withToolAnnotations, wrapServerWithToolGovernance } from '../chunk-FHXCNP2U.js';
+export { CircularDependencyError, DESTRUCTIVE_NAME_VERBS, McpAuthError, McpInternalError, McpUserError, MissingDependencyError, TOOL_NAME_LIMIT, buildContext, clientCredentialsFlow, createAuthStore, createConfigStore, createGqlClients, createLogger, createMcpServer, createProgress, errorResult, extractGqlErrorMessage, fetchWorkspaces, inferDestructiveHint, inferReadOnlyHint, issueWorkspaceToken, jsonResult, mcpPromptName, mcpResourceUri, mcpToolName, pollDeviceTokenOnce, registerTool, scopeToolFilter, sortModules, startDeviceCodeFlow, textResult, toServerCapabilities, toolArgsSha256, unionCapabilities, withToolAnnotations, wrapServerWithToolGovernance } from '../chunk-J74ZKEXL.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/core/logger.d.ts

@@ -0,0 +1,18 @@
+export type LogLevel = 'error' | 'warn' | 'info' | 'debug';
+export type LogFormat = 'json' | 'text';
+export interface LogContext {
+    [key: string]: unknown;
+}
+export interface Logger {
+    error(message: string, context?: LogContext): void;
+    warn(message: string, context?: LogContext): void;
+    info(message: string, context?: LogContext): void;
+    debug(message: string, context?: LogContext): void;
+    setLevel(level: LogLevel): void;
+    getLevel(): LogLevel;
+}
+export interface LoggerOptions {
+    level?: LogLevel;
+    format?: LogFormat;
+}
+export declare function createLogger(opts?: LoggerOptions): Logger;

package/dist/core/module.d.ts

@@ -0,0 +1,33 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { McpContext } from './context.js';
+import type { McpCapabilities } from './capabilities.js';
+import { McpInternalError } from './errors.js';
+export interface ModuleRegistration {
+    tools: readonly string[];
+    resources: readonly string[];
+    prompts: readonly string[];
+}
+export interface McpModule {
+    readonly id: string;
+    readonly version: string;
+    readonly displayName: string;
+    readonly dependsOn?: readonly string[];
+    readonly capabilities?: McpCapabilities;
+    register(server: McpServer, ctx: McpContext): ModuleRegistration;
+}
+export declare class MissingDependencyError extends McpInternalError {
+    constructor(moduleId: string, missingDep: string);
+}
+export declare class CircularDependencyError extends McpInternalError {
+    constructor(cycle: readonly string[]);
+}
+export declare function sortModules(modules: readonly McpModule[]): McpModule[];
+export interface ServerManifest {
+    modules: readonly {
+        id: string;
+        version: string;
+    }[];
+    tools: readonly string[];
+    resources: readonly string[];
+    prompts: readonly string[];
+}

package/dist/core/progress.d.ts

@@ -0,0 +1,5 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export type ProgressFn = (token: string | number | undefined, current: number, total?: number, message?: string) => void;
+export declare function createProgress(serverRef: {
+    current: McpServer | null;
+}): ProgressFn;

package/dist/core/result.d.ts

@@ -0,0 +1,29 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { ZodRawShape } from 'zod';
+import type { McpContext } from './context.js';
+import type { ToolAnnotations } from './tool-governance.js';
+export interface ToolTextContent {
+    type: 'text';
+    text: string;
+    [k: string]: unknown;
+}
+export interface ToolResult {
+    content: ToolTextContent[];
+    isError?: boolean;
+    structuredContent?: Record<string, unknown>;
+    [k: string]: unknown;
+}
+export interface ToolMeta {
+    progressToken?: string | number;
+}
+export declare function jsonResult(data: unknown, structured?: Record<string, unknown>): ToolResult;
+export declare function textResult(text: string): ToolResult;
+export declare function errorResult(message: string, hint?: string): ToolResult;
+export interface ToolMetadata {
+    title: string;
+    description: string;
+    inputSchema?: ZodRawShape;
+    annotations?: ToolAnnotations;
+}
+export type ToolHandler<TArgs = Record<string, unknown>> = (args: TArgs, ctx: McpContext, meta: ToolMeta) => Promise<unknown>;
+export declare function registerTool<TArgs extends Record<string, unknown>>(server: McpServer, ctx: McpContext, name: string, metadata: ToolMetadata, handler: ToolHandler<TArgs>): void;

package/dist/core/server.d.ts

@@ -0,0 +1,18 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { McpContext } from './context.js';
+import { type McpModule, type ServerManifest } from './module.js';
+import { type McpCapabilities } from './capabilities.js';
+import { type ToolGovernanceOptions } from './tool-governance.js';
+export interface CreateMcpServerOptions {
+    name: string;
+    version: string;
+    extraCapabilities?: McpCapabilities;
+    enforceDestructiveConfirmation?: boolean;
+    toolFilter?: ToolGovernanceOptions['toolFilter'];
+    onToolCall?: ToolGovernanceOptions['onToolCall'];
+}
+export interface McpServerHandle {
+    server: McpServer;
+    manifest: ServerManifest;
+}
+export declare function createMcpServer(ctx: McpContext, modules: readonly McpModule[], opts: CreateMcpServerOptions): McpServerHandle;

package/dist/core/tool-governance.d.ts

@@ -0,0 +1,25 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export interface ToolAnnotations {
+    title?: string;
+    readOnlyHint?: boolean;
+    destructiveHint?: boolean;
+    idempotentHint?: boolean;
+    openWorldHint?: boolean;
+}
+export interface ToolCallEvent {
+    name: string;
+    argsSha256: string;
+    status: 'ok' | 'error' | 'refused';
+    durationMs: number;
+    error?: string;
+}
+export interface ToolGovernanceOptions {
+    enforceDestructiveConfirmation?: boolean;
+    toolFilter?: (toolName: string) => boolean;
+    onToolCall?: (event: ToolCallEvent) => void;
+}
+export declare function scopeToolFilter(scopes: readonly string[]): (toolName: string) => boolean;
+export declare function toolArgsSha256(args: unknown): string;
+export declare function wrapServerWithToolGovernance(server: McpServer, options?: ToolGovernanceOptions): McpServer;
+export type ToolAnnotationResolver = (toolName: string) => ToolAnnotations | undefined;
+export declare function withToolAnnotations<T>(server: McpServer, resolve: ToolAnnotationResolver, register: () => T): T;

package/dist/core/tool-name.d.ts

@@ -0,0 +1,7 @@
+export declare function mcpToolName(productName: string, ...parts: string[]): string;
+export declare function mcpResourceUri(productName: string, ...parts: string[]): string;
+export declare function mcpPromptName(productName: string, ...parts: string[]): string;
+export declare const TOOL_NAME_LIMIT = 63;
+export declare const DESTRUCTIVE_NAME_VERBS: readonly ["delete", "destroy", "erase", "kill", "purge", "remove", "reset", "revoke", "rotate", "stop", "terminate", "uninstall", "wipe"];
+export declare function inferDestructiveHint(toolName: string): boolean;
+export declare function inferReadOnlyHint(toolName: string): boolean;

package/dist/index.cjs

@@ -7,9 +7,9 @@ var graphqlRequest = require('graphql-request');
 var fetch = require('cross-fetch');
 var mcp_js = require('@modelcontextprotocol/sdk/server/mcp.js');
 var types_js = require('@modelcontextprotocol/sdk/types.js');
+var crypto = require('crypto');
 var zod = require('zod');
 var stdio_js = require('@modelcontextprotocol/sdk/server/stdio.js');
-var crypto = require('crypto');
 var streamableHttp_js = require('@modelcontextprotocol/sdk/server/streamableHttp.js');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -731,6 +731,56 @@ function inferReadOnlyHint(toolName) {
 }
 
 // src/core/tool-governance.ts
+function canonicalJson(value, seen = /* @__PURE__ */ new Set()) {
+  if (value === null || value === void 0) return "null";
+  if (typeof value === "number") return Number.isFinite(value) ? JSON.stringify(value) : "null";
+  if (typeof value === "string" || typeof value === "boolean") return JSON.stringify(value);
+  if (typeof value === "bigint") return JSON.stringify(value.toString());
+  if (typeof value !== "object") return "null";
+  if (seen.has(value)) return "null";
+  seen.add(value);
+  try {
+    if (Array.isArray(value))
+      return `[${value.map((item) => canonicalJson(item, seen)).join(",")}]`;
+    const record = value;
+    const members = Object.keys(record).filter((key) => record[key] !== void 0).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(record[key], seen)}`);
+    return `{${members.join(",")}}`;
+  } finally {
+    seen.delete(value);
+  }
+}
+function toolArgsSha256(args) {
+  return crypto.createHash("sha256").update(canonicalJson(args), "utf8").digest("hex");
+}
+function isErrorResult(result) {
+  return typeof result === "object" && result !== null && result.isError === true;
+}
+function wrapAuditedHandler(name, handler, onToolCall) {
+  return async (...callbackArgs) => {
+    const started = Date.now();
+    const args = callbackArgs.length === 2 ? callbackArgs[0] : {};
+    const report = (status, error) => {
+      try {
+        onToolCall({
+          name,
+          argsSha256: toolArgsSha256(args),
+          status,
+          durationMs: Date.now() - started,
+          ...error ? { error } : {}
+        });
+      } catch {
+      }
+    };
+    try {
+      const result = await handler(...callbackArgs);
+      report(isErrorResult(result) ? "error" : "ok");
+      return result;
+    } catch (error) {
+      report("error", error instanceof Error ? error.message : String(error));
+      throw error;
+    }
+  };
+}
 var CONFIRM_FIELD_DESCRIPTION = "Must be true to execute this destructive tool. The call is rejected (no changes made) if omitted or false.";
 function resolveAnnotations(name, declared) {
   const destructiveHint = declared?.destructiveHint ?? inferDestructiveHint(name);
@@ -765,10 +815,11 @@ function wrapServerWithToolGovernance(server, options = {}) {
   const enforceConfirmation = options.enforceDestructiveConfirmation ?? false;
   const target = server;
   const originalRegisterTool = target.registerTool.bind(target);
-  target.registerTool = (name, config, handler) => {
+  const register = (name, config, handler) => {
     const annotations = resolveAnnotations(name, config.annotations);
+    const audited = options.onToolCall ? wrapAuditedHandler(name, handler, options.onToolCall) : handler;
     if (!enforceConfirmation || !annotations.destructiveHint) {
-      return originalRegisterTool(name, { ...config, annotations }, handler);
+      return originalRegisterTool(name, { ...config, annotations }, audited);
     }
     const gatedInputSchema = {
       ...config.inputSchema ?? {},
@@ -777,9 +828,16 @@ function wrapServerWithToolGovernance(server, options = {}) {
     return originalRegisterTool(
       name,
       { ...config, inputSchema: gatedInputSchema, annotations },
-      wrapDestructiveHandler(name, handler)
+      wrapDestructiveHandler(name, audited)
     );
   };
+  target.registerTool = (name, config, handler) => {
+    const registered = register(name, config, handler);
+    if (options.toolFilter && !options.toolFilter(name)) {
+      registered?.disable?.();
+    }
+    return registered;
+  };
   return server;
 }
 
@@ -807,7 +865,9 @@ function createMcpServer(ctx, modules, opts) {
     { capabilities: toServerCapabilities(capabilities) }
   );
   wrapServerWithToolGovernance(server, {
-    enforceDestructiveConfirmation: opts.enforceDestructiveConfirmation
+    enforceDestructiveConfirmation: opts.enforceDestructiveConfirmation,
+    toolFilter: opts.toolFilter,
+    onToolCall: opts.onToolCall
   });
   ctx._internal.serverRef.current = server;
   const inner = server.server ?? server;