ntfy-mcp-server 1.0.0

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

@@ -0,0 +1,252 @@
+import { z } from 'zod';
+/**
+ * Valid priority levels for ntfy messages
+ */
+export declare const NTFY_PRIORITIES: readonly [1, 2, 3, 4, 5];
+/**
+ * Creates a Zod schema for the send_ntfy tool with current environment values
+ * This function should be called at registration time to ensure it has the
+ * latest configuration values from the environment
+ *
+ * @returns A Zod schema for the ntfy tool
+ */
+export declare function createSendNtfyToolSchema(): z.ZodObject<{
+    topic: z.ZodEffects<z.ZodString, string, string>;
+    message: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    priority: z.ZodOptional<z.ZodNumber>;
+    click: z.ZodOptional<z.ZodString>;
+    actions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        action: z.ZodString;
+        url: z.ZodOptional<z.ZodString>;
+        method: z.ZodOptional<z.ZodString>;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        body: z.ZodOptional<z.ZodString>;
+        clear: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        label: string;
+        action: string;
+        method?: string | undefined;
+        url?: string | undefined;
+        headers?: Record<string, string> | undefined;
+        body?: string | undefined;
+        clear?: boolean | undefined;
+    }, {
+        id: string;
+        label: string;
+        action: string;
+        method?: string | undefined;
+        url?: string | undefined;
+        headers?: Record<string, string> | undefined;
+        body?: string | undefined;
+        clear?: boolean | undefined;
+    }>, "many">>;
+    attachment: z.ZodOptional<z.ZodObject<{
+        url: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        url: string;
+        name?: string | undefined;
+    }, {
+        url: string;
+        name?: string | undefined;
+    }>>;
+    email: z.ZodOptional<z.ZodString>;
+    delay: z.ZodOptional<z.ZodString>;
+    cache: z.ZodOptional<z.ZodString>;
+    firebase: z.ZodOptional<z.ZodString>;
+    id: z.ZodOptional<z.ZodString>;
+    expires: z.ZodOptional<z.ZodString>;
+    markdown: z.ZodOptional<z.ZodBoolean>;
+    baseUrl: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    topic: string;
+    title?: string | undefined;
+    id?: string | undefined;
+    priority?: number | undefined;
+    tags?: string[] | undefined;
+    baseUrl?: string | undefined;
+    click?: string | undefined;
+    actions?: {
+        id: string;
+        label: string;
+        action: string;
+        method?: string | undefined;
+        url?: string | undefined;
+        headers?: Record<string, string> | undefined;
+        body?: string | undefined;
+        clear?: boolean | undefined;
+    }[] | undefined;
+    attachment?: {
+        url: string;
+        name?: string | undefined;
+    } | undefined;
+    email?: string | undefined;
+    delay?: string | undefined;
+    cache?: string | undefined;
+    firebase?: string | undefined;
+    expires?: string | undefined;
+    markdown?: boolean | undefined;
+}, {
+    message: string;
+    topic: string;
+    title?: string | undefined;
+    id?: string | undefined;
+    priority?: number | undefined;
+    tags?: string[] | undefined;
+    baseUrl?: string | undefined;
+    click?: string | undefined;
+    actions?: {
+        id: string;
+        label: string;
+        action: string;
+        method?: string | undefined;
+        url?: string | undefined;
+        headers?: Record<string, string> | undefined;
+        body?: string | undefined;
+        clear?: boolean | undefined;
+    }[] | undefined;
+    attachment?: {
+        url: string;
+        name?: string | undefined;
+    } | undefined;
+    email?: string | undefined;
+    delay?: string | undefined;
+    cache?: string | undefined;
+    firebase?: string | undefined;
+    expires?: string | undefined;
+    markdown?: boolean | undefined;
+}>;
+export declare const SendNtfyToolInputSchema: () => z.ZodObject<{
+    topic: z.ZodEffects<z.ZodString, string, string>;
+    message: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    priority: z.ZodOptional<z.ZodNumber>;
+    click: z.ZodOptional<z.ZodString>;
+    actions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        action: z.ZodString;
+        url: z.ZodOptional<z.ZodString>;
+        method: z.ZodOptional<z.ZodString>;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        body: z.ZodOptional<z.ZodString>;
+        clear: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        label: string;
+        action: string;
+        method?: string | undefined;
+        url?: string | undefined;
+        headers?: Record<string, string> | undefined;
+        body?: string | undefined;
+        clear?: boolean | undefined;
+    }, {
+        id: string;
+        label: string;
+        action: string;
+        method?: string | undefined;
+        url?: string | undefined;
+        headers?: Record<string, string> | undefined;
+        body?: string | undefined;
+        clear?: boolean | undefined;
+    }>, "many">>;
+    attachment: z.ZodOptional<z.ZodObject<{
+        url: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        url: string;
+        name?: string | undefined;
+    }, {
+        url: string;
+        name?: string | undefined;
+    }>>;
+    email: z.ZodOptional<z.ZodString>;
+    delay: z.ZodOptional<z.ZodString>;
+    cache: z.ZodOptional<z.ZodString>;
+    firebase: z.ZodOptional<z.ZodString>;
+    id: z.ZodOptional<z.ZodString>;
+    expires: z.ZodOptional<z.ZodString>;
+    markdown: z.ZodOptional<z.ZodBoolean>;
+    baseUrl: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    topic: string;
+    title?: string | undefined;
+    id?: string | undefined;
+    priority?: number | undefined;
+    tags?: string[] | undefined;
+    baseUrl?: string | undefined;
+    click?: string | undefined;
+    actions?: {
+        id: string;
+        label: string;
+        action: string;
+        method?: string | undefined;
+        url?: string | undefined;
+        headers?: Record<string, string> | undefined;
+        body?: string | undefined;
+        clear?: boolean | undefined;
+    }[] | undefined;
+    attachment?: {
+        url: string;
+        name?: string | undefined;
+    } | undefined;
+    email?: string | undefined;
+    delay?: string | undefined;
+    cache?: string | undefined;
+    firebase?: string | undefined;
+    expires?: string | undefined;
+    markdown?: boolean | undefined;
+}, {
+    message: string;
+    topic: string;
+    title?: string | undefined;
+    id?: string | undefined;
+    priority?: number | undefined;
+    tags?: string[] | undefined;
+    baseUrl?: string | undefined;
+    click?: string | undefined;
+    actions?: {
+        id: string;
+        label: string;
+        action: string;
+        method?: string | undefined;
+        url?: string | undefined;
+        headers?: Record<string, string> | undefined;
+        body?: string | undefined;
+        clear?: boolean | undefined;
+    }[] | undefined;
+    attachment?: {
+        url: string;
+        name?: string | undefined;
+    } | undefined;
+    email?: string | undefined;
+    delay?: string | undefined;
+    cache?: string | undefined;
+    firebase?: string | undefined;
+    expires?: string | undefined;
+    markdown?: boolean | undefined;
+}>;
+export type SendNtfyToolInput = z.infer<ReturnType<typeof createSendNtfyToolSchema>>;
+/**
+ * Response structure for the send_ntfy tool
+ */
+export interface SendNtfyToolResponse {
+    success: boolean;
+    id: string;
+    topic: string;
+    time: number;
+    expires?: number;
+    message: string;
+    title?: string;
+    url?: string;
+    /** Number of retries needed (if any) */
+    retries?: number;
+}

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

