@davidfuchs/mcp-uptime-kuma 0.6.4 → 0.9.0

package/dist/server.js

@@ -2,7 +2,7 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { McpError, ErrorCode, SetLevelRequestSchema, LoggingLevelSchema } from '@modelcontextprotocol/sdk/types.js';
 import { z } from 'zod';
 import { UptimeKumaClient } from './uptime-kuma-client.js';
-import { HeartbeatSchema, MonitorBaseSchema, MonitorSummarySchema, SettingsSchema } from './types/index.js';
+import { HeartbeatSchema, MonitorBaseSchema, MonitorSummarySchema, SettingsSchema, NotificationSchema, MaintenanceSchema, StatusPageSchema, DockerHostSchema } from './types/index.js';
 import { VERSION } from './version.js';
 /**
  * Creates and configures the MCP server with tools, resources, and prompts
@@ -16,11 +16,27 @@ export async function createServer(config) {
         version: VERSION,
     }, {
         instructions: `
-        This MCP server provides access to Uptime Kuma monitoring data for system status and uptime/downtime information.
+        This MCP server provides access to Uptime Kuma monitoring data and management operations.
 
-        START with 'getMonitorSummary' for status overview questions ("how is everything?", "what's down?").
-        Use 'getHeartbeats' or 'listHeartbeats' for historical data (limit to 5-10 heartbeats unless user requests more).
-        Use 'listMonitors' only when you need configuration details (URLs, intervals, notification settings).
+        READ operations:
+        - START with 'getMonitorSummary' for status overview ("how is everything?", "what's down?").
+        - Use 'getHeartbeats' or 'listHeartbeats' for historical data (limit to 5-10 heartbeats unless user requests more).
+        - Use 'listMonitors' when you need configuration details (URLs, intervals, notification settings).
+        - Use 'listNotifications' to see notification channels.
+        - Use 'listTags' to see available tags.
+        - Use 'getMaintenanceWindows' to see scheduled maintenance.
+        - Use 'listStatusPages' to see status page configurations, or 'getStatusPage' for one page's full details (groups + monitors).
+        - Use 'listDockerHosts' to see configured docker daemons (used by docker container monitors).
+
+        WRITE operations:
+        - Use 'createMonitor' / 'updateMonitor' / 'deleteMonitor' to manage monitors.
+        - Use 'addNotification' / 'updateNotification' / 'deleteNotification' to manage notification channels.
+        - Use 'addTag' / 'deleteTag' to manage tags.
+        - Use 'createMaintenance' to schedule a maintenance window.
+        - Use 'addDockerHost' / 'updateDockerHost' / 'deleteDockerHost' to manage docker daemon connections.
+        - Use 'testDockerHost' to verify a docker daemon is reachable before saving.
+        - Use 'createStatusPage' / 'updateStatusPage' / 'deleteStatusPage' to manage status pages. Creating returns an empty page — follow up with updateStatusPage to set groups and monitors.
+        - Use 'pauseMonitor' / 'resumeMonitor' to temporarily stop/start checks.
       `,
         capabilities: {
             logging: {}
@@ -71,7 +87,7 @@ export async function createServer(config) {
         title: 'Get Monitor',
         description: 'Retrieves configuration details for a specific monitor by ID (URL, check interval, notification settings, etc.). Use this when you need to examine or modify settings for a specific monitor. For current status, use getMonitorSummary instead. By default returns only common fields plus runtime data (uptime, avgPing); set includeTypeSpecificFields to true to include type-specific fields (e.g., url for HTTP, hostname/port for TCP).',
         inputSchema: {
-            monitorID: z.number().int().nonnegative().describe('The ID of the monitor to retrieve'),
+            monitorID: z.coerce.number().int().nonnegative().describe('The ID of the monitor to retrieve'),
             includeTypeSpecificFields: z.boolean().optional().describe('Include type-specific fields (url, hostname, port, etc.) in addition to common fields. Default: false. When false, only returns MonitorBase fields plus uptime/avgPing.')
         },
         outputSchema: {
@@ -232,8 +248,8 @@ export async function createServer(config) {
         title: 'Get Heartbeats',
         description: 'Retrieves historical heartbeat data for a specific monitor (response times, status changes over time). Use this for analyzing patterns or history for one monitor. By default returns only the most recent heartbeat; set maxHeartbeats (up to 100) for historical analysis. Keep maxHeartbeats ≤10 unless user requests more.',
         inputSchema: {
-            monitorID: z.number().int().nonnegative().describe('The ID of the monitor to get heartbeats for'),
-            maxHeartbeats: z.number().int().positive().max(100).optional().describe('If set, returns the most recent X heartbeats (up to 100). If unset, returns only the most recent heartbeat (default: 1)')
+            monitorID: z.coerce.number().int().nonnegative().describe('The ID of the monitor to get heartbeats for'),
+            maxHeartbeats: z.coerce.number().int().positive().max(100).optional().describe('If set, returns the most recent X heartbeats (up to 100). If unset, returns only the most recent heartbeat (default: 1)')
         },
         outputSchema: {
             monitorID: z.number(),
@@ -296,7 +312,7 @@ export async function createServer(config) {
         title: 'List Heartbeats',
         description: 'Retrieves historical heartbeat data for ALL monitors (response times, status changes over time). Use this for analyzing patterns across multiple monitors or correlating events. By default returns only the most recent heartbeat per monitor; set maxHeartbeats (up to 100) for historical analysis. Keep maxHeartbeats ≤5 unless user requests more.',
         inputSchema: {
-            maxHeartbeats: z.number().int().positive().max(100).optional().describe('If set, returns the most recent X heartbeats per monitor (up to 100). If unset, returns only the most recent heartbeat per monitor (default: 1)')
+            maxHeartbeats: z.coerce.number().int().positive().max(100).optional().describe('If set, returns the most recent X heartbeats per monitor (up to 100). If unset, returns only the most recent heartbeat per monitor (default: 1)')
         },
         outputSchema: {
             heartbeats: z.record(z.string(), z.array(HeartbeatSchema)).describe('Map of monitor IDs to their heartbeat arrays'),
@@ -334,7 +350,7 @@ export async function createServer(config) {
         title: 'Pause Monitor',
         description: 'Pauses a monitor, stopping it from performing checks. The monitor will remain in the system but will not send notifications or collect data until resumed.',
         inputSchema: {
-            monitorID: z.number().int().nonnegative().describe('The ID of the monitor to pause')
+            monitorID: z.coerce.number().int().nonnegative().describe('The ID of the monitor to pause')
         },
         outputSchema: {
             ok: z.boolean(),
@@ -367,7 +383,7 @@ export async function createServer(config) {
         title: 'Resume Monitor',
         description: 'Resumes a paused monitor, restarting all checks. Use this to re-enable monitoring after pausing.',
         inputSchema: {
-            monitorID: z.number().int().nonnegative().describe('The ID of the monitor to resume')
+            monitorID: z.coerce.number().int().nonnegative().describe('The ID of the monitor to resume')
         },
         outputSchema: {
             ok: z.boolean(),
@@ -395,6 +411,724 @@ export async function createServer(config) {
             throw new McpError(ErrorCode.InternalError, `Failed to resume monitor: ${errorMessage}`);
         }
     });
+    // ─── Monitor write tools ──────────────────────────────────────────────────
+    server.registerTool('createMonitor', {
+        title: 'Create Monitor',
+        description: 'Creates a new monitor in Uptime Kuma. Requires at minimum a name and type. Use listMonitorTypes to see supported types. For HTTP monitors include url; for TCP/port monitors include hostname and port.',
+        inputSchema: {
+            name: z.string().describe('Display name for the monitor'),
+            type: z.string().describe('Monitor type (e.g. http, port, ping, dns, push, keyword). Use listMonitorTypes for all options.'),
+            url: z.string().optional().describe('URL to monitor (required for http/keyword/json-query types)'),
+            hostname: z.string().optional().describe('Hostname to monitor (required for port/ping/dns types)'),
+            port: z.coerce.number().optional().describe('Port number (required for port/tcp types)'),
+            interval: z.coerce.number().optional().describe('Check interval in seconds (default: 60)'),
+            retryInterval: z.coerce.number().optional().describe('Retry interval in seconds when monitor is down (default: 60)'),
+            maxretries: z.coerce.number().optional().describe('Max retries before marking as down (default: 0)'),
+            notificationIDList: z.record(z.string(), z.boolean()).optional().describe('Map of notification IDs to enable (e.g. {"1": true, "3": true})'),
+            tags: z.array(z.object({
+                name: z.string(),
+                value: z.string().optional(),
+                color: z.string().optional(),
+            })).optional().describe('Tags to assign to the monitor'),
+            keyword: z.string().optional().describe('Keyword to search for (keyword monitor type)'),
+            invertKeyword: z.boolean().optional().describe('Invert keyword match'),
+            method: z.string().optional().describe('HTTP method (GET, POST, etc.) for http type'),
+            body: z.string().optional().describe('HTTP request body'),
+            headers: z.string().optional().describe('HTTP headers as JSON string'),
+            accepted_statuscodes: z.array(z.string()).optional().describe('Accepted HTTP status codes (e.g. ["200-299"])'),
+            ignoreTls: z.boolean().optional().describe('Ignore TLS/SSL errors'),
+            maxredirects: z.coerce.number().optional().describe('Max HTTP redirects (default: 10)'),
+            upsideDown: z.boolean().optional().describe('Invert status — treat up as down'),
+            parent: z.coerce.number().nullable().optional().describe('Parent group monitor ID'),
+            docker_container: z.string().optional().describe('Docker container name (required for docker type)'),
+            docker_host: z.coerce.number().optional().describe('Docker host ID (required for docker type). Use listDockerHosts to find available IDs.'),
+        },
+        outputSchema: {
+            ok: z.boolean(),
+            monitorID: z.number().optional(),
+            msg: z.string().optional(),
+        },
+    }, async (input) => {
+        if (!isAuthenticated) {
+            throw new McpError(ErrorCode.InternalError, 'Not authenticated with Uptime Kuma');
+        }
+        try {
+            const defaults = {
+                notificationIDList: {},
+                accepted_statuscodes: ['200-299'],
+                conditions: [],
+                retryInterval: 60,
+            };
+            const monitorData = {
+                ...defaults,
+                ...input,
+            };
+            const response = await client.createMonitor(monitorData);
+            return {
+                content: [{ type: 'text', text: response.msg || `Monitor created with ID ${response.monitorID}` }],
+                structuredContent: { ok: response.ok, monitorID: response.monitorID, msg: response.msg },
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            throw new McpError(ErrorCode.InternalError, `Failed to create monitor: ${errorMessage}`);
+        }
+    });
+    server.registerTool('updateMonitor', {
+        title: 'Update Monitor',
+        description: 'Updates an existing monitor configuration. You must include the monitorID. Only the fields you provide will be changed (the server merges your changes with the existing config). Use getMonitor first to get the current config.',
+        inputSchema: {
+            monitorID: z.coerce.number().int().nonnegative().describe('The ID of the monitor to update'),
+            name: z.string().optional().describe('Display name'),
+            url: z.string().optional().describe('URL to monitor'),
+            hostname: z.string().optional().describe('Hostname'),
+            port: z.coerce.number().optional().describe('Port number'),
+            interval: z.coerce.number().optional().describe('Check interval in seconds'),
+            retryInterval: z.coerce.number().optional().describe('Retry interval in seconds'),
+            maxretries: z.coerce.number().optional().describe('Max retries before marking as down'),
+            notificationIDList: z.record(z.string(), z.boolean()).optional().describe('Notification ID map'),
+            tags: z.array(z.object({
+                name: z.string(),
+                value: z.string().optional(),
+                color: z.string().optional(),
+            })).optional().describe('Tags to assign'),
+            keyword: z.string().optional().describe('Keyword to search for'),
+            invertKeyword: z.boolean().optional().describe('Invert keyword match'),
+            method: z.string().optional().describe('HTTP method'),
+            body: z.string().optional().describe('HTTP request body'),
+            headers: z.string().optional().describe('HTTP headers as JSON string'),
+            accepted_statuscodes: z.array(z.string()).optional().describe('Accepted HTTP status codes'),
+            ignoreTls: z.boolean().optional().describe('Ignore TLS/SSL errors'),
+            maxredirects: z.coerce.number().optional().describe('Max HTTP redirects'),
+            upsideDown: z.boolean().optional().describe('Invert status'),
+            active: z.boolean().optional().describe('Whether the monitor is active'),
+            docker_container: z.string().optional().describe('Docker container name (required for docker type)'),
+            docker_host: z.coerce.number().optional().describe('Docker host ID (required for docker type). Use listDockerHosts to find available IDs.'),
+        },
+        outputSchema: {
+            ok: z.boolean(),
+            monitorID: z.number().optional(),
+            msg: z.string().optional(),
+        },
+    }, async ({ monitorID, ...rest }) => {
+        if (!isAuthenticated) {
+            throw new McpError(ErrorCode.InternalError, 'Not authenticated with Uptime Kuma');
+        }
+        try {
+            const existing = client.getMonitor(monitorID, true);
+            if (!existing) {
+                throw new Error(`Monitor ${monitorID} not found`);
+            }
+            // Strip undefined values so existing config is preserved for omitted fields
+            const defined = Object.fromEntries(Object.entries(rest).filter(([, v]) => v !== undefined));
+            const merged = { ...existing, ...defined, id: monitorID };
+            // Ensure retryInterval is valid — Kuma rejects values < 1 on edit even if
+            // it stored 0 during creation (pre-existing monitors or older defaults)
+            if (!merged.retryInterval || merged.retryInterval < 1) {
+                merged.retryInterval = merged.interval || 60;
+            }
+            const response = await client.updateMonitor(merged);
+            return {
+                content: [{ type: 'text', text: response.msg || `Monitor ${monitorID} updated successfully` }],
+                structuredContent: { ok: response.ok, monitorID: response.monitorID, msg: response.msg },
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            throw new McpError(ErrorCode.InternalError, `Failed to update monitor: ${errorMessage}`);
+        }
+    });
+    server.registerTool('deleteMonitor', {
+        title: 'Delete Monitor',
+        description: 'Permanently deletes a monitor and all its heartbeat history. This action cannot be undone.',
+        inputSchema: {
+            monitorID: z.coerce.number().int().nonnegative().describe('The ID of the monitor to delete'),
+        },
+        outputSchema: {
+            ok: z.boolean(),
+            msg: z.string().optional(),
+        },
+    }, async ({ monitorID }) => {
+        if (!isAuthenticated) {
+            throw new McpError(ErrorCode.InternalError, 'Not authenticated with Uptime Kuma');
+        }
+        try {
+            const response = await client.deleteMonitor(monitorID);
+            return {
+                content: [{ type: 'text', text: response.msg || `Monitor ${monitorID} deleted successfully` }],
+                structuredContent: { ok: response.ok, msg: response.msg },
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            throw new McpError(ErrorCode.InternalError, `Failed to delete monitor: ${errorMessage}`);
+        }
+    });
+    // ─── Notification tools ───────────────────────────────────────────────────
+    server.registerTool('listNotifications', {
+        title: 'List Notifications',
+        description: 'Returns all configured notification channels (Slack, ntfy, Discord, email, webhooks, etc.).',
+        inputSchema: {},
+        outputSchema: {
+            notifications: z.array(NotificationSchema).describe('Array of notification channel configurations'),
+            count: z.number(),
+        },
+    }, async () => {
+        if (!isAuthenticated) {
+            throw new McpError(ErrorCode.InternalError, 'Not authenticated with Uptime Kuma');
+        }
+        try {
+            const notifications = client.getNotificationList();
+            return {
+                content: [{ type: 'text', text: JSON.stringify(notifications, null, 2) }],
+                structuredContent: { notifications, count: notifications.length },
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            throw new McpError(ErrorCode.InternalError, `Failed to list notifications: ${errorMessage}`);
+        }
+    });
+    server.registerTool('addNotification', {
+        title: 'Add Notification',
+        description: 'Creates a new notification channel. The configuration fields depend on the notification type (e.g., for slack: webhookURL; for ntfy: ntfyTopic, ntfyServerUrl; for discord: discordWebhookUrl).',
+        inputSchema: {
+            name: z.string().describe('Human-readable name for this notification channel'),
+            type: z.string().describe('Notification type (e.g. slack, ntfy, discord, telegram, webhook, smtp)'),
+            isDefault: z.boolean().optional().describe('Enable by default for new monitors'),
+            applyExisting: z.boolean().optional().describe('Apply this notification to all existing monitors now'),
+            config: z.record(z.string(), z.unknown()).describe('Type-specific configuration fields (e.g. webhookURL for slack, ntfyTopic for ntfy)'),
+        },
+        outputSchema: {
+            ok: z.boolean(),
+            id: z.number().optional(),
+            msg: z.string().optional(),
+        },
+    }, async ({ name, type, isDefault, applyExisting, config }) => {
+        if (!isAuthenticated) {
+            throw new McpError(ErrorCode.InternalError, 'Not authenticated with Uptime Kuma');
+        }
+        try {
+            const notification = { name, type, isDefault, applyExisting, ...config };
+            const response = await client.addNotification(notification);
+            return {
+                content: [{ type: 'text', text: response.msg || `Notification created with ID ${response.id}` }],
+                structuredContent: { ok: response.ok, id: response.id, msg: response.msg },
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            throw new McpError(ErrorCode.InternalError, `Failed to add notification: ${errorMessage}`);
+        }
+    });
+    server.registerTool('updateNotification', {
+        title: 'Update Notification',
+        description: 'Updates an existing notification channel. Use listNotifications to find the notification ID.',
+        inputSchema: {
+            notificationID: z.coerce.number().int().nonnegative().describe('The ID of the notification to update'),
+            name: z.string().optional().describe('Human-readable name'),
+            type: z.string().optional().describe('Notification type'),
+            isDefault: z.boolean().optional().describe('Enable by default for new monitors'),
+            applyExisting: z.boolean().optional().describe('Apply to all existing monitors now'),
+            config: z.record(z.string(), z.unknown()).optional().describe('Type-specific configuration fields to update'),
+        },
+        outputSchema: {
+            ok: z.boolean(),
+            id: z.number().optional(),
+            msg: z.string().optional(),
+        },
+    }, async ({ notificationID, name, type, isDefault, applyExisting, config }) => {
+        if (!isAuthenticated) {
+            throw new McpError(ErrorCode.InternalError, 'Not authenticated with Uptime Kuma');
+        }
+        try {
+            const notification = { ...config };
+            if (name !== undefined)
+                notification['name'] = name;
+            if (type !== undefined)
+                notification['type'] = type;
+            if (isDefault !== undefined)
+                notification['isDefault'] = isDefault;
+            if (applyExisting !== undefined)
+                notification['applyExisting'] = applyExisting;
+            const response = await client.addNotification(notification, notificationID);
+            return {
+                content: [{ type: 'text', text: response.msg || `Notification ${notificationID} updated` }],
+                structuredContent: { ok: response.ok, id: response.id, msg: response.msg },
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            throw new McpError(ErrorCode.InternalError, `Failed to update notification: ${errorMessage}`);
+        }
+    });
+    server.registerTool('deleteNotification', {
+        title: 'Delete Notification',
+        description: 'Permanently deletes a notification channel. Monitors that used this channel will no longer send alerts through it.',
+        inputSchema: {
+            notificationID: z.coerce.number().int().nonnegative().describe('The ID of the notification to delete'),
+        },
+        outputSchema: {
+            ok: z.boolean(),
+            msg: z.string().optional(),
+        },
+    }, async ({ notificationID }) => {
+        if (!isAuthenticated) {
+            throw new McpError(ErrorCode.InternalError, 'Not authenticated with Uptime Kuma');
+        }
+        try {
+            const response = await client.deleteNotification(notificationID);
+            return {
+                content: [{ type: 'text', text: response.msg || `Notification ${notificationID} deleted` }],
+                structuredContent: { ok: response.ok, msg: response.msg },
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            throw new McpError(ErrorCode.InternalError, `Failed to delete notification: ${errorMessage}`);
+        }
+    });
+    // ─── Docker host tools ───────────────────────────────────────────────────
+    server.registerTool('listDockerHosts', {
+        title: 'List Docker Hosts',
+        description: 'Returns all docker daemon connections configured in Uptime Kuma. These are referenced by docker container monitors via docker_host.',
+        inputSchema: {},
+        outputSchema: {
+            dockerHosts: z.array(DockerHostSchema).describe('Array of docker host configurations'),
+            count: z.number(),
+        },
+    }, async () => {
+        if (!isAuthenticated) {
+            throw new McpError(ErrorCode.InternalError, 'Not authenticated with Uptime Kuma');
+        }
+        try {
+            const dockerHosts = client.getDockerHostList();
+            return {
+                content: [{ type: 'text', text: JSON.stringify(dockerHosts, null, 2) }],
+                structuredContent: { dockerHosts, count: dockerHosts.length },
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            throw new McpError(ErrorCode.InternalError, `Failed to list docker hosts: ${errorMessage}`);
+        }
+    });
+    server.registerTool('addDockerHost', {
+        title: 'Add Docker Host',
+        description: 'Creates a new docker daemon connection. For a unix socket use dockerType="socket" and dockerDaemon="/var/run/docker.sock". For a TCP proxy (e.g. tecnativa/docker-socket-proxy) use dockerType="tcp" and dockerDaemon="http://host:2375". Consider calling testDockerHost first to verify reachability.',
+        inputSchema: {
+            name: z.string().describe('Human-readable name for this docker host'),
+            dockerType: z.enum(['socket', 'tcp']).describe('"socket" for a unix socket path, "tcp" for an HTTP/HTTPS URL'),
+            dockerDaemon: z.string().describe('Unix socket path (e.g. /var/run/docker.sock) when dockerType=socket, or TCP URL (e.g. http://docker-proxy:2375) when dockerType=tcp'),
+        },
+        outputSchema: {
+            ok: z.boolean(),
+            id: z.number().optional(),
+            msg: z.string().optional(),
+        },
+    }, async ({ name, dockerType, dockerDaemon }) => {
+        if (!isAuthenticated) {
+            throw new McpError(ErrorCode.InternalError, 'Not authenticated with Uptime Kuma');
+        }
+        try {
+            const response = await client.addDockerHost({ name, dockerType, dockerDaemon });
+            return {
+                content: [{ type: 'text', text: response.msg || `Docker host created with ID ${response.id}` }],
+                structuredContent: { ok: response.ok, id: response.id, msg: response.msg },
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            throw new McpError(ErrorCode.InternalError, `Failed to add docker host: ${errorMessage}`);
+        }
+    });
+    server.registerTool('updateDockerHost', {
+        title: 'Update Docker Host',
+        description: 'Updates an existing docker daemon connection. Use listDockerHosts to find the docker host ID. Only the fields you pass are changed — the others are preserved.',
+        inputSchema: {
+            dockerHostID: z.coerce.number().int().nonnegative().describe('The ID of the docker host to update'),
+            name: z.string().optional().describe('New human-readable name'),
+            dockerType: z.enum(['socket', 'tcp']).optional().describe('New connection type'),
+            dockerDaemon: z.string().optional().describe('New socket path or TCP URL'),
+        },
+        outputSchema: {
+            ok: z.boolean(),
+            id: z.number().optional(),
+            msg: z.string().optional(),
+        },
+    }, async ({ dockerHostID, name, dockerType, dockerDaemon }) => {
+        if (!isAuthenticated) {
+            throw new McpError(ErrorCode.InternalError, 'Not authenticated with Uptime Kuma');
+        }
+        try {
+            // Merge new values onto the current record so callers can omit unchanged fields.
+            // Uptime Kuma's addDockerHost handler overwrites every column it receives, so we
+            // need to send the full set to avoid clobbering existing values with undefined.
+            const existing = client.getDockerHostList().find(h => h.id === dockerHostID);
+            if (!existing) {
+                throw new Error(`Docker host ${dockerHostID} not found — call listDockerHosts to see available IDs`);
+            }
+            const merged = {
+                name: name ?? existing.name,
+                dockerType: dockerType ?? existing.dockerType,
+                dockerDaemon: dockerDaemon ?? existing.dockerDaemon,
+            };
+            const response = await client.addDockerHost(merged, dockerHostID);
+            return {
+                content: [{ type: 'text', text: response.msg || `Docker host ${dockerHostID} updated` }],
+                structuredContent: { ok: response.ok, id: response.id, msg: response.msg },
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            throw new McpError(ErrorCode.InternalError, `Failed to update docker host: ${errorMessage}`);
+        }
+    });
+    server.registerTool('deleteDockerHost', {
+        title: 'Delete Docker Host',
+        description: 'Permanently deletes a docker daemon connection. Any monitors referencing it will have their docker_host cleared by Uptime Kuma (the monitors themselves are not deleted).',
+        inputSchema: {
+            dockerHostID: z.coerce.number().int().nonnegative().describe('The ID of the docker host to delete'),
+        },
+        outputSchema: {
+            ok: z.boolean(),
+            msg: z.string().optional(),
+        },
+    }, async ({ dockerHostID }) => {
+        if (!isAuthenticated) {
+            throw new McpError(ErrorCode.InternalError, 'Not authenticated with Uptime Kuma');
+        }
+        try {
+            const response = await client.deleteDockerHost(dockerHostID);
+            return {
+                content: [{ type: 'text', text: response.msg || `Docker host ${dockerHostID} deleted` }],
+                structuredContent: { ok: response.ok, msg: response.msg },
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            throw new McpError(ErrorCode.InternalError, `Failed to delete docker host: ${errorMessage}`);
+        }
+    });
+    server.registerTool('testDockerHost', {
+        title: 'Test Docker Host',
+        description: 'Tests connectivity to a docker daemon without persisting it. On success the message includes the number of containers. Use this before addDockerHost to avoid saving a broken configuration.',
+        inputSchema: {
+            name: z.string().describe('Display name (used only in the test request)'),
+            dockerType: z.enum(['socket', 'tcp']).describe('"socket" for a unix socket path, "tcp" for an HTTP/HTTPS URL'),
+            dockerDaemon: z.string().describe('Unix socket path or TCP URL to probe'),
+        },
+        outputSchema: {
+            ok: z.boolean(),
+            msg: z.string().optional(),
+        },
+    }, async ({ name, dockerType, dockerDaemon }) => {
+        if (!isAuthenticated) {
+            throw new McpError(ErrorCode.InternalError, 'Not authenticated with Uptime Kuma');
+        }
+        try {
+            const response = await client.testDockerHost({ name, dockerType, dockerDaemon });
+            return {
+                content: [{ type: 'text', text: response.msg || (response.ok ? 'Docker host reachable' : 'Docker host unreachable') }],
+                structuredContent: { ok: response.ok, msg: response.msg },
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            throw new McpError(ErrorCode.InternalError, `Failed to test docker host: ${errorMessage}`);
+        }
+    });
+    // ─── Tag tools ───────────────────────────────────────────────────────────
+    server.registerTool('listTags', {
+        title: 'List Tags',
+        description: 'Returns all tags defined in Uptime Kuma (name, color, and ID).',
+        inputSchema: {},
+        outputSchema: {
+            tags: z.array(z.object({
+                id: z.number(),
+                name: z.string(),
+                color: z.string(),
+            })).describe('Array of tags'),
+            count: z.number(),
+        },
+    }, async () => {
+        if (!isAuthenticated) {
+            throw new McpError(ErrorCode.InternalError, 'Not authenticated with Uptime Kuma');
+        }
+        try {
+            const tags = client.getTagList();
+            return {
+                content: [{ type: 'text', text: JSON.stringify(tags, null, 2) }],
+                structuredContent: { tags, count: tags.length },
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            throw new McpError(ErrorCode.InternalError, `Failed to list tags: ${errorMessage}`);
+        }
+    });
+    server.registerTool('addTag', {
+        title: 'Add Tag',
+        description: 'Creates a new tag that can be assigned to monitors.',
+        inputSchema: {
+            name: z.string().describe('Tag name'),
+            color: z.string().describe('Tag color as a hex string (e.g. "#ff0000") or CSS color name'),
+        },
+        outputSchema: {
+            ok: z.boolean(),
+            tag: z.object({ id: z.number(), name: z.string(), color: z.string() }).optional(),
+            msg: z.string().optional(),
+        },
+    }, async ({ name, color }) => {
+        if (!isAuthenticated) {
+            throw new McpError(ErrorCode.InternalError, 'Not authenticated with Uptime Kuma');
+        }
+        try {
+            const response = await client.addTag(name, color);
+            return {
+                content: [{ type: 'text', text: `Tag "${name}" created with ID ${response.tag?.id}` }],
+                structuredContent: { ok: response.ok, tag: response.tag, msg: response.msg },
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            throw new McpError(ErrorCode.InternalError, `Failed to add tag: ${errorMessage}`);
+        }
+    });
+    server.registerTool('deleteTag', {
+        title: 'Delete Tag',
+        description: 'Permanently deletes a tag. It will be removed from all monitors that use it. Use listTags to find the tag ID.',
+        inputSchema: {
+            tagID: z.coerce.number().int().nonnegative().describe('The ID of the tag to delete'),
+        },
+        outputSchema: {
+            ok: z.boolean(),
+            msg: z.string().optional(),
+        },
+    }, async ({ tagID }) => {
+        if (!isAuthenticated) {
+            throw new McpError(ErrorCode.InternalError, 'Not authenticated with Uptime Kuma');
+        }
+        try {
+            const response = await client.deleteTag(tagID);
+            return {
+                content: [{ type: 'text', text: response.msg || `Tag ${tagID} deleted` }],
+                structuredContent: { ok: response.ok, msg: response.msg },
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            throw new McpError(ErrorCode.InternalError, `Failed to delete tag: ${errorMessage}`);
+        }
+    });
+    // ─── Maintenance tools ────────────────────────────────────────────────────
+    server.registerTool('getMaintenanceWindows', {
+        title: 'Get Maintenance Windows',
+        description: 'Returns all scheduled maintenance windows defined in Uptime Kuma.',
+        inputSchema: {},
+        outputSchema: {
+            maintenanceWindows: z.array(MaintenanceSchema).describe('Array of maintenance windows'),
+            count: z.number(),
+        },
+    }, async () => {
+        if (!isAuthenticated) {
+            throw new McpError(ErrorCode.InternalError, 'Not authenticated with Uptime Kuma');
+        }
+        try {
+            const maintenanceWindows = client.getMaintenanceList();
+            return {
+                content: [{ type: 'text', text: JSON.stringify(maintenanceWindows, null, 2) }],
+                structuredContent: { maintenanceWindows, count: maintenanceWindows.length },
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            throw new McpError(ErrorCode.InternalError, `Failed to get maintenance windows: ${errorMessage}`);
+        }
+    });
+    server.registerTool('createMaintenance', {
+        title: 'Create Maintenance',
+        description: 'Schedules a new maintenance window. During maintenance, affected monitors are suppressed and show MAINTENANCE status instead of DOWN.',
+        inputSchema: {
+            title: z.string().describe('Title of the maintenance window'),
+            description: z.string().default('').describe('Description or reason for the maintenance'),
+            strategy: z.enum(['single', 'recurring-interval', 'recurring-weekday', 'recurring-day-of-month', 'manual'])
+                .describe('Scheduling strategy: single=one-time, recurring-interval=every N days, recurring-weekday=specific weekdays, recurring-day-of-month=specific dates, manual=manually activated'),
+            active: z.boolean().optional().describe('Whether the window is active (default: true)'),
+            timezone: z.string().optional().describe('Timezone (e.g. "America/New_York", "UTC"). Defaults to server timezone.'),
+            dateRange: z.array(z.string()).optional().describe('Date range as [startISO, endISO] (required for single strategy)'),
+            timeRange: z.array(z.object({ hours: z.coerce.number(), minutes: z.coerce.number() })).optional()
+                .describe('Start and end time within the day as [{hours, minutes}, {hours, minutes}]'),
+            weekdays: z.array(z.coerce.number().int().min(0).max(6)).optional()
+                .describe('Days of week (0=Sunday … 6=Saturday) for recurring-weekday strategy'),
+            daysOfMonth: z.array(z.coerce.number().int().min(1).max(31)).optional()
+                .describe('Days of month (1-31) for recurring-day-of-month strategy'),
+            intervalDay: z.coerce.number().int().positive().optional()
+                .describe('Interval in days for recurring-interval strategy'),
+        },
+        outputSchema: {
+            ok: z.boolean(),
+            maintenanceID: z.number().optional(),
+            msg: z.string().optional(),
+        },
+    }, async (input) => {
+        if (!isAuthenticated) {
+            throw new McpError(ErrorCode.InternalError, 'Not authenticated with Uptime Kuma');
+        }
+        try {
+            const response = await client.createMaintenance(input);
+            return {
+                content: [{ type: 'text', text: response.msg || `Maintenance window created with ID ${response.maintenanceID}` }],
+                structuredContent: { ok: response.ok, maintenanceID: response.maintenanceID, msg: response.msg },
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            throw new McpError(ErrorCode.InternalError, `Failed to create maintenance window: ${errorMessage}`);
+        }
+    });
+    // ─── Status page tools ────────────────────────────────────────────────────
+    server.registerTool('listStatusPages', {
+        title: 'List Status Pages',
+        description: 'Returns all configured status pages with their slug, title, visibility, and custom domain settings.',
+        inputSchema: {},
+        outputSchema: {
+            statusPages: z.array(StatusPageSchema).describe('Array of status page configurations'),
+            count: z.number(),
+        },
+    }, async () => {
+        if (!isAuthenticated) {
+            throw new McpError(ErrorCode.InternalError, 'Not authenticated with Uptime Kuma');
+        }
+        try {
+            const statusPages = client.getStatusPageList();
+            return {
+                content: [{ type: 'text', text: JSON.stringify(statusPages, null, 2) }],
+                structuredContent: { statusPages, count: statusPages.length },
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            throw new McpError(ErrorCode.InternalError, `Failed to list status pages: ${errorMessage}`);
+        }
+    });
+    server.registerTool('getStatusPage', {
+        title: 'Get Status Page',
+        description: 'Returns the full configuration of a status page by slug, including the ordered list of groups, the monitors inside each group, and active incidents. Only works for published status pages (fetches the public `/api/status-page/{slug}` endpoint).',
+        inputSchema: {
+            slug: z.string().describe('The status page slug (the URL-safe identifier)'),
+        },
+        outputSchema: {
+            ok: z.boolean(),
+            config: StatusPageSchema.optional(),
+            publicGroupList: z.array(z.record(z.string(), z.unknown())).optional().describe('Ordered groups with their monitorList'),
+            incidents: z.array(z.record(z.string(), z.unknown())).optional().describe('Active incidents on the status page'),
+            msg: z.string().optional(),
+        },
+    }, async ({ slug }) => {
+        if (!isAuthenticated) {
+            throw new McpError(ErrorCode.InternalError, 'Not authenticated with Uptime Kuma');
+        }
+        try {
+            const response = await client.getStatusPage(slug);
+            return {
+                content: [{ type: 'text', text: JSON.stringify(response, null, 2) }],
+                structuredContent: {
+                    ok: response.ok,
+                    config: response.config,
+                    publicGroupList: response.publicGroupList,
+                    incidents: response.incidents,
+                    msg: response.msg,
+                },
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            throw new McpError(ErrorCode.InternalError, `Failed to get status page: ${errorMessage}`);
+        }
+    });
+    server.registerTool('createStatusPage', {
+        title: 'Create Status Page',
+        description: 'Creates a new (empty) status page with the given title and slug. After creating, call updateStatusPage to set the description, theme, groups, and monitors. Slug must be lowercase letters, digits, and dashes only.',
+        inputSchema: {
+            title: z.string().describe('Display title of the status page'),
+            slug: z.string().regex(/^[a-z0-9-]+$/).describe('URL slug (lowercase letters, digits, and dashes only)'),
+        },
+        outputSchema: {
+            ok: z.boolean(),
+            msg: z.string().optional(),
+        },
+    }, async ({ title, slug }) => {
+        if (!isAuthenticated) {
+            throw new McpError(ErrorCode.InternalError, 'Not authenticated with Uptime Kuma');
+        }
+        try {
+            const response = await client.createStatusPage(title, slug);
+            return {
+                content: [{ type: 'text', text: response.msg || `Status page ${slug} created` }],
+                structuredContent: { ok: response.ok, msg: response.msg },
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            throw new McpError(ErrorCode.InternalError, `Failed to create status page: ${errorMessage}`);
+        }
+    });
+    server.registerTool('updateStatusPage', {
+        title: 'Update Status Page',
+        description: 'Updates an existing status page. Pass the full config (title, description, theme, published, etc.) and the full publicGroupList — both are replaced wholesale. Each group has a name, weight, and monitorList of [{id}]. Use getStatusPage first to read current state before modifying.',
+        inputSchema: {
+            slug: z.string().describe('The status page slug (immutable identifier)'),
+            config: z.record(z.string(), z.unknown()).describe('Full status page config (title, description, theme, published, showTags, showPoweredBy, domainNameList, customCSS, footerText, icon, etc.)'),
+            publicGroupList: z.array(z.record(z.string(), z.unknown())).optional().describe('Ordered groups. Each: {name, weight, monitorList: [{id}]}. Defaults to empty list.'),
+            imgDataUrl: z.string().optional().describe('Icon as data URL. Omit or pass empty string to keep existing.'),
+        },
+        outputSchema: {
+            ok: z.boolean(),
+            msg: z.string().optional(),
+        },
+    }, async ({ slug, config, publicGroupList, imgDataUrl }) => {
+        if (!isAuthenticated) {
+            throw new McpError(ErrorCode.InternalError, 'Not authenticated with Uptime Kuma');
+        }
+        try {
+            const response = await client.updateStatusPage(slug, config, publicGroupList ?? [], imgDataUrl ?? '');
+            return {
+                content: [{ type: 'text', text: response.msg || `Status page ${slug} updated` }],
+                structuredContent: { ok: response.ok, msg: response.msg },
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            throw new McpError(ErrorCode.InternalError, `Failed to update status page: ${errorMessage}`);
+        }
+    });
+    server.registerTool('deleteStatusPage', {
+        title: 'Delete Status Page',
+        description: 'Permanently deletes a status page by slug. The status page URL will no longer be accessible.',
+        inputSchema: {
+            slug: z.string().describe('The status page slug to delete'),
+        },
+        outputSchema: {
+            ok: z.boolean(),
+            msg: z.string().optional(),
+        },
+    }, async ({ slug }) => {
+        if (!isAuthenticated) {
+            throw new McpError(ErrorCode.InternalError, 'Not authenticated with Uptime Kuma');
+        }
+        try {
+            const response = await client.deleteStatusPage(slug);
+            return {
+                content: [{ type: 'text', text: response.msg || `Status page ${slug} deleted` }],
+                structuredContent: { ok: response.ok, msg: response.msg },
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            throw new McpError(ErrorCode.InternalError, `Failed to delete status page: ${errorMessage}`);
+        }
+    });
     // Clean up on server shutdown
     process.on('SIGINT', () => {
         client.disconnect();