@davidfuchs/mcp-uptime-kuma 0.6.4 → 0.9.0

package/dist/uptime-kuma-client.js

@@ -26,8 +26,14 @@ export class UptimeKumaClient {
     heartbeatListCache = {};
     uptimeCache = {};
     avgPingCache = {};
+    notificationListCache = {};
+    tagListCache = [];
+    maintenanceListCache = {};
+    statusPageListCache = {};
+    dockerHostListCache = [];
     server;
     shouldLog;
+    loginCredentials = null;
     constructor(url, server, shouldLog) {
         this.url = url;
         this.server = server;
@@ -55,18 +61,69 @@ export class UptimeKumaClient {
             this.socket = io(this.url, {
                 reconnection: true,
                 reconnectionDelay: 1000,
-                reconnectionAttempts: 5,
+                reconnectionAttempts: Infinity,
             });
+            let initialConnect = true;
             this.socket.on('connect', () => {
-                this.safeLog('info', 'Successfully connected to Uptime Kuma server');
-                resolve();
+                if (initialConnect) {
+                    initialConnect = false;
+                    this.safeLog('info', 'Successfully connected to Uptime Kuma server');
+                    resolve();
+                }
+                else {
+                    this.safeLog('info', 'Reconnected to Uptime Kuma server, re-authenticating...');
+                    this.reauthenticate();
+                }
             });
             this.socket.on('connect_error', (error) => {
                 this.safeLog('error', `Connection error: ${error.message}`);
-                reject(new Error(`Connection failed: ${error.message}`));
+                if (initialConnect) {
+                    reject(new Error(`Connection failed: ${error.message}`));
+                }
             });
         });
     }
+    /**
+     * Re-authenticate after a reconnection to refresh all cached data.
+     * When the server restarts or the connection drops, Socket.IO reconnects
+     * the transport but the server no longer considers the client authenticated.
+     * Without re-emitting login, the server won't send monitorList or heartbeat
+     * events, leaving the cache permanently stale.
+     */
+    reauthenticate() {
+        if (!this.socket || !this.loginCredentials)
+            return;
+        // Clear stale caches so they are fully replaced by fresh data from the server
+        this.monitorListCache = {};
+        this.heartbeatListCache = {};
+        this.uptimeCache = {};
+        this.avgPingCache = {};
+        const { username, password, token, jwtToken } = this.loginCredentials;
+        if (jwtToken) {
+            this.socket.emit('loginByToken', jwtToken, (response) => {
+                if (response.ok) {
+                    this.safeLog('info', 'Re-authenticated after reconnection (JWT)');
+                }
+                else {
+                    this.safeLog('error', `Re-authentication failed: ${response.msg || 'unknown error'}`);
+                }
+            });
+        }
+        else if (username) {
+            this.socket.emit('login', { username, password, token }, (response) => {
+                if (response.ok) {
+                    this.safeLog('info', 'Re-authenticated after reconnection');
+                }
+                else {
+                    this.safeLog('error', `Re-authentication failed: ${response.msg || 'unknown error'}`);
+                }
+            });
+        }
+        else {
+            this.socket.emit('login');
+            this.safeLog('info', 'Re-authenticated after reconnection (anonymous)');
+        }
+    }
     /**
      * Disconnect from the Uptime Kuma server
      */
@@ -78,6 +135,11 @@ export class UptimeKumaClient {
             this.socket.off('deleteMonitorFromList');
             this.socket.off('heartbeatList');
             this.socket.off('heartbeat');
+            this.socket.off('notificationList');
+            this.socket.off('tagList');
+            this.socket.off('maintenanceList');
+            this.socket.off('statusPageList');
+            this.socket.off('dockerHostList');
             this.socket.disconnect();
             this.socket = null;
         }
