@carbonvoice/cv-mcp-server 1.0.0

package/dist/server-test.js

@@ -0,0 +1,93 @@
+"use strict";
+// import express from 'express';
+// import { randomUUID } from 'node:crypto';
+// import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+// import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+// import { isInitializeRequest } from '@modelcontextprotocol/sdk/types.js';
+// import { z } from 'zod';
+Object.defineProperty(exports, "__esModule", { value: true });
+// const app = express();
+// app.use(express.json());
+// // Map to store transports by session ID
+// const transports: { [sessionId: string]: StreamableHTTPServerTransport } = {};
+// // Handle POST requests for client-to-server communication
+// app.post('/mcp', async (req, res) => {
+//   console.log('🚀 POST request received');
+//   // Check for existing session ID
+//   const sessionId = req.headers['mcp-session-id'] as string | undefined;
+//   let transport: StreamableHTTPServerTransport;
+//   if (sessionId && transports[sessionId]) {
+//     // Reuse existing transport
+//     transport = transports[sessionId];
+//   } else if (!sessionId && isInitializeRequest(req.body)) {
+//     // New initialization request
+//     transport = new StreamableHTTPServerTransport({
+//       sessionIdGenerator: () => randomUUID(),
+//       onsessioninitialized: (sessionId) => {
+//         // Store the transport by session ID
+//         transports[sessionId] = transport;
+//       },
+//     });
+//     // Clean up transport when closed
+//     transport.onclose = () => {
+//       if (transport.sessionId) {
+//         console.log('🚀 Disconnecting from MCP server');
+//         delete transports[transport.sessionId];
+//       }
+//     };
+//     const server = new McpServer({
+//       name: 'example-server',
+//       version: '1.0.0',
+//     });
+//     // ... set up server resources, tools, and prompts ...
+//     server.tool(
+//       'hello_world',
+//       'Simple Hello World tool',
+//       {
+//         name: z.string().optional().describe('Your name'),
+//       },
+//       async ({ name }) => ({
+//         content: [
+//           {
+//             type: 'text',
+//             text: `Hello, ${name ?? 'World'}! This response comes from an SSE MCP server.`,
+//           },
+//         ],
+//       }),
+//     );
+//     // Connect to the MCP server
+//     console.log('🚀 Connecting to MCP server');
+//     await server.connect(transport);
+//   } else {
+//     // Invalid request
+//     res.status(400).json({
+//       jsonrpc: '2.0',
+//       error: {
+//         code: -32000,
+//         message: 'Bad Request: No valid session ID provided',
+//       },
+//       id: null,
+//     });
+//     return;
+//   }
+//   // Handle the request
+//   await transport.handleRequest(req, res, req.body);
+// });
+// // Reusable handler for GET and DELETE requests
+// const handleSessionRequest = async (
+//   req: express.Request,
+//   res: express.Response,
+// ) => {
+//   const sessionId = req.headers['mcp-session-id'] as string | undefined;
+//   if (!sessionId || !transports[sessionId]) {
+//     res.status(400).send('Invalid or missing session ID');
+//     return;
+//   }
+//   const transport = transports[sessionId];
+//   await transport.handleRequest(req, res);
+// };
+// // Handle GET requests for server-to-client notifications via SSE
+// app.get('/mcp', handleSessionRequest);
+// // Handle DELETE requests for session termination
+// app.delete('/mcp', handleSessionRequest);
+// app.listen(4000);

package/dist/server.js

