ntfy-mcp-server 1.0.0

package/dist/mcp-server/server.js

@@ -0,0 +1,245 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { EventEmitter } from "events";
+import { promises as fs } from "fs";
+import path from "path";
+import { fileURLToPath } from 'url';
+import { config } from "../config/index.js";
+import { BaseErrorCode, McpError } from "../types-global/errors.js";
+import { ErrorHandler } from "../utils/errorHandler.js";
+import { idGenerator } from "../utils/idGenerator.js";
+import { logger } from "../utils/logger.js";
+import { createRequestContext } from "../utils/requestContext.js";
+import { sanitizeInput } from "../utils/security.js";
+// Calculate __dirname equivalent for ES modules
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// Import tool and resource registrations
+import { registerNtfyTool } from "./tools/ntfyTool/index.js";
+import { registerNtfyResource } from "./resources/ntfyResource/index.js";
+// Maximum file size for package.json (5MB) to prevent potential DoS
+const MAX_FILE_SIZE = 5 * 1024 * 1024;
+/**
+ * Load package information directly from package.json
+ *
+ * @returns A promise resolving to an object with the package name and version
+ */
+const loadPackageInfo = async () => {
+    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}`);
+        // Get file stats to check size before reading
+        const stats = await fs.stat(safePath);
+        // Check file size to prevent DoS attacks
+        if (stats.size > MAX_FILE_SIZE) {
+            throw new McpError(BaseErrorCode.VALIDATION_ERROR, `package.json file is too large (${stats.size} bytes)`, { path: safePath, maxSize: MAX_FILE_SIZE });
+        }
+        const pkgContent = await fs.readFile(safePath, 'utf-8');
+        const pkg = JSON.parse(pkgContent);
+        if (!pkg.name || typeof pkg.name !== 'string' ||
+            !pkg.version || typeof pkg.version !== 'string') {
+            throw new McpError(BaseErrorCode.VALIDATION_ERROR, 'Invalid package.json: missing name or version', { path: safePath });
+        }
+        return {
+            name: pkg.name,
+            version: pkg.version
+        };
+    }, {
+        operation: 'LoadPackageInfo',
+        errorCode: BaseErrorCode.VALIDATION_ERROR,
+        rethrow: true, // Changed to true so errors propagate
+        includeStack: true,
+        errorMapper: (error) => {
+            if (error instanceof SyntaxError) {
+                return new McpError(BaseErrorCode.VALIDATION_ERROR, `Failed to parse package.json: ${error.message}`, { errorType: 'SyntaxError' });
+            }
+            return new McpError(BaseErrorCode.INTERNAL_ERROR, `Failed to load package info: ${error instanceof Error ? error.message : String(error)}`, { errorType: error instanceof Error ? error.name : typeof error });
+        }
+    });
+};
+/**
+ * Server event emitter for lifecycle events
+ */
+class ServerEvents extends EventEmitter {
+    constructor() {
+        super();
+    }
+    // Type-safe event emitters
+    emitStateChange(oldState, newState) {
+        this.emit('stateChange', oldState, newState);
+        this.emit(`state:${newState}`, oldState);
+    }
+}
+/**
+ * Create and initialize an MCP server instance with all tools and resources
+ *
+ * This function configures the MCP server with security settings, tools, and resources.
+ * It connects the server to a transport (currently stdio) and returns the initialized
+ * server instance.
+ *
+ * @returns A promise that resolves to the initialized McpServer instance
+ * @throws {McpError} If the server fails to initialize
+ */
+export const createMcpServer = async () => {
+    // Initialize server variable outside try/catch
+    let server;
+    // Maximum registration retry attempts
+    const MAX_REGISTRATION_RETRIES = 3;
+    // Create a unique server instance ID
+    const serverId = idGenerator.generateRandomString(8);
+    // Initialize server state for tracking
+    const serverState = {
+        status: 'initializing',
+        startTime: new Date(),
+        lastHealthCheck: new Date(),
+        activeOperations: new Map(),
+        errors: [],
+        registeredTools: new Set(),
+        registeredResources: new Set(),
+        failedRegistrations: [],
+        requiredTools: new Set(['send_ntfy']), // Define tools that are required for the server to function properly
+        requiredResources: new Set([]) // Define resources that are required for the server to function properly
+    };
+    // Create operation context
+    const serverContext = createRequestContext({
+        operation: 'ServerStartup',
+        component: 'McpServer',
+        serverId
+    });
+    // Create server-specific logger with context
+    const serverLogger = logger.createChildLogger({
+        module: 'MCPServer',
+        service: 'MCPServer',
+        requestId: serverContext.requestId,
+        serverId,
+        environment: config.environment
+    });
+    // Create server events emitter
+    const serverEvents = new ServerEvents();
+    // Monitor state changes
+    serverEvents.on('stateChange', (oldState, newState) => {
+        serverLogger.info(`Server state changed from ${oldState} to ${newState}`, {
+            previousState: oldState,
+            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();
+        // 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...");
+        server = new McpServer({
+            name: packageInfo.name,
+            version: packageInfo.version
+        });
+        console.error("MCP server instance created");
+        const registerComponent = async (type, name, registerFn) => {
+            console.error(`Registering ${type}: ${name}`);
+            try {
+                await ErrorHandler.tryCatch(async () => await registerFn(), {
+                    operation: `Register${type === 'tool' ? 'Tool' : 'Resource'}`,
+                    context: { ...serverContext, componentName: name },
+                    errorCode: BaseErrorCode.INTERNAL_ERROR
+                });
+                // Update state based on component type
+                if (type === 'tool') {
+                    serverState.registeredTools.add(name);
+                }
+                else {
+                    serverState.registeredResources.add(name);
+                }
+                console.error(`Successfully registered ${type}: ${name}`);
+                return { success: true, type, name };
+            }
+            catch (error) {
+                console.error(`Failed to register ${type}: ${name}`, error);
+                return { success: false, type, name, error };
+            }
+        };
+        // Register components with proper error handling
+        console.error("Registering components...");
+        const registrationPromises = [
+            registerComponent('tool', 'send_ntfy', () => registerNtfyTool(server)),
+            registerComponent('resource', 'ntfy-resource', () => registerNtfyResource(server)),
+        ];
+        const registrationResults = await Promise.allSettled(registrationPromises);
+        // Process the results to find failed registrations
+        const failedRegistrations = [];
+        registrationResults.forEach(result => {
+            if (result.status === 'rejected') {
+                failedRegistrations.push({
+                    success: false,
+                    type: 'unknown',
+                    name: 'unknown',
+                    error: result.reason
+                });
+            }
+            else if (!result.value.success) {
+                failedRegistrations.push(result.value);
+            }
+        });
+        // 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");
+        try {
+            // Connect using stdio transport
+            const transport = new StdioServerTransport();
+            console.error("Created StdioServerTransport instance");
+            // Set event handlers - using type assertion to avoid TS errors
+            server.onerror = (err) => {
+                console.error(`Server error: ${err.message}`);
+            };
+            // Skip setting onrequest since we don't have access to the type
+            await server.connect(transport);
+            console.error("Connected to transport successfully");
+        }
+        catch (error) {
+            console.error("Error connecting to transport:", error);
+            throw error;
+        }
+        console.error("MCP server initialized and connected");
+        return server;
+    }, {
+        operation: 'CreateMcpServer',
+        context: serverContext,
+        critical: true,
+        errorMapper: (error) => new McpError(BaseErrorCode.INTERNAL_ERROR, `Failed to initialize MCP server: ${error instanceof Error ? error.message : String(error)}`, {
+            serverState: serverState.status,
+            startTime: serverState.startTime,
+            registeredTools: Array.from(serverState.registeredTools),
+            registeredResources: Array.from(serverState.registeredResources)
+        })
+    }).catch((error) => {
+        console.error("Fatal error in MCP server creation:", error);
+        // Attempt to close server
+        if (server) {
+            try {
+                server.close();
+            }
+            catch (closeError) {
+                // Already in error state, just log
+                console.error("Error while closing server during error recovery:", closeError);
+            }
+        }
+        // Re-throw to communicate error to caller
+        throw error;
+    });
+};

package/dist/mcp-server/tools/ntfyTool/index.d.ts

@@ -0,0 +1,11 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+/**
+ * Register the send_ntfy tool with the MCP server
+ *
+ * This function registers a tool for sending notifications via ntfy.sh with
+ * comprehensive parameter support for all ntfy features.
+ *
+ * @param server - The MCP server instance to register the tool with
+ * @returns Promise resolving when registration is complete
+ */
+export declare const registerNtfyTool: (server: McpServer) => Promise<void>;

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

@@ -0,0 +1,110 @@
+import { config } from "../../../config/index.js";
+import { BaseErrorCode, McpError } from "../../../types-global/errors.js";
+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
+const moduleLogger = logger.createChildLogger({
+    module: 'NtfyToolRegistration'
+});
+/**
+ * Register the send_ntfy tool with the MCP server
+ *
+ * This function registers a tool for sending notifications via ntfy.sh with
+ * comprehensive parameter support for all ntfy features.
+ *
+ * @param server - The MCP server instance to register the tool with
+ * @returns Promise resolving when registration is complete
+ */
+export const registerNtfyTool = async (server) => {
+    // Create a request context for tracking this registration operation
+    const requestCtx = createRequestContext({
+        operation: 'registerNtfyTool',
+        component: 'NtfyTool'
+    });
+    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 request context for tracking this invocation
+            const toolRequestCtx = createRequestContext({
+                operation: 'handleNtfyTool',
+                topic: params?.topic
+            });
+            toolLogger.debug('Received tool invocation', {
+                requestId: toolRequestCtx.requestId,
+                topic: params?.topic
+            });
+            // Use ErrorHandler for consistent error handling
+            return await ErrorHandler.tryCatch(async () => {
+                // Process the notification
+                const response = await processNtfyMessage(params);
+                toolLogger.info('Successfully processed ntfy message', {
+                    messageId: response.id,
+                    topic: response.topic,
+                    retries: response.retries
+                });
+                // Return in the standard MCP format
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify(response, null, 2)
+                        }]
+                };
+            }, {
+                operation: 'sending ntfy notification',
+                context: {
+                    requestId: toolRequestCtx.requestId,
+                    topic: params?.topic
+                },
+                input: sanitizeInputForLogging(params),
+                // Map errors appropriately
+                errorMapper: (error) => {
+                    // Log the error
+                    toolLogger.error('Error processing ntfy tool request', {
+                        error: error instanceof Error ? error.message : 'Unknown error',
+                        errorType: error instanceof Error ? error.name : 'Unknown',
+                        topic: params?.topic
+                    });
+                    // Pass through McpErrors, map others properly
+                    if (error instanceof McpError) {
+                        return error;
+                    }
+                    // Try to classify unknown errors
+                    if (error instanceof Error) {
+                        const errorMsg = error.message.toLowerCase();
+                        if (errorMsg.includes('validation') || errorMsg.includes('invalid')) {
+                            return new McpError(BaseErrorCode.VALIDATION_ERROR, `Validation error: ${error.message}`);
+                        }
+                        else if (errorMsg.includes('not found') || errorMsg.includes('missing')) {
+                            return new McpError(BaseErrorCode.NOT_FOUND, `Resource not found: ${error.message}`);
+                        }
+                        else if (errorMsg.includes('timeout')) {
+                            return new McpError(BaseErrorCode.TIMEOUT, `Request timed out: ${error.message}`);
+                        }
+                        else if (errorMsg.includes('rate limit')) {
+                            return new McpError(BaseErrorCode.RATE_LIMITED, `Rate limit exceeded: ${error.message}`);
+                        }
+                    }
+                    // Default to service unavailable for network/connection issues
+                    return new McpError(BaseErrorCode.SERVICE_UNAVAILABLE, `Failed to send notification: ${error instanceof Error ? error.message : 'Unknown error'}`);
+                }
+            });
+        });
+        toolLogger.info("Ntfy tool handler registered successfully");
+    });
+};

package/dist/mcp-server/tools/ntfyTool/ntfyMessage.d.ts

@@ -0,0 +1,9 @@
+import { SendNtfyToolInput, SendNtfyToolResponse } from "./types.js";
+/**
+ * Process and send a notification via ntfy
+ * Includes rate limiting, message validation, and retry logic
+ *
+ * @param params - Parameters for the ntfy message
+ * @returns Response with notification details
+ */
+export declare const processNtfyMessage: (params: SendNtfyToolInput) => Promise<SendNtfyToolResponse>;

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

@@ -0,0 +1,289 @@
+import { BaseErrorCode, McpError } from "../../../types-global/errors.js";
+import { ErrorHandler } from "../../../utils/errorHandler.js";
+import { publish, validateTopicSync } from "../../../services/ntfy/index.js";
+import { config } from "../../../config/index.js";
+import { logger } from "../../../utils/logger.js";
+import { createRequestContext } from "../../../utils/requestContext.js";
+import { sanitizeInput, sanitizeInputForLogging } from "../../../utils/sanitization.js";
+import { idGenerator } from "../../../utils/idGenerator.js";
+import { RateLimiter } from "../../../utils/rateLimiter.js";
+// Create a module-specific logger
+const ntfyToolLogger = logger.createChildLogger({
+    module: 'NtfyTool',
+    serviceId: idGenerator.generateRandomString(8)
+});
+// Create rate limiters for global and per-topic usage
+const rateLimit = config.rateLimit;
+const globalRateLimiter = new RateLimiter({
+    windowMs: rateLimit.windowMs,
+    maxRequests: rateLimit.maxRequests,
+    errorMessage: 'Global rate limit exceeded for ntfy notifications. Please try again in {waitTime} seconds.',
+});
+// Map to cache per-topic rate limiters
+const topicRateLimiters = new Map();
+/**
+ * Gets or creates a rate limiter for a specific topic
+ *
+ * @param topic - The ntfy topic
+ * @returns Rate limiter instance for the topic
+ */
+function getTopicRateLimiter(topic) {
+    const normalizedTopic = topic.toLowerCase().trim();
+    if (!topicRateLimiters.has(normalizedTopic)) {
+        // Make per-topic limit more restrictive than global
+        const perTopicLimit = Math.min(50, Math.floor(rateLimit.maxRequests / 2));
+        topicRateLimiters.set(normalizedTopic, new RateLimiter({
+            windowMs: rateLimit.windowMs,
+            maxRequests: perTopicLimit,
+            errorMessage: `Rate limit exceeded for topic '${normalizedTopic}'. Please try again in {waitTime} seconds.`,
+        }));
+    }
+    return topicRateLimiters.get(normalizedTopic);
+}
+/**
+ * Process and send a notification via ntfy
+ * Includes rate limiting, message validation, and retry logic
+ *
+ * @param params - Parameters for the ntfy message
+ * @returns Response with notification details
+ */
+export const processNtfyMessage = async (params) => {
+    return ErrorHandler.tryCatch(async () => {
+        // Create request context for tracking
+        const requestCtx = createRequestContext({
+            operation: 'processNtfyMessage',
+            messageId: idGenerator.generateRandomString(8),
+            hasTitle: !!params.title,
+            hasTags: !!params.tags && params.tags.length > 0,
+            priority: params.priority,
+            topic: params.topic
+        });
+        // Extract the necessary parameters
+        const { topic, message, ...options } = params;
+        ntfyToolLogger.info('Processing ntfy message request', {
+            topic,
+            hasTags: !!options.tags && options.tags.length > 0,
+            hasTitle: !!options.title,
+            messageLength: message?.length,
+            requestId: requestCtx.requestId
+        });
+        // Get the ntfy config
+        const ntfyConfig = config.ntfy;
+        // Use default topic from env if not provided
+        const finalTopic = topic || ntfyConfig.defaultTopic;
+        // Log the topic resolution (more visible INFO level)
+        ntfyToolLogger.info('Topic resolution', {
+            providedTopic: topic || '(not provided)',
+            defaultTopic: ntfyConfig.defaultTopic || '(not configured)',
+            finalTopic: finalTopic || '(none)',
+            requestId: requestCtx.requestId
+        });
+        // Validate topic is present
+        if (!finalTopic) {
+            ntfyToolLogger.error('Topic validation failed - missing topic', {
+                requestId: requestCtx.requestId
+            });
+            throw new McpError(BaseErrorCode.VALIDATION_ERROR, "Topic is required and no default topic is configured in the environment");
+        }
+        // Additional topic validation using our utility
+        if (!validateTopicSync(finalTopic)) {
+            ntfyToolLogger.error('Topic validation failed - invalid topic format', {
+                topic: finalTopic,
+                requestId: requestCtx.requestId
+            });
+            throw new McpError(BaseErrorCode.VALIDATION_ERROR, "Invalid topic format. Topics must be non-empty and cannot contain newlines");
+        }
+        // Apply rate limiting (both global and per-topic)
+        try {
+            // Check global rate limit first
+            globalRateLimiter.check('global');
+            // Then check per-topic rate limit
+            getTopicRateLimiter(finalTopic).check(finalTopic);
+        }
+        catch (error) {
+            if (error instanceof McpError && error.code === BaseErrorCode.RATE_LIMITED) {
+                ntfyToolLogger.warn('Rate limit exceeded', {
+                    requestId: requestCtx.requestId,
+                    topic: finalTopic,
+                    error: error.message
+                });
+            }
+            // Always throw rate limit errors
+            throw error;
+        }
+        // Message size validation
+        const messageSize = Buffer.byteLength(message, 'utf8');
+        const maxSize = ntfyConfig.maxMessageSize || 4096;
+        if (messageSize > maxSize) {
+            ntfyToolLogger.error('Message size validation failed', {
+                messageSize,
+                maxSize,
+                requestId: requestCtx.requestId
+            });
+            throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Message size (${messageSize} bytes) exceeds maximum allowed size (${maxSize} bytes)`);
+        }
+        // Prepare sanitized publish options
+        const publishOptions = {
+            // Message metadata
+            title: options.title ? sanitizeInput.string(options.title) : undefined,
+            tags: options.tags?.map(tag => sanitizeInput.string(tag)),
+            priority: options.priority,
+            markdown: options.markdown,
+            // Interactive elements
+            click: options.click ? sanitizeInput.url(options.click) : undefined,
+            actions: options.actions?.map(action => ({
+                id: sanitizeInput.string(action.id),
+                label: sanitizeInput.string(action.label),
+                action: sanitizeInput.string(action.action),
+                url: action.url ? sanitizeInput.url(action.url) : undefined,
+                method: action.method ? sanitizeInput.string(action.method) : undefined,
+                headers: action.headers,
+                body: action.body ? sanitizeInput.string(action.body) : undefined,
+                clear: action.clear
+            })),
+            // Media and attachments
+            attachment: options.attachment && {
+                url: sanitizeInput.url(options.attachment.url),
+                name: options.attachment.name
+                    ? sanitizeInput.string(options.attachment.name)
+                    : sanitizeInput.string(options.attachment.url.split('/').pop() || 'attachment')
+            },
+            // Delivery options
+            email: options.email ? sanitizeInput.string(options.email) : undefined,
+            delay: options.delay ? sanitizeInput.string(options.delay) : undefined,
+            cache: options.cache ? sanitizeInput.string(options.cache) : undefined,
+            firebase: options.firebase ? sanitizeInput.string(options.firebase) : undefined,
+            expires: options.expires ? sanitizeInput.string(options.expires) : undefined,
+            id: options.id ? sanitizeInput.string(options.id) : undefined,
+            // Server configuration
+            baseUrl: options.baseUrl ? sanitizeInput.url(options.baseUrl) : ntfyConfig.baseUrl,
+        };
+        ntfyToolLogger.debug('Prepared publish options', {
+            topic: finalTopic,
+            hasTitle: !!publishOptions.title,
+            hasTags: !!publishOptions.tags && publishOptions.tags.length > 0,
+            baseUrl: publishOptions.baseUrl,
+            messageSize,
+            requestId: requestCtx.requestId
+        });
+        // Set authentication if API key is available
+        if (ntfyConfig.apiKey) {
+            publishOptions.auth = ntfyConfig.apiKey;
+        }
+        ntfyToolLogger.debug('Authentication configured', {
+            hasAuth: !!publishOptions.auth,
+            apiKeyAvailable: !!ntfyConfig.apiKey,
+            requestId: requestCtx.requestId
+        });
+        ntfyToolLogger.debug('Publishing with options', {
+            topic: finalTopic,
+            messageSize,
+            hasAuth: !!publishOptions.auth,
+            hasTitle: !!publishOptions.title,
+            hasTags: !!publishOptions.tags,
+            requestId: requestCtx.requestId
+        });
+        // Send with retry logic
+        const maxRetries = ntfyConfig.maxRetries || 3;
+        let retries = 0;
+        let result;
+        for (retries = 0; retries <= maxRetries; retries++) {
+            try {
+                // Apply exponential backoff for retries
+                if (retries > 0) {
+                    const backoffMs = Math.min(100 * Math.pow(2, retries), 2000);
+                    await new Promise(resolve => setTimeout(resolve, backoffMs));
+                    ntfyToolLogger.info(`Retry attempt ${retries}/${maxRetries}`, {
+                        topic: finalTopic,
+                        requestId: requestCtx.requestId
+                    });
+                }
+                ntfyToolLogger.info(`Sending notification${retries > 0 ? ' (retry)' : ''}`, {
+                    topic: finalTopic,
+                    messageLength: messageSize,
+                    retry: retries,
+                    requestId: requestCtx.requestId
+                });
+                // Publish the message
+                result = await publish(finalTopic, message, publishOptions);
+                ntfyToolLogger.info('Notification sent successfully', {
+                    messageId: result.id,
+                    topic: result.topic,
+                    retries,
+                    requestId: requestCtx.requestId
+                });
+                // Success - exit retry loop
+                break;
+            }
+            catch (error) {
+                // Determine if error is retriable
+                const errorMsg = error instanceof Error ? error.message.toLowerCase() : '';
+                const isNetworkError = errorMsg.includes('network') ||
+                    errorMsg.includes('timeout') ||
+                    errorMsg.includes('connection') ||
+                    errorMsg.includes('econnrefused') ||
+                    errorMsg.includes('econnreset');
+                if (!isNetworkError || retries >= maxRetries) {
+                    ntfyToolLogger.error('Failed to send notification, giving up', {
+                        topic: finalTopic,
+                        error: error instanceof Error ? error.message : String(error),
+                        retries,
+                        requestId: requestCtx.requestId
+                    });
+                    throw error;
+                }
+                ntfyToolLogger.warn('Notification failed, will retry', {
+                    topic: finalTopic,
+                    error: error instanceof Error ? error.message : String(error),
+                    retryCount: retries,
+                    nextRetry: retries + 1,
+                    requestId: requestCtx.requestId
+                });
+            }
+        }
+        // Verify we have a result
+        if (!result) {
+            throw new McpError(BaseErrorCode.SERVICE_UNAVAILABLE, `Failed to send notification after ${maxRetries} retries`);
+        }
+        // Return the response
+        return {
+            success: true,
+            id: result.id,
+            topic: result.topic,
+            time: result.time,
+            expires: result.expires,
+            message: message,
+            title: options.title,
+            url: options.click,
+            retries: retries > 0 ? retries : undefined
+        };
+    }, {
+        operation: 'processNtfyMessage',
+        context: {
+            topic: params.topic || config.ntfy.defaultTopic,
+            hasTitle: !!params.title
+        },
+        input: sanitizeInputForLogging(params),
+        errorCode: BaseErrorCode.SERVICE_UNAVAILABLE,
+        errorMapper: (error) => {
+            if (error instanceof McpError) {
+                return error;
+            }
+            // Map common errors to more specific error codes
+            if (error instanceof Error) {
+                const errorMsg = error.message.toLowerCase();
+                if (errorMsg.includes('rate limit') || errorMsg.includes('too many requests')) {
+                    return new McpError(BaseErrorCode.RATE_LIMITED, `Rate limit exceeded: ${error.message}`);
+                }
+                if (errorMsg.includes('timeout')) {
+                    return new McpError(BaseErrorCode.TIMEOUT, `Request timed out: ${error.message}`);
+                }
+                if (errorMsg.includes('validation') || errorMsg.includes('invalid')) {
+                    return new McpError(BaseErrorCode.VALIDATION_ERROR, `Validation error: ${error.message}`);
+                }
+            }
+            return new McpError(BaseErrorCode.SERVICE_UNAVAILABLE, `Failed to send ntfy notification: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        },
+        rethrow: true
+    });
+};