Webby MCP Server

Instructions

Implementation Reference

• src/orchestrator/run-all.ts:212-258 (handler)

  Core handler function that executes the validate_comprehensive tool by orchestrating sub-tests across categories.

  export async function runComprehensive(
    url: string,
    options: {
      performance?: PerformanceTestOptions;
      accessibility?: AccessibilityTestOptions;
      security: SecurityTestOptions;
      categories?: Array<'performance' | 'accessibility' | 'seo' | 'security'>;
    }
  ): Promise<ComprehensiveResult> {
    const categories = options.categories || ['performance', 'accessibility', 'seo', 'security'];
    const result: ComprehensiveResult = {
      url,
      timestamp: new Date().toISOString(),
      summary: {
        categories_tested: categories,
        overall_health: 'good',
        critical_issues: 0,
      },
    };
  
    // Run selected categories
    if (categories.includes('performance') && options.performance) {
      result.performance = await runAllPerformance(url, options.performance);
    }
  
    if (categories.includes('accessibility') && options.accessibility) {
      result.accessibility = await runAllAccessibility(url, options.accessibility);
      result.summary.critical_issues += result.accessibility.axe?.critical || 0;
    }
  
    if (categories.includes('seo')) {
      result.seo = await runAllSEO(url);
    }
  
    if (categories.includes('security')) {
      result.security = await runAllSecurity(url, options.security);
    }
  
    // Calculate overall health
    if (result.summary.critical_issues > 5) {
      result.summary.overall_health = 'poor';
    } else if (result.summary.critical_issues > 2) {
      result.summary.overall_health = 'fair';
    }
  
    return result;
  }

• index.ts:104-113 (schema)

  Zod schema used to validate input arguments for the validate_comprehensive tool.

  const ComprehensiveArgsSchema = z.object({
    url: z.string().url(),
    email: z.string().email(),
    categories: z.array(z.enum(['performance', 'accessibility', 'seo', 'security'])).optional(),
    pagespeedApiKey: z.string().optional(),
    gtmetrixApiKey: z.string().optional(),
    waveApiKey: z.string().optional(),
    wcagLevel: z.string().optional(),
    waitForSSL: z.boolean().optional(),
  });

• index.ts:286-307 (registration)

  Tool registration definition including name, description, and input schema for MCP server.

  {
    name: 'validate_comprehensive',
    description: 'Run comprehensive validation across all categories (performance, accessibility, SEO, security).',
    inputSchema: {
      type: 'object',
      properties: {
        url: { type: 'string' },
        email: { type: 'string', description: 'Email for SSL Labs (required)' },
        categories: {
          type: 'array',
          items: { type: 'string', enum: ['performance', 'accessibility', 'seo', 'security'] },
          description: 'Categories to test (default: all)'
        },
        pagespeedApiKey: { type: 'string' },
        gtmetrixApiKey: { type: 'string' },
        waveApiKey: { type: 'string' },
        wcagLevel: { type: 'string' },
        waitForSSL: { type: 'boolean' },
      },
      required: ['url', 'email'],
    },
  },

• index.ts:435-455 (handler)

  Dispatch handler in main tool switch that validates args and invokes runComprehensive.

  case 'validate_comprehensive': {
    const validatedArgs = ComprehensiveArgsSchema.parse(args);
    const result = await runComprehensive(validatedArgs.url, {
      performance: {
        pagespeed: { apiKey: validatedArgs.pagespeedApiKey },
        gtmetrix: validatedArgs.gtmetrixApiKey ? { apiKey: validatedArgs.gtmetrixApiKey } : undefined,
      },
      accessibility: {
        wave: validatedArgs.waveApiKey ? { apiKey: validatedArgs.waveApiKey } : undefined,
        axe: { wcagLevel: validatedArgs.wcagLevel },
      },
      security: {
        sslLabs: {
          email: validatedArgs.email,
          waitForComplete: validatedArgs.waitForSSL,
        },
      },
      categories: validatedArgs.categories,
    });
    return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
  }

• src/orchestrator/run-all.ts:73-85 (schema)

  TypeScript interface defining the output structure of the comprehensive validation result.

  export interface ComprehensiveResult {
    url: string;
    timestamp: string;
    performance?: AllPerformanceResult;
    accessibility?: AllAccessibilityResult;
    seo?: AllSEOResult;
    security?: AllSecurityResult;
    summary: {
      categories_tested: string[];
      overall_health: 'excellent' | 'good' | 'fair' | 'poor';
      critical_issues: number;
    };
  }