@nekzus/mcp-server 1.0.25 → 1.0.27

package/dist/index.js

@@ -1,10 +1,9 @@
 #!/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 'dotenv/config';
-import { z } from 'zod';
 import availableTools from './tools/index.js';
-import { schemaConverter } from './utils/schema.js';
 export class McpUtilityServer {
     constructor() {
         this.server = new Server({
@@ -19,60 +18,55 @@ export class McpUtilityServer {
         });
         this.transport = new StdioServerTransport();
         this.tools = availableTools;
-        // Registrar el método tools/list
-        this.server.setRequestHandler(z.object({
-            method: z.literal('tools/list'),
-            params: z.object({}).optional(),
-        }), async () => {
-            return {
-                tools: this.tools.map((tool) => ({
-                    name: tool.name,
-                    description: tool.description,
-                    schema: tool.inputSchema,
-                })),
-            };
-        });
+        // Configurar los manejadores de solicitudes
+        this.setupRequestHandlers();
     }
-    registerTool(tool) {
-        try {
-            console.log(`[Tool Registration] Registering tool: ${tool.name}`);
-            const zodSchema = schemaConverter.toZod(tool.inputSchema);
-            const handler = tool.handler;
-            // Registrar el método de la herramienta
-            this.server.setRequestHandler(z.object({
-                method: z.literal('tool'),
-                params: z.object({
-                    name: z.literal(tool.name),
-                    arguments: zodSchema,
-                }),
-            }), async (request) => {
-                const result = await handler(request.params.arguments, {});
+    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: JSON.stringify(result),
+                            text: error instanceof Error ? error.message : String(error),
                         },
                     ],
+                    isError: true,
                 };
-            });
-            console.log(`[Tool Registration] Successfully registered: ${tool.name}`);
-        }
-        catch (error) {
-            console.error(`[Tool Registration] Failed to register tool ${tool.name}:`, error);
-            throw error;
-        }
-    }
-    initializeTools() {
-        console.log(`[Server] Initializing ${this.tools.length} tools...`);
-        for (const tool of this.tools) {
-            this.registerTool(tool);
-        }
-        console.log('[Server] Tool initialization completed successfully');
+            }
+        });
     }
     async start() {
         try {
-            this.initializeTools();
             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(', '));

package/dist/tools/index.js

@@ -10,7 +10,7 @@ export const greetingTool = {
         },
         required: ['name'],
     },
-    handler: async (args, _extra) => {
+    handler: async (args) => {
         try {
             return {
                 content: [
@@ -42,7 +42,7 @@ export const cardTool = {
         properties: {},
         required: [],
     },
-    handler: async (_args, _extra) => {
+    handler: async () => {
         try {
             const card = getRandomCard();
             return {
@@ -69,28 +69,28 @@ export const cardTool = {
 };
 export const dateTimeTool = {
     name: 'datetime',
-    description: 'Get current date and time for a specific timezone and locale',
+    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, Europe/London, Asia/Tokyo)',
+                description: 'Timezone identifier (e.g., "America/New_York")',
             },
             locale: {
                 type: 'string',
-                description: 'Locale identifier (e.g., en-US, es-ES, fr-FR)',
+                description: 'Locale identifier (e.g., "en-US")',
             },
         },
     },
-    handler: async (args, _extra) => {
+    handler: async (args) => {
         try {
-            const { date, time, timeZone } = getCurrentDateTime(args);
+            const { date, time, timezone } = getCurrentDateTime(args.timeZone, args.locale);
             return {
                 content: [
                     {
                         type: 'text',
-                        text: `🗓️ Date: ${date}\n⏰ Time: ${time}\n🌍 Timezone: ${timeZone}`,
+                        text: `🗓️ Date: ${date}\n⏰ Time: ${time}\n🌍 Timezone: ${timezone}`,
                     },
                 ],
             };
@@ -100,7 +100,7 @@ export const dateTimeTool = {
                 content: [
                     {
                         type: 'text',
-                        text: 'Error retrieving date and time information',
+                        text: 'Error getting date and time',
                     },
                 ],
                 isError: true,
@@ -108,6 +108,4 @@ export const dateTimeTool = {
         }
     },
 };
-// Export all available tools
-const availableTools = [greetingTool, cardTool, dateTimeTool];
-export default availableTools;
+export default [greetingTool, cardTool, dateTimeTool];

package/dist/utils/datetime.js

@@ -1,22 +1,28 @@
-export function getCurrentDateTime(options = {}) {
-    const { timeZone = Intl.DateTimeFormat().resolvedOptions().timeZone, locale = 'en-US' } = options;
-    const now = new Date();
-    const dateFormatter = new Intl.DateTimeFormat(locale, {
-        timeZone,
-        year: 'numeric',
-        month: 'long',
-        day: 'numeric',
-    });
-    const timeFormatter = new Intl.DateTimeFormat(locale, {
-        timeZone,
-        hour: '2-digit',
-        minute: '2-digit',
-        second: '2-digit',
-        hour12: true,
-    });
-    return {
-        date: dateFormatter.format(now),
-        time: timeFormatter.format(now),
-        timeZone,
-    };
+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/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@nekzus/mcp-server",
-  "version": "1.0.25",
+  "version": "1.0.27",
   "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": {
-    "@nekzus/mcp-server": "dist/index.js"
+    "mcp-server": "dist/index.js"
   },
   "files": [
     "dist"