@@ -86,6 +148,11 @@ export class UptimeKumaClient {
         this.heartbeatListCache = {};
         this.uptimeCache = {};
         this.avgPingCache = {};
+        this.notificationListCache = {};
+        this.tagListCache = [];
+        this.maintenanceListCache = {};
+        this.statusPageListCache = {};
+        this.dockerHostListCache = [];
     }
     /**
      * Login using username and password, or JWT token
@@ -102,11 +169,18 @@ export class UptimeKumaClient {
                 reject(new Error('Not connected to server'));
                 return;
             }
+            // Store credentials for re-authentication on reconnect
+            this.loginCredentials = { username, password, token, jwtToken };
             // Set up listeners for monitor list and heartbeat updates before login
             this.setupMonitorListListeners();
             this.setupHeartbeatListeners();
             this.setupUptimeListeners();
             this.setupAvgPingListeners();
+            this.setupNotificationListListeners();
+            this.setupTagListListeners();
+            this.setupMaintenanceListListeners();
+            this.setupStatusPageListListeners();
+            this.setupDockerHostListListeners();
             // If JWT token is provided, use token-based authentication
             if (jwtToken) {
                 this.socket.emit('loginByToken', jwtToken, (response) => {
@@ -528,6 +602,565 @@ export class UptimeKumaClient {
         }
         return summaries;
     }
+    // ─── New listener setup methods ────────────────────────────────────────────
+    setupNotificationListListeners() {
+        if (!this.socket)
+            return;
+        this.socket.on('notificationList', (notificationList) => {
+            this.safeLog('debug', `Received notificationList with ${Object.keys(notificationList).length} notifications`);
+            this.notificationListCache = notificationList;
+        });
+    }
+    setupTagListListeners() {
+        if (!this.socket)
+            return;
+        this.socket.on('tagList', (tagList) => {
+            this.safeLog('debug', `Received tagList with ${tagList.length} tags`);
+            this.tagListCache = tagList;
+        });
+    }
+    setupMaintenanceListListeners() {
+        if (!this.socket)
+            return;
+        this.socket.on('maintenanceList', (maintenanceList) => {
+            this.safeLog('debug', `Received maintenanceList with ${Object.keys(maintenanceList).length} windows`);
+            this.maintenanceListCache = maintenanceList;
+        });
+    }
+    setupStatusPageListListeners() {
+        if (!this.socket)
+            return;
+        this.socket.on('statusPageList', (statusPageList) => {
+            this.safeLog('debug', `Received statusPageList with ${Object.keys(statusPageList).length} status pages`);
+            this.statusPageListCache = statusPageList;
+        });
+    }
+    setupDockerHostListListeners() {
+        if (!this.socket)
+            return;
+        this.socket.on('dockerHostList', (dockerHostList) => {
+            this.safeLog('debug', `Received dockerHostList with ${dockerHostList.length} docker hosts`);
+            this.dockerHostListCache = dockerHostList;
+        });
+    }
+    // ─── Monitor write operations ───────────────────────────────────────────────
+    /**
+     * Create a new monitor. If `tags` are supplied, they are applied after
+     * creation using the separate `addMonitorTag` socket event — the `add`
+     * socket handler does not process tags.
+     *
+     * @param monitorData - Monitor configuration (type-specific fields should be included)
+     * @returns Promise resolving to the API response with the new monitorID
+     */
+    async createMonitor(monitorData) {
+        const { tags, ...payload } = monitorData;
+        const response = await new Promise((resolve, reject) => {
+            if (!this.socket || !this.socket.connected) {
+                reject(new Error('Not connected to server'));
+                return;
+            }
+            this.socket.emit('add', payload, (res) => {
+                if (res.ok) {
+                    this.safeLog('info', `Successfully created monitor (ID: ${res.monitorID})`);
+                    resolve(res);
+                }
+                else {
+                    reject(new Error(res.msg || 'Failed to create monitor'));
+                }
+            });
+        });
+        if (tags && Array.isArray(tags) && response.monitorID != null) {
+            await this.reconcileMonitorTags(response.monitorID, tags);
+        }
+        return response;
+    }
+    /**
+     * Update an existing monitor. If `tags` are supplied, they are reconciled
+     * against the monitor's current tag set using `addMonitorTag` /
+     * `deleteMonitorTag` — the `editMonitor` socket handler does not process
+     * tags. Tags whose name is not yet in the catalog are auto-created via
+     * `addTag` before binding.
+     *
+     * @param monitorData - Monitor configuration including the id field
+     * @returns Promise resolving to the API response
+     */
+    async updateMonitor(monitorData) {
+        const { tags, ...payload } = monitorData;
+        const response = await new Promise((resolve, reject) => {
+            if (!this.socket || !this.socket.connected) {
+                reject(new Error('Not connected to server'));
+                return;
+            }
+            this.socket.emit('editMonitor', payload, (res) => {
+                if (res.ok) {
+                    this.safeLog('info', `Successfully updated monitor (ID: ${monitorData['id']})`);
+                    resolve(res);
+                }
+                else {
+                    reject(new Error(res.msg || 'Failed to update monitor'));
+                }
+            });
+        });
+        if (tags && Array.isArray(tags) && monitorData['id'] != null) {
+            await this.reconcileMonitorTags(Number(monitorData['id']), tags);
+        }
+        return response;
+    }
+    /**
+     * Fetch the tag catalog synchronously from the server. Uptime Kuma does
+     * not push `tagList` events — it only responds to the `getTags` request —
+     * so relying on the push-populated cache returns stale (often empty) data.
+     * This method also refreshes `tagListCache` so subsequent cache reads work.
+     */
+    fetchTagList() {
+        return new Promise((resolve, reject) => {
+            if (!this.socket || !this.socket.connected) {
+                reject(new Error('Not connected to server'));
+                return;
+            }
+            this.socket.emit('getTags', (res) => {
+                if (res.ok && res.tags) {
+                    this.tagListCache = res.tags;
+                    resolve(res.tags);
+                }
+                else {
+                    reject(new Error(res.msg || 'Failed to fetch tag list'));
+                }
+            });
+        });
+    }
+    /**
+     * Bind a tag to a monitor (socket: `addMonitorTag`).
+     */
+    addMonitorTag(tagID, monitorID, value) {
+        return new Promise((resolve, reject) => {
+            if (!this.socket || !this.socket.connected) {
+                reject(new Error('Not connected to server'));
+                return;
+            }
+            this.socket.emit('addMonitorTag', tagID, monitorID, value, (res) => {
+                if (res.ok)
+                    resolve(res);
+                else
+                    reject(new Error(res.msg || `Failed to add tag ${tagID} to monitor ${monitorID}`));
+            });
+        });
+    }
+    /**
+     * Unbind a tag from a monitor (socket: `deleteMonitorTag`).
+     */
+    deleteMonitorTag(tagID, monitorID, value) {
+        return new Promise((resolve, reject) => {
+            if (!this.socket || !this.socket.connected) {
+                reject(new Error('Not connected to server'));
+                return;
+            }
+            this.socket.emit('deleteMonitorTag', tagID, monitorID, value, (res) => {
+                if (res.ok)
+                    resolve(res);
+                else
+                    reject(new Error(res.msg || `Failed to remove tag ${tagID} from monitor ${monitorID}`));
+            });
+        });
+    }
+    /**
+     * Reconcile a monitor's tags against the desired list. Auto-creates any
+     * tag name that isn't yet in the catalog. Tag identity is `(name, value)`.
+     */
+    async reconcileMonitorTags(monitorID, desiredTags) {
+        const currentMonitor = this.monitorListCache[String(monitorID)];
+        const currentTags = (currentMonitor?.tags ?? []);
+        const key = (name, value) => `${name}\u0000${value ?? ''}`;
+        const currentKeys = new Set(currentTags.map((t) => key(t.name, t.value)));
+        const desiredKeys = new Set(desiredTags.map((t) => key(String(t.name), t.value)));
+        // Uptime Kuma never pushes `tagList` events, so the cache is unreliable
+        // — fetch the catalog synchronously via the `getTags` socket request.
+        const freshTags = await this.fetchTagList();
+        const nameToID = new Map();
+        for (const t of freshTags)
+            nameToID.set(t.name, t.id);
+        for (const desired of desiredTags) {
+            const name = String(desired.name);
+            const value = desired.value ?? '';
+            if (currentKeys.has(key(name, value)))
+                continue;
+            let tagID = nameToID.get(name);
+            if (tagID == null) {
+                const color = desired.color ?? '#808080';
+                const created = await this.addTag(name, color);
+                tagID = created.tag?.id;
+                if (tagID != null)
+                    nameToID.set(name, tagID);
+            }
+            if (tagID == null) {
+                throw new Error(`Could not resolve tag ID for "${name}"`);
+            }
+            await this.addMonitorTag(tagID, monitorID, value);
+        }
+        for (const existing of currentTags) {
+            if (desiredKeys.has(key(existing.name, existing.value)))
+                continue;
+            const tagID = existing.tag_id ?? nameToID.get(existing.name);
+            if (tagID == null)
+                continue;
+            await this.deleteMonitorTag(tagID, monitorID, existing.value ?? '');
+        }
+    }
+    /**
+     * Delete a monitor
+     *
+     * @param monitorID - The ID of the monitor to delete
+     * @returns Promise resolving to the API response
+     */
+    deleteMonitor(monitorID) {
+        return new Promise((resolve, reject) => {
+            if (!this.socket || !this.socket.connected) {
+                reject(new Error('Not connected to server'));
+                return;
+            }
+            this.socket.emit('deleteMonitor', monitorID, (response) => {
+                if (response.ok) {
+                    this.safeLog('info', `Successfully deleted monitor ${monitorID}`);
+                    resolve(response);
+                }
+                else {
+                    reject(new Error(response.msg || 'Failed to delete monitor'));
+                }
+            });
+        });
+    }
+    // ─── Notification operations ────────────────────────────────────────────────
+    /**
+     * Get the cached notification list
+     */
+    getNotificationList() {
+        return Object.values(this.notificationListCache);
+    }
+    /**
+     * Add or update a notification channel
+     *
+     * @param notification - Notification configuration
+     * @param notificationID - If provided, updates existing; otherwise creates new
+     * @returns Promise resolving to the API response with the notification id
+     */
+    addNotification(notification, notificationID) {
+        return new Promise((resolve, reject) => {
+            if (!this.socket || !this.socket.connected) {
+                reject(new Error('Not connected to server'));
+                return;
+            }
+            const id = notificationID ?? null;
+            this.socket.emit('addNotification', notification, id, (response) => {
+                if (response.ok) {
+                    this.safeLog('info', `Successfully saved notification (ID: ${response.id})`);
+                    resolve(response);
+                }
+                else {
+                    reject(new Error(response.msg || 'Failed to save notification'));
+                }
+            });
+        });
+    }
+    /**
+     * Delete a notification channel
+     *
+     * @param notificationID - The ID of the notification to delete
+     * @returns Promise resolving to the API response
+     */
+    deleteNotification(notificationID) {
+        return new Promise((resolve, reject) => {
+            if (!this.socket || !this.socket.connected) {
+                reject(new Error('Not connected to server'));
+                return;
+            }
+            this.socket.emit('deleteNotification', notificationID, (response) => {
+                if (response.ok) {
+                    this.safeLog('info', `Successfully deleted notification ${notificationID}`);
+                    resolve(response);
+                }
+                else {
+                    reject(new Error(response.msg || 'Failed to delete notification'));
+                }
+            });
+        });
+    }
+    // ─── Docker host operations ─────────────────────────────────────────────────
+    /**
+     * Get the cached docker host list
+     */
+    getDockerHostList() {
+        return this.dockerHostListCache;
+    }
+    /**
+     * Add or update a docker host
+     *
+     * @param dockerHost - Docker host configuration (name, dockerType, dockerDaemon)
+     * @param dockerHostID - If provided, updates existing; otherwise creates new
+     * @returns Promise resolving to the API response with the docker host id
+     */
+    addDockerHost(dockerHost, dockerHostID) {
+        return new Promise((resolve, reject) => {
+            if (!this.socket || !this.socket.connected) {
+                reject(new Error('Not connected to server'));
+                return;
+            }
+            const id = dockerHostID ?? null;
+            this.socket.emit('addDockerHost', dockerHost, id, (response) => {
+                if (response.ok) {
+                    this.safeLog('info', `Successfully saved docker host (ID: ${response.id})`);
+                    resolve(response);
+                }
+                else {
+                    reject(new Error(response.msg || 'Failed to save docker host'));
+                }
+            });
+        });
+    }
+    /**
+     * Delete a docker host. Any monitors referencing it will have their docker_host
+     * field cleared by Uptime Kuma.
+     *
+     * @param dockerHostID - The ID of the docker host to delete
+     * @returns Promise resolving to the API response
+     */
+    deleteDockerHost(dockerHostID) {
+        return new Promise((resolve, reject) => {
+            if (!this.socket || !this.socket.connected) {
+                reject(new Error('Not connected to server'));
+                return;
+            }
+            this.socket.emit('deleteDockerHost', dockerHostID, (response) => {
+                if (response.ok) {
+                    this.safeLog('info', `Successfully deleted docker host ${dockerHostID}`);
+                    resolve(response);
+                }
+                else {
+                    reject(new Error(response.msg || 'Failed to delete docker host'));
+                }
+            });
+        });
+    }
+    /**
+     * Test connectivity to a docker host without persisting it. Returns a friendly
+     * message containing the number of containers when reachable.
+     *
+     * @param dockerHost - Docker host configuration to test (name, dockerType, dockerDaemon)
+     * @returns Promise resolving to the API response
+     */
+    testDockerHost(dockerHost) {
+        return new Promise((resolve, reject) => {
+            if (!this.socket || !this.socket.connected) {
+                reject(new Error('Not connected to server'));
+                return;
+            }
+            this.socket.emit('testDockerHost', dockerHost, (response) => {
+                // Resolve either way so callers can inspect ok/msg without try/catch
+                // (matches the pattern used by UK's UI, which shows both success and
+                // failure messages from the same callback).
+                resolve(response);
+            });
+        });
+    }
+    // ─── Tag operations ─────────────────────────────────────────────────────────
+    /**
+     * Get the cached tag list
+     */
+    getTagList() {
+        return this.tagListCache;
+    }
+    /**
+     * Create a new tag
+     *
+     * @param name - Tag name
+     * @param color - Tag color (hex string, e.g. '#ff0000')
+     * @returns Promise resolving to the created tag object
+     */
+    addTag(name, color) {
+        return new Promise((resolve, reject) => {
+            if (!this.socket || !this.socket.connected) {
+                reject(new Error('Not connected to server'));
+                return;
+            }
+            this.socket.emit('addTag', { name, color }, (response) => {
+                if (response.ok) {
+                    this.safeLog('info', `Successfully created tag "${name}" (ID: ${response.tag?.id})`);
+                    resolve(response);
+                }
+                else {
+                    reject(new Error(response.msg || 'Failed to create tag'));
+                }
+            });
+        });
+    }
+    /**
+     * Delete a tag
+     *
+     * @param tagID - The ID of the tag to delete
+     * @returns Promise resolving to the API response
+     */
+    deleteTag(tagID) {
+        return new Promise((resolve, reject) => {
+            if (!this.socket || !this.socket.connected) {
+                reject(new Error('Not connected to server'));
+                return;
+            }
+            this.socket.emit('deleteTag', tagID, (response) => {
+                if (response.ok) {
+                    this.safeLog('info', `Successfully deleted tag ${tagID}`);
+                    resolve(response);
+                }
+                else {
+                    reject(new Error(response.msg || 'Failed to delete tag'));
+                }
+            });
+        });
+    }
+    // ─── Maintenance operations ─────────────────────────────────────────────────
+    /**
+     * Get the cached maintenance window list
+     */
+    getMaintenanceList() {
+        return Object.values(this.maintenanceListCache);
+    }
+    /**
+     * Create a new maintenance window
+     *
+     * @param maintenanceData - Maintenance window configuration
+     * @returns Promise resolving to the API response with the maintenance ID
+     */
+    createMaintenance(maintenanceData) {
+        return new Promise((resolve, reject) => {
+            if (!this.socket || !this.socket.connected) {
+                reject(new Error('Not connected to server'));
+                return;
+            }
+            this.socket.emit('addMaintenance', maintenanceData, (response) => {
+                if (response.ok) {
+                    this.safeLog('info', `Successfully created maintenance window (ID: ${response.maintenanceID})`);
+                    resolve(response);
+                }
+                else {
+                    reject(new Error(response.msg || 'Failed to create maintenance window'));
+                }
+            });
+        });
+    }
+    // ─── Status page operations ─────────────────────────────────────────────────
+    /**
+     * Get the cached status page list
+     */
+    getStatusPageList() {
+        return Object.values(this.statusPageListCache);
+    }
+    /**
+     * Get full details of a single status page, including publicGroupList with monitors
+     * and any active incidents. Uses the public HTTP API (`/api/status-page/{slug}`),
+     * which returns the same data the status page UI renders — richer than the
+     * socket `getStatusPage` event, which only returns config.
+     *
+     * @param slug - The status page slug
+     * @returns Promise resolving to the status page config, groups, and incidents
+     */
+    async getStatusPage(slug) {
+        try {
+            const baseUrl = this.url.replace(/\/$/, '');
+            const res = await fetch(`${baseUrl}/api/status-page/${encodeURIComponent(slug)}`);
+            if (res.status === 404) {
+                return { ok: false, msg: `Status page ${slug} not found` };
+            }
+            if (!res.ok) {
+                throw new Error(`HTTP ${res.status} ${res.statusText}`);
+            }
+            const data = await res.json();
+            return {
+                ok: true,
+                config: data.config,
+                publicGroupList: data.publicGroupList,
+                incidents: data.incidents ?? [],
+            };
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : 'Unknown error';
+            throw new Error(`Failed to get status page ${slug}: ${msg}`);
+        }
+    }
+    /**
+     * Create a new (empty) status page with the given title and slug
+     *
+     * Note: This creates a blank status page. Use updateStatusPage afterwards to
+     * set description, theme, groups, monitors, etc.
+     *
+     * @param title - Display title of the status page
+     * @param slug - URL slug (lowercase letters, digits, and dashes only)
+     * @returns Promise resolving to the API response
+     */
+    createStatusPage(title, slug) {
+        return new Promise((resolve, reject) => {
+            if (!this.socket || !this.socket.connected) {
+                reject(new Error('Not connected to server'));
+                return;
+            }
+            this.socket.emit('addStatusPage', title, slug, (response) => {
+                if (response.ok) {
+                    this.safeLog('info', `Successfully created status page ${slug}`);
+                    resolve(response);
+                }
+                else {
+                    reject(new Error(response.msg || `Failed to create status page ${slug}`));
+                }
+            });
+        });
+    }
+    /**
+     * Update an existing status page's config and group/monitor list
+     *
+     * @param slug - The status page slug (immutable identifier)
+     * @param config - Status page configuration (title, description, theme, published, etc.)
+     * @param publicGroupList - Ordered groups, each with a name, weight, and monitorList `[{id}]`
+     * @param imgDataUrl - Optional icon as data URL (pass empty string to keep existing)
+     * @returns Promise resolving to the API response
+     */
+    updateStatusPage(slug, config, publicGroupList = [], imgDataUrl = '') {
+        return new Promise((resolve, reject) => {
+            if (!this.socket || !this.socket.connected) {
+                reject(new Error('Not connected to server'));
+                return;
+            }
+            this.socket.emit('saveStatusPage', slug, config, imgDataUrl, publicGroupList, (response) => {
+                if (response.ok) {
+                    this.safeLog('info', `Successfully updated status page ${slug}`);
+                    resolve(response);
+                }
+                else {
+                    reject(new Error(response.msg || `Failed to update status page ${slug}`));
+                }
+            });
+        });
+    }
+    /**
+     * Delete a status page
+     *
+     * @param slug - The status page slug
+     * @returns Promise resolving to the API response
+     */
+    deleteStatusPage(slug) {
+        return new Promise((resolve, reject) => {
+            if (!this.socket || !this.socket.connected) {
+                reject(new Error('Not connected to server'));
+                return;
+            }
+            this.socket.emit('deleteStatusPage', slug, (response) => {
+                if (response.ok) {
+                    this.safeLog('info', `Successfully deleted status page ${slug}`);
+                    resolve(response);
+                }
+                else {
+                    reject(new Error(response.msg || `Failed to delete status page ${slug}`));
+                }
+            });
+        });
+    }
+    // ─── Socket accessor ─────────────────────────────────────────────────────────
     /**
      * Get the socket instance (for advanced usage)
      */