@@ -0,0 +1,144 @@
+import { z } from 'zod';
+import { config } from '../../../config/index.js';
+import { logger } from '../../../utils/logger.js';
+import { createRequestContext } from '../../../utils/requestContext.js';
+// Create a module-specific logger
+const schemaLogger = logger.createChildLogger({
+    module: 'NtfyToolSchema'
+});
+/**
+ * Valid priority levels for ntfy messages
+ */
+export const NTFY_PRIORITIES = [1, 2, 3, 4, 5];
+/**
+ * Validates a ntfy topic string format
+ *
+ * @param topic - The topic string to validate
+ * @returns boolean indicating if topic is valid
+ */
+function isValidTopic(topic) {
+    if (!topic)
+        return false;
+    return topic.trim() !== '' && !/[\r\n]/.test(topic);
+}
+/**
+ * Creates a Zod schema for the send_ntfy tool with current environment values
+ * This function should be called at registration time to ensure it has the
+ * latest configuration values from the environment
+ *
+ * @returns A Zod schema for the ntfy tool
+ */
+export function createSendNtfyToolSchema() {
+    // Create request context for tracking
+    const requestCtx = createRequestContext({
+        operation: 'createSendNtfyToolSchema'
+    });
+    schemaLogger.debug('Creating send_ntfy tool schema');
+    // Get the latest configuration
+    const ntfyConfig = config.ntfy;
+    // Process configuration values
+    const baseUrl = ntfyConfig.baseUrl || 'https://ntfy.sh';
+    const defaultTopic = ntfyConfig.defaultTopic || '';
+    const maxMessageSize = ntfyConfig.maxMessageSize || 4096;
+    // Log the loaded config values for debugging
+    schemaLogger.debug('Loaded ntfy configuration', {
+        defaultTopic: defaultTopic || '(not set)',
+        baseUrl,
+        maxMessageSize
+    });
+    // Generate better description text based on current config
+    const topicDesc = defaultTopic
+        ? `The ntfy topic to send the notification to (required). Default topic configured: "${defaultTopic}". Use ntfy://default resource to identify the configured topic.`
+        : `The ntfy topic to send the notification to (required). No default topic configured. Use ntfy://default resource to check if a topic has been configured.`;
+    schemaLogger.debug('Schema configuration loaded', {
+        hasBaseUrl: !!baseUrl,
+        hasDefaultTopic: !!defaultTopic,
+        hasApiKey: !!ntfyConfig.apiKey,
+        maxMessageSize
+    });
+    // Create schema with the latest config values
+    const schema = z.object({
+        // Required parameters
+        topic: z.string()
+            .min(1, "Topic must not be empty")
+            .refine(isValidTopic, "Topic must not contain newlines")
+            .describe(topicDesc),
+        message: z.string()
+            .min(1, "Message must not be empty")
+            .max(maxMessageSize, `Message size cannot exceed ${maxMessageSize} bytes`)
+            .describe(`The message to send (notification body, max ${maxMessageSize} bytes)`),
+        // Optional parameters with improved descriptions
+        title: z.string()
+            .max(250, "Title should be under 250 characters")
+            .optional()
+            .describe('Message title (optional)'),
+        tags: z.array(z.string())
+            .max(5, "Maximum of 5 tags allowed")
+            .optional()
+            .describe('Tags that show as emojis (e.g., ["warning", "skull", "robot"])'),
+        priority: z.number()
+            .int()
+            .min(1)
+            .max(5)
+            .optional()
+            .describe('Message priority: 1=min, 2=low, 3=default, 4=high, 5=max'),
+        click: z.string()
+            .url("Must be a valid URL")
+            .optional()
+            .describe('URL to open when notification is clicked'),
+        actions: z.array(z.object({
+            id: z.string().describe('Action identifier'),
+            label: z.string().describe('Label for the action button'),
+            action: z.string().describe('Action type (e.g., view, broadcast, http)'),
+            url: z.string().url("Must be a valid URL").optional().describe('URL or data for the action'),
+            method: z.string().optional().describe('HTTP method for http actions'),
+            headers: z.record(z.string()).optional().describe('Additional headers for http actions'),
+            body: z.string().optional().describe('Body for http actions'),
+            clear: z.boolean().optional().describe('Clear notification after action (Default: false)')
+        }))
+            .max(3, "Maximum of 3 actions supported")
+            .optional()
+            .describe('Action buttons in the notification (max 3)'),
+        attachment: z.object({
+            url: z.string().url("Must be a valid URL").describe('URL of the attachment'),
+            name: z.string().optional().describe('Name of the attachment'),
+        })
+            .optional()
+            .describe('Attachment for the notification'),
+        email: z.string()
+            .email("Must be a valid email address")
+            .optional()
+            .describe('Email address to send the notification to'),
+        delay: z.string()
+            .optional()
+            .describe('Delay the message (e.g., 30m, 1h, tomorrow)'),
+        cache: z.string()
+            .optional()
+            .describe('Cache duration (e.g., 10m, 1h, 1d)'),
+        firebase: z.string()
+            .optional()
+            .describe('Firebase Cloud Messaging (FCM) topic to forward to'),
+        id: z.string()
+            .optional()
+            .describe('Unique ID for the message'),
+        expires: z.string()
+            .optional()
+            .describe('Message expiration (e.g., 10m, 1h, 1d)'),
+        markdown: z.boolean()
+            .optional()
+            .describe('Format message as markdown'),
+        // Server options
+        baseUrl: z.string()
+            .url("Must be a valid URL")
+            .optional()
+            .describe(`Base URL for the ntfy server (default: ${baseUrl})`)
+        // Authentication is handled automatically using API key from .env when available
+    });
+    schemaLogger.info('Send_ntfy tool schema created successfully', {
+        fieldCount: Object.keys(schema.shape).length
+    });
+    return schema;
+}
+// Create a dynamic version of the schema for type inference
+// We want to ensure this is always recreated at runtime with the latest env values
+export const SendNtfyToolInputSchema = () => createSendNtfyToolSchema();

