@cc-monitoring/proxy-core 0.1.4 → 0.1.5

package/dist/server/chat-route.js

@@ -0,0 +1,401 @@
+import { Readable } from 'stream';
+import { randomUUID } from 'node:crypto';
+import { loadConfig } from '../config/index.js';
+import { saveRequestDB, extractTokenUsage, loadSessionHistory } from '../utils/request-writer.js';
+import { cleanOldRequestsDB } from '../utils/request-writer.js';
+import { pushNewRequest } from './data-push.js';
+import { initDatabase, getDatabase } from '../utils/db.js';
+import { resolveProxyTarget, getProxyModel, filterForwardHeaders, extractSafeHeaders } from './proxy.js';
+import { injectMcpTools } from '../utils/tool-injector.js';
+import { findInjectedCall, runJsonInjectLoop, runStreamingInjectLoop } from '../utils/inject-loop.js';
+import { findEnabledTool } from '../tools/index.js';
+import { writeSSEEvent, writeTextAsSSE, shouldMock } from '../utils/sse-writer.js';
+import { SSEStreamProcessor } from '../utils/sse-stream-processor.js';
+import { getMachineIdSync, preloadMachineId } from '../utils/machine-id.js';
+export async function setupChatRoute(fastify, proxyConfig) {
+    const fullConfig = await loadConfig();
+    const maxDays = fullConfig.storage?.maxDays ?? 7;
+    initDatabase();
+    await preloadMachineId();
+    fastify.post('/api/chat', async (request, reply) => {
+        const startTime = Date.now();
+        const resolved = resolveProxyTarget(proxyConfig);
+        // Generate or reuse session ID
+        const providedSessionId = request.headers['x-chat-session-id'];
+        const sessionId = providedSessionId || randomUUID();
+        // Validate request body
+        if (!request.body?.model || !Array.isArray(request.body?.messages)) {
+            return reply.code(400).send({
+                error: 'invalid_request',
+                message: 'Request body must contain "model" and "messages" fields'
+            });
+        }
+        // Session resume: if sessionId exists in DB, load history and prepend
+        if (providedSessionId) {
+            const history = loadSessionHistory(providedSessionId);
+            if (history) {
+                // Prepend history messages before the new user messages
+                request.body.messages = [...history.messages, ...request.body.messages];
+                // Carry over system prompt if provided and not in current request
+                if (history.system && !request.body.system && !request.body.system_prompt) {
+                    request.body.system = history.system;
+                }
+                request.log.info(`[chat] session resumed: ${providedSessionId}, history: ${history.messages.length} messages`);
+            }
+        }
+        // Rewrite model based on tier
+        const originalModel = request.body.model;
+        const proxyModel = getProxyModel(originalModel, resolved);
+        if (proxyModel) {
+            request.body.model = proxyModel;
+        }
+        const forwardedModel = request.body.model;
+        // Inject MCP tools only (not probe/curl)
+        const injectedNames = injectMcpTools(request.body);
+        const injected = injectedNames.length > 0;
+        if (injected) {
+            request.log.info(`[chat] MCP tools injected: ${injectedNames.join(',')} (${request.id})`);
+        }
+        // Filter and forward headers
+        const forwardHeaders = filterForwardHeaders(extractSafeHeaders(request.headers), resolved.apiKey);
+        forwardHeaders['x-chat-session-id'] = sessionId;
+        // Extract API keys for recording
+        const authHeader = request.headers['authorization'];
+        const apiKey = authHeader?.startsWith('Bearer ')
+            ? authHeader.slice(7)
+            : request.headers['x-api-key'];
+        const forwardedAuthHeader = forwardHeaders['authorization'];
+        const proxyApiKey = forwardHeaders['x-api-key'] ||
+            (forwardedAuthHeader?.startsWith('Bearer ') ? forwardedAuthHeader.slice(7) : undefined);
+        // Build request data
+        const machineId = getMachineIdSync() ?? undefined;
+        const requestData = {
+            requestId: request.id,
+            sessionId,
+            timestamp: new Date().toISOString(),
+            apiKey,
+            proxyApiKey,
+            baseUrl: resolved.baseUrl,
+            model: forwardedModel,
+            machineId,
+            request: {
+                method: request.method,
+                path: request.url,
+                headers: forwardHeaders,
+                body: request.body
+            },
+            response: {
+                statusCode: 0,
+                events: []
+            }
+        };
+        await cleanOldRequestsDB(maxDays);
+        // Save initial record + push pending status to frontend
+        await saveRequestDB(sessionId, request.id, requestData);
+        pushNewRequest({
+            requestId: request.id,
+            sessionId,
+            compositeId: `${sessionId}:${request.id}`,
+            method: request.method,
+            path: request.url,
+            timestamp: requestData.timestamp,
+            statusCode: 0,
+            responseTime: 0,
+            model: forwardedModel,
+            machineId,
+            baseUrl: resolved.baseUrl
+        }, 'pending');
+        // Mock interception (PoC)
+        if (shouldMock(request.body)) {
+            reply.hijack();
+            reply.raw.writeHead(200, {
+                'content-type': 'text/event-stream',
+                'cache-control': 'no-cache',
+                'connection': 'keep-alive'
+            });
+            writeTextAsSSE(reply.raw, '[PoC] 这是 /api/chat 构造的合成响应，未经过真实大模型。', `msg_poc_chat_${request.id}`);
+            reply.raw.end();
+            return;
+        }
+        // Build target URL — always target /v1/messages
+        const targetUrlStr = `${resolved.baseUrl}${resolved.targetPath}/v1/messages`;
+        request.log.info(`[chat] forwarding to: ${targetUrlStr}`);
+        // Forward to upstream
+        const response = await fetch(targetUrlStr, {
+            method: 'POST',
+            headers: forwardHeaders,
+            body: JSON.stringify(request.body)
+        });
+        request.log.info(`[chat] response status: ${response.status}`);
+        // Extract cloud request ID
+        const cloudRequestId = response.headers.get('x-request-id') || request.id;
+        requestData.requestId = cloudRequestId;
+        requestData.response.statusCode = response.status;
+        requestData.response.headers = Object.fromEntries(response.headers);
+        // Check response type
+        const contentType = response.headers.get('content-type') || '';
+        const isSSE = contentType.includes('text/event-stream');
+        const isJSON = contentType.includes('application/json');
+        // === JSON response (non-streaming) ===
+        if (isJSON && !isSSE && response.body) {
+            const responseBody = await response.text();
+            let jsonBody;
+            try {
+                jsonBody = JSON.parse(responseBody);
+                requestData.response.events.push(jsonBody);
+            }
+            catch {
+                requestData.response.events.push({ raw: responseBody });
+            }
+            // JSON inject loop: if MCP tools injected and response has tool_use
+            if (injected && jsonBody && jsonBody.stop_reason === 'tool_use') {
+                const toolCalls = (jsonBody.content || []).filter((b) => b.type === 'tool_use');
+                const hitCall = toolCalls.find((b) => findEnabledTool(b.name));
+                if (hitCall) {
+                    request.log.info(`[chat] json tool hit: ${hitCall.name} (${cloudRequestId})`);
+                    const loopResult = await runJsonInjectLoop({
+                        initialBody: jsonBody,
+                        requestBody: request.body,
+                        callUpstream: async (b) => {
+                            const r = await fetch(targetUrlStr, {
+                                method: 'POST',
+                                headers: forwardHeaders,
+                                body: JSON.stringify(b)
+                            });
+                            const loopResponseBody = await r.text();
+                            let loopJson;
+                            try {
+                                loopJson = JSON.parse(loopResponseBody);
+                            }
+                            catch { /* ignore */ }
+                            // Record each loop iteration as a separate request
+                            if (loopJson) {
+                                const loopRequestId = r.headers.get('x-request-id') || `loop_${request.id}_${Date.now()}`;
+                                const loopData = {
+                                    requestId: loopRequestId,
+                                    sessionId,
+                                    timestamp: new Date().toISOString(),
+                                    apiKey,
+                                    proxyApiKey,
+                                    baseUrl: resolved.baseUrl,
+                                    model: forwardedModel,
+                                    machineId,
+                                    request: { method: 'POST', path: '/api/chat', headers: forwardHeaders, body: b },
+                                    response: {
+                                        statusCode: r.status,
+                                        headers: Object.fromEntries(r.headers),
+                                        events: [loopJson],
+                                        completedAt: new Date().toISOString()
+                                    }
+                                };
+                                await saveRequestDB(sessionId, loopRequestId, loopData);
+                                const loopUsage = extractTokenUsage(loopData.response.events);
+                                pushNewRequest({
+                                    requestId: loopRequestId,
+                                    sessionId,
+                                    compositeId: `${sessionId}:${loopRequestId}`,
+                                    method: 'POST',
+                                    path: '/api/chat',
+                                    timestamp: loopData.timestamp,
+                                    statusCode: r.status,
+                                    responseTime: 0,
+                                    model: forwardedModel,
+                                    machineId,
+                                    baseUrl: resolved.baseUrl,
+                                    usage: loopUsage
+                                }, 'completed');
+                            }
+                            return loopJson || JSON.parse(loopResponseBody);
+                        }
+                    });
+                    request.log.info(`[chat] json loop done: ${loopResult.iterations} iter (${cloudRequestId})`);
+                    requestData.response.completedAt = new Date().toISOString();
+                    // Remove pending row if cloudRequestId differs from request.id
+                    if (cloudRequestId !== request.id) {
+                        const db = getDatabase();
+                        db.prepare('DELETE FROM requests WHERE request_id = ? AND session_id = ?').run(request.id, sessionId);
+                    }
+                    await saveRequestDB(sessionId, cloudRequestId, requestData);
+                    const usage = extractTokenUsage(requestData.response.events);
+                    pushNewRequest({
+                        requestId: cloudRequestId,
+                        sessionId,
+                        compositeId: `${sessionId}:${cloudRequestId}`,
+                        method: request.method,
+                        path: request.url,
+                        timestamp: requestData.timestamp,
+                        statusCode: response.status,
+                        responseTime: Date.now() - startTime,
+                        model: forwardedModel,
+                        machineId,
+                        baseUrl: resolved.baseUrl,
+                        usage,
+                        pendingId: cloudRequestId !== request.id ? `${sessionId}:${request.id}` : undefined
+                    }, 'completed');
+                    const finalBody = { ...loopResult.finalBody, _sessionId: sessionId };
+                    reply.code(200).header('x-chat-session-id', sessionId).send(JSON.stringify(finalBody));
+                    return;
+                }
+            }
+            // Normal JSON passthrough
+            requestData.response.completedAt = new Date().toISOString();
+            // Remove pending row if cloudRequestId differs from request.id
+            if (cloudRequestId !== request.id) {
+                const db = getDatabase();
+                db.prepare('DELETE FROM requests WHERE request_id = ? AND session_id = ?').run(request.id, sessionId);
+            }
+            await saveRequestDB(sessionId, cloudRequestId, requestData);
+            const usage = extractTokenUsage(requestData.response.events);
+            pushNewRequest({
+                requestId: cloudRequestId,
+                sessionId,
+                compositeId: `${sessionId}:${cloudRequestId}`,
+                method: request.method,
+                path: request.url,
+                timestamp: requestData.timestamp,
+                statusCode: response.status,
+                responseTime: Date.now() - startTime,
+                model: forwardedModel,
+                machineId,
+                baseUrl: resolved.baseUrl,
+                usage,
+                pendingId: cloudRequestId !== request.id ? `${sessionId}:${request.id}` : undefined
+            }, 'completed');
+            // Inject session ID into response for passthrough
+            try {
+                const passthroughBody = JSON.parse(responseBody);
+                passthroughBody._sessionId = sessionId;
+                reply.code(response.status);
+                reply.header('x-chat-session-id', sessionId);
+                reply.send(JSON.stringify(passthroughBody));
+            }
+            catch {
+                reply.code(response.status);
+                reply.headers(Object.fromEntries(response.headers));
+                reply.send(responseBody);
+            }
+            return;
+        }
+        // === SSE response (streaming — unified path) ===
+        if (isSSE && response.body) {
+            reply.hijack();
+            reply.raw.writeHead(response.status, { ...Object.fromEntries(response.headers), 'x-chat-session-id': sessionId });
+            const processor = new SSEStreamProcessor(reply.raw);
+            const nodeStream = Readable.fromWeb(response.body);
+            nodeStream.on('data', (chunk) => {
+                // SSEStreamProcessor.processChunk 同时转发到 reply.raw + 增量解析
+                processor.processChunk(chunk);
+            });
+            nodeStream.on('end', async () => {
+                processor.flushLeftover();
+                // 保存原始请求到 DB
+                requestData.response.events = processor.events;
+                requestData.response.completedAt = new Date().toISOString();
+                // Remove pending row if cloudRequestId differs from request.id
+                if (cloudRequestId !== request.id) {
+                    const db = getDatabase();
+                    db.prepare('DELETE FROM requests WHERE request_id = ? AND session_id = ?').run(request.id, sessionId);
+                }
+                await saveRequestDB(sessionId, cloudRequestId, requestData);
+                const usage = extractTokenUsage(requestData.response.events);
+                pushNewRequest({
+                    requestId: cloudRequestId,
+                    sessionId,
+                    compositeId: `${sessionId}:${cloudRequestId}`,
+                    method: request.method,
+                    path: request.url,
+                    timestamp: requestData.timestamp,
+                    statusCode: response.status,
+                    responseTime: Date.now() - startTime,
+                    model: forwardedModel,
+                    machineId,
+                    baseUrl: resolved.baseUrl,
+                    usage,
+                    pendingId: cloudRequestId !== request.id ? `${sessionId}:${request.id}` : undefined
+                }, 'completed');
+                request.log.info(`[chat] stream completed: ${cloudRequestId} ${response.status} (${Date.now() - startTime}ms, ${processor.events.length} events)`);
+                // 检测注入的 MCP tool_use → 发 proxy_status 信号 + 跑 streaming inject loop
+                if (processor.hasInjectedToolUse()) {
+                    const injectedCall = findInjectedCall(processor.getParsedUpstream());
+                    // 通知客户端：proxy 正在代行 tool，同连接上还有续接数据
+                    writeSSEEvent(reply.raw, { type: 'proxy_status', status: 'tool_executing', tool: injectedCall?.name });
+                    request.log.info(`[chat] SSE tool hit, entering streaming inject loop: ${cloudRequestId}`);
+                    await runStreamingInjectLoop({
+                        initialParsed: processor.getParsedUpstream(),
+                        body: request.body,
+                        callUpstream: async (b) => {
+                            const r = await fetch(targetUrlStr, {
+                                method: 'POST',
+                                headers: forwardHeaders,
+                                body: JSON.stringify(b)
+                            });
+                            const loopRequestId = r.headers.get('x-request-id') || `loop_${request.id}_${Date.now()}`;
+                            return { response: r, requestId: loopRequestId };
+                        },
+                        streamAndParse: async (loopResponse) => {
+                            // 流式转发 loop 迭代的 SSE 到同一 reply.raw
+                            const loopProcessor = new SSEStreamProcessor(reply.raw);
+                            const loopStream = Readable.fromWeb(loopResponse.body);
+                            loopStream.on('data', (chunk) => loopProcessor.processChunk(chunk));
+                            return new Promise((resolve, reject) => {
+                                loopStream.on('end', () => {
+                                    loopProcessor.flushLeftover();
+                                    resolve({ processor: loopProcessor, statusCode: loopResponse.status });
+                                });
+                                loopStream.on('error', (err) => {
+                                    request.log.error({ err }, `[chat] loop stream error`);
+                                    reject(err);
+                                });
+                            });
+                        },
+                        sessionId,
+                        saveIterationDB: async (loopRequestId, loopProcessor, loopStatusCode, loopBody) => {
+                            const loopData = {
+                                requestId: loopRequestId,
+                                sessionId,
+                                timestamp: new Date().toISOString(),
+                                apiKey,
+                                proxyApiKey,
+                                baseUrl: resolved.baseUrl,
+                                model: forwardedModel,
+                                machineId,
+                                request: { method: 'POST', path: '/api/chat', headers: forwardHeaders, body: loopBody },
+                                response: {
+                                    statusCode: loopStatusCode,
+                                    events: loopProcessor.events,
+                                    completedAt: new Date().toISOString()
+                                }
+                            };
+                            await saveRequestDB(sessionId, loopRequestId, loopData);
+                            const loopUsage = extractTokenUsage(loopProcessor.events);
+                            pushNewRequest({
+                                requestId: loopRequestId,
+                                sessionId,
+                                compositeId: `${sessionId}:${loopRequestId}`,
+                                method: 'POST',
+                                path: '/api/chat',
+                                timestamp: loopData.timestamp,
+                                statusCode: loopStatusCode,
+                                responseTime: 0,
+                                model: forwardedModel,
+                                machineId,
+                                baseUrl: resolved.baseUrl,
+                                usage: loopUsage
+                            }, 'completed');
+                        },
+                        raw: reply.raw
+                    });
+                    request.log.info(`[chat] SSE streaming inject loop done: ${cloudRequestId}`);
+                }
+                reply.raw.end();
+            });
+            nodeStream.on('error', (err) => {
+                request.log.error({ err }, `[chat] stream error: ${cloudRequestId}`);
+                reply.raw.end();
+            });
+            return;
+        }
+        // No body — error
+        reply.code(response.status).send('');
+    });
+}

