@nekzus/mcp-server 1.0.29 → 1.0.31

package/dist/index.js

@@ -1,106 +1,178 @@
 #!/usr/bin/env node
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import 'dotenv/config';
-import availableTools from './tools/index.js';
-export class McpUtilityServer {
-    constructor() {
-        this.server = new Server({
-            name: '@nekzus/mcp-server',
-            version: '1.0.0',
-            description: 'MCP Server implementation providing utility functions and tools for development and testing',
-        }, {
-            capabilities: {
-                resources: {},
-                tools: {},
+const TOOLS = [
+    {
+        name: 'greeting',
+        description: 'Generate a personalized greeting message for the specified person',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: {
+                    type: 'string',
+                    description: 'Name of the recipient for the greeting',
+                },
             },
-        });
-        this.transport = new StdioServerTransport();
-        this.tools = availableTools;
-        // Configurar los manejadores de solicitudes
-        this.setupRequestHandlers();
+            required: ['name'],
+        },
+    },
+    {
+        name: 'card',
+        description: 'Draw a random card from a standard 52-card poker deck',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                random_string: {
+                    type: 'string',
+                    description: 'Dummy parameter for no-parameter tools',
+                },
+            },
+            required: ['random_string'],
+        },
+    },
+    {
+        name: 'datetime',
+        description: 'Get the current date and time for a specific timezone',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                timeZone: {
+                    type: 'string',
+                    description: 'Timezone identifier (e.g., "America/New_York")',
+                },
+                locale: {
+                    type: 'string',
+                    description: 'Locale identifier (e.g., "en-US")',
+                },
+            },
+        },
+    },
+];
+async function handleGreeting(args) {
+    const { name } = args;
+    return {
+        content: [
+            {
+                type: 'text',
+                text: `¡Hola ${name}! ¿Cómo estás?`,
+            },
+        ],
+        isError: false,
+    };
+}
+async function handleCard() {
+    const suits = ['♠', '♥', '♦', '♣'];
+    const values = ['A', '2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K'];
+    const suit = suits[Math.floor(Math.random() * suits.length)];
+    const value = values[Math.floor(Math.random() * values.length)];
+    return {
+        content: [
+            {
+                type: 'text',
+                text: `${value}${suit}`,
+            },
+        ],
+        isError: false,
+    };
+}
+async function handleDateTime(args) {
+    const { timeZone = 'UTC', locale = 'en-US' } = args;
+    try {
+        const date = new Date();
+        const formattedDate = new Intl.DateTimeFormat(locale, {
+            timeZone,
+            dateStyle: 'full',
+            timeStyle: 'long',
+        }).format(date);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: formattedDate,
+                },
+            ],
+            isError: false,
+        };
     }
-    setupRequestHandlers() {
-        // Listar herramientas disponibles
-        this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
-            tools: this.tools,
-        }));
-        // Manejar llamadas a herramientas
-        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-            const { name, arguments: args = {} } = request.params;
-            try {
-                const tool = this.tools.find((t) => t.name === name);
-                if (!tool) {
-                    throw new Error(`Tool not found: ${name}`);
-                }
-                const handler = tool.handler;
-                const result = await handler(args);
-                return {
-                    content: result.content.map((content) => {
-                        const mappedContent = {
-                            type: content.type,
-                            text: typeof content.text === 'string'
-                                ? content.text
-                                : JSON.stringify(content.text, null, 2),
-                        };
-                        if (content.data !== undefined) {
-                            return { ...mappedContent, data: content.data };
-                        }
-                        return mappedContent;
-                    }),
-                    isError: result.isError,
-                };
-            }
-            catch (error) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: error instanceof Error ? error.message : String(error),
-                        },
-                    ],
-                    isError: true,
-                };
-            }
-        });
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                },
+            ],
+            isError: true,
+        };
     }