package/dist/mcp-server/utils/registrationHelper.d.ts

@@ -0,0 +1,48 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { ChildLogger } from "../../utils/logger.js";
+/**
+ * Base interface for registration options
+ */
+export interface RegistrationOptions {
+    /** Name of the component being registered */
+    name: string;
+    /** Logger context for creating a child logger */
+    loggerContext?: Record<string, unknown>;
+}
+/**
+ * Full options with component type
+ */
+interface InternalRegistrationOptions extends RegistrationOptions {
+    /** Type of component (tool, resource, etc.) */
+    type: string;
+}
+/**
+ * Helper for consistent registration pattern with proper error handling
+ * @param server MCP server instance
+ * @param options Registration options
+ * @param registerFn Function that performs the actual registration
+ * @returns Promise resolving when registration is complete
+ */
+export declare function registerComponent(server: McpServer, options: InternalRegistrationOptions, registerFn: (server: McpServer, childLogger: ChildLogger) => Promise<void>): Promise<void>;
+/**
+ * Register a tool with the MCP server using a consistent pattern
+ * @param server MCP server instance
+ * @param options Tool registration options
+ * @param handlerFn Function that sets up the tool handler
+ * @returns Promise resolving when registration is complete
+ */
+export declare function registerTool(server: McpServer, options: RegistrationOptions, handlerFn: (server: McpServer, logger: ChildLogger) => Promise<void>): Promise<void>;
+/**
+ * Register a resource with the MCP server using a consistent pattern
+ * @param server MCP server instance
+ * @param options Resource registration options
+ * @param handlerFn Function that sets up the resource handler
+ * @returns Promise resolving when registration is complete
+ */
+export declare function registerResource(server: McpServer, options: RegistrationOptions, handlerFn: (server: McpServer, logger: ChildLogger) => Promise<void>): Promise<void>;
+declare const _default: {
+    registerComponent: typeof registerComponent;
+    registerTool: typeof registerTool;
+    registerResource: typeof registerResource;
+};
+export default _default;