@@ -0,0 +1,365 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const constants_1 = require("./constants");
+const generated_1 = require("./generated");
+const CarbonVoiceSimplifiedAPI_zod_1 = require("./generated/carbon-voice-api/CarbonVoiceSimplifiedAPI.zod");
+const utils_1 = require("./utils");
+// Create server instance
+const server = new mcp_js_1.McpServer({
+    name: constants_1.SERVICE_NAME,
+    version: constants_1.SERVICE_VERSION,
+    capabilities: {
+        resources: {},
+        tools: {},
+    },
+});
+const api = (0, generated_1.getCarbonVoiceSimplifiedAPI)();
+// type GetMessageInput = z.infer<typeof getMessageByIdParams> &
+//   z.infer<typeof getMessageByIdQueryParams>;
+/**********************
+ * Tools
+ *********************/
+// Messages
+server.registerTool('list_messages', {
+    description: 'List Messages. By default returns messages created in last 5 days. The maximum allowed range between dates is 31 days.',
+    inputSchema: CarbonVoiceSimplifiedAPI_zod_1.listMessagesQueryParams.shape,
+}, async (params) => {
+    try {
+        return (0, utils_1.formatToMCPToolResponse)(await api.listMessages(params));
+    }
+    catch (error) {
+        utils_1.logger.error('Error listing messages:', { params, error });
+        return (0, utils_1.formatToMCPToolResponse)(error);
+    }
+});
+server.registerTool('get_message', {
+    description: 'Get a message by its ID.',
+    inputSchema: CarbonVoiceSimplifiedAPI_zod_1.getMessageByIdParams.merge(CarbonVoiceSimplifiedAPI_zod_1.getMessageByIdQueryParams).shape,
+}, async (args) => {
+    try {
+        const { id, ...queryParams } = args;
+        return (0, utils_1.formatToMCPToolResponse)(await api.getMessageById(id, queryParams));
+    }
+    catch (error) {
+        utils_1.logger.error('Error getting message by id:', { args, error });
+        return (0, utils_1.formatToMCPToolResponse)(error);
+    }
+});
+server.registerTool('get_recent_messages', {
+    description: 'Get most recent messages, including their associated Conversation, Creator, and Labels information. ' +
+        'Returns a maximum of 10 messages.',
+    inputSchema: CarbonVoiceSimplifiedAPI_zod_1.getTenRecentMessagesResponseQueryParams.shape,
+}, async (args) => {
+    try {
+        return (0, utils_1.formatToMCPToolResponse)(await api.getTenRecentMessagesResponse(args));
+    }
+    catch (error) {
+        utils_1.logger.error('Error getting recent messages:', { args, error });
+        return (0, utils_1.formatToMCPToolResponse)(error);
+    }
+});
+server.registerTool('create_conversation_message', {
+    description: 'Send a message to a conversation. In order to create a Message, you must provide transcript or link attachments.',
+    inputSchema: CarbonVoiceSimplifiedAPI_zod_1.createConversationMessageParams.merge(CarbonVoiceSimplifiedAPI_zod_1.createConversationMessageBody).shape,
+}, async (args) => {
+    try {
+        return (0, utils_1.formatToMCPToolResponse)(await api.createConversationMessage(args.id, args));
+    }
+    catch (error) {
+        utils_1.logger.error('Error creating conversation message:', { args, error });
+        return (0, utils_1.formatToMCPToolResponse)(error);
+    }
+});
+server.registerTool('create_direct_message', {
+    description: 'Send a Direct Message (DM) to a User or a Group of Users. ' +
+        'In order to create a Direct Message, you must provide transcript or link attachments.',
+    inputSchema: CarbonVoiceSimplifiedAPI_zod_1.sendDirectMessageBody.shape,
+}, async (args) => {
+    try {
+        return (0, utils_1.formatToMCPToolResponse)(await api.sendDirectMessage(args));
+    }
+    catch (error) {
+        utils_1.logger.error('Error creating direct message:', { args, error });
+        return (0, utils_1.formatToMCPToolResponse)(error);
+    }
+});
+server.registerTool('create_voicememo_message', {
+    description: 'Create a VoiceMemo Message. In order to create a VoiceMemo Message, you must provide a transcript or link attachments.',
+    inputSchema: CarbonVoiceSimplifiedAPI_zod_1.createVoiceMemoMessageBody.shape,
+}, async (args) => {
+    try {
+        return (0, utils_1.formatToMCPToolResponse)(await api.createVoiceMemoMessage(args));
+    }
+    catch (error) {
+        utils_1.logger.error('Error creating voicememo message:', { args, error });
+        return (0, utils_1.formatToMCPToolResponse)(error);
+    }
+});
+server.registerTool('add_attachments_to_message', {
+    description: 'Add attachments to a message. In order to add attachments to a message, you must provide a message id and the attachments.',
+    inputSchema: CarbonVoiceSimplifiedAPI_zod_1.addLinkAttachmentsToMessageParams.merge(CarbonVoiceSimplifiedAPI_zod_1.addLinkAttachmentsToMessageBody).shape,
+}, async (args) => {
+    try {
+        return (0, utils_1.formatToMCPToolResponse)(await api.addLinkAttachmentsToMessage(args.id, { links: args.links }));
+    }
+    catch (error) {
+        utils_1.logger.error('Error adding attachments to message:', { args, error });
+        return (0, utils_1.formatToMCPToolResponse)(error);
+    }
+});
+// Users
+server.registerTool('get_user', {
+    description: 'Get a User by their ID.',
+    inputSchema: CarbonVoiceSimplifiedAPI_zod_1.getUserByIdParams.shape,
+}, async (args) => {
+    try {
+        return (0, utils_1.formatToMCPToolResponse)(await api.getUserById(args.id));
+    }
+    catch (error) {
+        utils_1.logger.error('Error getting user by id:', { args, error });
+        return (0, utils_1.formatToMCPToolResponse)(error);
+    }
+});
+server.registerTool('search_user', {
+    description: 'Search for a User by their phone number or email address. ' +
+        '(In order to search for a User, you must provide a phone number or email address.)',
+    inputSchema: CarbonVoiceSimplifiedAPI_zod_1.searchUserQueryParams.shape,
+}, async (args) => {
+    try {
+        return (0, utils_1.formatToMCPToolResponse)(await api.searchUser(args));
+    }
+    catch (error) {
+        utils_1.logger.error('Error searching for user:', { args, error });
+        return (0, utils_1.formatToMCPToolResponse)(error);
+    }
+});
+server.registerTool('search_users', {
+    description: 'Search multiple Users by their phone numbers, email addresses or ids. ' +
+        '(In order to search Users, you must provide phone numbers, email addresses or ids.)',
+    inputSchema: CarbonVoiceSimplifiedAPI_zod_1.searchUsersBody.shape,
+}, async (args) => {
+    try {
+        return (0, utils_1.formatToMCPToolResponse)(await api.searchUsers(args));
+    }
+    catch (error) {
+        utils_1.logger.error('Error searching users:', { args, error });
+        return (0, utils_1.formatToMCPToolResponse)(error);
+    }
+});
+// Conversations
+server.registerTool('list_conversations', {
+    description: 'List all conversations. ' +
+        'Returns a simplified view of user conversations that have had messages sent or received within the last 6 months.',
+}, async () => {
+    try {
+        return (0, utils_1.formatToMCPToolResponse)(await api.getAllConversations());
+    }
+    catch (error) {
+        utils_1.logger.error('Error listing conversations:', { error });
+        return (0, utils_1.formatToMCPToolResponse)(error);
+    }
+});
+server.registerTool('get_conversation', {
+    description: 'Get a conversation by its ID.',
+    inputSchema: CarbonVoiceSimplifiedAPI_zod_1.getConversationByIdParams.shape,
+}, async (args) => {
+    try {
+        return (0, utils_1.formatToMCPToolResponse)(await api.getConversationById(args.id));
+    }
+    catch (error) {
+        utils_1.logger.error('Error getting conversation by id:', { error });
+        return (0, utils_1.formatToMCPToolResponse)(error);
+    }
+});
+server.registerTool('get_conversation_users', {
+    description: 'Get users in a conversation.',
+    inputSchema: CarbonVoiceSimplifiedAPI_zod_1.getConversationByIdParams.shape,
+}, async (args) => {
+    try {
+        return (0, utils_1.formatToMCPToolResponse)(await api.getConversationUsers(args.id));
+    }
+    catch (error) {
+        utils_1.logger.error('Error getting conversation users:', { error });
+        return (0, utils_1.formatToMCPToolResponse)(error);
+    }
+});
+// Folders
+server.registerTool('get_workspace_folders_and_message_counts', {
+    description: 'Returns, for each workspace, the total number of folders and messages, as well as a breakdown of folders, ' +
+        'messages, and messages not in any folder.(Required to inform message type:voicememo,prerecorded)',
+    inputSchema: CarbonVoiceSimplifiedAPI_zod_1.getCountsGroupedByWorkspaceQueryParams.shape,
+}, async (args) => {
+    try {
+        return (0, utils_1.formatToMCPToolResponse)(await api.getCountsGroupedByWorkspace(args));
+    }
+    catch (error) {
+        utils_1.logger.error('Error listing workspace folders:', { error });
+        return (0, utils_1.formatToMCPToolResponse)(error);
+    }
+});
+server.registerTool('get_root_folders', {
+    description: 'Lists all root folders for a given workspace, including their names, IDs, and basic structure, ' +
+        'but does not provide aggregate counts.(Required to inform message type:voicememo,prerecorded)',
+    inputSchema: CarbonVoiceSimplifiedAPI_zod_1.getAllRootFoldersQueryParams.shape,
+}, async (args) => {
+    try {
+        return (0, utils_1.formatToMCPToolResponse)(await api.getAllRootFolders(args));
+    }
+    catch (error) {
+        utils_1.logger.error('Error listing root folders:', { error });
+        return (0, utils_1.formatToMCPToolResponse)(error);
+    }
+});
+server.registerTool('create_folder', {
+    description: 'Create a new folder.',
+    inputSchema: CarbonVoiceSimplifiedAPI_zod_1.createFolderBody.shape,
+}, async (args) => {
+    try {
+        return (0, utils_1.formatToMCPToolResponse)(await api.createFolder(args));
+    }
+    catch (error) {
+        utils_1.logger.error('Error creating folder:', { error });
+        return (0, utils_1.formatToMCPToolResponse)(error);
+    }
+});
+server.registerTool('get_folder', {
+    description: 'Get a folder by its ID.',
+    inputSchema: CarbonVoiceSimplifiedAPI_zod_1.getFolderByIdParams.merge(CarbonVoiceSimplifiedAPI_zod_1.getFolderByIdQueryParams).shape,
+}, async (args) => {
+    try {
+        return (0, utils_1.formatToMCPToolResponse)(await api.getFolderById(args.id, args));
+    }
+    catch (error) {
+        utils_1.logger.error('Error getting folder by id:', { error });
+        return (0, utils_1.formatToMCPToolResponse)(error);
+    }
+});
+server.registerTool('get_folder_with_messages', {
+    description: 'Get a folder including its messages by its ID. (Only messages at folder level are returned.)',
+    inputSchema: CarbonVoiceSimplifiedAPI_zod_1.getFolderMessagesParams.shape,
+}, async (args) => {
+    try {
+        return (0, utils_1.formatToMCPToolResponse)(await api.getFolderMessages(args.id));
+    }
+    catch (error) {
+        utils_1.logger.error('Error getting folder with messages:', { error });
+        return (0, utils_1.formatToMCPToolResponse)(error);
+    }
+});
+server.registerTool('update_folder_name', {
+    description: 'Update a folder name by its ID.',
+    inputSchema: CarbonVoiceSimplifiedAPI_zod_1.updateFolderNameParams.merge(CarbonVoiceSimplifiedAPI_zod_1.updateFolderNameBody).shape,
+}, async (args) => {
+    try {
+        return (0, utils_1.formatToMCPToolResponse)(await api.updateFolderName(args.id, args));
+    }
+    catch (error) {
+        utils_1.logger.error('Error updating folder name:', { error });
+        return (0, utils_1.formatToMCPToolResponse)(error);
+    }
+});
+server.registerTool('delete_folder', {
+    description: 'Delete a folder by its ID. Deleting a folder will also delete nested folders and all the messages in referenced folders. ' +
+        '(This is a destructive action and cannot be undone, so please be careful.)',
+    inputSchema: CarbonVoiceSimplifiedAPI_zod_1.deleteFolderParams.shape,
+}, async (args) => {
+    try {
+        return (0, utils_1.formatToMCPToolResponse)(await api.deleteFolder(args.id));
+    }
+    catch (error) {
+        utils_1.logger.error('Error deleting folder:', { error });
+        return (0, utils_1.formatToMCPToolResponse)(error);
+    }
+});
+server.registerTool('move_folder', {
+    description: 'Move a folder by its ID. Move a Folder into another Folder or into a Workspace.',
+    inputSchema: CarbonVoiceSimplifiedAPI_zod_1.moveFolderParams.merge(CarbonVoiceSimplifiedAPI_zod_1.moveFolderBody).shape,
+}, async (args) => {
+    try {
+        return (0, utils_1.formatToMCPToolResponse)(await api.moveFolder(args.id, args));
+    }
+    catch (error) {
+        utils_1.logger.error('Error moving folder:', { error });
+        return (0, utils_1.formatToMCPToolResponse)(error);
+    }
+});
+server.registerTool('move_message_to_folder', {
+    description: 'Move a message to a folder by its ID. Move a Message into another Folder or into a Workspace. ' +
+        'Only allowed to move messages of type: voicememo,prerecorded.',
+    inputSchema: CarbonVoiceSimplifiedAPI_zod_1.addMessageToFolderOrWorkspaceBody.shape,
+}, async (args) => {
+    try {
+        return (0, utils_1.formatToMCPToolResponse)(await api.addMessageToFolderOrWorkspace(args));
+    }
+    catch (error) {
+        utils_1.logger.error('Error moving message to folder:', { error });
+        return (0, utils_1.formatToMCPToolResponse)(error);
+    }
+});
+// Workspace
+server.registerTool('get_workspaces_basic_info', {
+    description: 'Get basic information about a workspace.',
+}, async () => {
+    try {
+        return (0, utils_1.formatToMCPToolResponse)(await api.getAllWorkspacesWithBasicInfo());
+    }
+    catch (error) {
+        utils_1.logger.error('Error getting workspaces basic info:', { error });
+        return (0, utils_1.formatToMCPToolResponse)(error);
+    }
+});
+// AI Magic
+server.registerTool('list_ai_actions', {
+    description: 'List AI Actions (Prompts). Optionally, you can filter by owner type and workspace id. ' +
+        'Filtering by owner type, Possible values: "user", "workspace", "system". ' +
+        'Do not use unless the user explicitly requests it.',
+    inputSchema: CarbonVoiceSimplifiedAPI_zod_1.aIPromptControllerGetPromptsQueryParams.shape,
+}, async (args) => {
+    try {
+        return (0, utils_1.formatToMCPToolResponse)(await api.aIPromptControllerGetPrompts(args));
+    }
+    catch (error) {
+        utils_1.logger.error('Error listing ai actions:', { error });
+        return (0, utils_1.formatToMCPToolResponse)(error);
+    }
+});
+server.registerTool('run_ai_action', {
+    description: 'Run an AI Action (Prompt) for a message. You can run an AI Action for a message by its ID or a list of message IDs.',
+    inputSchema: CarbonVoiceSimplifiedAPI_zod_1.aIResponseControllerCreateResponseBody.shape,
+}, async (args) => {
+    try {
+        return (0, utils_1.formatToMCPToolResponse)(await api.aIResponseControllerCreateResponse(args));
+    }
+    catch (error) {
+        utils_1.logger.error('Error running ai action:', { error });
+        return (0, utils_1.formatToMCPToolResponse)(error);
+    }
+});
+server.registerTool('run_ai_action_for_shared_link', {
+    description: 'Run an AI Action (Prompt) for a shared link. You can run an AI Action for a shared link by its ID or a list of shared link IDs. ' +
+        'You can also provide the language of the response.',
+    inputSchema: CarbonVoiceSimplifiedAPI_zod_1.createShareLinkAIResponseBody.shape,
+}, async (args) => {
+    try {
+        return (0, utils_1.formatToMCPToolResponse)(await api.createShareLinkAIResponse(args));
+    }
+    catch (error) {
+        utils_1.logger.error('Error running ai action for shared link:', { error });
+        return (0, utils_1.formatToMCPToolResponse)(error);
+    }
+});
+server.registerTool('get_ai_action_responses', {
+    description: 'Retrieve previously generated AI Action (Prompt) responses by filtering for a specific prompt, message, or conversation ID. ' +
+        'Combine filters to narrow results and view all AI-generated responses related to a particular prompt, message, or conversation.',
+    inputSchema: CarbonVoiceSimplifiedAPI_zod_1.aIResponseControllerGetAllResponsesQueryParams.shape,
+}, async (args) => {
+    try {
+        return (0, utils_1.formatToMCPToolResponse)(await api.aIResponseControllerGetAllResponses(args));
+    }
+    catch (error) {
+        utils_1.logger.error('Error getting ai action responses:', { error });
+        return (0, utils_1.formatToMCPToolResponse)(error);
+    }
+});
+exports.default = server;