-    async start() {
-        try {
-            await this.server.connect(this.transport);
-            console.log('[Server] MCP Utility Server is running');
-            console.log('[Server] Available tools:', this.tools.map((t) => t.name).join(', '));
-            // Handle termination signals
-            process.on('SIGTERM', () => this.cleanup());
-            process.on('SIGINT', () => this.cleanup());
-            // Handle stdin close
-            process.stdin.on('close', () => {
-                console.log('[Server] Input stream closed');
-                this.cleanup();
-            });
-        }
-        catch (error) {
-            console.error('[Server] Failed to start MCP Utility Server:', error);
-            throw error;
-        }
+}
+async function handleToolCall(name, args) {
+    switch (name) {
+        case 'greeting':
+            return handleGreeting(args);
+        case 'card':
+            return handleCard();
+        case 'datetime':
+            return handleDateTime(args);
+        default:
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error: Unknown tool '${name}'`,
+                    },
+                ],
+                isError: true,
+            };
     }
-    async cleanup() {
-        try {
-            await this.transport.close();
-            console.log('[Server] MCP Utility Server stopped gracefully');
-            process.exit(0);
-        }
-        catch (error) {
-            console.error('[Server] Error during cleanup:', error);
-            process.exit(1);
-        }
+}
+const server = new Server({
+    name: '@nekzus/mcp-server',
+    version: '0.1.0',
+    description: 'MCP Server implementation for development',
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+        tools: TOOLS,
+    };
+});
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    return handleToolCall(name, args ?? {});
+});
+async function runServer() {
+    try {
+        const transport = new StdioServerTransport();
+        await server.connect(transport);
+        console.log('[Server] MCP Server is running');
+        console.log('[Server] Available tools:', TOOLS.map((t) => t.name).join(', '));
+        process.on('SIGTERM', () => cleanup());
+        process.on('SIGINT', () => cleanup());
+        process.stdin.on('close', () => {
+            console.log('[Server] Input stream closed');
+            cleanup();
+        });
+    }
+    catch (error) {
+        console.error('[Server] Failed to start MCP Server:', error);
+        process.exit(1);
     }
 }
-// Auto-start server if this is the main module
-if (import.meta.url === new URL(import.meta.url).href) {
-    const server = new McpUtilityServer();
-    server.start().catch((error) => {
-        console.error('[Server] Fatal error:', error);
+async function cleanup() {
+    try {
+        await server.close();
+        console.log('[Server] MCP Server stopped gracefully');
+        process.exit(0);
+    }
+    catch (error) {
+        console.error('[Server] Error during cleanup:', error);
         process.exit(1);
-    });
+    }
 }
+runServer();

package/package.json

@@ -1,24 +1,24 @@
 {
   "name": "@nekzus/mcp-server",
-  "version": "1.0.29",
+  "version": "1.0.31",
   "description": "Personal MCP Server implementation providing extensible utility functions and tools for development and testing purposes",
   "type": "module",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "bin": {
-    "mcp-server": "./dist/index.js"
-  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": "./dist/index.js",
   "files": [
-    "dist"
+    "dist",
+    "README.md",
+    "LICENSE"
   ],
   "scripts": {
-    "build": "tsc && shx chmod +x dist/*.js",
+    "build": "tsc && shx chmod +x dist/index.js",
     "dev": "tsx src/index.ts",
     "start": "node dist/index.js",
     "test": "jest --passWithNoTests",
-    "format": "biome format --write ./src",
-    "lint": "biome lint --write ./src",
-    "check": "biome check --apply ./src",
+    "format": "biome format --write .",
+    "lint": "biome lint --write .",
+    "check": "biome check --apply .",
     "commit": "git-cz",
     "semantic-release": "semantic-release --branches main",
     "prepare": "npm run build",

package/dist/tools/index.js

@@ -1,111 +0,0 @@
-import { getRandomCard } from '../utils/cards.js';
-import { getCurrentDateTime } from '../utils/datetime.js';
-export const greetingTool = {
-    name: 'greeting',
-    description: 'Generate a personalized greeting message for the specified person',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            name: { type: 'string', description: 'Name of the recipient for the greeting' },
-        },
-        required: ['name'],
-    },
-    handler: async (args) => {
-        try {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `👋 Hello ${args.name}! Welcome to the MCP server!`,
-                    },
-                ],
-            };
-        }
-        catch (err) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `Error generating greeting for ${args.name}`,
-                    },
-                ],
-                isError: true,
-            };
-        }
-    },
-};
-export const cardTool = {
-    name: 'card',
-    description: 'Draw a random card from a standard 52-card poker deck',
-    inputSchema: {
-        type: 'object',
-        properties: {},
-        required: [],
-    },
-    handler: async () => {
-        try {
-            const card = getRandomCard();
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `🎴 You drew: ${card.value} of ${card.suit}`,
-                    },
-                ],
-            };
-        }
-        catch (err) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: 'Error drawing card from deck',
-                    },
-                ],
-                isError: true,
-            };
-        }
-    },
-};
-export const dateTimeTool = {
-    name: 'datetime',
-    description: 'Get the current date and time for a specific timezone',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            timeZone: {
-                type: 'string',
-                description: 'Timezone identifier (e.g., "America/New_York")',
-            },
-            locale: {
-                type: 'string',
-                description: 'Locale identifier (e.g., "en-US")',
-            },
-        },
-    },
-    handler: async (args) => {
-        try {
-            const { date, time, timezone } = getCurrentDateTime(args.timeZone, args.locale);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `🗓️ Date: ${date}\n⏰ Time: ${time}\n🌍 Timezone: ${timezone}`,
-                    },
-                ],
-            };
-        }
-        catch (err) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: 'Error getting date and time',
-                    },
-                ],
-                isError: true,
-            };
-        }
-    },
-};
-export default [greetingTool, cardTool, dateTimeTool];

package/dist/types/index.js

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

package/dist/utils/cards.js

@@ -1,10 +0,0 @@
-export const SUITS = ['♠️ Spades', '♥️ Hearts', '♦️ Diamonds', '♣️ Clubs'];
-export const VALUES = ['Ace', '2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K'];
-export function getRandomCard() {
-    const randomSuit = SUITS[Math.floor(Math.random() * SUITS.length)];
-    const randomValue = VALUES[Math.floor(Math.random() * VALUES.length)];
-    return {
-        suit: randomSuit,
-        value: randomValue,
-    };
-}

package/dist/utils/datetime.js

@@ -1,28 +0,0 @@
-export function getCurrentDateTime(timeZone, locale) {
-    try {
-        const now = new Date();
-        const defaultTimeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
-        const options = {
-            timeZone: timeZone || defaultTimeZone,
-            dateStyle: 'full',
-            timeStyle: 'medium',
-        };
-        const formatter = new Intl.DateTimeFormat(locale || 'en-US', options);
-        const [datePart, timePart] = formatter.format(now).split(' at ');
-        return {
-            date: datePart,
-            time: timePart,
-            timezone: timeZone || defaultTimeZone,
-        };
-    }
-    catch (error) {
-        console.error('[DateTime] Error formatting date and time:', error);
-        const now = new Date();
-        const defaultTimeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
-        return {
-            date: now.toLocaleDateString(),
-            time: now.toLocaleTimeString(),
-            timezone: defaultTimeZone,
-        };
-    }
-}

package/dist/utils/schema.js

@@ -1,35 +0,0 @@
-import { z } from 'zod';
-function convertProperty(prop) {
-    switch (prop.type) {
-        case 'string':
-            return z.string();
-        case 'number':
-            return z.number();
-        case 'boolean':
-            return z.boolean();
-        case 'array':
-            if (!prop.items) {
-                throw new Error('Array schema must have items property');
-            }
-            return z.array(convertProperty(prop.items));
-        case 'object':
-            return z.record(z.string(), z.unknown());
-        default:
-            return z.unknown();
-    }
-}
-export const schemaConverter = {
-    toZod: (schema) => {
-        if (schema.type !== 'object') {
-            throw new Error('Only object schemas are supported');
-        }
-        const shape = {};
-        if (schema.properties) {
-            for (const [key, prop] of Object.entries(schema.properties)) {
-                shape[key] = convertProperty(prop);
-            }
-        }
-        const zodSchema = z.object(shape);
-        return schema.required?.length ? zodSchema.required() : zodSchema;
-    },
-};