package/dist/mcp-server/utils/registrationHelper.js

@@ -0,0 +1,63 @@
+import { BaseErrorCode, McpError } from "../../types-global/errors.js";
+import { ErrorHandler } from "../../utils/errorHandler.js";
+import { logger } from "../../utils/logger.js";
+/**
+ * Helper for consistent registration pattern with proper error handling
+ * @param server MCP server instance
+ * @param options Registration options
+ * @param registerFn Function that performs the actual registration
+ * @returns Promise resolving when registration is complete
+ */
+export async function registerComponent(server, options, registerFn) {
+    // Create a component-specific logger
+    const componentLogger = logger.createChildLogger({
+        module: `${options.type}Registration`,
+        componentName: options.name,
+        ...options.loggerContext
+    });
+    componentLogger.info(`Registering ${options.type}: ${options.name}`);
+    // Use ErrorHandler.tryCatch for consistent error handling
+    return await ErrorHandler.tryCatch(async () => {
+        // Call the registration function
+        await registerFn(server, componentLogger);
+        componentLogger.info(`${options.type} registered successfully: ${options.name}`);
+    }, {
+        operation: `registering ${options.type}`,
+        // Provide context for better error tracking
+        context: {
+            componentType: options.type,
+            componentName: options.name
+        },
+        // Use a specific error code for registration failures
+        errorCode: BaseErrorCode.INTERNAL_ERROR,
+        // Custom error mapper for clearer error messages
+        errorMapper: (error) => new McpError(error instanceof McpError ? error.code : BaseErrorCode.INTERNAL_ERROR, `Failed to register ${options.type} '${options.name}': ${error instanceof Error ? error.message : 'Unknown error'}`, { componentType: options.type, componentName: options.name }),
+        // Registration errors are considered critical
+        critical: true
+    });
+}
+/**
+ * Register a tool with the MCP server using a consistent pattern
+ * @param server MCP server instance
+ * @param options Tool registration options
+ * @param handlerFn Function that sets up the tool handler
+ * @returns Promise resolving when registration is complete
+ */
+export async function registerTool(server, options, handlerFn) {
+    return registerComponent(server, { ...options, type: 'tool' }, handlerFn);
+}
+/**
+ * Register a resource with the MCP server using a consistent pattern
+ * @param server MCP server instance
+ * @param options Resource registration options
+ * @param handlerFn Function that sets up the resource handler
+ * @returns Promise resolving when registration is complete
+ */
+export async function registerResource(server, options, handlerFn) {
+    return registerComponent(server, { ...options, type: 'resource' }, handlerFn);
+}
+export default {
+    registerComponent,
+    registerTool,
+    registerResource
+};

