@outfitter/mcp 0.2.0 → 0.4.0

package/dist/shared/@outfitter/mcp-jk0ka9hw.d.ts

@@ -0,0 +1,30 @@
+import { McpServer } from "./mcp-h2twz77x";
+import { Server } from "@modelcontextprotocol/sdk/server/index";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio";
+import { CallToolResult } from "@modelcontextprotocol/sdk/types";
+type McpToolResponse = CallToolResult;
+/**
+* Wrap a handler success value into an MCP CallToolResult.
+*
+* If the value is already a valid McpToolResponse (has a `content` array),
+* it is returned as-is. Otherwise it is wrapped in a text content block.
+* Plain objects are also attached as `structuredContent` for SDK clients
+* that support structured output.
+*/
+declare function wrapToolResult(value: unknown): McpToolResponse;
+/**
+* Wrap an error into an MCP CallToolResult with `isError: true`.
+*
+* Serializes the error (preserving `_tag`, `message`, `code`, `context` if
+* present) and wraps it as a text content block.
+*/
+declare function wrapToolError(error: unknown): McpToolResponse;
+/**
+* Create an MCP SDK server from an Outfitter MCP server.
+*/
+declare function createSdkServer(server: McpServer): Server;
+/**
+* Connect an MCP server over stdio transport.
+*/
+declare function connectStdio(server: McpServer, transport?: StdioServerTransport): Promise<Server>;
+export { McpToolResponse, wrapToolResult, wrapToolError, createSdkServer, connectStdio };

package/dist/shared/@outfitter/mcp-k8r6kefr.js