package/dist/sse.js

@@ -0,0 +1,134 @@
+"use strict";
+// #!/usr/bin/env node
+// import express, { Request, Response } from 'express';
+// import cors from 'cors';
+// import dotenv from 'dotenv';
+// import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+// import { z } from 'zod';
+// import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
+Object.defineProperty(exports, "__esModule", { value: true });
+// // Load .env
+// dotenv.config();
+// // Environment variables
+// const CV_API_BASE_URL = 'https://wf5whhzd-8081.brs.devtunnels.ms';
+// const CV_API_SIMPLIFIED_BASE_URL = `${CV_API_BASE_URL}/simplified`;
+// const API_KEY = process.env.CARBON_VOICE_API_KEY;
+// if (!API_KEY) {
+//   console.error('❌ Missing CARBON_VOICE_API_KEY');
+//   process.exit(1);
+// }
+// // ---- API CLIENT ---- //
+// class CarbonVoiceClient {
+//   constructor(private apiKey: string) {}
+//   async listChannels(limit = 100, cursor = '') {
+//     try {
+//       const res = await fetch(
+//         `${CV_API_SIMPLIFIED_BASE_URL}/conversations/all`,
+//         {
+//           headers: {
+//             'x-api-key': this.apiKey,
+//             'Content-Type': 'application/json',
+//           },
+//         },
+//       );
+//       if (!res.ok) throw new Error(`Failed with status ${res.status}`);
+//       return await res.json();
+//     } catch (error) {
+//       console.error('🔴 Error in listChannels:', error);
+//       return null;
+//     }
+//   }
+// }
+// const client = new CarbonVoiceClient(API_KEY);
+// // ---- MCP SERVER ---- //
+// const server = new McpServer({
+//   name: 'Carbon Voice MCP Server (SSE)',
+//   version: '1.0.0',
+//   capabilities: {
+//     resources: {},
+//     tools: {},
+//   },
+// });
+// server.tool(
+//   'list_channels',
+//   'List channels',
+//   {
+//     workspace_id: z.string().optional().describe('Carbon Voice workspace ID'),
+//   },
+//   async ({ workspace_id }) => {
+//     const channelsData = await client.listChannels(100, '');
+//     if (!channelsData) {
+//       return {
+//         content: [
+//           {
+//             type: 'text',
+//             text: 'Failed to retrieve channels data',
+//           },
+//         ],
+//       };
+//     }
+//     return {
+//       content: [
+//         {
+//           type: 'text',
+//           text: JSON.stringify(channelsData),
+//         },
+//       ],
+//     };
+//   },
+// );
+// // ---- EXPRESS + SSE ---- //
+// async function run() {
+//   const app = express();
+//   app.use(cors());
+//   app.use(express.json());
+//   const transports = new Map<string, SSEServerTransport>();
+//   app.get('/mcp/stream', async (req: Request, res: Response) => {
+//     const clientId = crypto.randomUUID();
+//     const transport = new SSEServerTransport('/mcp/stream', res);
+//     transports.set(clientId, transport);
+//     // Connect the SSE transport (this writes SSE headers) BEFORE writing any response
+//     await server.connect(transport);
+//     // Send a "clientId" event (so the client knows its ID)
+//     res.write(`event: clientId\ndata: ${clientId}\n\n`);
+//     // Send a "list_tools" event (so the client sees available tools) – mimicking MCP protocol's tool discovery
+//     const toolsList = {
+//       type: 'list_tools',
+//       tools: [
+//         {
+//           name: 'list_channels',
+//           description: 'List channels',
+//           args_schema: { workspace_id: 'string (optional)' },
+//         },
+//       ],
+//     };
+//     res.write(`event: list_tools\ndata: ${JSON.stringify(toolsList)}\n\n`);
+//     req.on('close', () => transports.delete(clientId));
+//     console.log('✅ SSE MCP server connected (transport started)');
+//   });
+//   app.post('/mcp/message', async (req: any, res: any) => {
+//     // if (!transport) {
+//     //   return res.status(400).send('❌ SSE transport not initialized');
+//     // }
+//     // await transport.handlePostMessage(req, res, req.body);
+//     const { clientId, ...body } = req.body;
+//     const transport = transports.get(clientId);
+//     if (!transport) {
+//       return res.status(400).send('❌ SSE connection not established');
+//     }
+//     try {
+//       return await transport.handlePostMessage(req, res, body);
+//     } catch (error) {
+//       console.error('🔴 Error in handlePostMessage:', error);
+//       return res.status(500).send('❌ Error processing message');
+//     }
+//   });
+//   const PORT = process.env.PORT ?? 3333;
+//   app.listen(PORT, () =>
+//     console.log(`✅ SSE MCP server listening at http://localhost:${PORT}/mcp`),
+//   );
+// }
+// run().catch((err) => {
+//   console.error('🛑 Fatal server error:', err);
+//   process.exit(1);
+// });

