ntfy-mcp-server 1.0.2 → 1.0.4

package/README.md

@@ -1,8 +1,8 @@
 # Ntfy MCP Server
 
-[![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.2-blue.svg)](https://github.com/cyanheads/ntfy-mcp-server/releases)
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.8.3-blue.svg)](https://www.typescriptlang.org/)
+[![Model Context Protocol](https://img.shields.io/badge/MCP-1.10.2-green.svg)](https://modelcontextprotocol.io/)
+[![Version](https://img.shields.io/badge/Version-1.0.4-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/config/index.js

@@ -101,7 +101,7 @@ export const config = {
 configLogger.info('Configuration loaded', {
     environment: config.environment,
     logLevel: config.logLevel,
-    server: config.server,
+    server: { host: config.server.host }, // Log only host, not port
     ntfy: {
         baseUrl: config.ntfy.baseUrl,
         defaultTopic: config.ntfy.defaultTopic || '(not set)',

package/dist/mcp-server/resources/ntfyResource/getNtfyTopic.d.ts

@@ -1,2 +1,2 @@
 import { NtfyResourceResponse } from './types.js';
-export declare const getNtfyTopic: (uri: URL) => Promise<NtfyResourceResponse>;
+export declare const getNtfyTopic: (topic: string, uri: URL) => Promise<NtfyResourceResponse>;

package/dist/mcp-server/resources/ntfyResource/getNtfyTopic.js

@@ -8,15 +8,16 @@ const resourceLogger = logger.createChildLogger({
     module: 'NtfyResource',
     service: 'NtfyResource'
 });
-export const getNtfyTopic = async (uri) => {
+// Updated signature to accept topic explicitly
+export const getNtfyTopic = async (topic, uri) => {
     // Create a request context with unique ID
     const requestContext = createRequestContext({
         operation: 'getNtfyTopic',
         uri: uri.toString()
     });
     const requestId = requestContext.requestId;
-    // Extract the topic from the URI pathname
-    const topic = uri.hostname || "";
+    // Topic is now passed as an argument, no need to extract from hostname
+    // const topic = uri.hostname || ""; // Removed
     resourceLogger.info("Ntfy resource request received", {
         requestId,
         uri: uri.href,
@@ -25,25 +26,35 @@ export const getNtfyTopic = async (uri) => {
     return ErrorHandler.tryCatch(async () => {
         // Get the default topic from configuration
         const ntfyConfig = config.ntfy;
-        let defaultTopic = ntfyConfig.defaultTopic;
-        if (!defaultTopic) {
-            resourceLogger.warn("Default ntfy topic is not configured, using fallback value", {
+        const defaultTopic = ntfyConfig.defaultTopic;
+        // Handle case where 'default' is requested but not configured
+        if (topic === "default" && !defaultTopic) {
+            resourceLogger.error("Requested default ntfy topic, but none is configured.", {
                 requestId,
                 uri: uri.href
             });
-            // Provide a fallback value instead of failing
-            defaultTopic = "ATLAS";
+            throw new McpError(BaseErrorCode.VALIDATION_ERROR, // Corrected error code
+            "Default ntfy topic requested via ntfy://default, but no default topic is configured in the environment variables.", { requestId, uri: uri.toString() });
         }
+        // Determine the actual topic to fetch messages for
+        const topicToFetch = topic === "default" ? defaultTopic : topic;
         // Get recent messages asynchronously for this topic
-        let recentMessages = [];
+        let recentMessages = []; // Define type for recentMessages
         try {
-            // Use a different topic for actual fetching based on whether this is default or not
-            const topicToFetch = topic === "default" ? defaultTopic : topic;
-            // Attempt to fetch the 10 most recent messages
-            const response = await fetch(`${config.ntfy.baseUrl || 'https://ntfy.sh'}/${topicToFetch}/json?poll=1&since=30d`, {
+            // Ensure topicToFetch is valid before fetching
+            if (!topicToFetch) {
+                // This case should theoretically be caught by the check above, but adding for safety
+                throw new Error("Cannot fetch messages for an empty topic.");
+            }
+            // Attempt to fetch the 10 most recent messages - removed poll=1
+            const fetchUrl = `${config.ntfy.baseUrl || 'https://ntfy.sh'}/${topicToFetch}/json?since=30d`;
+            resourceLogger.debug("Fetching recent messages", { requestId, url: fetchUrl });
+            const response = await fetch(fetchUrl, {
                 method: 'GET',
                 headers: {
-                    'Accept': 'application/json'
+                    'Accept': 'application/json',
+                    // Add API key header if configured
+                    ...(config.ntfy.apiKey && { 'Authorization': `Bearer ${config.ntfy.apiKey}` })
                 }
             });
             if (response.ok) {
@@ -51,8 +62,18 @@ export const getNtfyTopic = async (uri) => {
                 const text = await response.text();
                 const lines = text.split('\n').filter(line => line.trim());
                 // Parse each line as a JSON object and add to recent messages
-                recentMessages = lines.map(line => JSON.parse(line))
-                    .filter(msg => msg.event === 'message')
+                // Ensure messages have an 'id' and 'time' for potential sorting/filtering if needed later
+                recentMessages = lines.map(line => {
+                    try {
+                        return JSON.parse(line);
+                    }
+                    catch (parseError) {
+                        resourceLogger.warn("Failed to parse message line from ntfy stream", { requestId, line, error: parseError instanceof Error ? parseError.message : String(parseError) });
+                        return null; // Skip invalid lines
+                    }
+                })
+                    .filter(msg => msg && msg.event === 'message' && msg.id && msg.time) // Ensure it's a valid message event
+                    .sort((a, b) => b.time - a.time) // Sort by time descending (most recent first)
                     .slice(0, 10); // Keep only the 10 most recent
                 resourceLogger.info(`Retrieved ${recentMessages.length} recent messages`, {
                     topic: topicToFetch,
@@ -68,17 +89,18 @@ export const getNtfyTopic = async (uri) => {
                 requestId
             });
         }
-        // Handle the "default" topic case specially
+        // Prepare response data based on whether 'default' was the requested topic
         const responseData = topic === "default" ?
             {
-                defaultTopic,
+                requestedTopic: "default", // Clarify what was requested
+                resolvedTopic: defaultTopic, // Show the resolved topic
                 timestamp: new Date().toISOString(),
                 requestUri: uri.href,
                 requestId,
-                recentMessages: recentMessages.length > 0 ? recentMessages : undefined
+                recentMessages: recentMessages.length > 0 ? recentMessages : undefined // Keep undefined if empty
             } :
             {
-                topic,
+                topic: topicToFetch, // Use the actual topic fetched
                 timestamp: new Date().toISOString(),
                 requestUri: uri.href,
                 requestId,

package/dist/mcp-server/resources/ntfyResource/index.js

@@ -50,22 +50,27 @@ export const registerNtfyResource = async (server) => {
         }, 
         // Resource handler
         async (uri, params) => {
-            // Extract the topic from the URI
-            const topic = params.topic;
-            resourceLogger.info(`Processing ntfy resource request for topic: ${topic}`, {
-                topic,
+            // Extract the topic from the URI parameters provided by the SDK
+            const topicParam = params.topic;
+            resourceLogger.info(`Processing ntfy resource request for topic parameter: ${topicParam}`, {
+                topicParam,
                 href: uri.href
             });
-            // Check if the topic is valid
-            if (!topic) {
-                resourceLogger.error(`Missing topic in ntfy resource uri: ${uri.href}`, {
+            // Check if the topic parameter is valid and is a string
+            if (typeof topicParam !== 'string' || !topicParam) {
+                resourceLogger.error(`Invalid or missing topic parameter in ntfy resource uri: ${uri.href}`, {
                     href: uri.href,
-                    protocol: uri.protocol
+                    params: params,
+                    topicType: typeof topicParam
                 });
-                throw new McpError(BaseErrorCode.NOT_FOUND, `Resource not found: ${uri.href}`, { uri: uri.href });
+                // Use VALIDATION_ERROR as it's an issue with the input derived from the URI
+                throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid resource URI: Topic parameter must be a non-empty string in ${uri.href}`, { uri: uri.href, params: params });
             }
+            // Now we know topicParam is a string
+            const topic = topicParam;
             // Process the request using our dedicated handler
-            return await getNtfyTopic(uri);
+            // Pass the validated topic string and the original URI to the handler
+            return await getNtfyTopic(topic, uri);
         });
         resourceLogger.info("Ntfy resource handler registered");
     });

package/dist/mcp-server/resources/ntfyResource/types.d.ts

@@ -18,10 +18,42 @@ export interface NtfyResourceResponse {
     ];
 }
 /**
- * Data structure for the ntfy response
+ * Represents a single message retrieved from the ntfy topic history.
+ * Based on the structure observed from ntfy.sh/topic/json.
  */
-export interface NtfyData {
-    defaultTopic: string;
+export interface NtfyMessage {
+    id: string;
+    time: number;
+    event: 'message';
+    topic: string;
+    message: string;
+    title?: string;
+    tags?: string[];
+    priority?: number;
+    click?: string;
+    actions?: any[];
+    attachment?: {
+        name: string;
+        type?: string;
+        size?: number;
+        expires?: number;
+        url: string;
+    };
+    [key: string]: any;
+}
+/**
+ * Data structure for the ntfy resource response content.
+ * This reflects the actual JSON structure returned within the 'text' field
+ * of the McpContent object.
+ */
+export type NtfyResourceData = {
     timestamp: string;
     requestUri: string;
-}
+    requestId: string;
+    recentMessages?: NtfyMessage[];
+} & ({
+    requestedTopic: "default";
+    resolvedTopic: string;
+} | {
+    topic: string;
+});

package/dist/mcp-server/server.js

@@ -88,8 +88,8 @@ class ServerEvents extends EventEmitter {
 export const createMcpServer = async () => {
     // Initialize server variable outside try/catch
     let server;
-    // Maximum registration retry attempts
-    const MAX_REGISTRATION_RETRIES = 3;
+    // Maximum registration retry attempts (currently not implemented, but placeholder)
+    const MAX_REGISTRATION_RETRIES = 1;
     // Create a unique server instance ID
     const serverId = idGenerator.generateRandomString(8);
     // Initialize server state for tracking
@@ -161,11 +161,11 @@ export const createMcpServer = async () => {
                     serverState.registeredResources.add(name);
                 }
                 serverLogger.debug(`Successfully registered ${type}: ${name}`);
-                return { success: true, type, name };
+                return { success: true, type, name }; // No error on success
             }
             catch (error) {
                 serverLogger.error(`Failed to register ${type}: ${name}`, { error });
-                return { success: false, type, name, error };
+                return { success: false, type, name, error }; // Error included on failure
             }
         };
         // Register components with proper error handling
@@ -176,35 +176,77 @@ export const createMcpServer = async () => {
         ];
         const registrationResults = await Promise.allSettled(registrationPromises);
         // Process the results to find failed registrations
-        const failedRegistrations = [];
+        let hasRequiredFailure = false;
         registrationResults.forEach(result => {
             if (result.status === 'rejected') {
-                failedRegistrations.push({
-                    success: false,
+                // This indicates an unexpected error during the registerComponent wrapper itself
+                const failure = {
                     type: 'unknown',
                     name: 'unknown',
-                    error: result.reason
-                });
+                    error: result.reason ?? new Error('Unknown registration wrapper error'), // Ensure error exists
+                    attempts: 1 // Assuming 1 attempt for now
+                };
+                serverState.failedRegistrations.push(failure);
+                serverLogger.error("Unexpected error during component registration wrapper", { failure });
+                // Assume any unknown failure could be critical
+                hasRequiredFailure = true;
             }
             else if (!result.value.success) {
-                failedRegistrations.push(result.value);
+                // This indicates a failure within the specific registerFn (result.value.error should exist)
+                const failure = {
+                    type: result.value.type,
+                    name: result.value.name,
+                    // Provide a fallback error just in case, though logic implies error exists
+                    error: result.value.error ?? new Error(`Unknown error registering ${result.value.type} ${result.value.name}`),
+                    attempts: 1 // Assuming 1 attempt for now
+                };
+                serverState.failedRegistrations.push(failure);
+                serverLogger.warn(`Registration failed for ${failure.type}: ${failure.name}`, { error: failure.error });
+                // Check if the failed component was required
+                if ((failure.type === 'tool' && serverState.requiredTools.has(failure.name)) ||
+                    (failure.type === 'resource' && serverState.requiredResources.has(failure.name))) {
+                    serverLogger.error(`Required ${failure.type} '${failure.name}' failed to register. Server will be degraded.`, { error: failure.error });
+                    hasRequiredFailure = true;
+                }
             }
         });
-        // Process failed registrations
-        if (failedRegistrations.length > 0) {
-            serverLogger.warn(`${failedRegistrations.length} registrations failed initially`, {
-                failedComponents: failedRegistrations.map(f => `${f.type}:${f.name}`)
-            });
+        // Update server status based on registration results
+        const previousStatus = serverState.status;
+        if (hasRequiredFailure) {
+            serverState.status = 'degraded';
+        }
+        else {
+            serverState.status = 'running'; // Move to running only if all required components registered
         }
+        // Emit state change if status updated
+        if (serverState.status !== previousStatus) {
+            serverEvents.emitStateChange(previousStatus, serverState.status);
+        }
+        serverLogger.info(`Component registration complete. Status: ${serverState.status}`, {
+            registeredTools: Array.from(serverState.registeredTools),
+            registeredResources: Array.from(serverState.registeredResources),
+            failedCount: serverState.failedRegistrations.length,
+            failedComponents: serverState.failedRegistrations.map(f => `${f.type}:${f.name}`)
+        });
         // Add debug logs to diagnose the connection issue
         serverLogger.debug("About to connect to stdio transport");
         try {
             // Connect using stdio transport
             const transport = new StdioServerTransport();
             serverLogger.debug("Created StdioServerTransport instance");
-            // Set event handlers - using type assertion to avoid TS errors
+            // Set event handlers
+            // Using 'as any' for onerror as the type might not be directly exposed or stable in the SDK.
+            // This bypasses TypeScript checks but allows attaching the handler.
+            // TODO: Revisit if future SDK versions provide a type-safe way to attach error handlers.
             server.onerror = (err) => {
-                serverLogger.error(`Server error: ${err.message}`, { stack: err.stack });
+                serverLogger.error(`Server transport error: ${err.message}`, { stack: err.stack });
+                // Optionally update server state on transport errors
+                if (serverState.status !== 'error' && serverState.status !== 'shutting_down') {
+                    const oldStatus = serverState.status;
+                    serverState.status = 'error';
+                    serverEvents.emitStateChange(oldStatus, 'error');
+                }
+                serverState.errors.push({ timestamp: new Date(), message: err.message, code: 'TRANSPORT_ERROR' });
             };
             // Skip setting onrequest since we don't have access to the type
             await server.connect(transport);
@@ -215,7 +257,11 @@ export const createMcpServer = async () => {
                 error: error instanceof Error ? error.message : String(error),
                 stack: error instanceof Error ? error.stack : undefined
             });
-            throw error;
+            // Update state on connection failure
+            const oldStatus = serverState.status;
+            serverState.status = 'error';
+            serverEvents.emitStateChange(oldStatus, 'error');
+            throw error; // Re-throw connection error
         }
         serverLogger.info("MCP server initialized and connected");
         return server;

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

@@ -21,8 +21,9 @@ const globalRateLimiter = new RateLimiter({
 });
 // Map to cache per-topic rate limiters
 const topicRateLimiters = new Map();
+const MAX_CACHED_TOPIC_LIMITERS = 1000; // Limit the cache size
 /**
- * Gets or creates a rate limiter for a specific topic
+ * Gets or creates a rate limiter for a specific topic, with cache cleanup.
  *
  * @param topic - The ntfy topic
  * @returns Rate limiter instance for the topic
@@ -30,6 +31,18 @@ const topicRateLimiters = new Map();
 function getTopicRateLimiter(topic) {
     const normalizedTopic = topic.toLowerCase().trim();
     if (!topicRateLimiters.has(normalizedTopic)) {
+        // Check cache size before adding a new limiter
+        if (topicRateLimiters.size >= MAX_CACHED_TOPIC_LIMITERS) {
+            // Remove the oldest entry (first key in insertion order)
+            const oldestTopic = topicRateLimiters.keys().next().value;
+            if (oldestTopic) {
+                topicRateLimiters.delete(oldestTopic);
+                ntfyToolLogger.debug(`Removed oldest topic rate limiter due to cache size limit: ${oldestTopic}`, {
+                    cacheSize: topicRateLimiters.size,
+                    limit: MAX_CACHED_TOPIC_LIMITERS
+                });
+            }
+        }
         // Make per-topic limit more restrictive than global
         const perTopicLimit = Math.min(50, Math.floor(rateLimit.maxRequests / 2));
         topicRateLimiters.set(normalizedTopic, new RateLimiter({
@@ -37,6 +50,9 @@ function getTopicRateLimiter(topic) {
             maxRequests: perTopicLimit,
             errorMessage: `Rate limit exceeded for topic '${normalizedTopic}'. Please try again in {waitTime} seconds.`,
         }));
+        ntfyToolLogger.debug(`Created new rate limiter for topic: ${normalizedTopic}`, {
+            cacheSize: topicRateLimiters.size
+        });
     }
     return topicRateLimiters.get(normalizedTopic);
 }
@@ -137,6 +153,8 @@ export const processNtfyMessage = async (params) => {
                 action: sanitizeInput.string(action.action),
                 url: action.url ? sanitizeInput.url(action.url) : undefined,
                 method: action.method ? sanitizeInput.string(action.method) : undefined,
+                // TODO: Review if action.headers need sanitization/validation based on ntfy processing.
+                // Currently passed through as-is.
                 headers: action.headers,
                 body: action.body ? sanitizeInput.string(action.body) : undefined,
                 clear: action.clear

package/dist/types-global/tool.d.ts

@@ -1,6 +1,5 @@
 import { z } from 'zod';
 import { RateLimitConfig } from "../utils/rateLimiter.js";
-import { OperationContext } from "../utils/security.js";
 /**
  * Metadata for a tool example
  */
@@ -43,19 +42,3 @@ export declare function createToolExample(input: Record<string, unknown>, output
  * @returns Tool metadata configuration
  */
 export declare function createToolMetadata(metadata: ToolMetadata): ToolMetadata;
-/**
- * Register a tool with the MCP server
- *
- * This is a compatibility wrapper for the McpServer.tool() method.
- * In the current implementation, the tool registration is handled by the McpServer class,
- * so this function primarily exists to provide a consistent API.
- *
- * @param server MCP server instance
- * @param name Tool name
- * @param description Tool description
- * @param inputSchema Schema for validating input
- * @param handler Handler function for the tool
- * @param metadata Optional tool metadata
- */
-export declare function registerTool(server: any, // Using any to avoid type conflicts
-name: string, description: string, inputSchema: Record<string, z.ZodType<any>>, handler: (input: unknown, context: OperationContext) => Promise<unknown>, metadata?: ToolMetadata): Promise<void>;

package/dist/types-global/tool.js

@@ -1,4 +1,3 @@
-import { ErrorHandler } from "../utils/errorHandler.js";
 import { logger } from "../utils/logger.js";
 // Create a module-level logger
 const toolLogger = logger.createChildLogger({
@@ -28,72 +27,4 @@ export function createToolExample(input, output, description) {
 export function createToolMetadata(metadata) {
     return metadata;
 }
-/**
- * Register a tool with the MCP server
- *
- * This is a compatibility wrapper for the McpServer.tool() method.
- * In the current implementation, the tool registration is handled by the McpServer class,
- * so this function primarily exists to provide a consistent API.
- *
- * @param server MCP server instance
- * @param name Tool name
- * @param description Tool description
- * @param inputSchema Schema for validating input
- * @param handler Handler function for the tool
- * @param metadata Optional tool metadata
- */
-export function registerTool(server, // Using any to avoid type conflicts
-name, description, inputSchema, handler, metadata) {
-    return ErrorHandler.tryCatch(async () => {
-        // Log the registration attempt
-        toolLogger.info(`Registering tool: ${name}`, {
-            toolName: name,
-            schemaKeys: Object.keys(inputSchema),
-            hasMetadata: Boolean(metadata),
-            hasExamples: Boolean(metadata?.examples?.length)
-        });
-        // Some basic validation
-        if (!name) {
-            throw new Error('Tool name is required');
-        }
-        if (!inputSchema) {
-            throw new Error('Input schema is required');
-        }
-        if (!handler || typeof handler !== 'function') {
-            throw new Error('Handler must be a function');
-        }
-        // Convert schema to a more standardized format if needed
-        const schemaDescription = Object.entries(inputSchema).map(([key, schema]) => {
-            const description = schema.description;
-            const isRequired = !schema.isOptional?.();
-            return `${key}${isRequired ? ' (required)' : ''}: ${description || 'No description'}`;
-        }).join('\n');
-        toolLogger.debug(`Tool ${name} schema:`, {
-            toolName: name,
-            schema: schemaDescription
-        });
-        // Actually register the tool with the server
-        // Check if it's an McpServer instance with tool() method
-        if (server.tool && typeof server.tool === 'function') {
-            // Use the McpServer.tool() method directly
-            toolLogger.debug('Using McpServer.tool() method');
-            server.tool(name, inputSchema, handler, {
-                description,
-                examples: metadata?.examples
-            });
-        }
-        else {
-            // For other server types or for testing, log a warning
-            toolLogger.warn(`Unable to register tool ${name} with server - missing tool() method`, {
-                toolName: name
-            });
-        }
-        // Log successful registration
-        toolLogger.info(`Tool ${name} registered successfully`);
-    }, {
-        context: { toolName: name },
-        operation: "registering tool",
-        errorMapper: (error) => new Error(`Failed to register tool ${name}: ${error instanceof Error ? error.message : String(error)}`),
-        rethrow: true
-    });
-}
+// Removed unused registerTool function (registration handled elsewhere)

package/dist/utils/logger.d.ts

@@ -13,6 +13,13 @@ declare class Logger {
     info(message: string, context?: Record<string, unknown>): void;
     warn(message: string, context?: Record<string, unknown>): void;
     error(message: string, context?: Record<string, unknown>): void;
+    /**
+     * Creates a child logger that automatically includes the provided metadata
+     * in the context object of every log message.
+     *
+     * @param metadata - Static metadata to include with every log from this child.
+     * @returns A ChildLogger instance.
+     */
     createChildLogger(metadata: {
         module: string;
         service?: string;
@@ -25,12 +32,7 @@ declare class Logger {
         environment?: string;
         serverId?: string;
         [key: string]: any;
-    }): {
-        debug: (message: string, context?: Record<string, unknown>) => void;
-        info: (message: string, context?: Record<string, unknown>) => void;
-        warn: (message: string, context?: Record<string, unknown>) => void;
-        error: (message: string, context?: Record<string, unknown>) => void;
-    };
+    }): ChildLogger;
 }
 export declare const logger: Logger;
 export {};

package/dist/utils/logger.js

@@ -16,19 +16,30 @@ class Logger {
             fs.mkdirSync(logsDir, { recursive: true });
         }
         // Common format for all transports
-        const commonFormat = winston.format.combine(winston.format.timestamp(), winston.format.errors({ stack: true }), winston.format.printf(({ timestamp, level, message, context, stack }) => {
-            const contextStr = context ? `\n  Context: ${JSON.stringify(context, null, 2)}` : "";
+        const commonFormat = winston.format.combine(winston.format.timestamp(), winston.format.errors({ stack: true }), 
+        // The 'context' object passed to logger methods (e.g., logger.info(message, context))
+        // will be available here in the 'info' object passed to the printf function.
+        // Winston automatically merges the metadata passed during logger creation 
+        // with the metadata passed at the call site if you use logger.child().
+        // However, since we are implementing a custom child logger wrapper, 
+        // we need to handle the merging manually.
+        winston.format.printf(({ timestamp, level, message, context, stack }) => {
+            // Ensure context is an object before stringifying
+            const contextStr = (context && typeof context === 'object' && Object.keys(context).length > 0)
+                ? `\n  Context: ${JSON.stringify(context, null, 2)}`
+                : "";
             const stackStr = stack ? `\n  Stack: ${stack}` : "";
             return `[${timestamp}] ${level}: ${message}${contextStr}${stackStr}`;
         }));
         this.logger = winston.createLogger({
             level: logLevel,
+            // Use json format for structured logging internally, printf for files
             format: winston.format.json(),
             transports: [
                 // Combined log file for all levels
                 new winston.transports.File({
                     filename: path.join(logsDir, 'combined.log'),
-                    format: commonFormat
+                    format: commonFormat // Apply the custom format here
                 }),
                 // Separate log files for each level
                 new winston.transports.File({
@@ -53,6 +64,20 @@ class Logger {
                 })
             ]
         });
+        // Add console transport only if not in production
+        if (process.env.NODE_ENV !== 'production') {
+            this.logger.add(new winston.transports.Console({
+                format: winston.format.combine(winston.format.colorize(), winston.format.simple(), // Use simple format for console readability
+                winston.format.printf(({ level, message, timestamp, context, stack }) => {
+                    const contextStr = (context && typeof context === 'object' && Object.keys(context).length > 0)
+                        ? ` ${JSON.stringify(context)}`
+                        : "";
+                    const stackStr = stack ? `\n${stack}` : "";
+                    // Simple console format
+                    return `${level}: ${message}${contextStr}${stackStr}`;
+                }))
+            }));
+        }
     }
     static getInstance() {
         if (!Logger.instance) {
@@ -60,31 +85,55 @@ class Logger {
         }
         return Logger.instance;
     }
+    // Base log methods now accept the context directly
     debug(message, context) {
-        this.logger.debug(message, { context });
+        this.logger.debug(message, context);
     }
     info(message, context) {
-        this.logger.info(message, { context });
+        this.logger.info(message, context);
     }
     warn(message, context) {
-        this.logger.warn(message, { context });
+        this.logger.warn(message, context);
     }
     error(message, context) {
-        this.logger.error(message, { context });
+        // Ensure error context includes stack if available
+        const errorContext = context || {};
+        if (errorContext.error instanceof Error && !errorContext.stack) {
+            errorContext.stack = errorContext.error.stack;
+        }
+        this.logger.error(message, errorContext);
     }
+    /**
+     * Creates a child logger that automatically includes the provided metadata
+     * in the context object of every log message.
+     *
+     * @param metadata - Static metadata to include with every log from this child.
+     * @returns A ChildLogger instance.
+     */
     createChildLogger(metadata) {
+        // Filter out undefined values from metadata once
+        const staticMetadata = Object.fromEntries(Object.entries(metadata).filter(([_, v]) => v !== undefined));
         return {
             debug: (message, context) => {
-                this.debug(`[${metadata.module}] ${message}`, context);
+                // Merge static metadata with call-site context
+                const mergedContext = { ...staticMetadata, ...context };
+                this.debug(message, mergedContext);
             },
             info: (message, context) => {
-                this.info(`[${metadata.module}] ${message}`, context);
+                const mergedContext = { ...staticMetadata, ...context };
+                this.info(message, mergedContext);
             },
             warn: (message, context) => {
-                this.warn(`[${metadata.module}] ${message}`, context);
+                const mergedContext = { ...staticMetadata, ...context };
+                this.warn(message, mergedContext);
             },
             error: (message, context) => {
-                this.error(`[${metadata.module}] ${message}`, context);
+                const mergedContext = { ...staticMetadata, ...context };
+                // Ensure error context includes stack if available
+                if (mergedContext.error instanceof Error && !mergedContext.stack) {
+                    mergedContext.stack = mergedContext.error.stack;
+                }
+                this.error(message, mergedContext);
             }
         };
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ntfy-mcp-server",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "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",
@@ -16,17 +16,17 @@
     "watch": "tail -f logs/combined.log"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.8.0",
-    "@types/node": "^22.13.14",
-    "@types/sanitize-html": "^2.13.0",
-    "@types/validator": "^13.12.3",
+    "@modelcontextprotocol/sdk": "^1.10.2",
+    "@types/node": "^22.14.1",
+    "@types/sanitize-html": "^2.15.0",
+    "@types/validator": "^13.15.0",
     "@types/xss-filters": "^1.2.0",
-    "dotenv": "^16.4.7",
+    "dotenv": "^16.5.0",
     "path-normalize": "^6.0.13",
-    "sanitize-html": "^2.15.0",
+    "sanitize-html": "^2.16.0",
     "ts-node": "^10.9.2",
-    "typescript": "^5.8.2",
-    "undici-types": "^7.5.0",
+    "typescript": "^5.8.3",
+    "undici-types": "^7.8.0",
     "validator": "^13.15.0",
     "winston": "^3.17.0",
     "winston-daily-rotate-file": "^5.0.0",