@verifik/mcp 0.0.0-stage → 0.1.2

package/server.js

@@ -0,0 +1,140 @@
+#!/usr/bin/env node
+"use strict";
+
+const { Server } = require("@modelcontextprotocol/sdk/server/index.js");
+const { StdioServerTransport } = require("@modelcontextprotocol/sdk/server/stdio.js");
+const {
+	CallToolRequestSchema,
+	ListToolsRequestSchema,
+} = require("@modelcontextprotocol/sdk/types.js");
+
+const { loadConfig } = require("./lib/config");
+const { CatalogCache } = require("./lib/catalog");
+const { invokeFeature, formatProxyResult, formatValidationError } = require("./lib/proxy");
+const {
+	META_TOOL_DEFINITIONS,
+	handleListCatalog,
+	handleGetFeature,
+} = require("./lib/meta-tools");
+const { buildInputSchema } = require("./lib/tool-schema");
+const { validateToolArgs } = require("./lib/validate-args");
+
+const { version: packageVersion } = require("./package.json");
+
+const SERVER_NAME = "verifik-smartcheck";
+const SERVER_VERSION = packageVersion;
+
+const logStderr = (message) => {
+	process.stderr.write(`[${SERVER_NAME}] ${message}\n`);
+};
+
+const createServer = async () => {
+	const config = loadConfig();
+	const catalogCache = new CatalogCache(config);
+
+	logStderr(`Loading catalog from ${config.apiBase} ...`);
+	await catalogCache.getState();
+	logStderr(`Catalog loaded with ${catalogCache.state.tools.length} proxy tools.`);
+
+	const server = new Server(
+		{
+			name: SERVER_NAME,
+			version: SERVER_VERSION,
+		},
+		{
+			capabilities: {
+				tools: {},
+			},
+		}
+	);
+
+	server.setRequestHandler(ListToolsRequestSchema, async () => {
+		const state = await catalogCache.getState();
+		return {
+			tools: [...META_TOOL_DEFINITIONS, ...state.tools],
+		};
+	});
+
+	server.setRequestHandler(CallToolRequestSchema, async (request) => {
+		const toolName = request.params.name;
+		const args = request.params.arguments || {};
+
+		try {
+			if (toolName === "verifik_list_catalog") {
+				const payload = await handleListCatalog(catalogCache, args);
+				return structuredResult(payload);
+			}
+
+			if (toolName === "verifik_get_feature") {
+				const payload = await handleGetFeature(catalogCache, args);
+				return structuredResult(payload);
+			}
+
+			const feature = catalogCache.resolveFeatureByToolName(toolName);
+
+			if (!feature) {
+				return errorResult(`Unknown tool: ${toolName}`);
+			}
+
+			const inputSchema = buildInputSchema(feature);
+			const validationError = validateToolArgs(args, feature, inputSchema);
+
+			if (validationError) {
+				const formatted = formatValidationError(validationError);
+				return {
+					content: [{ type: "text", text: formatted.text }],
+					structuredContent: formatted.structuredContent,
+					isError: true,
+				};
+			}
+
+			const proxyResult = await invokeFeature(feature, args, config);
+			const formatted = formatProxyResult(proxyResult);
+
+			return {
+				content: [{ type: "text", text: formatted.text }],
+				structuredContent: formatted.structuredContent,
+				isError: !proxyResult.ok,
+			};
+		} catch (error) {
+			return errorResult(error instanceof Error ? error.message : String(error));
+		}
+	});
+
+	return server;
+};
+
+/**
+ * @param {unknown} payload
+ */
+const structuredResult = (payload) => {
+	const text = JSON.stringify(payload, null, 2);
+	return {
+		content: [{ type: "text", text }],
+		structuredContent: payload,
+	};
+};
+
+/**
+ * @param {string} message
+ */
+const errorResult = (message) => {
+	const formatted = formatValidationError(message);
+	return {
+		content: [{ type: "text", text: formatted.text }],
+		structuredContent: formatted.structuredContent,
+		isError: true,
+	};
+};
+
+const main = async () => {
+	const server = await createServer();
+	const transport = new StdioServerTransport();
+	await server.connect(transport);
+	logStderr("stdio transport connected.");
+};
+
+main().catch((error) => {
+	logStderr(error instanceof Error ? error.message : String(error));
+	process.exit(1);
+});