@bryan-thompson/inspector-assessment-cli 1.32.2 → 1.32.3

package/build/__tests__/assessment-runner/server-config.test.js

@@ -191,9 +191,10 @@ describe("loadServerConfig", () => {
                     },
                 },
             }));
-            expect(() => loadServerConfig("nourl", "/config.json")).toThrow(/'url' is missing/);
+            // Zod union validation returns "Invalid input" when neither HTTP/SSE nor stdio schema matches
+            expect(() => loadServerConfig("nourl", "/config.json")).toThrow(/Invalid/);
         });
-        it('should throw "url is missing" when transport=sse but no url', () => {
+        it("should throw validation error when transport=sse but no url", () => {
             mockExistsSync.mockReturnValue(true);
             mockReadFileSync.mockReturnValue(JSON.stringify({
                 mcpServers: {
@@ -202,14 +203,16 @@ describe("loadServerConfig", () => {
                     },
                 },
             }));
-            expect(() => loadServerConfig("nourl", "/config.json")).toThrow(/'url' is missing/);
+            // Zod union validation returns "Invalid input" when neither HTTP/SSE nor stdio schema matches
+            expect(() => loadServerConfig("nourl", "/config.json")).toThrow(/Invalid/);
         });
-        it('should throw "url is missing" for root-level transport:http without url', () => {
+        it("should throw validation error for root-level transport:http without url", () => {
             mockExistsSync.mockReturnValue(true);
             mockReadFileSync.mockReturnValue(JSON.stringify({
                 transport: "http",
             }));
-            expect(() => loadServerConfig("server", "/config.json")).toThrow(/'url' is missing/);
+            // Zod union validation returns "Invalid input" when neither HTTP/SSE nor stdio schema matches
+            expect(() => loadServerConfig("server", "/config.json")).toThrow(/Invalid/);
         });
         it('should throw "Server config not found" when server not in any path', () => {
             mockExistsSync.mockReturnValue(false);

package/build/__tests__/jsonl-events.test.js

@@ -2,9 +2,14 @@
  * JSONL Events Module Unit Tests
  *
  * Tests for JSONL event emission functions used for real-time monitoring.
+ *
+ * NOTE: This tests the cli/src/lib/jsonl-events.ts implementation.
+ * A parallel implementation exists in scripts/lib/jsonl-events.ts and is tested
+ * in scripts/__tests__/jsonl-events-phase7.test.ts. Both implementations must
+ * emit identical JSONL structure for Phase 7 events (TEST-REQ-001).
  */
 import { jest, describe, it, expect, beforeEach, afterEach, } from "@jest/globals";
-import { emitJSONL, emitServerConnected, emitToolDiscovered, emitToolsDiscoveryComplete, emitAssessmentComplete, emitTestBatch, emitVulnerabilityFound, emitAnnotationMissing, emitAnnotationMisaligned, emitAnnotationReviewRecommended, emitAnnotationAligned, emitModulesConfigured, extractToolParams, } from "../lib/jsonl-events.js";
+import { emitJSONL, emitServerConnected, emitToolDiscovered, emitToolsDiscoveryComplete, emitAssessmentComplete, emitTestBatch, emitVulnerabilityFound, emitAnnotationMissing, emitAnnotationMisaligned, emitAnnotationReviewRecommended, emitAnnotationAligned, emitModulesConfigured, emitToolTestComplete, emitValidationSummary, emitPhaseStarted, emitPhaseComplete, extractToolParams, SCHEMA_VERSION, } from "../lib/jsonl-events.js";
 describe("JSONL Event Emission", () => {
     let consoleErrorSpy;
     let emittedEvents;
@@ -290,6 +295,195 @@ describe("JSONL Event Emission", () => {
             expect(emittedEvents[0]).toHaveProperty("reason", "default");
         });
     });
+    // ============================================================================
+    // Phase 7 Events - Per-Tool Testing & Phase Lifecycle
+    // ============================================================================
+    describe("emitToolTestComplete", () => {
+        it("should emit tool_test_complete with all required fields", () => {
+            emitToolTestComplete("test_calculator", "security", 15, 20, "high", "PASS", 5000);
+            expect(emittedEvents[0]).toHaveProperty("event", "tool_test_complete");
+            expect(emittedEvents[0]).toHaveProperty("tool", "test_calculator");
+            expect(emittedEvents[0]).toHaveProperty("module", "security");
+            expect(emittedEvents[0]).toHaveProperty("scenariosPassed", 15);
+            expect(emittedEvents[0]).toHaveProperty("scenariosExecuted", 20);
+            expect(emittedEvents[0]).toHaveProperty("confidence", "high");
+            expect(emittedEvents[0]).toHaveProperty("status", "PASS");
+            expect(emittedEvents[0]).toHaveProperty("executionTime", 5000);
+        });
+        it("should include version and schemaVersion fields", () => {
+            emitToolTestComplete("tool", "module", 10, 10, "high", "PASS", 1000);
+            expect(emittedEvents[0]).toHaveProperty("version");
+            expect(emittedEvents[0]).toHaveProperty("schemaVersion", SCHEMA_VERSION);
+        });
+        it("should handle FAIL status", () => {
+            emitToolTestComplete("vulnerable_tool", "security", 5, 20, "low", "FAIL", 3000);
+            expect(emittedEvents[0]).toHaveProperty("status", "FAIL");
+            expect(emittedEvents[0]).toHaveProperty("confidence", "low");
+            expect(emittedEvents[0]).toHaveProperty("scenariosPassed", 5);
+            expect(emittedEvents[0]).toHaveProperty("scenariosExecuted", 20);
+        });
+        it("should handle ERROR status", () => {
+            emitToolTestComplete("broken_tool", "functionality", 0, 10, "medium", "ERROR", 2000);
+            expect(emittedEvents[0]).toHaveProperty("status", "ERROR");
+            expect(emittedEvents[0]).toHaveProperty("scenariosPassed", 0);
+        });
+        it("should handle different confidence levels", () => {
+            emitToolTestComplete("t1", "m1", 10, 10, "high", "PASS", 1000);
+            emitToolTestComplete("t2", "m2", 5, 10, "medium", "PASS", 1000);
+            emitToolTestComplete("t3", "m3", 2, 10, "low", "FAIL", 1000);
+            expect(emittedEvents[0]).toHaveProperty("confidence", "high");
+            expect(emittedEvents[1]).toHaveProperty("confidence", "medium");
+            expect(emittedEvents[2]).toHaveProperty("confidence", "low");
+        });
+        it("should handle zero execution time", () => {
+            emitToolTestComplete("fast_tool", "module", 10, 10, "high", "PASS", 0);
+            expect(emittedEvents[0]).toHaveProperty("executionTime", 0);
+        });
+        it("should handle different modules", () => {
+            emitToolTestComplete("tool1", "security", 10, 10, "high", "PASS", 1000);
+            emitToolTestComplete("tool2", "functionality", 10, 10, "high", "PASS", 1000);
+            emitToolTestComplete("tool3", "error_handling", 10, 10, "high", "PASS", 1000);
+            expect(emittedEvents[0]).toHaveProperty("module", "security");
+            expect(emittedEvents[1]).toHaveProperty("module", "functionality");
+            expect(emittedEvents[2]).toHaveProperty("module", "error_handling");
+        });
+    });
+    describe("emitValidationSummary", () => {
+        it("should emit validation_summary with all required fields", () => {
+            emitValidationSummary("test_tool", 5, 3, 2, 1, 4);
+            expect(emittedEvents[0]).toHaveProperty("event", "validation_summary");
+            expect(emittedEvents[0]).toHaveProperty("tool", "test_tool");
+            expect(emittedEvents[0]).toHaveProperty("wrongType", 5);
+            expect(emittedEvents[0]).toHaveProperty("missingRequired", 3);
+            expect(emittedEvents[0]).toHaveProperty("extraParams", 2);
+            expect(emittedEvents[0]).toHaveProperty("nullValues", 1);
+            expect(emittedEvents[0]).toHaveProperty("invalidValues", 4);
+        });
+        it("should include version and schemaVersion fields", () => {
+            emitValidationSummary("tool", 0, 0, 0, 0, 0);
+            expect(emittedEvents[0]).toHaveProperty("version");
+            expect(emittedEvents[0]).toHaveProperty("schemaVersion", SCHEMA_VERSION);
+        });
+        it("should handle zero validation errors", () => {
+            emitValidationSummary("perfect_tool", 0, 0, 0, 0, 0);
+            expect(emittedEvents[0]).toHaveProperty("wrongType", 0);
+            expect(emittedEvents[0]).toHaveProperty("missingRequired", 0);
+            expect(emittedEvents[0]).toHaveProperty("extraParams", 0);
+            expect(emittedEvents[0]).toHaveProperty("nullValues", 0);
+            expect(emittedEvents[0]).toHaveProperty("invalidValues", 0);
+        });
+        it("should handle high validation error counts", () => {
+            emitValidationSummary("poor_validation_tool", 100, 50, 25, 10, 75);
+            expect(emittedEvents[0]).toHaveProperty("wrongType", 100);
+            expect(emittedEvents[0]).toHaveProperty("missingRequired", 50);
+            expect(emittedEvents[0]).toHaveProperty("extraParams", 25);
+            expect(emittedEvents[0]).toHaveProperty("nullValues", 10);
+            expect(emittedEvents[0]).toHaveProperty("invalidValues", 75);
+        });
+        it("should handle only specific error types", () => {
+            emitValidationSummary("type_check_only", 10, 0, 0, 0, 0);
+            emitValidationSummary("required_check_only", 0, 5, 0, 0, 0);
+            emitValidationSummary("null_check_only", 0, 0, 0, 3, 0);
+            expect(emittedEvents[0]).toHaveProperty("wrongType", 10);
+            expect(emittedEvents[0]).toHaveProperty("missingRequired", 0);
+            expect(emittedEvents[1]).toHaveProperty("wrongType", 0);
+            expect(emittedEvents[1]).toHaveProperty("missingRequired", 5);
+            expect(emittedEvents[2]).toHaveProperty("nullValues", 3);
+            expect(emittedEvents[2]).toHaveProperty("wrongType", 0);
+        });
+    });
+    describe("emitPhaseStarted", () => {
+        it("should emit phase_started with phase name", () => {
+            emitPhaseStarted("discovery");
+            expect(emittedEvents[0]).toHaveProperty("event", "phase_started");
+            expect(emittedEvents[0]).toHaveProperty("phase", "discovery");
+        });
+        it("should include version and schemaVersion fields", () => {
+            emitPhaseStarted("assessment");
+            expect(emittedEvents[0]).toHaveProperty("version");
+            expect(emittedEvents[0]).toHaveProperty("schemaVersion", SCHEMA_VERSION);
+        });
+        it("should handle different phase names", () => {
+            emitPhaseStarted("discovery");
+            emitPhaseStarted("assessment");
+            emitPhaseStarted("analysis");
+            emitPhaseStarted("reporting");
+            expect(emittedEvents[0]).toHaveProperty("phase", "discovery");
+            expect(emittedEvents[1]).toHaveProperty("phase", "assessment");
+            expect(emittedEvents[2]).toHaveProperty("phase", "analysis");
+            expect(emittedEvents[3]).toHaveProperty("phase", "reporting");
+        });
+        it("should handle custom phase names", () => {
+            emitPhaseStarted("custom_phase");
+            expect(emittedEvents[0]).toHaveProperty("phase", "custom_phase");
+        });
+    });
+    describe("emitPhaseComplete", () => {
+        it("should emit phase_complete with phase name and duration", () => {
+            emitPhaseComplete("discovery", 5000);
+            expect(emittedEvents[0]).toHaveProperty("event", "phase_complete");
+            expect(emittedEvents[0]).toHaveProperty("phase", "discovery");
+            expect(emittedEvents[0]).toHaveProperty("duration", 5000);
+        });
+        it("should include version and schemaVersion fields", () => {
+            emitPhaseComplete("assessment", 10000);
+            expect(emittedEvents[0]).toHaveProperty("version");
+            expect(emittedEvents[0]).toHaveProperty("schemaVersion", SCHEMA_VERSION);
+        });
+        it("should handle zero duration", () => {
+            emitPhaseComplete("fast_phase", 0);
+            expect(emittedEvents[0]).toHaveProperty("duration", 0);
+        });
+        it("should handle long durations", () => {
+            emitPhaseComplete("long_phase", 120000);
+            expect(emittedEvents[0]).toHaveProperty("duration", 120000);
+        });
+        it("should handle different phase names", () => {
+            emitPhaseComplete("discovery", 1000);
+            emitPhaseComplete("assessment", 50000);
+            emitPhaseComplete("analysis", 3000);
+            expect(emittedEvents[0]).toHaveProperty("phase", "discovery");
+            expect(emittedEvents[0]).toHaveProperty("duration", 1000);
+            expect(emittedEvents[1]).toHaveProperty("phase", "assessment");
+            expect(emittedEvents[1]).toHaveProperty("duration", 50000);
+            expect(emittedEvents[2]).toHaveProperty("phase", "analysis");
+            expect(emittedEvents[2]).toHaveProperty("duration", 3000);
+        });
+    });
+    describe("Phase 7 Event Schema Consistency", () => {
+        it("all Phase 7 events should have consistent schema version", () => {
+            emitToolTestComplete("tool", "module", 10, 10, "high", "PASS", 1000);
+            emitValidationSummary("tool", 1, 2, 3, 4, 5);
+            emitPhaseStarted("phase");
+            emitPhaseComplete("phase", 1000);
+            expect(emittedEvents[0]).toHaveProperty("schemaVersion", SCHEMA_VERSION);
+            expect(emittedEvents[1]).toHaveProperty("schemaVersion", SCHEMA_VERSION);
+            expect(emittedEvents[2]).toHaveProperty("schemaVersion", SCHEMA_VERSION);
+            expect(emittedEvents[3]).toHaveProperty("schemaVersion", SCHEMA_VERSION);
+        });
+        it("all Phase 7 events should have version field", () => {
+            emitToolTestComplete("tool", "module", 10, 10, "high", "PASS", 1000);
+            emitValidationSummary("tool", 1, 2, 3, 4, 5);
+            emitPhaseStarted("phase");
+            emitPhaseComplete("phase", 1000);
+            emittedEvents.forEach((event) => {
+                expect(event).toHaveProperty("version");
+                expect(typeof event.version).toBe("string");
+            });
+        });
+        it("all Phase 7 events should emit valid JSON", () => {
+            emitToolTestComplete("tool", "module", 10, 10, "high", "PASS", 1000);
+            emitValidationSummary("tool", 1, 2, 3, 4, 5);
+            emitPhaseStarted("phase");
+            emitPhaseComplete("phase", 1000);
+            // If parsing failed, emittedEvents would be empty
+            expect(emittedEvents.length).toBe(4);
+            emittedEvents.forEach((event) => {
+                expect(event).toBeDefined();
+                expect(typeof event).toBe("object");
+            });
+        });
+    });
 });
 describe("extractToolParams", () => {
     it("should return empty array for null schema", () => {

package/build/__tests__/lib/server-configSchemas.test.js

@@ -0,0 +1,314 @@
+/**
+ * Server Config Schemas Type Guard Tests
+ *
+ * Tests for isHttpSseConfig and isStdioConfig type guards to ensure
+ * proper mutual exclusivity and correct type discrimination.
+ *
+ * Addresses QA requirement: Test that type guards are mutually exclusive
+ * and correctly discriminate between transport types.
+ */
+import { describe, it, expect } from "@jest/globals";
+import { z } from "zod";
+// Define schemas inline to avoid import issues with client/lib in CLI tests
+const HttpSseServerConfigSchema = z.object({
+    transport: z.enum(["http", "sse"]).optional(),
+    url: z
+        .string()
+        .min(1, "'url' is required for HTTP/SSE transport")
+        .url("url must be a valid URL"),
+});
+const StdioServerConfigSchema = z.object({
+    transport: z.literal("stdio").optional(),
+    command: z.string().min(1, "command is required for stdio transport"),
+    args: z.array(z.string()).optional().default([]),
+    env: z.record(z.string()).optional().default({}),
+    cwd: z.string().optional(),
+});
+const ServerEntrySchema = z.union([
+    HttpSseServerConfigSchema,
+    StdioServerConfigSchema,
+]);
+// Type guard functions (copied from server-configSchemas.ts)
+function isHttpSseConfig(entry) {
+    return ("url" in entry || entry.transport === "http" || entry.transport === "sse");
+}
+function isStdioConfig(entry) {
+    return "command" in entry && !("url" in entry);
+}
+describe("server-configSchemas type guards", () => {
+    describe("isHttpSseConfig", () => {
+        it("should return true for HTTP transport config", () => {
+            const config = {
+                transport: "http",
+                url: "http://localhost:8080",
+            };
+            expect(isHttpSseConfig(config)).toBe(true);
+        });
+        it("should return true for SSE transport config", () => {
+            const config = {
+                transport: "sse",
+                url: "http://localhost:3000/events",
+            };
+            expect(isHttpSseConfig(config)).toBe(true);
+        });
+        it("should return true for config with url but no explicit transport", () => {
+            const config = {
+                url: "http://api.example.com/mcp",
+            };
+            expect(isHttpSseConfig(config)).toBe(true);
+        });
+        it("should return false for stdio transport config", () => {
+            const config = {
+                transport: "stdio",
+                command: "node",
+                args: ["server.js"],
+            };
+            expect(isHttpSseConfig(config)).toBe(false);
+        });
+        it("should return false for config with command but no url", () => {
+            const config = {
+                command: "python",
+                args: ["server.py"],
+            };
+            expect(isHttpSseConfig(config)).toBe(false);
+        });
+    });
+    describe("isStdioConfig", () => {
+        it("should return true for stdio transport config", () => {
+            const config = {
+                transport: "stdio",
+                command: "node",
+                args: ["index.js"],
+            };
+            expect(isStdioConfig(config)).toBe(true);
+        });
+        it("should return true for config with command but no explicit transport", () => {
+            const config = {
+                command: "python",
+                args: ["-m", "server"],
+            };
+            expect(isStdioConfig(config)).toBe(true);
+        });
+        it("should return true for minimal stdio config (command only)", () => {
+            const config = {
+                command: "simple-server",
+            };
+            expect(isStdioConfig(config)).toBe(true);
+        });
+        it("should return false for HTTP transport config", () => {
+            const config = {
+                transport: "http",
+                url: "http://localhost:8080",
+            };
+            expect(isStdioConfig(config)).toBe(false);
+        });
+        it("should return false for SSE transport config", () => {
+            const config = {
+                transport: "sse",
+                url: "http://localhost:3000/events",
+            };
+            expect(isStdioConfig(config)).toBe(false);
+        });
+        it("should return false for config with url but no command", () => {
+            const config = {
+                url: "http://api.example.com",
+            };
+            expect(isStdioConfig(config)).toBe(false);
+        });
+    });
+    describe("mutual exclusivity", () => {
+        it("HTTP config should not be stdio config", () => {
+            const config = {
+                transport: "http",
+                url: "http://localhost:8080",
+            };
+            expect(isHttpSseConfig(config)).toBe(true);
+            expect(isStdioConfig(config)).toBe(false);
+        });
+        it("SSE config should not be stdio config", () => {
+            const config = {
+                transport: "sse",
+                url: "http://localhost:3000/events",
+            };
+            expect(isHttpSseConfig(config)).toBe(true);
+            expect(isStdioConfig(config)).toBe(false);
+        });
+        it("stdio config should not be HTTP/SSE config", () => {
+            const config = {
+                transport: "stdio",
+                command: "node",
+                args: ["server.js"],
+            };
+            expect(isStdioConfig(config)).toBe(true);
+            expect(isHttpSseConfig(config)).toBe(false);
+        });
+        it("config with url should not be stdio config", () => {
+            const config = {
+                url: "http://api.example.com",
+            };
+            expect(isHttpSseConfig(config)).toBe(true);
+            expect(isStdioConfig(config)).toBe(false);
+        });
+        it("config with command should not be HTTP/SSE config", () => {
+            const config = {
+                command: "python",
+                args: ["server.py"],
+            };
+            expect(isStdioConfig(config)).toBe(true);
+            expect(isHttpSseConfig(config)).toBe(false);
+        });
+        it("every valid ServerEntry must be exactly one transport type", () => {
+            // Property: For all valid ServerEntry configs, exactly one type guard returns true
+            const validConfigs = [
+                // HTTP configs
+                { transport: "http", url: "http://localhost:8080" },
+                { url: "http://api.example.com" },
+                // SSE configs
+                { transport: "sse", url: "http://localhost:3000/events" },
+                // stdio configs
+                { transport: "stdio", command: "node", args: ["server.js"] },
+                { command: "python", args: ["server.py"] },
+                { command: "simple-server" },
+            ];
+            for (const config of validConfigs) {
+                const isHttp = isHttpSseConfig(config);
+                const isStdio = isStdioConfig(config);
+                // Exactly one should be true (XOR)
+                const exclusivelyOne = isHttp !== isStdio;
+                expect(exclusivelyOne).toBe(true);
+                // Additional check: at least one must be true
+                const atLeastOne = isHttp || isStdio;
+                expect(atLeastOne).toBe(true);
+            }
+        });
+    });
+    describe("type guard integration with schemas", () => {
+        it("validated HTTP config should pass isHttpSseConfig", () => {
+            const input = {
+                transport: "http",
+                url: "http://localhost:8080",
+            };
+            const result = ServerEntrySchema.safeParse(input);
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(isHttpSseConfig(result.data)).toBe(true);
+            }
+        });
+        it("validated SSE config should pass isHttpSseConfig", () => {
+            const input = {
+                transport: "sse",
+                url: "http://localhost:3000/events",
+            };
+            const result = ServerEntrySchema.safeParse(input);
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(isHttpSseConfig(result.data)).toBe(true);
+            }
+        });
+        it("validated stdio config should pass isStdioConfig", () => {
+            const input = {
+                command: "node",
+                args: ["server.js"],
+            };
+            const result = ServerEntrySchema.safeParse(input);
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(isStdioConfig(result.data)).toBe(true);
+            }
+        });
+        it("type guards should work with Zod-parsed data", () => {
+            const httpInput = { url: "http://api.example.com" };
+            const stdioInput = { command: "python", args: ["server.py"] };
+            const httpResult = HttpSseServerConfigSchema.safeParse(httpInput);
+            const stdioResult = StdioServerConfigSchema.safeParse(stdioInput);
+            expect(httpResult.success).toBe(true);
+            expect(stdioResult.success).toBe(true);
+            if (httpResult.success) {
+                expect(isHttpSseConfig(httpResult.data)).toBe(true);
+                expect(isStdioConfig(httpResult.data)).toBe(false);
+            }
+            if (stdioResult.success) {
+                expect(isStdioConfig(stdioResult.data)).toBe(true);
+                expect(isHttpSseConfig(stdioResult.data)).toBe(false);
+            }
+        });
+    });
+    describe("edge cases", () => {
+        it("should handle config with both url and command (ambiguous)", () => {
+            // This should not be possible with valid ServerEntry union,
+            // but test the type guard behavior if it happens
+            const ambiguousConfig = {
+                url: "http://localhost:8080",
+                command: "node",
+            };
+            // Type guards should prioritize based on their implementation
+            // isHttpSseConfig checks for 'url' or transport='http'/'sse'
+            // isStdioConfig checks for 'command' AND NOT 'url'
+            expect(isHttpSseConfig(ambiguousConfig)).toBe(true);
+            expect(isStdioConfig(ambiguousConfig)).toBe(false);
+            // This demonstrates the priority: url takes precedence over command
+        });
+        it("should handle config with transport field only (incomplete)", () => {
+            const incompleteHttpConfig = { transport: "http" };
+            const incompleteStdioConfig = {
+                transport: "stdio",
+            };
+            // These won't validate, but test type guard behavior
+            expect(isHttpSseConfig(incompleteHttpConfig)).toBe(true);
+            expect(isStdioConfig(incompleteStdioConfig)).toBe(false);
+        });
+        it("should handle empty config object", () => {
+            const emptyConfig = {};
+            // Neither type guard should match empty config
+            expect(isHttpSseConfig(emptyConfig)).toBe(false);
+            expect(isStdioConfig(emptyConfig)).toBe(false);
+        });
+    });
+    describe("TypeScript type narrowing", () => {
+        it("should narrow type to HttpSseServerConfig after guard check", () => {
+            const config = {
+                url: "http://localhost:8080",
+            };
+            if (isHttpSseConfig(config)) {
+                // TypeScript should infer config as HttpSseServerConfig here
+                const url = config.url;
+                expect(url).toBe("http://localhost:8080");
+                // @ts-expect-error - command should not exist on HttpSseServerConfig
+                const _command = config.command;
+            }
+        });
+        it("should narrow type to StdioServerConfig after guard check", () => {
+            const config = {
+                command: "node",
+                args: ["server.js"],
+            };
+            if (isStdioConfig(config)) {
+                // TypeScript should infer config as StdioServerConfig here
+                const command = config.command;
+                expect(command).toBe("node");
+                // @ts-expect-error - url should not exist on StdioServerConfig
+                const _url = config.url;
+            }
+        });
+        it("should handle exhaustive type checking pattern", () => {
+            const testConfigs = [
+                { url: "http://localhost:8080" },
+                { command: "node", args: ["server.js"] },
+            ];
+            for (const config of testConfigs) {
+                if (isHttpSseConfig(config)) {
+                    // Handle HTTP/SSE case
+                    expect(config.url).toBeTruthy();
+                }
+                else if (isStdioConfig(config)) {
+                    // Handle stdio case
+                    expect(config.command).toBeTruthy();
+                }
+                else {
+                    // This branch should never be reached for valid ServerEntry
+                    fail("Config should be either HTTP/SSE or stdio");
+                }
+            }
+        });
+    });
+});