basic initialize working

Author: pcarleton

src/checks/server.ts

@@ -28,7 +28,7 @@ export function createServerInitializationCheck(initializeResponse: any, expecte
         specReferences: [{ id: 'MCP-Lifecycle', url: 'https://modelcontextprotocol.io/specification/2025-06-18/basic/lifecycle' }],
         details: {
             expectedSpecVersion,
-            ...initializeResponse
+            response: initializeResponse
         },
         errorMessage: errors.length > 0 ? errors.join('; ') : undefined,
         logs: errors.length > 0 ? errors : undefined

src/scenarios/index.ts

@@ -9,7 +9,7 @@ export const scenarios = new Map<string, Scenario>([
 ]);
 
 export const clientScenarios = new Map<string, ClientScenario>([
-    ['server-initialize', new ServerInitializeClientScenario()]
+    ['initialize', new ServerInitializeClientScenario()]
 ]);
 
 export function registerScenario(name: string, scenario: Scenario): void {

src/scenarios/server/server_initialize.ts

@@ -13,6 +13,7 @@ export class ServerInitializeClientScenario implements ClientScenario {
                 method: 'POST',
                 headers: {
                     'Content-Type': 'application/json',
+                    'Accept': 'application/json, text/event-stream',
                 },
                 body: JSON.stringify({
                     jsonrpc: '2.0',
@@ -30,10 +31,29 @@ export class ServerInitializeClientScenario implements ClientScenario {
             });
 
             if (!response.ok) {
-                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+                const responseBody = await response.text();
+                throw new Error(`HTTP ${response.status}: ${response.statusText}. Response body: ${responseBody}`);
             }
 
-            const result = await response.json();
+            const responseText = await response.text();
+            
+            // Handle SSE format
+            let result;
+            if (responseText.startsWith('event:') || responseText.includes('\ndata:')) {
+                // Parse SSE format - extract JSON from data: lines
+                const lines = responseText.split('\n');
+                const dataLines = lines.filter(line => line.startsWith('data: '));
+                if (dataLines.length > 0) {
+                    const jsonData = dataLines[0].substring(6); // Remove 'data: ' prefix
+                    result = JSON.parse(jsonData);
+                } else {
+                    throw new Error(`SSE response without data line: ${responseText}`);
+                }
+            } else {
+                // Regular JSON response
+                result = JSON.parse(responseText);
+            }
+            
             const check = serverChecks.createServerInitializationCheck(result);
             checks.push(check);
         } catch (error) {
@@ -44,6 +64,10 @@ export class ServerInitializeClientScenario implements ClientScenario {
                 status: 'FAILURE',
                 timestamp: new Date().toISOString(),
                 errorMessage: `Failed to send initialize request: ${error instanceof Error ? error.message : String(error)}`,
+                details: {
+                    error: error instanceof Error ? error.message : String(error),
+                    serverUrl
+                },
                 specReferences: [
                     {
                         id: 'MCP-Initialize',

src/server-runner.ts

@@ -0,0 +1,101 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+import { ConformanceCheck } from './types.js';
+import { getClientScenario } from './scenarios/index.js';
+
+async function ensureResultsDir(): Promise<string> {
+    const resultsDir = path.join(process.cwd(), 'results');
+    await fs.mkdir(resultsDir, { recursive: true });
+    return resultsDir;
+}
+
+function createResultDir(scenario: string): string {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    return path.join('results', `server-${scenario}-${timestamp}`);
+}
+
+export async function runServerConformanceTest(
+    serverUrl: string,
+    scenarioName: string
+): Promise<{
+    checks: ConformanceCheck[];
+    resultDir: string;
+}> {
+    await ensureResultsDir();
+    const resultDir = createResultDir(scenarioName);
+    await fs.mkdir(resultDir, { recursive: true });
+
+    const scenario = getClientScenario(scenarioName);
+    if (!scenario) {
+        throw new Error(`Unknown client scenario: ${scenarioName}`);
+    }
+
+    console.log(`Running client scenario '${scenarioName}' against server: ${serverUrl}`);
+
+    const checks = await scenario.run(serverUrl);
+
+    await fs.writeFile(path.join(resultDir, 'checks.json'), JSON.stringify(checks, null, 2));
+
+    console.log(`Results saved to ${resultDir}`);
+
+    return {
+        checks,
+        resultDir
+    };
+}
+
+async function main(): Promise<void> {
+    const args = process.argv.slice(2);
+    let serverUrl: string | null = null;
+    let scenario: string | null = null;
+
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--server-url' && i + 1 < args.length) {
+            serverUrl = args[i + 1];
+            i++;
+        } else if (args[i] === '--scenario' && i + 1 < args.length) {
+            scenario = args[i + 1];
+            i++;
+        }
+    }
+
+    if (!serverUrl || !scenario) {
+        console.error('Usage: server-runner --server-url <url> --scenario <scenario>');
+        console.error('Example: server-runner --server-url http://localhost:3000 --scenario initialize');
+        process.exit(1);
+    }
+
+    try {
+        const result = await runServerConformanceTest(serverUrl, scenario);
+
+        const denominator = result.checks.filter(c => c.status === 'SUCCESS' || c.status == 'FAILURE').length;
+        const passed = result.checks.filter(c => c.status === 'SUCCESS').length;
+        const failed = result.checks.filter(c => c.status === 'FAILURE').length;
+
+        console.log(`Checks:\n${JSON.stringify(result.checks, null, 2)}`);
+
+        console.log(`\nTest Results:`);
+        console.log(`Passed: ${passed}/${denominator}, ${failed} failed`);
+
+        if (failed > 0) {
+            console.log('\nFailed Checks:');
+            result.checks
+                .filter(c => c.status === 'FAILURE')
+                .forEach(c => {
+                    console.log(`  - ${c.name}: ${c.description}`);
+                    if (c.errorMessage) {
+                        console.log(`    Error: ${c.errorMessage}`);
+                    }
+                });
+        }
+
+        process.exit(failed > 0 ? 1 : 0);
+    } catch (error) {
+        console.error('Server test runner error:', error);
+        process.exit(1);
+    }
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+    main();
+}