status

Instructions

Implementation Reference

• src/index.ts:1135-1169 (handler)

  Main MCP tool handler for 'status': parses command (list, --all, --<platform>) and delegates to StatusObserver methods.

  if (name === "status") {
    const command = (typeof args?.command === 'string' ? args.command : '').toLowerCase() || '';
    
    if (command === 'list') {
      return {
        content: [
          {
            type: "text",
            text: statusObserver.getPlatformsList()
          }
        ]
      };
    } else if (command === '--all') {
      return {
        content: [
          {
            type: "text",
            text: await statusObserver.getAllPlatformsStatus()
          }
        ]
      };
    } else if (command.startsWith('--')) {
      const platformId = command.slice(2);
      return {
        content: [
          {
            type: "text",
            text: await statusObserver.getPlatformStatus(platformId)
          }
        ]
      };
    } else {
      throw new Error(`Unknown command: ${command}. Available commands: list, --all, or platform with -- prefix like --openrouter, --openai, --github`);
    }
  }

• src/index.ts:1092-1104 (schema)

  Input schema definition for the 'status' tool, specifying the 'command' parameter.

  status: {
    description: "Check operational status of major digital platforms including AI providers, cloud services, and developer tools",
    schema: {
      type: "object",
      properties: {
        command: {
          type: "string",
          description: "Command to execute (list, --all, or platform with -- prefix like --openrouter, --openai, --github)"
        }
      },
      required: ["command"]
    }
  }

• src/index.ts:1084-1108 (registration)

  Server initialization registering the 'status' tool via capabilities.

  const server = new Server(
    {
      name: "mcp-status-observer",
      version: "0.1.0",
    },
    {
      capabilities: {
        tools: {
          status: {
            description: "Check operational status of major digital platforms including AI providers, cloud services, and developer tools",
            schema: {
              type: "object",
              properties: {
                command: {
                  type: "string",
                  description: "Command to execute (list, --all, or platform with -- prefix like --openrouter, --openai, --github)"
                }
              },
              required: ["command"]
            }
          }
        },
      },
    }
  );

• src/index.ts:1110-1129 (registration)

  ListTools handler registering/declaring the 'status' tool schema.

  server.setRequestHandler(ListToolsRequestSchema, async () => {
    return {
      tools: [
        {
          name: "status",
          description: "Check operational status of major digital platforms including AI providers like OpenRouter, OpenAI, Anthropic; cloud services like GCP, Vercel; and developer tools",
          inputSchema: {
            type: "object",
            properties: {
              command: {
                type: "string",
                description: "Command to execute (list, --all, or platform with -- prefix like --openrouter, --openai, --github, --gcp)"
              }
            },
            required: ["command"]
          }
        }
      ]
    };
  });

• src/index.ts:285-368 (helper)

  Core helper method in StatusObserver that fetches and formats status for a specific platform, dispatching to platform-specific handlers.

  async getPlatformStatus(platformId: string): Promise<string> {
    const platform = this.platforms.get(platformId);
    if (!platform) {
      return `Platform '${platformId}' not found. Use 'status list' to see available platforms.`;
    }
  
    try {
      if (platformId === 'anthropic') {
        return await this.getAnthropicStatus(platform);
      }
  
      if (platformId === 'atlassian') {
        return await this.getAtlassianStatus(platform);
      }
  
      if (platformId === 'docker') {
        return await this.getDockerStatus(platform);
      }
  
      if (platformId === 'gcp') {
        return await this.getGCPStatus(platform);
      }
  
      if (platformId === 'gemini') {
        return await this.getGeminiStatus(platform);
      }
  
      if (platformId === 'linkedin') {
        return await this.getLinkedInStatus(platform);
      }
  
      if (platformId === 'openai') {
        return await this.getOpenAIStatus(platform);
      }
  
      if (platformId === 'openrouter') {
        return await this.getOpenRouterStatus(platform);
      }
  
      if (platformId === 'supabase') {
        return await this.getSupabaseStatus(platform);
      }
  
      if (platformId === 'x') {
        return await this.getXStatus(platform);
      }
      
      const response = await axios.get(platform.url);
      const data = response.data;
      
      let statusOutput = `${platform.name} Status:\n`;
      statusOutput += `${this.formatOverallStatus(data, platformId)}\n\n`;
      
      if (data.components && Array.isArray(data.components)) {
        statusOutput += `Components:\n`;
        data.components.forEach((component: any) => {
          statusOutput += `- ${component.name}: ${this.normalizeStatus(component.status)}\n`;
          if (component.description) {
            statusOutput += `  Description: ${component.description}\n`;
          }
        });
      } else if (data.components && typeof data.components === 'object') {
        statusOutput += `Components:\n`;
        Object.keys(data.components).forEach(key => {
          const component = data.components[key];
          statusOutput += `- ${component.name}: ${this.normalizeStatus(component.status)}\n`;
          if (component.description) {
            statusOutput += `  Description: ${component.description}\n`;
          }
        });
      } else if (platformId === 'github') {
        this.processGitHubComponents(data, platform);
        statusOutput += this.getGitHubComponentsText(platform);
      }
      
      statusOutput += `\nLast Updated: ${this.formatUpdateTime(data.page?.updated_at || data.updated || new Date().toISOString())}`;
      
      return statusOutput;
    } catch (error) {
      console.error(`Error fetching status for ${platform.name}:`, error);
      
      return `Unable to fetch real-time status for ${platform.name}. The status API might be unavailable or the format has changed.`;
    }
  }