@@ -0,0 +1,538 @@
+// @bun
+import {
+  shouldEmitLog
+} from "./mcp-fjtxsa0x.js";
+import {
+  McpError
+} from "./mcp-9m5hs2z0.js";
+import {
+  zodToJsonSchema
+} from "./mcp-f91wbr49.js";
+
+// packages/mcp/src/server.ts
+import { getEnvironment, getEnvironmentDefaults } from "@outfitter/config";
+import { generateRequestId, Result } from "@outfitter/contracts";
+import {
+  createOutfitterLoggerFactory,
+  createPrettyFormatter
+} from "@outfitter/logging";
+var VALID_MCP_LOG_LEVELS = new Set([
+  "debug",
+  "info",
+  "notice",
+  "warning",
+  "error",
+  "critical",
+  "alert",
+  "emergency"
+]);
+var DEFAULTS_TO_MCP = {
+  debug: "debug",
+  info: "info",
+  warn: "warning",
+  error: "error"
+};
+function createDefaultMcpSink() {
+  const formatter = createPrettyFormatter({ colors: false });
+  return {
+    formatter,
+    write(record, formatted) {
+      const serialized = formatted ?? formatter.format(record);
+      const line = serialized.endsWith(`
+`) ? serialized : `${serialized}
+`;
+      if (typeof process !== "undefined" && process.stderr?.write) {
+        process.stderr.write(line);
+      }
+    }
+  };
+}
+function resolveDefaultLogLevel(options) {
+  const envLogLevel = process.env["OUTFITTER_LOG_LEVEL"];
+  if (envLogLevel !== undefined && VALID_MCP_LOG_LEVELS.has(envLogLevel)) {
+    return envLogLevel;
+  }
+  if (options.defaultLogLevel !== undefined && (options.defaultLogLevel === null || VALID_MCP_LOG_LEVELS.has(options.defaultLogLevel))) {
+    return options.defaultLogLevel;
+  }
+  const env = getEnvironment();
+  const defaults = getEnvironmentDefaults(env);
+  if (defaults.logLevel !== null) {
+    const mapped = DEFAULTS_TO_MCP[defaults.logLevel];
+    if (mapped !== undefined) {
+      return mapped;
+    }
+  }
+  return null;
+}
+function createMcpServer(options) {
+  const { name, version, logger: providedLogger } = options;
+  let loggerFactory = null;
+  const logger = providedLogger ?? (() => {
+    loggerFactory = createOutfitterLoggerFactory({
+      defaults: { sinks: [createDefaultMcpSink()] }
+    });
+    return loggerFactory.createLogger({
+      name: "mcp",
+      context: { serverName: name, serverVersion: version, surface: "mcp" }
+    });
+  })();
+  const tools = new Map;
+  const resources = new Map;
+  const resourceTemplates = new Map;
+  const prompts = new Map;
+  let sdkServer = null;
+  const subscriptions = new Set;
+  let clientLogLevel = resolveDefaultLogLevel(options);
+  function createHandlerContext(toolName, requestId, signal, progressToken) {
+    const ctx = {
+      requestId,
+      logger: logger.child({ tool: toolName, requestId }),
+      cwd: process.cwd(),
+      env: process.env
+    };
+    if (signal !== undefined) {
+      ctx.signal = signal;
+    }
+    if (progressToken !== undefined && sdkServer) {
+      ctx.progress = {
+        report(progress, total, message) {
+          sdkServer?.notification?.({
+            method: "notifications/progress",
+            params: {
+              progressToken,
+              progress,
+              ...total !== undefined ? { total } : {},
+              ...message ? { message } : {}
+            }
+          });
+        }
+      };
+    }
+    return ctx;
+  }
+  function translateError(error) {
+    const codeMap = {
+      validation: -32602,
+      not_found: -32601,
+      permission: -32600,
+      internal: -32603,
+      timeout: -32603,
+      network: -32603,
+      rate_limit: -32603,
+      auth: -32600,
+      conflict: -32603,
+      cancelled: -32603
+    };
+    const code = codeMap[error.category] ?? -32603;
+    return new McpError({
+      message: error.message,
+      code,
+      context: {
+        originalTag: error._tag,
+        category: error.category
+      }
+    });
+  }
+  const server = {
+    name,
+    version,
+    registerTool(tool) {
+      logger.debug("Registering tool", { name: tool.name });
+      const description = tool.description?.trim() ?? "";
+      if (description.length < 8) {
+        logger.warn("Tool description may be too short for search discovery", {
+          name: tool.name,
+          description
+        });
+      }
+      const jsonSchema = zodToJsonSchema(tool.inputSchema);
+      const handler = (input, ctx) => tool.handler(input, ctx);
+      const deferLoading = tool.deferLoading ?? true;
+      const stored = {
+        name: tool.name,
+        description,
+        inputSchema: jsonSchema,
+        deferLoading,
+        handler,
+        zodSchema: tool.inputSchema
+      };
+      if (tool.annotations !== undefined) {
+        stored.annotations = tool.annotations;
+      }
+      tools.set(tool.name, stored);
+      logger.info("Tool registered", { name: tool.name });
+      if (sdkServer) {
+        sdkServer.sendToolListChanged?.();
+      }
+    },
+    registerResource(resource) {
+      logger.debug("Registering resource", {
+        uri: resource.uri,
+        name: resource.name
+      });
+      resources.set(resource.uri, resource);
+      logger.info("Resource registered", { uri: resource.uri });
+      if (sdkServer) {
+        sdkServer.sendResourceListChanged?.();
+      }
+    },
+    registerResourceTemplate(template) {
+      logger.debug("Registering resource template", {
+        uriTemplate: template.uriTemplate,
+        name: template.name
+      });
+      resourceTemplates.set(template.uriTemplate, template);
+      logger.info("Resource template registered", {
+        uriTemplate: template.uriTemplate
+      });
+      if (sdkServer) {
+        sdkServer.sendResourceListChanged?.();
+      }
+    },
+    getTools() {
+      return Array.from(tools.values()).map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        inputSchema: tool.inputSchema,
+        defer_loading: tool.deferLoading,
+        ...tool.annotations ? { annotations: tool.annotations } : {}
+      }));
+    },
+    getResources() {
+      return Array.from(resources.values());
+    },
+    getResourceTemplates() {
+      return Array.from(resourceTemplates.values());
+    },
+    async complete(ref, argumentName, value) {
+      if (ref.type === "ref/prompt") {
+        const prompt = prompts.get(ref.name);
+        if (!prompt) {
+          return Result.err(new McpError({
+            message: `Prompt not found: ${ref.name}`,
+            code: -32601,
+            context: { prompt: ref.name }
+          }));
+        }
+        const arg = prompt.arguments.find((a) => a.name === argumentName);
+        if (!arg?.complete) {
+          return Result.ok({ values: [] });
+        }
+        try {
+          const result = await arg.complete(value);
+          return Result.ok(result);
+        } catch (error) {
+          return Result.err(new McpError({
+            message: error instanceof Error ? error.message : "Unknown error",
+            code: -32603,
+            context: {
+              prompt: ref.name,
+              argument: argumentName,
+              thrown: true
+            }
+          }));
+        }
+      }
+      if (ref.type === "ref/resource") {
+        const template = resourceTemplates.get(ref.uri);
+        if (!template) {
+          return Result.err(new McpError({
+            message: `Resource template not found: ${ref.uri}`,
+            code: -32601,
+            context: { uri: ref.uri }
+          }));
+        }
+        const handler = template.complete?.[argumentName];
+        if (!handler) {
+          return Result.ok({ values: [] });
+        }
+        try {
+          const result = await handler(value);
+          return Result.ok(result);
+        } catch (error) {
+          return Result.err(new McpError({
+            message: error instanceof Error ? error.message : "Unknown error",
+            code: -32603,
+            context: { uri: ref.uri, argument: argumentName, thrown: true }
+          }));
+        }
+      }
+      return Result.err(new McpError({
+        message: "Invalid completion reference type",
+        code: -32602,
+        context: { ref }
+      }));
+    },
+    registerPrompt(prompt) {
+      logger.debug("Registering prompt", { name: prompt.name });
+      prompts.set(prompt.name, prompt);
+      logger.info("Prompt registered", { name: prompt.name });
+      if (sdkServer) {
+        sdkServer.sendPromptListChanged?.();
+      }
+    },
+    getPrompts() {
+      return Array.from(prompts.values()).map((p) => ({
+        name: p.name,
+        ...p.description ? { description: p.description } : {},
+        arguments: p.arguments
+      }));
+    },
+    async getPrompt(promptName, args) {
+      const prompt = prompts.get(promptName);
+      if (!prompt) {
+        return Result.err(new McpError({
+          message: `Prompt not found: ${promptName}`,
+          code: -32601,
+          context: { prompt: promptName }
+        }));
+      }
+      for (const arg of prompt.arguments) {
+        if (arg.required && (args[arg.name] === undefined || args[arg.name] === "")) {
+          return Result.err(new McpError({
+            message: `Missing required argument: ${arg.name}`,
+            code: -32602,
+            context: { prompt: promptName, argument: arg.name }
+          }));
+        }
+      }
+      try {
+        const result = await prompt.handler(args);
+        if (result.isErr()) {
+          return Result.err(translateError(result.error));
+        }
+        return Result.ok(result.value);
+      } catch (error) {
+        return Result.err(new McpError({
+          message: error instanceof Error ? error.message : "Unknown error",
+          code: -32603,
+          context: { prompt: promptName, thrown: true }
+        }));
+      }
+    },
+    async readResource(uri) {
+      const resource = resources.get(uri);
+      if (resource) {
+        if (!resource.handler) {
+          return Result.err(new McpError({
+            message: `Resource not readable: ${uri}`,
+            code: -32002,
+            context: { uri }
+          }));
+        }
+        const requestId = generateRequestId();
+        const ctx = {
+          requestId,
+          logger: logger.child({ resource: uri, requestId }),
+          cwd: process.cwd(),
+          env: process.env
+        };
+        try {
+          const result = await resource.handler(uri, ctx);
+          if (result.isErr()) {
+            return Result.err(translateError(result.error));
+          }
+          return Result.ok(result.value);
+        } catch (error) {
+          return Result.err(new McpError({
+            message: error instanceof Error ? error.message : "Unknown error",
+            code: -32603,
+            context: { uri, thrown: true }
+          }));
+        }
+      }
+      for (const template of resourceTemplates.values()) {
+        const variables = matchUriTemplate(template.uriTemplate, uri);
+        if (variables) {
+          const templateRequestId = generateRequestId();
+          const templateCtx = {
+            requestId: templateRequestId,
+            logger: logger.child({
+              resource: uri,
+              requestId: templateRequestId
+            }),
+            cwd: process.cwd(),
+            env: process.env
+          };
+          try {
+            const result = await template.handler(uri, variables, templateCtx);
+            if (result.isErr()) {
+              return Result.err(translateError(result.error));
+            }
+            return Result.ok(result.value);
+          } catch (error) {
+            return Result.err(new McpError({
+              message: error instanceof Error ? error.message : "Unknown error",
+              code: -32603,
+              context: { uri, thrown: true }
+            }));
+          }
+        }
+      }
+      return Result.err(new McpError({
+        message: `Resource not found: ${uri}`,
+        code: -32002,
+        context: { uri }
+      }));
+    },
+    async invokeTool(toolName, input, invokeOptions) {
+      const requestId = invokeOptions?.requestId ?? generateRequestId();
+      logger.debug("Invoking tool", { tool: toolName, requestId });
+      const tool = tools.get(toolName);
+      if (!tool) {
+        logger.warn("Tool not found", { tool: toolName, requestId });
+        return Result.err(new McpError({
+          message: `Tool not found: ${toolName}`,
+          code: -32601,
+          context: { tool: toolName }
+        }));
+      }
+      const parseResult = tool.zodSchema.safeParse(input);
+      if (!parseResult.success) {
+        const errorMessages = parseResult.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; ");
+        logger.warn("Input validation failed", {
+          tool: toolName,
+          requestId,
+          errors: errorMessages
+        });
+        return Result.err(new McpError({
+          message: `Invalid input: ${errorMessages}`,
+          code: -32602,
+          context: {
+            tool: toolName,
+            validationErrors: parseResult.error.issues
+          }
+        }));
+      }
+      const ctx = createHandlerContext(toolName, requestId, invokeOptions?.signal, invokeOptions?.progressToken);
+      try {
+        const result = await tool.handler(parseResult.data, ctx);
+        if (result.isErr()) {
+          logger.debug("Tool returned error", {
+            tool: toolName,
+            requestId,
+            error: result.error._tag
+          });
+          return Result.err(translateError(result.error));
+        }
+        logger.debug("Tool completed successfully", {
+          tool: toolName,
+          requestId
+        });
+        return Result.ok(result.value);
+      } catch (error) {
+        logger.error("Tool threw exception", {
+          tool: toolName,
+          requestId,
+          error: error instanceof Error ? error.message : String(error)
+        });
+        return Result.err(new McpError({
+          message: error instanceof Error ? error.message : "Unknown error",
+          code: -32603,
+          context: {
+            tool: toolName,
+            thrown: true
+          }
+        }));
+      }
+    },
+    subscribe(uri) {
+      subscriptions.add(uri);
+      logger.debug("Resource subscription added", { uri });
+    },
+    unsubscribe(uri) {
+      subscriptions.delete(uri);
+      logger.debug("Resource subscription removed", { uri });
+    },
+    notifyResourceUpdated(uri) {
+      if (subscriptions.has(uri)) {
+        sdkServer?.sendResourceUpdated?.({ uri });
+      }
+    },
+    notifyToolsChanged() {
+      sdkServer?.sendToolListChanged?.();
+    },
+    notifyResourcesChanged() {
+      sdkServer?.sendResourceListChanged?.();
+    },
+    notifyPromptsChanged() {
+      sdkServer?.sendPromptListChanged?.();
+    },
+    setLogLevel(level) {
+      clientLogLevel = level;
+      logger.debug("Client log level set", { level });
+    },
+    sendLogMessage(level, data, loggerName) {
+      if (!sdkServer || clientLogLevel === null || !shouldEmitLog(level, clientLogLevel)) {
+        return;
+      }
+      const params = {
+        level,
+        data
+      };
+      if (loggerName !== undefined) {
+        params.logger = loggerName;
+      }
+      sdkServer.sendLoggingMessage?.(params);
+    },
+    bindSdkServer(server2) {
+      sdkServer = server2;
+      clientLogLevel = resolveDefaultLogLevel(options);
+      logger.debug("SDK server bound for notifications");
+    },
+    async start() {
+      logger.info("MCP server starting", { name, version, tools: tools.size });
+    },
+    async stop() {
+      logger.info("MCP server stopping", { name, version });
+      if (loggerFactory !== null) {
+        await loggerFactory.flush();
+      }
+    }
+  };
+  return server;
+}
+function defineTool(definition) {
+  return definition;
+}
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function matchUriTemplate(template, uri) {
+  const paramNames = [];
+  const parts = template.split(/(\{[^}]+\})/);
+  const regexSource = parts.map((part) => {
+    const paramMatch = part.match(/^\{([^}]+)\}$/);
+    if (paramMatch?.[1]) {
+      paramNames.push(paramMatch[1]);
+      return "([^/]+)";
+    }
+    return escapeRegex(part);
+  }).join("");
+  const regex = new RegExp(`^${regexSource}$`);
+  const match = uri.match(regex);
+  if (!match) {
+    return null;
+  }
+  const variables = {};
+  for (let i = 0;i < paramNames.length; i++) {
+    const name = paramNames[i];
+    const value = match[i + 1];
+    if (name !== undefined && value !== undefined) {
+      variables[name] = value;
+    }
+  }
+  return variables;
+}
+function defineResource(definition) {
+  return definition;
+}
+function defineResourceTemplate(definition) {
+  return definition;
+}
+function definePrompt(definition) {
+  return definition;
+}
+
+export { createMcpServer, defineTool, defineResource, defineResourceTemplate, definePrompt };