package/dist/sse.v2.js

@@ -0,0 +1,29 @@
+"use strict";
+// import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
+// import { createServer } from './server.js';
+// import express from 'express';
+Object.defineProperty(exports, "__esModule", { value: true });
+// // Create Express app and MCP server
+// const app = express();
+// const mcpServer = createServer();
+// // Handle SSE connections
+// app.get('/mcp', (req, res) => {
+//   const transport = new SSEServerTransport('/mcp', res);
+//   // Set SSE headers
+//   res.setHeader('Content-Type', 'text/event-stream');
+//   res.setHeader('Cache-Control', 'no-cache');
+//   res.setHeader('Connection', 'keep-alive');
+//   res.setHeader('Access-Control-Allow-Origin', '*'); // For development, restrict in production
+//   transport.handleMessage(req);
+//   // Handle the SSE connection using the MCP server's connect method
+//   mcpServer.connect(transport);
+//   // Handle client disconnect
+//   req.on('close', () => {
+//     console.log('Client disconnected');
+//   });
+// });
+// // Start the server
+// const PORT = process.env.PORT || 3000;
+// app.listen(PORT, () => {
+//   console.log(`Server running on port ${PORT}`);
+// });

package/dist/stdio.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+'use strict';
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const constants_1 = require("./constants");
+const server_1 = __importDefault(require("./server"));
+const utils_1 = require("./utils");
+// Set stdio mode for logger (Needed for the logger to work in stdio mode)
+process.env.MCP_STDIO_MODE = 'true';
+const logArgs = {
+    name: constants_1.SERVICE_NAME,
+    version: constants_1.SERVICE_VERSION,
+};
+async function runServer() {
+    const transport = new stdio_js_1.StdioServerTransport();
+    // Log startup information
+    utils_1.logger.debug('🚀 Starting stdio server...', logArgs);
+    try {
+        await server_1.default.connect(transport);
+        utils_1.logger.info('✅ MCP server connected to stdio transport', logArgs);
+    }
+    catch (error) {
+        utils_1.logger.error('❌ Failed to connect server to stdio transport', {
+            error,
+            ...logArgs,
+        });
+        process.exit(1);
+    }
+}
+runServer().catch((error) => {
+    utils_1.logger.error('❌ Fatal server error', {
+        error,
+        ...logArgs,
+    });
+    process.exit(1);
+});