@bryan-thompson/inspector-assessment-cli 1.43.1 → 1.43.3

package/build/__tests__/assessment-runner/index.test.js

@@ -11,7 +11,7 @@ describe("assessment-runner index exports", () => {
         jest.clearAllMocks();
     });
     describe("function exports", () => {
-        it("should export all 7 public functions", () => {
+        it("should export all 10 public functions", () => {
             expect(typeof assessmentRunner.loadServerConfig).toBe("function");
             expect(typeof assessmentRunner.loadSourceFiles).toBe("function");
             expect(typeof assessmentRunner.resolveSourcePath).toBe("function");
@@ -19,19 +19,27 @@ describe("assessment-runner index exports", () => {
             expect(typeof assessmentRunner.createCallToolWrapper).toBe("function");
             expect(typeof assessmentRunner.buildConfig).toBe("function");
             expect(typeof assessmentRunner.runFullAssessment).toBe("function");
+            // Issue #184: Single module execution
+            expect(typeof assessmentRunner.runSingleModule).toBe("function");
+            expect(typeof assessmentRunner.getValidModuleNames).toBe("function");
+            // Issue #212: Native module detection
+            expect(typeof assessmentRunner.detectNativeModules).toBe("function");
         });
-        it("should export exactly 7 functions", () => {
+        it("should export exactly 10 functions", () => {
             const functionNames = Object.keys(assessmentRunner).filter((key) => typeof assessmentRunner[key] ===
                 "function");
-            expect(functionNames).toHaveLength(7);
+            expect(functionNames).toHaveLength(10);
             expect(functionNames.sort()).toEqual([
                 "buildConfig",
                 "connectToServer",
                 "createCallToolWrapper",
+                "detectNativeModules", // Issue #212
+                "getValidModuleNames", // Issue #184
                 "loadServerConfig",
                 "loadSourceFiles",
                 "resolveSourcePath",
                 "runFullAssessment",
+                "runSingleModule", // Issue #184
             ]);
         });
     });

package/build/__tests__/assessment-runner/native-module-detector.test.js

@@ -0,0 +1,199 @@
+/**
+ * Native Module Detector Tests
+ *
+ * Tests for the pre-flight native module detection that warns about
+ * potential issues before MCP server connection.
+ *
+ * @see https://github.com/triepod-ai/inspector-assessment/issues/212
+ */
+import { describe, it, expect, jest, beforeEach, afterEach, } from "@jest/globals";
+import { detectNativeModules, } from "../../lib/assessment-runner/native-module-detector.js";
+// Mock the jsonl-events module
+jest.mock("../../lib/jsonl-events.js", () => ({
+    emitNativeModuleWarning: jest.fn(),
+}));
+// Import the mocked function for assertions
+import { emitNativeModuleWarning } from "../../lib/jsonl-events.js";
+describe("native-module-detector", () => {
+    // Store original console methods
+    let consoleLogSpy;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        // Mock console.log to suppress output during tests
+        consoleLogSpy = jest.spyOn(console, "log").mockImplementation(() => { });
+    });
+    afterEach(() => {
+        consoleLogSpy.mockRestore();
+    });
+    describe("detectNativeModules", () => {
+        it("should return empty result for undefined packageJson", () => {
+            const result = detectNativeModules(undefined, { jsonOnly: true });
+            expect(result.detected).toBe(false);
+            expect(result.count).toBe(0);
+            expect(result.modules).toHaveLength(0);
+            expect(Object.keys(result.suggestedEnvVars)).toHaveLength(0);
+            expect(emitNativeModuleWarning).not.toHaveBeenCalled();
+        });
+        it("should return empty result for package without native modules", () => {
+            const packageJson = {
+                dependencies: {
+                    express: "^4.18.0",
+                    lodash: "^4.17.21",
+                },
+            };
+            const result = detectNativeModules(packageJson, { jsonOnly: true });
+            expect(result.detected).toBe(false);
+            expect(result.count).toBe(0);
+            expect(result.modules).toHaveLength(0);
+            expect(emitNativeModuleWarning).not.toHaveBeenCalled();
+        });
+        it("should detect canvas in dependencies", () => {
+            const packageJson = {
+                dependencies: { canvas: "^2.11.0" },
+            };
+            const result = detectNativeModules(packageJson, { jsonOnly: true });
+            expect(result.detected).toBe(true);
+            expect(result.count).toBe(1);
+            expect(result.modules).toHaveLength(1);
+            expect(result.modules[0].name).toBe("canvas");
+            expect(result.modules[0].category).toBe("image");
+            expect(result.modules[0].severity).toBe("HIGH");
+            expect(result.modules[0].dependencyType).toBe("dependencies");
+            expect(result.modules[0].version).toBe("^2.11.0");
+        });
+        it("should emit JSONL event for each detected module", () => {
+            const packageJson = {
+                dependencies: { canvas: "^2.11.0" },
+            };
+            detectNativeModules(packageJson, { jsonOnly: true });
+            expect(emitNativeModuleWarning).toHaveBeenCalledTimes(1);
+            expect(emitNativeModuleWarning).toHaveBeenCalledWith("canvas", "image", "HIGH", expect.stringContaining("Cairo"), "dependencies", "^2.11.0", expect.objectContaining({ CANVAS_BACKEND: "mock" }));
+        });
+        it("should detect multiple native modules", () => {
+            const packageJson = {
+                dependencies: {
+                    canvas: "^2.11.0",
+                    sharp: "^0.32.0",
+                },
+            };
+            const result = detectNativeModules(packageJson, { jsonOnly: true });
+            expect(result.detected).toBe(true);
+            expect(result.count).toBe(2);
+            expect(result.modules).toHaveLength(2);
+            const names = result.modules.map((m) => m.name);
+            expect(names).toContain("canvas");
+            expect(names).toContain("sharp");
+            expect(emitNativeModuleWarning).toHaveBeenCalledTimes(2);
+        });
+        it("should collect suggested env vars from all modules", () => {
+            const packageJson = {
+                dependencies: {
+                    canvas: "^2.11.0",
+                    sharp: "^0.32.0",
+                    "maplibre-gl-native": "^1.0.0",
+                },
+            };
+            const result = detectNativeModules(packageJson, { jsonOnly: true });
+            expect(result.suggestedEnvVars).toEqual({
+                CANVAS_BACKEND: "mock",
+                SHARP_IGNORE_GLOBAL_LIBVIPS: "1",
+                ENABLE_DYNAMIC_MAPS: "false",
+            });
+        });
+        it("should detect modules in devDependencies", () => {
+            const packageJson = {
+                devDependencies: { "better-sqlite3": "^9.0.0" },
+            };
+            const result = detectNativeModules(packageJson, { jsonOnly: true });
+            expect(result.detected).toBe(true);
+            expect(result.modules[0].dependencyType).toBe("devDependencies");
+        });
+        it("should detect modules in optionalDependencies", () => {
+            const packageJson = {
+                optionalDependencies: { bcrypt: "^5.1.0" },
+            };
+            const result = detectNativeModules(packageJson, { jsonOnly: true });
+            expect(result.detected).toBe(true);
+            expect(result.modules[0].dependencyType).toBe("optionalDependencies");
+        });
+        it("should suppress console output when jsonOnly is true", () => {
+            const packageJson = {
+                dependencies: { canvas: "^2.11.0" },
+            };
+            detectNativeModules(packageJson, { jsonOnly: true });
+            // Console should not have been called (except for the mock)
+            expect(consoleLogSpy).not.toHaveBeenCalled();
+        });
+        it("should print console warnings when jsonOnly is false", () => {
+            const packageJson = {
+                dependencies: { canvas: "^2.11.0" },
+            };
+            detectNativeModules(packageJson, { jsonOnly: false });
+            // Console should have been called with warning message
+            expect(consoleLogSpy).toHaveBeenCalled();
+            const allCalls = consoleLogSpy.mock.calls.flat().join(" ");
+            expect(allCalls).toContain("Native Module Warning");
+        });
+        it("should handle modules without suggested env vars", () => {
+            const packageJson = {
+                dependencies: { "better-sqlite3": "^9.0.0" },
+            };
+            const result = detectNativeModules(packageJson, { jsonOnly: true });
+            expect(result.detected).toBe(true);
+            expect(result.modules[0].suggestedEnvVars).toBeUndefined();
+            // Env vars should be empty since better-sqlite3 has no suggestions
+            expect(Object.keys(result.suggestedEnvVars)).toHaveLength(0);
+        });
+        it("should handle empty dependencies objects", () => {
+            const packageJson = {
+                dependencies: {},
+                devDependencies: {},
+            };
+            const result = detectNativeModules(packageJson, { jsonOnly: true });
+            expect(result.detected).toBe(false);
+            expect(result.count).toBe(0);
+        });
+        it("should include correct severity icons in console output", () => {
+            const packageJson = {
+                dependencies: {
+                    canvas: "^2.11.0", // HIGH severity
+                    bcrypt: "^5.1.0", // MEDIUM severity
+                },
+            };
+            detectNativeModules(packageJson, { jsonOnly: false });
+            // Check that console.log was called
+            expect(consoleLogSpy).toHaveBeenCalled();
+        });
+    });
+    describe("return type shape", () => {
+        it("should return correct result shape for detected modules", () => {
+            const packageJson = {
+                dependencies: { canvas: "^2.11.0" },
+            };
+            const result = detectNativeModules(packageJson, { jsonOnly: true });
+            // Verify all expected properties exist
+            expect(result).toHaveProperty("detected");
+            expect(result).toHaveProperty("count");
+            expect(result).toHaveProperty("modules");
+            expect(result).toHaveProperty("suggestedEnvVars");
+            // Verify types
+            expect(typeof result.detected).toBe("boolean");
+            expect(typeof result.count).toBe("number");
+            expect(Array.isArray(result.modules)).toBe(true);
+            expect(typeof result.suggestedEnvVars).toBe("object");
+        });
+        it("should return correct module shape", () => {
+            const packageJson = {
+                dependencies: { canvas: "^2.11.0" },
+            };
+            const result = detectNativeModules(packageJson, { jsonOnly: true });
+            const module = result.modules[0];
+            expect(module).toHaveProperty("name");
+            expect(module).toHaveProperty("category");
+            expect(module).toHaveProperty("severity");
+            expect(module).toHaveProperty("warningMessage");
+            expect(module).toHaveProperty("dependencyType");
+            expect(module).toHaveProperty("version");
+        });
+    });
+});

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

@@ -123,7 +123,7 @@ describe("connectToServer", () => {
             };
             await expect(connectToServer(config)).rejects.toThrow("Command required for stdio transport");
         });
-        it("should merge process.env with config.env", async () => {
+        it("should pass minimal env vars plus config.env overrides", async () => {
             const originalEnv = process.env;
             process.env = { PATH: "/usr/bin", HOME: "/home/user" };
             const config = {
@@ -134,11 +134,40 @@ describe("connectToServer", () => {
             };
             await connectToServer(config);
             const callArg = StdioClientTransport.mock.calls[0][0];
+            // Minimal env vars (PATH, HOME) should be present
             expect(callArg.env).toEqual(expect.objectContaining({
                 PATH: "/usr/bin",
                 HOME: "/home/user",
                 CUSTOM_VAR: "value",
             }));
+            // NODE_ENV should default to "production" when not set
+            expect(callArg.env.NODE_ENV).toBe("production");
+            process.env = originalEnv;
+        });
+        it("should NOT pass arbitrary process.env vars (Issue #211)", async () => {
+            const originalEnv = process.env;
+            process.env = {
+                PATH: "/usr/bin",
+                HOME: "/home/user",
+                SOME_RANDOM_VAR: "should-not-pass",
+                ENABLE_DYNAMIC_MAPS: "true", // This caused TomTom MCP issues
+                AWS_ACCESS_KEY_ID: "secret", // Sensitive vars should not leak
+            };
+            const config = {
+                transport: "stdio",
+                command: "node",
+                args: [],
+                env: {},
+            };
+            await connectToServer(config);
+            const callArg = StdioClientTransport.mock.calls[0][0];
+            // These arbitrary vars should NOT be in the env
+            expect(callArg.env.SOME_RANDOM_VAR).toBeUndefined();
+            expect(callArg.env.ENABLE_DYNAMIC_MAPS).toBeUndefined();
+            expect(callArg.env.AWS_ACCESS_KEY_ID).toBeUndefined();
+            // But essential vars should still be present
+            expect(callArg.env.PATH).toBe("/usr/bin");
+            expect(callArg.env.HOME).toBe("/home/user");
             process.env = originalEnv;
         });
         it("should setup stderr listener before connecting", async () => {
@@ -226,4 +255,158 @@ describe("connectToServer", () => {
             await expect(connectToServer(config)).rejects.toThrow("Failed to connect to MCP server: Connection timeout");
         });
     });
+    // ============================================================================
+    // GAP-002: SIGKILL Detection Tests (Issue #212)
+    // ============================================================================
+    describe("SIGKILL detection (Issue #212)", () => {
+        it('should detect SIGKILL from "exit code 137" error message', async () => {
+            let stderrCallback = () => { };
+            mockStdioTransport.stderr.on.mockImplementation((event, cb) => {
+                if (event === "data") {
+                    stderrCallback = cb;
+                }
+            });
+            mockConnect.mockImplementation(async () => {
+                throw new Error("Process exited with exit code 137");
+            });
+            const config = {
+                transport: "stdio",
+                command: "node",
+                args: ["server.js"],
+            };
+            await expect(connectToServer(config)).rejects.toThrow(/Exit code 137 \(SIGKILL\) detected/);
+        });
+        it('should detect SIGKILL from "SIGKILL" in error message', async () => {
+            mockConnect.mockRejectedValue(new Error("Process killed with SIGKILL"));
+            const config = {
+                transport: "stdio",
+                command: "python",
+                args: ["server.py"],
+            };
+            await expect(connectToServer(config)).rejects.toThrow(/Exit code 137 \(SIGKILL\) detected/);
+        });
+        it('should detect SIGKILL from "killed" (lowercase) in error message', async () => {
+            mockConnect.mockRejectedValue(new Error("Server process was killed unexpectedly"));
+            const config = {
+                transport: "stdio",
+                command: "node",
+                args: [],
+            };
+            await expect(connectToServer(config)).rejects.toThrow(/Exit code 137 \(SIGKILL\) detected/);
+        });
+        it("should NOT trigger SIGKILL help for regular errors", async () => {
+            mockConnect.mockRejectedValue(new Error("Connection refused"));
+            const config = {
+                transport: "stdio",
+                command: "node",
+                args: [],
+            };
+            const error = await connectToServer(config).catch((e) => e);
+            expect(error.message).not.toMatch(/Exit code 137 \(SIGKILL\) detected/);
+            expect(error.message).toMatch(/Failed to connect to MCP server/);
+            expect(error.message).toMatch(/Common causes/);
+        });
+        it("should include xattr suggestion in SIGKILL error message", async () => {
+            mockConnect.mockRejectedValue(new Error("exit code 137"));
+            const config = {
+                transport: "stdio",
+                command: "node",
+                args: [],
+            };
+            await expect(connectToServer(config)).rejects.toThrow(/xattr -d com\.apple\.quarantine/);
+        });
+        it("should include Security & Privacy suggestion in SIGKILL error message", async () => {
+            mockConnect.mockRejectedValue(new Error("Process killed with SIGKILL"));
+            const config = {
+                transport: "stdio",
+                command: "node",
+                args: [],
+            };
+            await expect(connectToServer(config)).rejects.toThrow(/System Preferences > Security & Privacy/);
+        });
+        it("should mention Gatekeeper in SIGKILL error message", async () => {
+            mockConnect.mockRejectedValue(new Error("exit code 137"));
+            const config = {
+                transport: "stdio",
+                command: "node",
+                args: [],
+            };
+            await expect(connectToServer(config)).rejects.toThrow(/macOS Gatekeeper blocked unsigned native binaries/);
+        });
+        it("should mention native module examples in SIGKILL error message", async () => {
+            mockConnect.mockRejectedValue(new Error("killed"));
+            const config = {
+                transport: "stdio",
+                command: "node",
+                args: [],
+            };
+            await expect(connectToServer(config)).rejects.toThrow(/canvas, sharp, better-sqlite3/);
+        });
+        it("should mention pre-flight warnings in SIGKILL error message", async () => {
+            mockConnect.mockRejectedValue(new Error("SIGKILL"));
+            const config = {
+                transport: "stdio",
+                command: "node",
+                args: [],
+            };
+            await expect(connectToServer(config)).rejects.toThrow(/Check pre-flight warnings above for detected native modules/);
+        });
+        it("should suggest pure JavaScript alternatives in SIGKILL error message", async () => {
+            mockConnect.mockRejectedValue(new Error("exit code 137"));
+            const config = {
+                transport: "stdio",
+                command: "node",
+                args: [],
+            };
+            await expect(connectToServer(config)).rejects.toThrow(/jimp instead of sharp/);
+        });
+        it("should include both stderr and SIGKILL help when process is killed", async () => {
+            let stderrCallback = () => { };
+            mockStdioTransport.stderr.on.mockImplementation((event, cb) => {
+                if (event === "data") {
+                    stderrCallback = cb;
+                }
+            });
+            mockConnect.mockImplementation(async () => {
+                stderrCallback(Buffer.from("Loading canvas module..."));
+                throw new Error("Process killed (exit code 137)");
+            });
+            const config = {
+                transport: "stdio",
+                command: "node",
+                args: ["server.js"],
+            };
+            const error = await connectToServer(config).catch((e) => e);
+            expect(error.message).toMatch(/Loading canvas module/);
+            expect(error.message).toMatch(/Exit code 137 \(SIGKILL\) detected/);
+            expect(error.message).toMatch(/macOS Gatekeeper/);
+            expect(error.message).toMatch(/xattr/);
+        });
+        it("should handle SIGKILL detection for HTTP transport", async () => {
+            // SIGKILL can occur during startup even for HTTP servers
+            mockConnect.mockRejectedValue(new Error("Server startup failed: exit code 137"));
+            const config = {
+                transport: "http",
+                url: "http://localhost:8080",
+            };
+            await expect(connectToServer(config)).rejects.toThrow(/Exit code 137 \(SIGKILL\) detected/);
+        });
+        it("should handle SIGKILL detection for SSE transport", async () => {
+            mockConnect.mockRejectedValue(new Error("Connection killed"));
+            const config = {
+                transport: "sse",
+                url: "http://localhost:3000/events",
+            };
+            await expect(connectToServer(config)).rejects.toThrow(/Exit code 137 \(SIGKILL\) detected/);
+        });
+        it("should mention OOM as possible cause in SIGKILL error", async () => {
+            mockConnect.mockRejectedValue(new Error("SIGKILL"));
+            const config = {
+                transport: "stdio",
+                command: "node",
+                args: [],
+            };
+            await expect(connectToServer(config)).rejects.toThrow(/Out of memory during native module initialization/);
+        });
+    });
 });

package/build/__tests__/assessment-runner-facade.test.js

@@ -82,17 +82,20 @@ describe("Assessment Runner Facade", () => {
         });
     });
     describe("Export Completeness", () => {
-        it("should export exactly 6 functions", () => {
+        it("should export exactly 10 functions", () => {
             const exportedFunctions = Object.entries(AssessmentRunner).filter(([, value]) => typeof value === "function");
-            expect(exportedFunctions.length).toBe(7);
+            expect(exportedFunctions.length).toBe(10);
             expect(exportedFunctions.map(([name]) => name).sort()).toEqual([
                 "buildConfig",
                 "connectToServer",
                 "createCallToolWrapper",
+                "detectNativeModules", // Issue #212
+                "getValidModuleNames", // Issue #184
                 "loadServerConfig",
                 "loadSourceFiles",
                 "resolveSourcePath",
                 "runFullAssessment",
+                "runSingleModule", // Issue #184
             ]);
         });
         it("should not have unexpected exports", () => {
@@ -105,6 +108,11 @@ describe("Assessment Runner Facade", () => {
                 "createCallToolWrapper",
                 "buildConfig",
                 "runFullAssessment",
+                // Issue #184: Single module execution
+                "runSingleModule",
+                "getValidModuleNames",
+                // Issue #212: Native module detection
+                "detectNativeModules",
             ];
             // All exports should be in the expected list
             for (const exportName of allExports) {

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

@@ -9,7 +9,7 @@
  * 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, emitToolTestComplete, emitValidationSummary, emitPhaseStarted, emitPhaseComplete, extractToolParams, SCHEMA_VERSION, } from "../lib/jsonl-events.js";
+import { emitJSONL, emitServerConnected, emitToolDiscovered, emitToolsDiscoveryComplete, emitAssessmentComplete, emitTestBatch, emitVulnerabilityFound, emitAnnotationMissing, emitAnnotationMisaligned, emitAnnotationReviewRecommended, emitAnnotationAligned, emitModulesConfigured, emitToolTestComplete, emitValidationSummary, emitPhaseStarted, emitPhaseComplete, emitNativeModuleWarning, extractToolParams, SCHEMA_VERSION, } from "../lib/jsonl-events.js";
 describe("JSONL Event Emission", () => {
     let consoleErrorSpy;
     let emittedEvents;
@@ -460,6 +460,88 @@ describe("JSONL Event Emission", () => {
         });
     });
     // ============================================================================
+    // GAP-001: emitNativeModuleWarning() Tests
+    // ============================================================================
+    describe("emitNativeModuleWarning", () => {
+        it("should emit native_module_warning with all required fields", () => {
+            emitNativeModuleWarning("canvas", "NATIVE_BINARY", "HIGH", "Native binary may trigger Gatekeeper on macOS", "dependencies", "^2.11.2", { CANVAS_BACKEND: "node" });
+            expect(emittedEvents[0]).toHaveProperty("event", "native_module_warning");
+            expect(emittedEvents[0]).toHaveProperty("moduleName", "canvas");
+            expect(emittedEvents[0]).toHaveProperty("category", "NATIVE_BINARY");
+            expect(emittedEvents[0]).toHaveProperty("severity", "HIGH");
+            expect(emittedEvents[0]).toHaveProperty("warningMessage", "Native binary may trigger Gatekeeper on macOS");
+            expect(emittedEvents[0]).toHaveProperty("dependencyType", "dependencies");
+            expect(emittedEvents[0]).toHaveProperty("moduleVersion", "^2.11.2");
+            expect(emittedEvents[0]).toHaveProperty("suggestedEnvVars");
+            expect(emittedEvents[0].suggestedEnvVars).toEqual({
+                CANVAS_BACKEND: "node",
+            });
+        });
+        it("should emit native_module_warning without suggestedEnvVars (optional parameter)", () => {
+            emitNativeModuleWarning("sharp", "NATIVE_BINARY", "MEDIUM", "Image processing module with native dependencies", "devDependencies", "^0.33.0");
+            expect(emittedEvents[0]).toHaveProperty("event", "native_module_warning");
+            expect(emittedEvents[0]).toHaveProperty("moduleName", "sharp");
+            expect(emittedEvents[0]).toHaveProperty("category", "NATIVE_BINARY");
+            expect(emittedEvents[0]).toHaveProperty("severity", "MEDIUM");
+            expect(emittedEvents[0]).toHaveProperty("warningMessage", "Image processing module with native dependencies");
+            expect(emittedEvents[0]).toHaveProperty("dependencyType", "devDependencies");
+            expect(emittedEvents[0]).toHaveProperty("moduleVersion", "^0.33.0");
+            expect(emittedEvents[0]).not.toHaveProperty("suggestedEnvVars");
+        });
+        it("should not include suggestedEnvVars when empty object provided", () => {
+            emitNativeModuleWarning("better-sqlite3", "NATIVE_BINARY", "HIGH", "SQLite with native bindings", "dependencies", "^9.0.0", {});
+            expect(emittedEvents[0]).toHaveProperty("event", "native_module_warning");
+            expect(emittedEvents[0]).toHaveProperty("moduleName", "better-sqlite3");
+            expect(emittedEvents[0]).not.toHaveProperty("suggestedEnvVars");
+        });
+        it("should handle HIGH severity", () => {
+            emitNativeModuleWarning("canvas", "NATIVE_BINARY", "HIGH", "Critical native module", "dependencies", "^2.0.0");
+            expect(emittedEvents[0]).toHaveProperty("severity", "HIGH");
+        });
+        it("should handle MEDIUM severity", () => {
+            emitNativeModuleWarning("node-gyp", "BUILD_TOOL", "MEDIUM", "Build toolchain required", "devDependencies", "^10.0.0");
+            expect(emittedEvents[0]).toHaveProperty("severity", "MEDIUM");
+        });
+        it("should include version and schemaVersion fields", () => {
+            emitNativeModuleWarning("test-module", "TEST_CATEGORY", "HIGH", "Test warning", "dependencies", "^1.0.0");
+            expect(emittedEvents[0]).toHaveProperty("version");
+            expect(emittedEvents[0]).toHaveProperty("schemaVersion", SCHEMA_VERSION);
+        });
+        it("should handle multiple suggestedEnvVars", () => {
+            emitNativeModuleWarning("puppeteer", "NATIVE_BINARY", "MEDIUM", "Chromium download may be blocked", "dependencies", "^21.0.0", {
+                PUPPETEER_SKIP_CHROMIUM_DOWNLOAD: "true",
+                PUPPETEER_EXECUTABLE_PATH: "/usr/bin/chromium",
+            });
+            expect(emittedEvents[0].suggestedEnvVars).toEqual({
+                PUPPETEER_SKIP_CHROMIUM_DOWNLOAD: "true",
+                PUPPETEER_EXECUTABLE_PATH: "/usr/bin/chromium",
+            });
+        });
+        it("should handle different dependencyType values", () => {
+            emitNativeModuleWarning("module1", "NATIVE_BINARY", "HIGH", "Warning 1", "dependencies", "^1.0.0");
+            emitNativeModuleWarning("module2", "NATIVE_BINARY", "HIGH", "Warning 2", "devDependencies", "^2.0.0");
+            emitNativeModuleWarning("module3", "NATIVE_BINARY", "MEDIUM", "Warning 3", "optionalDependencies", "^3.0.0");
+            expect(emittedEvents[0]).toHaveProperty("dependencyType", "dependencies");
+            expect(emittedEvents[1]).toHaveProperty("dependencyType", "devDependencies");
+            expect(emittedEvents[2]).toHaveProperty("dependencyType", "optionalDependencies");
+        });
+        it("should handle different category values", () => {
+            emitNativeModuleWarning("canvas", "NATIVE_BINARY", "HIGH", "Binary warning", "dependencies", "^1.0.0");
+            emitNativeModuleWarning("node-gyp", "BUILD_TOOL", "MEDIUM", "Build warning", "devDependencies", "^2.0.0");
+            emitNativeModuleWarning("custom", "CUSTOM_CATEGORY", "HIGH", "Custom warning", "dependencies", "^3.0.0");
+            expect(emittedEvents[0]).toHaveProperty("category", "NATIVE_BINARY");
+            expect(emittedEvents[1]).toHaveProperty("category", "BUILD_TOOL");
+            expect(emittedEvents[2]).toHaveProperty("category", "CUSTOM_CATEGORY");
+        });
+        it("should emit valid JSON", () => {
+            emitNativeModuleWarning("test-module", "TEST", "HIGH", "Test message", "dependencies", "^1.0.0", { VAR1: "value1" });
+            // If parsing failed, emittedEvents would be empty
+            expect(emittedEvents.length).toBe(1);
+            expect(emittedEvents[0]).toBeDefined();
+            expect(typeof emittedEvents[0]).toBe("object");
+        });
+    });
+    // ============================================================================
     // Phase 7 Events - Per-Tool Testing & Phase Lifecycle
     // ============================================================================
     describe("emitToolTestComplete", () => {