package/dist/services/ntfy/constants.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Constants for the ntfy service
+ */
+/** Default ntfy server URL */
+export declare const DEFAULT_NTFY_BASE_URL = "https://ntfy.sh";
+/** HTTP subscription format endpoints */
+export declare const SUBSCRIPTION_ENDPOINTS: {
+    json: string;
+    sse: string;
+    raw: string;
+    ws: string;
+};
+/** Default subscription options */
+export declare const DEFAULT_SUBSCRIPTION_OPTIONS: {
+    baseUrl: string;
+    poll: boolean;
+    scheduled: boolean;
+};
+/** Default HTTP request timeout in milliseconds */
+export declare const DEFAULT_REQUEST_TIMEOUT = 30000;
+/** Keepalive timeout in milliseconds (how long to wait before considering connection dead) */
+export declare const KEEPALIVE_TIMEOUT = 120000;
+/** Reconnect delay in milliseconds (delay before attempting to reconnect after failure) */
+export declare const RECONNECT_DELAY = 5000;
+/** Maximum reconnect attempts before giving up */
+export declare const MAX_RECONNECT_ATTEMPTS = 5;
+/** User agent string for requests */
+export declare const USER_AGENT = "ntfy-mcp-server/1.0.0";
+/** Error messages */
+export declare const ERROR_MESSAGES: {
+    INVALID_TOPIC: string;
+    CONNECTION_FAILED: string;
+    SUBSCRIPTION_CLOSED: string;
+    PARSE_ERROR: string;
+    NETWORK_ERROR: string;
+    AUTHENTICATION_FAILED: string;
+};

package/dist/services/ntfy/constants.js