package/dist/server/claude-settings-route.d.ts

@@ -0,0 +1,2 @@
+import { FastifyInstance } from 'fastify';
+export declare function setupClaudeSettingsRoutes(fastify: FastifyInstance, config: any): Promise<void>;

package/dist/server/claude-settings-route.js

@@ -0,0 +1,76 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { isClaudeInstalled } from '../utils/version.js';
+function getClaudeSettingsPath() {
+    return path.join(os.homedir(), '.claude', 'settings.json');
+}
+function buildServerAddress(config) {
+    const host = config.server.host === '0.0.0.0' ? 'localhost' : config.server.host;
+    return `http://${host}:${config.server.port}`;
+}
+export async function setupClaudeSettingsRoutes(fastify, config) {
+    fastify.post('/ui/api/claude-settings/sync', async (request, reply) => {
+        // 1. 检测 Claude Code 是否安装
+        if (!isClaudeInstalled()) {
+            return reply.send({
+                success: false,
+                message: '未检测到 Claude Code，请安装完以后重试'
+            });
+        }
+        // 2. 检测 settings.json 是否存在
+        const settingsPath = getClaudeSettingsPath();
+        if (!fs.existsSync(settingsPath)) {
+            return reply.send({
+                success: false,
+                message: '未检测到配置文件，请手动修改'
+            });
+        }
+        // 3. 读取 settings.json
+        let settings;
+        try {
+            const raw = fs.readFileSync(settingsPath, 'utf-8');
+            settings = JSON.parse(raw);
+        }
+        catch {
+            return reply.code(500).send({
+                success: false,
+                message: '配置文件格式错误，请手动检查'
+            });
+        }
+        // 4. 构建当前 ccm 服务地址
+        const serverAddress = buildServerAddress(config);
+        const currentBaseUrl = settings?.env?.ANTHROPIC_BASE_URL;
+        // 5. 比较
+        if (currentBaseUrl === serverAddress) {
+            return reply.send({
+                success: true,
+                message: '已使用 CCM 的配置，无需改动',
+                alreadyMatched: true
+            });
+        }
+        // 6. 备份旧值 + 设置新值
+        if (!settings.env) {
+            settings.env = {};
+        }
+        if (currentBaseUrl) {
+            settings.env.ANTHROPIC_BASE_URL_CCM_BACKUP = currentBaseUrl;
+        }
+        settings.env.ANTHROPIC_BASE_URL = serverAddress;
+        // 7. 写回 settings.json
+        try {
+            fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2), 'utf-8');
+        }
+        catch (err) {
+            return reply.code(500).send({
+                success: false,
+                message: `写入配置文件失败: ${err.message}`
+            });
+        }
+        return reply.send({
+            success: true,
+            message: '修改成功，请重启 Claude 终端生效',
+            alreadyMatched: false
+        });
+    });
+}

