@access-mcp/system-status 0.2.0

package/README.md

@@ -0,0 +1,65 @@
+# ACCESS-CI System Status MCP Server
+
+MCP server providing real-time system status information for ACCESS-CI resources.
+
+## Overview
+
+This server provides critical operational information about ACCESS-CI systems, including current outages, scheduled maintenance, and system-wide announcements.
+
+## Tools
+
+### get_current_outages
+Get current system outages and issues affecting ACCESS-CI resources.
+
+**Parameters:**
+- `resource_filter` (string, optional): Filter by specific resource name or ID
+
+### get_scheduled_maintenance
+Get scheduled maintenance and future outages for ACCESS-CI resources.
+
+**Parameters:**
+- `resource_filter` (string, optional): Filter by specific resource name or ID
+
+### get_system_announcements
+Get all system announcements (current and scheduled).
+
+**Parameters:**
+- `limit` (number, optional): Maximum number of announcements to return (default: 50)
+
+### get_resource_status
+Get the current operational status of a specific resource.
+
+**Parameters:**
+- `resource_id` (string): The resource ID to check status for
+
+## Resources
+
+- `accessci://system-status`: Current operational status of all ACCESS-CI resources
+
+## Installation
+
+```bash
+npm install -g @access-mcp/system-status
+```
+
+## Usage
+
+Add to your Claude Desktop configuration:
+
+```json
+{
+  "mcpServers": {
+    "access-system-status": {
+      "command": "access-mcp-system-status"
+    }
+  }
+}
+```
+
+## API Endpoints
+
+This server connects to the ACCESS-CI Operations API at `https://operations-api.access-ci.org`
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+import { SystemStatusServer } from './server.js';
+import { startWebServer } from './web-server.js';
+async function main() {
+    // Check if we should run as web server (for deployment)
+    const port = process.env.PORT;
+    if (port) {
+        // Running in web mode (deployment)
+        startWebServer(parseInt(port));
+    }
+    else {
+        // Running in MCP mode (stdio)
+        const server = new SystemStatusServer();
+        await server.start();
+    }
+}
+main().catch((error) => {
+    // Log errors to a file instead of stderr to avoid interfering with JSON-RPC
+    process.exit(1);
+});

package/dist/server.d.ts

@@ -0,0 +1,76 @@
+import { BaseAccessServer } from '../../shared/dist/index.js';
+export declare class SystemStatusServer extends BaseAccessServer {
+    constructor();
+    protected getTools(): ({
+        name: string;
+        description: string;
+        inputSchema: {
+            type: string;
+            properties: {
+                resource_filter: {
+                    type: string;
+                    description: string;
+                };
+                limit?: undefined;
+                resource_ids?: undefined;
+            };
+            required: never[];
+        };
+    } | {
+        name: string;
+        description: string;
+        inputSchema: {
+            type: string;
+            properties: {
+                limit: {
+                    type: string;
+                    description: string;
+                };
+                resource_filter?: undefined;
+                resource_ids?: undefined;
+            };
+            required: never[];
+        };
+    } | {
+        name: string;
+        description: string;
+        inputSchema: {
+            type: string;
+            properties: {
+                resource_ids: {
+                    type: string;
+                    items: {
+                        type: string;
+                    };
+                    description: string;
+                };
+                resource_filter?: undefined;
+                limit?: undefined;
+            };
+            required: string[];
+        };
+    })[];
+    protected getResources(): {
+        uri: string;
+        name: string;
+        description: string;
+        mimeType: string;
+    }[];
+    handleToolCall(request: any): Promise<{
+        content: {
+            type: string;
+            text: string;
+        }[];
+    }>;
+    handleResourceRead(request: any): Promise<{
+        contents: {
+            uri: any;
+            mimeType: string;
+            text: string;
+        }[];
+    }>;
+    private getCurrentOutages;
+    private getScheduledMaintenance;
+    private getSystemAnnouncements;
+    private checkResourceStatus;
+}

package/dist/server.js

