@davidfuchs/mcp-uptime-kuma 0.7.0 → 0.10.0

package/README.md

@@ -86,16 +86,56 @@ See [Authentication Methods](#authentication-methods) for JWT token and anonymou
 
 ## Available Tools
 
+### Monitors
+
 | Tool | Purpose |
 |------|---------|
 | `getMonitorSummary` | Get a quick overview of all monitors with their current status. Supports filtering. |
 | `listMonitors` | Get the full list of all monitors with configurations. Supports filtering. |
 | `listMonitorTypes` | Get all available monitor types supported by Uptime Kuma. |
 | `getMonitor` | Get detailed configuration for a specific monitor by ID. |
+| `createMonitor` | Create a new monitor (requires name and type at minimum). |
+| `updateMonitor` | Update an existing monitor's configuration. |
+| `deleteMonitor` | Permanently delete a monitor and all its heartbeat history. |
 | `pauseMonitor` | Pause a monitor to stop performing checks. |
 | `resumeMonitor` | Resume a paused monitor to restart checks. |
+
+### Heartbeats
+
+| Tool | Purpose |
+|------|---------|
 | `listHeartbeats` | Get status check history for all monitors. |
 | `getHeartbeats` | Get status check history for a specific monitor. |
+
+### Notifications
+
+| Tool | Purpose |
+|------|---------|
+| `listNotifications` | List all configured notification channels (Slack, Discord, email, webhooks, etc.). |
+| `addNotification` | Create a new notification channel. |
+| `updateNotification` | Update an existing notification channel. |
+| `deleteNotification` | Permanently delete a notification channel. |
+
+### Tags
+
+| Tool | Purpose |
+|------|---------|
+| `listTags` | List all tags defined in Uptime Kuma. |
+| `addTag` | Create a new tag that can be assigned to monitors. |
+| `deleteTag` | Permanently delete a tag (removes it from all monitors). |
+
+### Maintenance
+
+| Tool | Purpose |
+|------|---------|
+| `getMaintenanceWindows` | List all scheduled maintenance windows. |
+| `createMaintenance` | Schedule a new maintenance window. |
+
+### Status Pages & Settings
+
+| Tool | Purpose |
+|------|---------|
+| `listStatusPages` | List all configured status pages. |
 | `getSettings` | Get Uptime Kuma server settings. |
 
 ### Filtering
@@ -167,12 +207,19 @@ mcpServers:
 ```
 
 **streamable HTTP transport:**
+
+Update the allowed domains to whatever domain you're using in the URL (e.g., `localhost` or `host.docker.internal` for Docker setups):
+
 ```yaml
 mcpServers:
   uptime-kuma:
     type: streamable-http
     url: "http://mcp-uptime-kuma:3000/mcp"
     serverInstructions: true
+
+mcpSettings:
+  allowedDomains:
+    - 'mcp-uptime-kuma'
 ```
 
 ## Contributing

package/dist/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAGpE,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAE3D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAGzD;;;GAGG;AACH,wBAAsB,YAAY,CAAC,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAAC;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,MAAM,EAAE,gBAAgB,CAAC;IAAC,kBAAkB,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CAAE,CAAC,CA2gC9J"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAGpE,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAE3D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAGzD;;;GAGG;AACH,wBAAsB,YAAY,CAAC,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAAC;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,MAAM,EAAE,gBAAgB,CAAC;IAAC,kBAAkB,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CAAE,CAAC,CAs2C9J"}

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, NotificationSchema, MaintenanceSchema, StatusPageSchema } 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
@@ -25,13 +25,17 @@ export async function createServer(config) {
         - 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.
+        - 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: {
@@ -436,6 +440,10 @@ export async function createServer(config) {
             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.'),
+            dns_resolve_server: z.string().optional().describe('DNS server to use for resolution (required for dns type, default: 1.1.1.1)'),
+            dns_resolve_type: z.enum(['A', 'AAAA', 'CNAME', 'MX', 'NS', 'PTR', 'SOA', 'SRV', 'TXT', 'CAA']).optional().describe('DNS record type to query (required for dns type, default: A)'),
         },
         outputSchema: {
             ok: z.boolean(),
@@ -447,10 +455,18 @@ export async function createServer(config) {
             throw new McpError(ErrorCode.InternalError, 'Not authenticated with Uptime Kuma');
         }
         try {
-            const monitorData = {
+            const defaults = {
                 notificationIDList: {},
                 accepted_statuscodes: ['200-299'],
                 conditions: [],
+                retryInterval: 60,
+            };
+            if (input.type === 'dns') {
+                defaults.dns_resolve_server = '1.1.1.1';
+                defaults.dns_resolve_type = 'A';
+            }
+            const monitorData = {
+                ...defaults,
                 ...input,
             };
             const response = await client.createMonitor(monitorData);
@@ -492,6 +508,10 @@ export async function createServer(config) {
             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.'),
+            dns_resolve_server: z.string().optional().describe('DNS server to use for resolution (for dns type)'),
+            dns_resolve_type: z.enum(['A', 'AAAA', 'CNAME', 'MX', 'NS', 'PTR', 'SOA', 'SRV', 'TXT', 'CAA']).optional().describe('DNS record type to query (for dns type)'),
         },
         outputSchema: {
             ok: z.boolean(),
@@ -507,7 +527,14 @@ export async function createServer(config) {
             if (!existing) {
                 throw new Error(`Monitor ${monitorID} not found`);
             }
-            const merged = { ...existing, ...rest, id: monitorID };
+            // 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` }],
@@ -669,6 +696,156 @@ export async function createServer(config) {
             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',
@@ -687,7 +864,7 @@ export async function createServer(config) {
             throw new McpError(ErrorCode.InternalError, 'Not authenticated with Uptime Kuma');
         }
         try {
-            const tags = client.getTagList();
+            const tags = await client.getTagList();
             return {
                 content: [{ type: 'text', text: JSON.stringify(tags, null, 2) }],
                 structuredContent: { tags, count: tags.length },
@@ -782,7 +959,7 @@ export async function createServer(config) {
         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().optional().describe('Description or reason for the maintenance'),
+            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)'),
@@ -843,6 +1020,123 @@ export async function createServer(config) {
             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();