package/dist/server/data-push.d.ts

@@ -1,5 +1,7 @@
 import { WebSocket } from 'ws';
 export declare function addDataClient(ws: WebSocket): void;
 export declare function removeDataClient(ws: WebSocket): void;
-export declare function pushNewRequest(summary: any): void;
+export declare function getDataClientCount(): number;
+export declare function pushNewRequest(summary: any, status?: 'pending' | 'completed'): void;
 export declare function pushStatsNotify(): void;
+export declare function broadcastToDataClients(msg: any): void;

package/dist/server/data-push.js

@@ -7,12 +7,15 @@ export function addDataClient(ws) {
 export function removeDataClient(ws) {
     dataClients.delete(ws);
 }
+export function getDataClientCount() {
+    return dataClients.size;
+}
 // Broadcast helpers
-export function pushNewRequest(summary) {
+export function pushNewRequest(summary, status = 'completed') {
     broadcast({
         type: 'request',
-        action: 'new',
-        data: summary
+        action: status === 'pending' ? 'new' : 'update',
+        data: { ...summary, status }
     });
 }
 export function pushStatsNotify() {
@@ -30,3 +33,7 @@ function broadcast(msg) {
         }
     }
 }
+// Expose broadcast for global status timer (ui-route.ts)
+export function broadcastToDataClients(msg) {
+    broadcast(msg);
+}

package/dist/server/docs-route.d.ts

@@ -0,0 +1,2 @@
+import { FastifyInstance } from 'fastify';
+export declare function setupDocsRoutes(fastify: FastifyInstance): Promise<void>;

package/dist/server/docs-route.js

@@ -0,0 +1,63 @@
+import multipart from '@fastify/multipart';
+import fs from 'fs';
+import path from 'path';
+import { registry } from '../parsers/index.js';
+import { dataDir } from '../utils/paths.js';
+const docsDir = path.join(dataDir, 'docs');
+export async function setupDocsRoutes(fastify) {
+    await fastify.register(multipart, { limits: { fileSize: 10 * 1024 * 1024 } });
+    fastify.post('/ui/api/docs/upload', async (request, reply) => {
+        const data = await request.file();
+        if (!data) {
+            return reply.code(400).send({ success: false, error: 'No file uploaded' });
+        }
+        const filename = path.basename(data.filename);
+        const buffer = await data.toBuffer();
+        // 校验扩展名
+        const supported = registry.getSupportedExtensions();
+        const dotIndex = filename.lastIndexOf('.');
+        if (dotIndex === -1) {
+            return reply.code(400).send({
+                success: false,
+                error: `File has no extension. Supported types: ${supported.join(', ')}`
+            });
+        }
+        const ext = filename.slice(dotIndex).toLowerCase();
+        if (!supported.includes(ext)) {
+            return reply.code(400).send({
+                success: false,
+                error: `Unsupported file type: "${ext}". Supported types: ${supported.join(', ')}`
+            });
+        }
+        // 解析文件内容为 md
+        let mdContent;
+        try {
+            mdContent = await registry.parse(buffer, filename);
+        }
+        catch (err) {
+            request.log.error({ err, filename }, 'File parsing failed');
+            return reply.code(500).send({
+                success: false,
+                error: err.message || 'File parsing failed'
+            });
+        }
+        // 确保 docs 目录存在
+        if (!fs.existsSync(docsDir)) {
+            fs.mkdirSync(docsDir, { recursive: true });
+        }
+        // 写入 md 文件
+        const mdFilename = filename.slice(0, dotIndex) + '.md';
+        const mdPath = path.join(docsDir, mdFilename);
+        try {
+            fs.writeFileSync(mdPath, mdContent, 'utf-8');
+        }
+        catch (err) {
+            request.log.error({ err, mdPath }, 'Failed to write md file');
+            return reply.code(500).send({
+                success: false,
+                error: 'Failed to save file'
+            });
+        }
+        return { success: true, path: `docs/${mdFilename}` };
+    });
+}

package/dist/server/index.js

@@ -5,6 +5,8 @@ import { configureDbPath } from '../utils/db.js';
 import { getCurrentModuleUrl } from '../utils/esm-dirname.js';
 import { setupProxy } from './proxy.js';
 import { setupUiRoutes } from './ui-route.js';
+import { setupChatRoute } from './chat-route.js';
+import { setupDocsRoutes } from './docs-route.js';
 import { requestIdMiddleware } from './middleware/request-id.js';
 export async function createServer() {
     const config = await loadConfig();
@@ -19,6 +21,8 @@ export async function createServer() {
     fastify.register(requestIdMiddleware);
     await setupUiRoutes(fastify); // UI routes registered BEFORE proxy to avoid being proxied
     await setupProxy(fastify, config.proxy);
+    await setupChatRoute(fastify, config.proxy); // MCP-enhanced chat endpoint
+    await setupDocsRoutes(fastify);
     return fastify;
 }
 export async function startServer() {

package/dist/server/mcp-route.d.ts

@@ -0,0 +1,2 @@
+import { FastifyInstance } from 'fastify';
+export declare function setupMcpRoutes(fastify: FastifyInstance, config: any): Promise<void>;