@kynver-app/mcp-estimator 0.1.1

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+/**
+ * Kynver Estimator MCP server — stdio entry point.
+ * Run: node dist/index.js
+ * Env: KYNVER_API_URL (default https://kynver.com), KYNVER_API_KEY (required for all tools)
+ */
+export {};

package/dist/index.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+/**
+ * Kynver Estimator MCP server — stdio entry point.
+ * Run: node dist/index.js
+ * Env: KYNVER_API_URL (default https://kynver.com), KYNVER_API_KEY (required for all tools)
+ */
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { createEstimatorServer } from "./server.js";
+const server = createEstimatorServer();
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/dist/lib/kynver-client.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Thin fetch wrapper for Kynver API. Base URL from KYNVER_API_URL; optional Bearer from KYNVER_API_KEY.
+ *
+ * Supports per-request user identity via AsyncLocalStorage. When a userId is
+ * set in the request context (e.g. from the SSE route), all API calls include
+ * X-Kynver-User-Id and X-Kynver-Service-Secret headers so the Kynver API
+ * executes operations on behalf of the correct user.
+ */
+import { AsyncLocalStorage } from "node:async_hooks";
+interface RequestContext {
+    userId?: string;
+}
+export declare const requestContext: AsyncLocalStorage<RequestContext>;
+export declare function get<T = unknown>(path: string): Promise<T>;
+export declare function post<T = unknown>(path: string, body: unknown): Promise<T>;
+export declare function patch<T = unknown>(path: string, body: unknown): Promise<T>;
+export declare function del<T = unknown>(path: string): Promise<T>;
+export declare function hasApiKey(): boolean;
+export declare function noApiKeyMessage(): string;
+export {};

package/dist/lib/kynver-client.js

