MCP Server

┌────────────────────┐
│   MCP Client         │
│  (Claude Desktop,   │
│   Cursor, etc.)     │
└─────────┬──────────┘
         │
         │ MCP Protocol
         │ (JSON-RPC over stdio)
         │
┌────────┴────────────────────┐
│   AccessibilityHub MCP Server   │
│                                  │
│  ┌──────────────────────┐  │
│  │ Tools                 │  │
│  │ - analyze-with-axe    │  │
│  │ - analyze-with-pa11y  │  │
│  │ - analyze-contrast    │  │
│  │ - analyze-mixed       │  │
│  │ - analyze-lighthouse  │  │
│  └──────────────────────┘  │
│                                  │
│  ┌──────────────────────┐  │
│  │ Resources             │  │
│  │ - wcag://criteria     │  │
│  │ - contrast://thresholds│ │
│  │ - lighthouse://audits │  │
│  └──────────────────────┘  │
│                                  │
│  ┌──────────────────────┐  │
│  │ Prompts               │  │
│  │ - full-audit          │  │
│  │ - quick-check         │  │
│  │ - pre-deploy-check    │  │
│  └──────────────────────┘  │
└──────────────────────────────────┘
         │
┌────────┴────────────────────┐
│   Testing Tools               │
│   - axe-core                  │
│   - Pa11y                     │
│   - Lighthouse                │
│   - Puppeteer                 │
└──────────────────────────────┘

function registerTools(): void {
  analyzeWithAxeTool.register(server);
  analyzeWithPa11yTool.register(server);
  analyzeMixedTool.register(server);
  analyzeContrastTool.register(server);
  analyzeWithLighthouseTool.register(server);
}

import { z } from 'zod';

export const AxeToolInputSchema = z.object({
  url: z.string().url().optional(),
  html: z.string().optional(),
  options: z.object({
    wcagLevel: z.enum(['A', 'AA', 'AAA']).optional(),
    includeIncomplete: z.boolean().optional(),
    browser: z.object({
      waitForSelector: z.string().optional(),
      waitForTimeout: z.number().optional(),
      viewport: z.object({
        width: z.number().optional(),
        height: z.number().optional()
      }).optional()
    }).optional()
  }).optional()
}).refine(
  data => !!data.url || !!data.html,
  { message: 'Either url or html must be provided' }
);

function registerResources(): void {
  registerWcagResources(server);      // WCAG 2.1 criteria
  registerContrastResources(server);  // Contrast thresholds
  registerLighthouseResources(server); // Lighthouse audits
}

function registerPrompts(): void {
  const prompts = [
    fullAccessibilityAuditPrompt,
    lighthouseAuditPrompt,
    quickAccessibilityCheckPrompt,
    contrastCheckPrompt,
    preDeployCheckPrompt,
    quickWinsReportPrompt,
    lighthouseScoreImprovementPrompt,
    explainWcagCriterionPrompt
  ];

  for (const prompt of prompts) {
    prompt.register(server);
  }
}

Use the full-accessibility-audit prompt with:
- url: https://example.com
- wcagLevel: AA

export function createErrorResponse(error: Error): ToolResponse {
  return {
    content: [
      {
        type: 'text',
        text: JSON.stringify({
          success: false,
          error: error.message,
          timestamp: new Date().toISOString()
        }, null, 2)
      }
    ],
    isError: true
  };
}

const server = new McpServer({
  name: 'AccesibilityHub',
  version: APP_VERSION,
  icons: [
    {
      src: `${REPO_RAW_URL}/assets/logo_light.svg`,
      mimeType: 'image/svg+xml',
      theme: 'light',
    },
    {
      src: `${REPO_RAW_URL}/assets/logo_dark.svg`,
      mimeType: 'image/svg+xml',
      theme: 'dark',
    },
  ],
});

async function main(): Promise<void> {
  registerTools();
  registerPrompts();
  registerResources();

  const transport = new StdioServerTransport();
  await server.connect(transport);
}

// From src/tools/Axe/main.ts:14-30
let sharedAdapter: AxeAdapter | null = null;

function getAdapter(ignoreHTTPSErrors = false): AxeAdapter {
  if (!sharedAdapter || currentIgnoreHTTPS !== ignoreHTTPSErrors) {
    if (sharedAdapter) {
      sharedAdapter.dispose().catch(() => {});
    }
    sharedAdapter = new AxeAdapter({
      headless: true,
      timeout: 30000,
      ignoreHTTPSErrors,
    });
  }
  return sharedAdapter;
}