@@ -0,0 +1,347 @@
+import { BaseAccessServer, handleApiError } from '../../shared/dist/index.js';
+export class SystemStatusServer extends BaseAccessServer {
+    constructor() {
+        super('access-mcp-system-status', '0.1.0', 'https://operations-api.access-ci.org');
+    }
+    getTools() {
+        return [
+            {
+                name: 'get_current_outages',
+                description: 'Get current system outages and issues affecting ACCESS-CI resources',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        resource_filter: {
+                            type: 'string',
+                            description: 'Optional: filter by specific resource name or ID',
+                        },
+                    },
+                    required: [],
+                },
+            },
+            {
+                name: 'get_scheduled_maintenance',
+                description: 'Get scheduled maintenance and future outages for ACCESS-CI resources',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        resource_filter: {
+                            type: 'string',
+                            description: 'Optional: filter by specific resource name or ID',
+                        },
+                    },
+                    required: [],
+                },
+            },
+            {
+                name: 'get_system_announcements',
+                description: 'Get all system announcements (current and scheduled)',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        limit: {
+                            type: 'number',
+                            description: 'Maximum number of announcements to return (default: 50)',
+                        },
+                    },
+                    required: [],
+                },
+            },
+            {
+                name: 'check_resource_status',
+                description: 'Check the operational status of specific ACCESS-CI resources',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        resource_ids: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'List of resource IDs to check status for',
+                        },
+                    },
+                    required: ['resource_ids'],
+                },
+            },
+        ];
+    }
+    getResources() {
+        return [
+            {
+                uri: 'accessci://system-status',
+                name: 'ACCESS-CI System Status',
+                description: 'Real-time status of ACCESS-CI infrastructure, outages, and maintenance',
+                mimeType: 'application/json',
+            },
+            {
+                uri: 'accessci://outages/current',
+                name: 'Current Outages',
+                description: 'Currently active outages and system issues',
+                mimeType: 'application/json',
+            },
+            {
+                uri: 'accessci://outages/scheduled',
+                name: 'Scheduled Maintenance',
+                description: 'Upcoming scheduled maintenance and planned outages',
+                mimeType: 'application/json',
+            },
+        ];
+    }
+    async handleToolCall(request) {
+        const { name, arguments: args = {} } = request.params;
+        try {
+            switch (name) {
+                case 'get_current_outages':
+                    return await this.getCurrentOutages(args.resource_filter);
+                case 'get_scheduled_maintenance':
+                    return await this.getScheduledMaintenance(args.resource_filter);
+                case 'get_system_announcements':
+                    return await this.getSystemAnnouncements(args.limit);
+                case 'check_resource_status':
+                    return await this.checkResourceStatus(args.resource_ids);
+                default:
+                    throw new Error(`Unknown tool: ${name}`);
+            }
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error: ${handleApiError(error)}`,
+                    },
+                ],
+            };
+        }
+    }
+    async handleResourceRead(request) {
+        const { uri } = request.params;
+        switch (uri) {
+            case 'accessci://system-status':
+                return {
+                    contents: [
+                        {
+                            uri,
+                            mimeType: 'text/plain',
+                            text: 'ACCESS-CI System Status API - Monitor real-time status, outages, and maintenance for ACCESS-CI resources.',
+                        },
+                    ],
+                };
+            case 'accessci://outages/current':
+                const currentOutages = await this.getCurrentOutages();
+                return {
+                    contents: [
+                        {
+                            uri,
+                            mimeType: 'application/json',
+                            text: currentOutages.content[0].text,
+                        },
+                    ],
+                };
+            case 'accessci://outages/scheduled':
+                const scheduledMaintenance = await this.getScheduledMaintenance();
+                return {
+                    contents: [
+                        {
+                            uri,
+                            mimeType: 'application/json',
+                            text: scheduledMaintenance.content[0].text,
+                        },
+                    ],
+                };
+            default:
+                throw new Error(`Unknown resource: ${uri}`);
+        }
+    }
+    async getCurrentOutages(resourceFilter) {
+        const response = await this.httpClient.get('/wh2/news/v1/affiliation/access-ci.org/current_outages/');
+        let outages = response.data.results || [];
+        // Filter by resource if specified
+        if (resourceFilter) {
+            const filter = resourceFilter.toLowerCase();
+            outages = outages.filter((outage) => outage.Subject?.toLowerCase().includes(filter) ||
+                outage.AffectedResources?.some((resource) => resource.ResourceName?.toLowerCase().includes(filter) ||
+                    resource.ResourceID?.toString().includes(filter)));
+        }
+        // Initialize tracking variables
+        const affectedResources = new Set();
+        const severityCounts = { high: 0, medium: 0, low: 0, unknown: 0 };
+        // Enhance outages with status summary
+        const enhancedOutages = outages.map((outage) => {
+            // Track affected resources
+            outage.AffectedResources?.forEach((resource) => {
+                affectedResources.add(resource.ResourceName);
+            });
+            // Categorize severity (basic heuristic)
+            const subject = outage.Subject?.toLowerCase() || '';
+            let severity = 'unknown';
+            if (subject.includes('emergency') || subject.includes('critical')) {
+                severity = 'high';
+            }
+            else if (subject.includes('maintenance') || subject.includes('scheduled')) {
+                severity = 'low';
+            }
+            else {
+                severity = 'medium';
+            }
+            severityCounts[severity]++;
+            return {
+                ...outage,
+                severity,
+                posted_time: outage.CreationTime,
+                last_updated: outage.LastModificationTime,
+            };
+        });
+        const summary = {
+            total_outages: outages.length,
+            affected_resources: Array.from(affectedResources),
+            severity_counts: severityCounts,
+            outages: enhancedOutages
+        };
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        ...summary,
+                        affected_resources: summary.affected_resources
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    async getScheduledMaintenance(resourceFilter) {
+        const response = await this.httpClient.get('/wh2/news/v1/affiliation/access-ci.org/future_outages/');
+        let maintenance = response.data.results || [];
+        // Filter by resource if specified
+        if (resourceFilter) {
+            const filter = resourceFilter.toLowerCase();
+            maintenance = maintenance.filter((item) => item.Subject?.toLowerCase().includes(filter) ||
+                item.AffectedResources?.some((resource) => resource.ResourceName?.toLowerCase().includes(filter) ||
+                    resource.ResourceID?.toString().includes(filter)));
+        }
+        // Sort by scheduled start time
+        maintenance.sort((a, b) => {
+            const dateA = new Date(a.OutageStartDateTime || a.CreationTime);
+            const dateB = new Date(b.OutageStartDateTime || b.CreationTime);
+            return dateA.getTime() - dateB.getTime();
+        });
+        const summary = {
+            total_scheduled: maintenance.length,
+            upcoming_24h: 0,
+            upcoming_week: 0,
+            affected_resources: new Set(),
+            maintenance: maintenance.map((item) => {
+                // Track affected resources
+                item.AffectedResources?.forEach((resource) => {
+                    summary.affected_resources.add(resource.ResourceName);
+                });
+                // Check timing
+                const startTime = new Date(item.OutageStartDateTime || item.CreationTime);
+                const now = new Date();
+                const hoursUntil = (startTime.getTime() - now.getTime()) / (1000 * 60 * 60);
+                if (hoursUntil <= 24)
+                    summary.upcoming_24h++;
+                if (hoursUntil <= 168)
+                    summary.upcoming_week++; // 7 days * 24 hours
+                return {
+                    ...item,
+                    scheduled_start: item.OutageStartDateTime,
+                    scheduled_end: item.OutageEndDateTime,
+                    hours_until_start: Math.max(0, Math.round(hoursUntil)),
+                    duration_hours: item.OutageEndDateTime && item.OutageStartDateTime
+                        ? Math.round((new Date(item.OutageEndDateTime).getTime() -
+                            new Date(item.OutageStartDateTime).getTime()) / (1000 * 60 * 60))
+                        : null,
+                };
+            })
+        };
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        ...summary,
+                        affected_resources: summary.affected_resources
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    async getSystemAnnouncements(limit = 50) {
+        // Get both current and future announcements
+        const [currentResponse, futureResponse] = await Promise.all([
+            this.httpClient.get('/wh2/news/v1/affiliation/access-ci.org/current_outages/'),
+            this.httpClient.get('/wh2/news/v1/affiliation/access-ci.org/future_outages/')
+        ]);
+        const currentOutages = currentResponse.data.results || [];
+        const futureOutages = futureResponse.data.results || [];
+        // Combine and sort by creation time
+        const allAnnouncements = [...currentOutages, ...futureOutages]
+            .sort((a, b) => {
+            const dateA = new Date(a.CreationTime);
+            const dateB = new Date(b.CreationTime);
+            return dateB.getTime() - dateA.getTime(); // Most recent first
+        })
+            .slice(0, limit);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        total_announcements: allAnnouncements.length,
+                        current_outages: currentOutages.length,
+                        scheduled_maintenance: futureOutages.length,
+                        announcements: allAnnouncements
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    async checkResourceStatus(resourceIds) {
+        // Get current outages to check against resource IDs
+        const currentOutages = await this.getCurrentOutages();
+        const outageData = JSON.parse(currentOutages.content[0].text);
+        const resourceStatus = resourceIds.map(resourceId => {
+            const affectedOutages = outageData.outages.filter((outage) => outage.AffectedResources?.some((resource) => resource.ResourceID?.toString() === resourceId ||
+                resource.ResourceName?.toLowerCase().includes(resourceId.toLowerCase())));
+            let status = 'operational';
+            let severity = null;
+            if (affectedOutages.length > 0) {
+                status = 'affected';
+                // Get highest severity
+                const severities = affectedOutages.map((o) => o.severity);
+                if (severities.includes('high'))
+                    severity = 'high';
+                else if (severities.includes('medium'))
+                    severity = 'medium';
+                else
+                    severity = 'low';
+            }
+            return {
+                resource_id: resourceId,
+                status,
+                severity,
+                active_outages: affectedOutages.length,
+                outage_details: affectedOutages.map((outage) => ({
+                    subject: outage.Subject,
+                    severity: outage.severity,
+                    posted: outage.posted_time
+                }))
+            };
+        });
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        checked_at: new Date().toISOString(),
+                        resources_checked: resourceIds.length,
+                        operational: resourceStatus.filter(r => r.status === 'operational').length,
+                        affected: resourceStatus.filter(r => r.status === 'affected').length,
+                        resource_status: resourceStatus
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+}

package/dist/web-server.d.ts

@@ -0,0 +1 @@
+export declare function startWebServer(port?: number): void;

package/dist/web-server.js

@@ -0,0 +1,50 @@
+import express from 'express';
+import path from 'path';
+import { SystemStatusServer } from './server.js';
+export function startWebServer(port = 3000) {
+    const app = express();
+    const server = new SystemStatusServer();
+    // Serve static files from public directory
+    const publicDir = path.join(__dirname, '../../../public');
+    app.use(express.static(publicDir));
+    // Health check endpoint
+    app.get('/health', (req, res) => {
+        res.json({ status: 'ok', service: 'access-mcp-system-status' });
+    });
+    // API endpoint to list tools (for documentation)
+    app.get('/api/tools', (req, res) => {
+        res.json({
+            server: 'ACCESS-CI System Status MCP Server',
+            version: '0.1.0',
+            tools: [
+                {
+                    name: 'get_current_outages',
+                    description: 'Get current system outages and issues affecting ACCESS-CI resources'
+                },
+                {
+                    name: 'get_scheduled_maintenance',
+                    description: 'Get scheduled maintenance and future outages for ACCESS-CI resources'
+                },
+                {
+                    name: 'get_system_announcements',
+                    description: 'Get all system announcements (current and scheduled)'
+                },
+                {
+                    name: 'check_resource_status',
+                    description: 'Check the operational status of specific ACCESS-CI resources'
+                }
+            ],
+            resources: [
+                {
+                    uri: 'accessci://system-status',
+                    name: 'ACCESS-CI System Status',
+                    description: 'Real-time status of ACCESS-CI infrastructure, outages, and maintenance'
+                }
+            ]
+        });
+    });
+    // Start server
+    app.listen(port, () => {
+        console.log(`ACCESS-CI System Status web server running on port ${port}`);
+    });
+}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@access-mcp/system-status",
+  "version": "0.2.0",
+  "description": "MCP server for ACCESS-CI System Status and Outages API",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "access-mcp-system-status": "dist/index.js"
+  },
+  "files": [
+    "dist/**/*",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "access-ci",
+    "hpc",
+    "system-status",
+    "outages",
+    "monitoring"
+  ],
+  "author": "ACCESS-CI",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/access-ci/access-mcp.git",
+    "directory": "packages/system-status"
+  },
+  "homepage": "https://github.com/access-ci/access-mcp#readme",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@access-mcp/shared": "^0.1.0",
+    "express": "^4.18.0"
+  }
+}