@@ -0,0 +1,110 @@
+/**
+ * Thin fetch wrapper for Kynver API. Base URL from KYNVER_API_URL; optional Bearer from KYNVER_API_KEY.
+ *
+ * Supports per-request user identity via AsyncLocalStorage. When a userId is
+ * set in the request context (e.g. from the SSE route), all API calls include
+ * X-Kynver-User-Id and X-Kynver-Service-Secret headers so the Kynver API
+ * executes operations on behalf of the correct user.
+ */
+import { AsyncLocalStorage } from "node:async_hooks";
+export const requestContext = new AsyncLocalStorage();
+// ---------------------------------------------------------------------------
+// Config
+// ---------------------------------------------------------------------------
+const baseUrl = process.env.KYNVER_API_URL ?? "https://kynver.com";
+const apiKey = process.env.KYNVER_API_KEY ?? "";
+function assertSafeApiPath(path) {
+    const p = path.startsWith("/") ? path : `/${path}`;
+    if (p.includes("..") || p.includes("\0")) {
+        throw new Error("Invalid API path: path traversal is not allowed");
+    }
+}
+function url(path) {
+    assertSafeApiPath(path);
+    const p = path.startsWith("/") ? path : `/${path}`;
+    const apiPath = p.startsWith("/api") ? p : `/api${p}`;
+    return `${baseUrl.replace(/\/$/, "")}${apiPath}`;
+}
+function getHeaders() {
+    const headers = {
+        "Content-Type": "application/json",
+    };
+    if (apiKey) {
+        headers["Authorization"] = `Bearer ${apiKey}`;
+    }
+    const ctx = requestContext.getStore();
+    const userId = ctx?.userId ?? process.env.KYNVER_USER_ID?.trim();
+    const serviceSecret = process.env.KYNVER_SERVICE_SECRET?.trim();
+    if (userId) {
+        if (!serviceSecret) {
+            throw new Error("X-Kynver-User-Id was set in context but KYNVER_SERVICE_SECRET is missing; refusing to send an unscoped request.");
+        }
+        headers["X-Kynver-User-Id"] = userId;
+        headers["X-Kynver-Service-Secret"] = serviceSecret;
+    }
+    return headers;
+}
+// ---------------------------------------------------------------------------
+// Response handling
+// ---------------------------------------------------------------------------
+async function handleResponse(res) {
+    const text = await res.text();
+    if (!res.ok) {
+        let msg = text;
+        try {
+            const j = JSON.parse(text);
+            msg = j.error ?? j.message ?? text;
+        }
+        catch {
+            // use text as-is
+        }
+        throw new Error(msg || `HTTP ${res.status}`);
+    }
+    if (!text)
+        return undefined;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+// ---------------------------------------------------------------------------
+// HTTP methods
+// ---------------------------------------------------------------------------
+export async function get(path) {
+    const res = await fetch(url(path), {
+        method: "GET",
+        headers: getHeaders(),
+    });
+    return handleResponse(res);
+}
+export async function post(path, body) {
+    const res = await fetch(url(path), {
+        method: "POST",
+        headers: getHeaders(),
+        body: JSON.stringify(body),
+    });
+    return handleResponse(res);
+}
+export async function patch(path, body) {
+    const res = await fetch(url(path), {
+        method: "PATCH",
+        headers: getHeaders(),
+        body: JSON.stringify(body),
+    });
+    return handleResponse(res);
+}
+export async function del(path) {
+    const res = await fetch(url(path), {
+        method: "DELETE",
+        headers: getHeaders(),
+    });
+    return handleResponse(res);
+}
+export function hasApiKey() {
+    return !!apiKey;
+}
+export function noApiKeyMessage() {
+    return "No API key configured. Set KYNVER_API_KEY in your MCP server config.";
+}

package/dist/lib/mcp-sse-server.d.ts

@@ -0,0 +1,29 @@
+import { type IncomingMessage } from "node:http";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare const MAX_SSE_BODY_BYTES: number;
+export type SessionAuth = {
+    kind: "apiKey";
+    apiKey: string;
+} | {
+    kind: "internal";
+    userId: string;
+};
+type RequestContextStore = {
+    run: <T>(store: {
+        userId?: string;
+    }, fn: () => Promise<T>) => Promise<T>;
+};
+export type StartKynverMcpSseServerOptions = {
+    label: string;
+    defaultPort: number;
+    createMcpServer: () => McpServer | Promise<McpServer>;
+    requestContext: RequestContextStore;
+};
+export declare function headerValue(req: IncomingMessage, name: string): string | null;
+export declare function timingSafeEqualString(a: string, b: string): boolean;
+export declare function hasForbiddenQueryAuth(url: URL): boolean;
+export declare function resolveListenHost(): string;
+export declare function parseJsonBody(req: IncomingMessage, maxBytes?: number): Promise<unknown>;
+export declare function validateMcporterServerName(name: string): string;
+export declare function startKynverMcpSseServer(options: StartKynverMcpSseServerOptions): void;
+export {};

package/dist/lib/mcp-sse-server.js

@@ -0,0 +1,191 @@
+// @generated — synced from packages/kynver-mcp-sse-lib/src/index.ts via scripts/sync-mcp-sse-server.mjs
+// Do not edit by hand; change the canonical file and re-run the sync script.
+import { createServer } from "node:http";
+import { timingSafeEqual } from "node:crypto";
+import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
+export const MAX_SSE_BODY_BYTES = 1 * 1024 * 1024;
+const FORBIDDEN_QUERY_KEYS = ["secret", "userId"];
+export function headerValue(req, name) {
+    const v = req.headers[name];
+    return typeof v === "string" ? v : Array.isArray(v) ? (v[0] ?? null) : null;
+}
+export function timingSafeEqualString(a, b) {
+    const left = Buffer.from(a);
+    const right = Buffer.from(b);
+    if (left.length !== right.length)
+        return false;
+    return timingSafeEqual(left, right);
+}
+export function hasForbiddenQueryAuth(url) {
+    return FORBIDDEN_QUERY_KEYS.some((key) => url.searchParams.has(key));
+}
+function queryApiKey(url) {
+    return url.searchParams.get("apiKey")?.trim() ?? "";
+}
+export function resolveListenHost() {
+    const configured = process.env.MCP_SSE_HOST?.trim();
+    return configured || "127.0.0.1";
+}
+export function parseJsonBody(req, maxBytes = MAX_SSE_BODY_BYTES) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        let totalSize = 0;
+        req.on("data", (chunk) => {
+            totalSize += chunk.length;
+            if (totalSize > maxBytes) {
+                req.destroy();
+                reject(new Error("Request body too large"));
+                return;
+            }
+            chunks.push(chunk);
+        });
+        req.on("end", () => {
+            try {
+                resolve(JSON.parse(Buffer.concat(chunks).toString()));
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+        req.on("error", reject);
+    });
+}
+export function validateMcporterServerName(name) {
+    const trimmed = name.trim();
+    if (!/^[a-zA-Z0-9_-]+$/.test(trimmed)) {
+        throw new Error("Invalid mcporter server name.");
+    }
+    return trimmed;
+}
+function bearerToken(req) {
+    const auth = headerValue(req, "authorization");
+    if (!auth)
+        return "";
+    const match = /^Bearer\s+(.+)$/i.exec(auth);
+    return match?.[1]?.trim() ?? "";
+}
+function resolveInternalAuth(req, serviceSecret) {
+    const internalUserId = headerValue(req, "x-kynver-user-id");
+    const internalSecret = headerValue(req, "x-kynver-service-secret");
+    if (!internalUserId || !serviceSecret || !internalSecret)
+        return null;
+    if (!timingSafeEqualString(internalSecret, serviceSecret))
+        return null;
+    return { userId: internalUserId, auth: { kind: "internal", userId: internalUserId } };
+}
+function verifyPostAuth(req, url, sessionAuth, serviceSecret) {
+    if (sessionAuth.kind === "apiKey") {
+        const token = bearerToken(req) || queryApiKey(url);
+        return token.length > 0 && timingSafeEqualString(token, sessionAuth.apiKey);
+    }
+    const internal = resolveInternalAuth(req, serviceSecret);
+    return (internal !== null &&
+        internal.userId === sessionAuth.userId &&
+        internal.auth.kind === "internal");
+}
+async function resolveUserFromApiKey(baseUrl, apiKey) {
+    try {
+        const res = await fetch(`${baseUrl.replace(/\/$/, "")}/api/users/me`, {
+            headers: { Authorization: `Bearer ${apiKey}` },
+        });
+        if (!res.ok)
+            return null;
+        const data = (await res.json());
+        return data.id ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+function parseUrl(req, port) {
+    return new URL(req.url ?? "/", `http://localhost:${port}`);
+}
+function json(res, status, body) {
+    res.writeHead(status, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(body));
+}
+export function startKynverMcpSseServer(options) {
+    const port = parseInt(process.env.PORT ?? String(options.defaultPort), 10);
+    const baseUrl = process.env.KYNVER_API_URL ?? "https://kynver.com";
+    const serviceSecret = process.env.KYNVER_SERVICE_SECRET ?? "";
+    const host = resolveListenHost();
+    const sessions = {};
+    const httpServer = createServer(async (req, res) => {
+        const url = parseUrl(req, port);
+        const path = url.pathname;
+        if (req.method === "GET" && path === "/sse") {
+            if (hasForbiddenQueryAuth(url)) {
+                json(res, 400, {
+                    error: "Internal auth via query params is not allowed. Use X-Kynver-User-Id and X-Kynver-Service-Secret headers.",
+                });
+                return;
+            }
+            if (url.searchParams.has("apiKey")) {
+                console.warn("[MCP SSE] WARNING: apiKey in query string may leak via logs. Prefer Authorization header when your client supports it.");
+            }
+            let userId = null;
+            let auth = null;
+            const internal = serviceSecret ? resolveInternalAuth(req, serviceSecret) : null;
+            if (internal) {
+                userId = internal.userId;
+                auth = internal.auth;
+            }
+            else {
+                const apiKey = bearerToken(req) || queryApiKey(url);
+                if (apiKey) {
+                    userId = await resolveUserFromApiKey(baseUrl, apiKey);
+                    if (userId)
+                        auth = { kind: "apiKey", apiKey };
+                }
+            }
+            if (!userId || !auth) {
+                json(res, 401, {
+                    error: "Unauthorized. Pass API key via Authorization: Bearer <key> or internal X-Kynver-User-Id + X-Kynver-Service-Secret headers.",
+                });
+                return;
+            }
+            console.log(`[MCP SSE] New connection (${options.label}, user: ${userId.slice(0, 8)}...)`);
+            const transport = new SSEServerTransport("/messages", res);
+            sessions[transport.sessionId] = { transport, userId, auth };
+            res.on("close", () => {
+                delete sessions[transport.sessionId];
+            });
+            const server = await options.createMcpServer();
+            await server.connect(transport);
+            return;
+        }
+        if (req.method === "POST" && path === "/messages") {
+            const sessionId = url.searchParams.get("sessionId");
+            const entry = sessionId ? sessions[sessionId] : undefined;
+            if (!entry) {
+                json(res, 400, { error: "No active SSE session for this sessionId" });
+                return;
+            }
+            if (!verifyPostAuth(req, url, entry.auth, serviceSecret)) {
+                json(res, 401, { error: "Unauthorized. Re-send the same credentials used to open the SSE session." });
+                return;
+            }
+            try {
+                const body = await parseJsonBody(req);
+                await options.requestContext.run({ userId: entry.userId }, async () => {
+                    await entry.transport.handlePostMessage(req, res, body);
+                });
+            }
+            catch (error) {
+                json(res, 400, {
+                    error: error instanceof Error ? error.message : "Invalid request body",
+                });
+            }
+            return;
+        }
+        if (req.method === "GET" && path === "/health") {
+            res.writeHead(200, { "Content-Type": "text/plain" });
+            res.end("ok");
+            return;
+        }
+        json(res, 404, { error: "Not found" });
+    });
+    httpServer.listen(port, host, () => {
+        console.log(`[MCP SSE] ${options.label} listening on ${host}:${port}`);
+    });
+}

package/dist/server.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Creates and configures the estimator MCP server with all tools registered.
+ * Separated from transport so it can be used with stdio (CLI) or SSE (hosted).
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function createEstimatorServer(): McpServer;

package/dist/server.js

@@ -0,0 +1,78 @@
+/**
+ * Creates and configures the estimator MCP server with all tools registered.
+ * Separated from transport so it can be used with stdio (CLI) or SSE (hosted).
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import * as catalogTools from "./tools/catalog-tools.js";
+import * as estimateTools from "./tools/estimate-tools.js";
+import * as templateTools from "./tools/template-tools.js";
+import * as versionTools from "./tools/version-tools.js";
+import * as photoTools from "./tools/photo-tools.js";
+import * as statsPdfTools from "./tools/stats-pdf-tools.js";
+import * as visionTools from "./tools/vision-tools.js";
+import * as companyTools from "./tools/company-tools.js";
+import * as clientTools from "./tools/client-tools.js";
+function toolResult(text) {
+    return { content: [{ type: "text", text }] };
+}
+export function createEstimatorServer() {
+    const server = new McpServer({ name: "kynver-mcp-estimator", version: "0.1.0" }, { capabilities: { tools: {} } });
+    function register(name, config, run) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        server.registerTool(name, config, async (args) => toolResult(await run(args)));
+    }
+    // --- Catalog tools (8) ---
+    register(catalogTools.importCatalog.name, { description: catalogTools.importCatalog.description, inputSchema: catalogTools.importCatalog.inputSchemaZod }, (args) => catalogTools.importCatalog.execute(args));
+    register(catalogTools.reviewImport.name, { description: catalogTools.reviewImport.description, inputSchema: catalogTools.reviewImport.inputSchemaZod }, (args) => catalogTools.reviewImport.execute(args));
+    register(catalogTools.commitImport.name, { description: catalogTools.commitImport.description, inputSchema: catalogTools.commitImport.inputSchemaZod }, (args) => catalogTools.commitImport.execute(args));
+    register(catalogTools.setupPrice.name, { description: catalogTools.setupPrice.description, inputSchema: catalogTools.setupPrice.inputSchemaZod }, (args) => catalogTools.setupPrice.execute(args));
+    register(catalogTools.updatePrice.name, { description: catalogTools.updatePrice.description, inputSchema: catalogTools.updatePrice.inputSchemaZod }, (args) => catalogTools.updatePrice.execute(args));
+    register(catalogTools.getCatalog.name, { description: catalogTools.getCatalog.description, inputSchema: catalogTools.getCatalog.inputSchemaZod }, (args) => catalogTools.getCatalog.execute(args));
+    register(catalogTools.getConfig.name, { description: catalogTools.getConfig.description, inputSchema: catalogTools.getConfig.inputSchemaZod }, (args) => catalogTools.getConfig.execute(args));
+    register(catalogTools.updateConfig.name, { description: catalogTools.updateConfig.description, inputSchema: catalogTools.updateConfig.inputSchemaZod }, (args) => catalogTools.updateConfig.execute(args));
+    register(catalogTools.importTemplate.name, { description: catalogTools.importTemplate.description, inputSchema: catalogTools.importTemplate.inputSchemaZod }, (args) => catalogTools.importTemplate.execute(args));
+    // --- Estimate tools (11) ---
+    register(estimateTools.createReplacement.name, { description: estimateTools.createReplacement.description, inputSchema: estimateTools.createReplacement.inputSchemaZod }, (args) => estimateTools.createReplacement.execute(args));
+    register(estimateTools.createRepair.name, { description: estimateTools.createRepair.description, inputSchema: estimateTools.createRepair.inputSchemaZod }, (args) => estimateTools.createRepair.execute(args));
+    register(estimateTools.getEstimate.name, { description: estimateTools.getEstimate.description, inputSchema: estimateTools.getEstimate.inputSchemaZod }, (args) => estimateTools.getEstimate.execute(args));
+    register(estimateTools.listEstimates.name, { description: estimateTools.listEstimates.description, inputSchema: estimateTools.listEstimates.inputSchemaZod }, (args) => estimateTools.listEstimates.execute(args));
+    register(estimateTools.addLineItem.name, { description: estimateTools.addLineItem.description, inputSchema: estimateTools.addLineItem.inputSchemaZod }, (args) => estimateTools.addLineItem.execute(args));
+    register(estimateTools.removeLineItem.name, { description: estimateTools.removeLineItem.description, inputSchema: estimateTools.removeLineItem.inputSchemaZod }, (args) => estimateTools.removeLineItem.execute(args));
+    register(estimateTools.updateLineItem.name, { description: estimateTools.updateLineItem.description, inputSchema: estimateTools.updateLineItem.inputSchemaZod }, (args) => estimateTools.updateLineItem.execute(args));
+    register(estimateTools.adjustToTarget.name, { description: estimateTools.adjustToTarget.description, inputSchema: estimateTools.adjustToTarget.inputSchemaZod }, (args) => estimateTools.adjustToTarget.execute(args));
+    register(estimateTools.updateEstimate.name, { description: estimateTools.updateEstimate.description, inputSchema: estimateTools.updateEstimate.inputSchemaZod }, (args) => estimateTools.updateEstimate.execute(args));
+    register(estimateTools.deleteEstimate.name, { description: estimateTools.deleteEstimate.description, inputSchema: estimateTools.deleteEstimate.inputSchemaZod }, (args) => estimateTools.deleteEstimate.execute(args));
+    register(estimateTools.duplicateEstimate.name, { description: estimateTools.duplicateEstimate.description, inputSchema: estimateTools.duplicateEstimate.inputSchemaZod }, (args) => estimateTools.duplicateEstimate.execute(args));
+    // --- Template tools (4) ---
+    register(templateTools.saveTemplate.name, { description: templateTools.saveTemplate.description, inputSchema: templateTools.saveTemplate.inputSchemaZod }, (args) => templateTools.saveTemplate.execute(args));
+    register(templateTools.listTemplates.name, { description: templateTools.listTemplates.description, inputSchema: templateTools.listTemplates.inputSchemaZod }, (args) => templateTools.listTemplates.execute(args));
+    register(templateTools.deleteTemplate.name, { description: templateTools.deleteTemplate.description, inputSchema: templateTools.deleteTemplate.inputSchemaZod }, (args) => templateTools.deleteTemplate.execute(args));
+    register(templateTools.createFromTemplate.name, { description: templateTools.createFromTemplate.description, inputSchema: templateTools.createFromTemplate.inputSchemaZod }, (args) => templateTools.createFromTemplate.execute(args));
+    // --- Version tools (2) ---
+    register(versionTools.listVersions.name, { description: versionTools.listVersions.description, inputSchema: versionTools.listVersions.inputSchemaZod }, (args) => versionTools.listVersions.execute(args));
+    register(versionTools.getVersion.name, { description: versionTools.getVersion.description, inputSchema: versionTools.getVersion.inputSchemaZod }, (args) => versionTools.getVersion.execute(args));
+    // --- Photo tools (3) ---
+    register(photoTools.uploadPhoto.name, { description: photoTools.uploadPhoto.description, inputSchema: photoTools.uploadPhoto.inputSchemaZod }, (args) => photoTools.uploadPhoto.execute(args));
+    register(photoTools.listPhotos.name, { description: photoTools.listPhotos.description, inputSchema: photoTools.listPhotos.inputSchemaZod }, (args) => photoTools.listPhotos.execute(args));
+    register(photoTools.deletePhoto.name, { description: photoTools.deletePhoto.description, inputSchema: photoTools.deletePhoto.inputSchemaZod }, (args) => photoTools.deletePhoto.execute(args));
+    // --- Stats / PDF tools (3) ---
+    register(statsPdfTools.getStats.name, { description: statsPdfTools.getStats.description, inputSchema: statsPdfTools.getStats.inputSchemaZod }, (args) => statsPdfTools.getStats.execute(args));
+    register(statsPdfTools.exportPdf.name, { description: statsPdfTools.exportPdf.description, inputSchema: statsPdfTools.exportPdf.inputSchemaZod }, (args) => statsPdfTools.exportPdf.execute(args));
+    register(statsPdfTools.updateOutputConfig.name, { description: statsPdfTools.updateOutputConfig.description, inputSchema: statsPdfTools.updateOutputConfig.inputSchemaZod }, (args) => statsPdfTools.updateOutputConfig.execute(args));
+    // --- Vision tools (2) ---
+    register(visionTools.analyzePhotos.name, { description: visionTools.analyzePhotos.description, inputSchema: visionTools.analyzePhotos.inputSchemaZod }, (args) => visionTools.analyzePhotos.execute(args));
+    register(visionTools.analyzeDocument.name, { description: visionTools.analyzeDocument.description, inputSchema: visionTools.analyzeDocument.inputSchemaZod }, (args) => visionTools.analyzeDocument.execute(args));
+    // --- Company tools (5) ---
+    register(companyTools.createCompany.name, { description: companyTools.createCompany.description, inputSchema: companyTools.createCompany.inputSchemaZod }, (args) => companyTools.createCompany.execute(args));
+    register(companyTools.listCompanies.name, { description: companyTools.listCompanies.description, inputSchema: companyTools.listCompanies.inputSchemaZod }, (args) => companyTools.listCompanies.execute(args));
+    register(companyTools.getCompany.name, { description: companyTools.getCompany.description, inputSchema: companyTools.getCompany.inputSchemaZod }, (args) => companyTools.getCompany.execute(args));
+    register(companyTools.updateCompany.name, { description: companyTools.updateCompany.description, inputSchema: companyTools.updateCompany.inputSchemaZod }, (args) => companyTools.updateCompany.execute(args));
+    register(companyTools.deleteCompany.name, { description: companyTools.deleteCompany.description, inputSchema: companyTools.deleteCompany.inputSchemaZod }, (args) => companyTools.deleteCompany.execute(args));
+    // --- Client tools (5) ---
+    register(clientTools.createClient.name, { description: clientTools.createClient.description, inputSchema: clientTools.createClient.inputSchemaZod }, (args) => clientTools.createClient.execute(args));
+    register(clientTools.listClients.name, { description: clientTools.listClients.description, inputSchema: clientTools.listClients.inputSchemaZod }, (args) => clientTools.listClients.execute(args));
+    register(clientTools.getClient.name, { description: clientTools.getClient.description, inputSchema: clientTools.getClient.inputSchemaZod }, (args) => clientTools.getClient.execute(args));
+    register(clientTools.updateClient.name, { description: clientTools.updateClient.description, inputSchema: clientTools.updateClient.inputSchemaZod }, (args) => clientTools.updateClient.execute(args));
+    register(clientTools.deleteClient.name, { description: clientTools.deleteClient.description, inputSchema: clientTools.deleteClient.inputSchemaZod }, (args) => clientTools.deleteClient.execute(args));
+    return server;
+}

package/dist/sse.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/sse.js

@@ -0,0 +1,9 @@
+import { startKynverMcpSseServer } from "./lib/mcp-sse-server.js";
+import { createEstimatorServer } from "./server.js";
+import { requestContext } from "./lib/kynver-client.js";
+startKynverMcpSseServer({
+    label: "Estimator server",
+    defaultPort: 3100,
+    createMcpServer: createEstimatorServer,
+    requestContext,
+});