@@ -0,0 +1,37 @@
+/**
+ * Constants for the ntfy service
+ */
+/** Default ntfy server URL */
+export const DEFAULT_NTFY_BASE_URL = 'https://ntfy.sh';
+/** HTTP subscription format endpoints */
+export const SUBSCRIPTION_ENDPOINTS = {
+    json: '/json',
+    sse: '/sse',
+    raw: '/raw',
+    ws: '/ws',
+};
+/** Default subscription options */
+export const DEFAULT_SUBSCRIPTION_OPTIONS = {
+    baseUrl: DEFAULT_NTFY_BASE_URL,
+    poll: false,
+    scheduled: false,
+};
+/** Default HTTP request timeout in milliseconds */
+export const DEFAULT_REQUEST_TIMEOUT = 30000;
+/** Keepalive timeout in milliseconds (how long to wait before considering connection dead) */
+export const KEEPALIVE_TIMEOUT = 120000;
+/** Reconnect delay in milliseconds (delay before attempting to reconnect after failure) */
+export const RECONNECT_DELAY = 5000;
+/** Maximum reconnect attempts before giving up */
+export const MAX_RECONNECT_ATTEMPTS = 5;
+/** User agent string for requests */
+export const USER_AGENT = 'ntfy-mcp-server/1.0.0';
+/** Error messages */
+export const ERROR_MESSAGES = {
+    INVALID_TOPIC: 'Invalid topic name',
+    CONNECTION_FAILED: 'Failed to connect to ntfy server',
+    SUBSCRIPTION_CLOSED: 'Subscription closed',
+    PARSE_ERROR: 'Failed to parse message',
+    NETWORK_ERROR: 'Network error occurred',
+    AUTHENTICATION_FAILED: 'Authentication failed',
+};

package/dist/services/ntfy/errors.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Custom error classes for the ntfy service
+ */
+import { McpError } from '../../types-global/errors.js';
+/**
+ * Base error class for ntfy service errors
+ */
+export declare class NtfyError extends McpError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+/**
+ * Error thrown when connection to ntfy server fails
+ */
+export declare class NtfyConnectionError extends NtfyError {
+    readonly url?: string | undefined;
+    constructor(message: string, url?: string | undefined);
+}
+/**
+ * Error thrown when authentication fails
+ */
+export declare class NtfyAuthenticationError extends NtfyError {
+    constructor(message: string);
+}
+/**
+ * Error thrown when a message cannot be parsed
+ */
+export declare class NtfyParseError extends NtfyError {
+    readonly rawData?: string | undefined;
+    constructor(message: string, rawData?: string | undefined);
+}
+/**
+ * Error thrown when a subscription is closed unexpectedly
+ */
+export declare class NtfySubscriptionClosedError extends NtfyError {
+    readonly reason?: string | undefined;
+    constructor(message: string, reason?: string | undefined);
+}
+/**
+ * Error thrown when an invalid topic name is provided
+ */
+export declare class NtfyInvalidTopicError extends NtfyError {
+    readonly topic?: string | undefined;
+    constructor(message: string, topic?: string | undefined);
+}
+/**
+ * Error thrown when a timeout occurs
+ */
+export declare class NtfyTimeoutError extends NtfyError {
+    readonly timeoutMs?: number | undefined;
+    constructor(message: string, timeoutMs?: number | undefined);
+}
+/**
+ * Error mapping for ntfy errors
+ */
+export declare const NTFY_ERROR_MAPPINGS: ({
+    pattern: RegExp;
+    errorCode: "UNAUTHORIZED";
+    factory: (error: unknown) => NtfyAuthenticationError;
+} | {
+    pattern: RegExp;
+    errorCode: "VALIDATION_ERROR";
+    factory: (error: unknown, context?: Record<string, unknown>) => NtfyParseError;
+} | {
+    pattern: RegExp;
+    errorCode: "VALIDATION_ERROR";
+    factory: (error: unknown, context?: Record<string, unknown>) => NtfyInvalidTopicError;
+} | {
+    pattern: RegExp;
+    errorCode: "TIMEOUT";
+    factory: (error: unknown, context?: Record<string, unknown>) => NtfyTimeoutError;
+} | {
+    pattern: RegExp;
+    errorCode: "SERVICE_UNAVAILABLE";
+    factory: (error: unknown, context?: Record<string, unknown>) => NtfyConnectionError;
+})[];
+/**
+ * Create an error mapper function for ntfy errors
+ */
+export declare const ntfyErrorMapper: (error: unknown, context?: Record<string, unknown>) => McpError;