ntfy-mcp-server 1.0.1 → 1.0.2

package/README.md

@@ -2,7 +2,7 @@
 
 [![TypeScript](https://img.shields.io/badge/TypeScript-5.8.2-blue.svg)](https://www.typescriptlang.org/)
 [![Model Context Protocol](https://img.shields.io/badge/MCP-1.8.0-green.svg)](https://modelcontextprotocol.io/)
-[![Version](https://img.shields.io/badge/Version-1.0.1-blue.svg)](https://github.com/cyanheads/ntfy-mcp-server/releases)
+[![Version](https://img.shields.io/badge/Version-1.0.2-blue.svg)](https://github.com/cyanheads/ntfy-mcp-server/releases)
 [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
 [![Status](https://img.shields.io/badge/Status-Stable-green.svg)](https://github.com/cyanheads/ntfy-mcp-server)
 [![GitHub](https://img.shields.io/github/stars/cyanheads/ntfy-mcp-server?style=social)](https://github.com/cyanheads/ntfy-mcp-server)

package/dist/mcp-server/server.js

@@ -23,14 +23,16 @@ const MAX_FILE_SIZE = 5 * 1024 * 1024;
 /**
  * Load package information directly from package.json
  *
+ * @param logger - The logger instance to use for logging
  * @returns A promise resolving to an object with the package name and version
  */
-const loadPackageInfo = async () => {
+const loadPackageInfo = async (loggerInstance) => {
+    const pkgLogger = loggerInstance || logger.createChildLogger({ module: 'PackageInfo' });
     return await ErrorHandler.tryCatch(async () => {
         // Use the globally defined __dirname from the top of the file
         const pkgPath = path.resolve(__dirname, '../../package.json');
         const safePath = sanitizeInput.path(pkgPath);
-        console.error(`Looking for package.json at: ${safePath}`);
+        pkgLogger.debug(`Looking for package.json at: ${safePath}`);
         // Get file stats to check size before reading
         const stats = await fs.stat(safePath);
         // Check file size to prevent DoS attacks
@@ -126,27 +128,25 @@ export const createMcpServer = async () => {
             newState
         });
     });
-    console.error("Initializing MCP server...");
     serverLogger.info("Initializing server...");
     const timers = [];
     return await ErrorHandler.tryCatch(async () => {
         // Load package info asynchronously
-        const packageInfo = await loadPackageInfo();
+        const packageInfo = await loadPackageInfo(serverLogger);
         // Update logger with package info
-        console.error("Loaded package info:", packageInfo.name, packageInfo.version);
         serverLogger.info("Loaded package info", {
             name: packageInfo.name,
             version: packageInfo.version
         });
         // Create the MCP server instance
-        console.error("Creating MCP server instance...");
+        serverLogger.debug("Creating MCP server instance...");
         server = new McpServer({
             name: packageInfo.name,
             version: packageInfo.version
         });
-        console.error("MCP server instance created");
+        serverLogger.debug("MCP server instance created");
         const registerComponent = async (type, name, registerFn) => {
-            console.error(`Registering ${type}: ${name}`);
+            serverLogger.debug(`Registering ${type}: ${name}`);
             try {
                 await ErrorHandler.tryCatch(async () => await registerFn(), {
                     operation: `Register${type === 'tool' ? 'Tool' : 'Resource'}`,
@@ -160,16 +160,16 @@ export const createMcpServer = async () => {
                 else {
                     serverState.registeredResources.add(name);
                 }
-                console.error(`Successfully registered ${type}: ${name}`);
+                serverLogger.debug(`Successfully registered ${type}: ${name}`);
                 return { success: true, type, name };
             }
             catch (error) {
-                console.error(`Failed to register ${type}: ${name}`, error);
+                serverLogger.error(`Failed to register ${type}: ${name}`, { error });
                 return { success: false, type, name, error };
             }
         };
         // Register components with proper error handling
-        console.error("Registering components...");
+        serverLogger.debug("Registering components...");
         const registrationPromises = [
             registerComponent('tool', 'send_ntfy', () => registerNtfyTool(server)),
             registerComponent('resource', 'ntfy-resource', () => registerNtfyResource(server)),
@@ -192,30 +192,32 @@ export const createMcpServer = async () => {
         });
         // Process failed registrations
         if (failedRegistrations.length > 0) {
-            console.error(`${failedRegistrations.length} registrations failed initially`, failedRegistrations.map(f => `${f.type}:${f.name}`));
             serverLogger.warn(`${failedRegistrations.length} registrations failed initially`, {
                 failedComponents: failedRegistrations.map(f => `${f.type}:${f.name}`)
             });
         }
         // Add debug logs to diagnose the connection issue
-        console.error("About to connect to stdio transport");
+        serverLogger.debug("About to connect to stdio transport");
         try {
             // Connect using stdio transport
             const transport = new StdioServerTransport();
-            console.error("Created StdioServerTransport instance");
+            serverLogger.debug("Created StdioServerTransport instance");
             // Set event handlers - using type assertion to avoid TS errors
             server.onerror = (err) => {
-                console.error(`Server error: ${err.message}`);
+                serverLogger.error(`Server error: ${err.message}`, { stack: err.stack });
             };
             // Skip setting onrequest since we don't have access to the type
             await server.connect(transport);
-            console.error("Connected to transport successfully");
+            serverLogger.debug("Connected to transport successfully");
         }
         catch (error) {
-            console.error("Error connecting to transport:", error);
+            serverLogger.error("Error connecting to transport", {
+                error: error instanceof Error ? error.message : String(error),
+                stack: error instanceof Error ? error.stack : undefined
+            });
             throw error;
         }
-        console.error("MCP server initialized and connected");
+        serverLogger.info("MCP server initialized and connected");
         return server;
     }, {
         operation: 'CreateMcpServer',
@@ -228,7 +230,10 @@ export const createMcpServer = async () => {
             registeredResources: Array.from(serverState.registeredResources)
         })
     }).catch((error) => {
-        console.error("Fatal error in MCP server creation:", error);
+        serverLogger.error("Fatal error in MCP server creation", {
+            error: error instanceof Error ? error.message : String(error),
+            stack: error instanceof Error ? error.stack : undefined
+        });
         // Attempt to close server
         if (server) {
             try {
@@ -236,7 +241,10 @@ export const createMcpServer = async () => {
             }
             catch (closeError) {
                 // Already in error state, just log
-                console.error("Error while closing server during error recovery:", closeError);
+                serverLogger.error("Error while closing server during error recovery", {
+                    error: closeError instanceof Error ? closeError.message : String(closeError),
+                    stack: closeError instanceof Error ? closeError.stack : undefined
+                });
             }
         }
         // Re-throw to communicate error to caller

package/dist/mcp-server/tools/ntfyTool/index.js

@@ -4,7 +4,6 @@ import { ErrorHandler } from "../../../utils/errorHandler.js";
 import { logger } from "../../../utils/logger.js";
 import { createRequestContext } from "../../../utils/requestContext.js";
 import { sanitizeInputForLogging } from "../../../utils/sanitization.js";
-import { registerTool } from "../../utils/registrationHelper.js";
 import { processNtfyMessage } from "./ntfyMessage.js";
 import { SendNtfyToolInputSchema } from "./types.js";
 // Create module logger
@@ -26,20 +25,29 @@ export const registerNtfyTool = async (server) => {
         operation: 'registerNtfyTool',
         component: 'NtfyTool'
     });
+    // Create a tool-specific logger
+    const toolLogger = logger.createChildLogger({
+        module: 'NtfyTool',
+        operation: 'registration'
+    });
     moduleLogger.info('Starting ntfy tool registration');
-    return registerTool(server, { name: "send_ntfy" }, async (server, toolLogger) => {
-        // Create a fresh schema with the latest config values
-        // This ensures we have the most up-to-date environment variables
-        const schemaWithLatestConfig = SendNtfyToolInputSchema();
-        // Log default topic info at registration time for verification
-        const ntfyConfig = config.ntfy;
-        toolLogger.info('Registering ntfy tool handler with config', {
-            defaultTopic: ntfyConfig.defaultTopic || '(not set)',
-            baseUrl: ntfyConfig.baseUrl,
-            apiKeyPresent: !!ntfyConfig.apiKey
-        });
-        // Register the tool using the simplified SDK pattern
-        server.tool("send_ntfy", schemaWithLatestConfig.shape, async (params) => {
+    // Create a fresh schema with the latest config values
+    // This ensures we have the most up-to-date environment variables
+    const schemaWithLatestConfig = SendNtfyToolInputSchema();
+    // Log default topic info at registration time for verification
+    const ntfyConfig = config.ntfy;
+    toolLogger.info('Registering ntfy tool handler with config', {
+        defaultTopic: ntfyConfig.defaultTopic || '(not set)',
+        baseUrl: ntfyConfig.baseUrl,
+        apiKeyPresent: !!ntfyConfig.apiKey
+    });
+    try {
+        // Prepare the description with the default topic information
+        const defaultTopicInfo = ntfyConfig.defaultTopic
+            ? `Default topic: "${ntfyConfig.defaultTopic}"`
+            : "No default topic configured";
+        // Register the tool directly using the SDK pattern
+        server.tool("send_ntfy", `Send notifications to the user's devices using ntfy.sh service with support for titles, priorities, tags, attachments, and actions. Use this tool to externally notify the user of something important. ${defaultTopicInfo}.`, schemaWithLatestConfig.shape, async (params) => {
             // Create request context for tracking this invocation
             const toolRequestCtx = createRequestContext({
                 operation: 'handleNtfyTool',
@@ -106,5 +114,11 @@ export const registerNtfyTool = async (server) => {
             });
         });
         toolLogger.info("Ntfy tool handler registered successfully");
-    });
+    }
+    catch (error) {
+        toolLogger.error("Failed to register ntfy tool", {
+            error: error instanceof Error ? error.message : String(error)
+        });
+        throw error; // Re-throw to propagate the error
+    }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ntfy-mcp-server",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "An MCP (Model Context Protocol) server designed to interact with the ntfy push notification service. It enables LLMs and AI agents to send notifications to your devices with extensive customization options.",
   "main": "dist/index.js",
   "type": "module",