@bryan-thompson/inspector-assessment 1.35.2 → 1.36.0

package/cli/build/__tests__/assess-full-e2e.test.js

@@ -14,7 +14,7 @@
  *
  * @see https://github.com/triepod-ai/inspector-assessment/issues/97
  */
-import { describe, it, expect, beforeAll, afterAll } from "@jest/globals";
+import { jest, describe, it, expect, beforeAll, afterAll, afterEach, } from "@jest/globals";
 import { spawn } from "child_process";
 import * as fs from "fs";
 import * as path from "path";
@@ -76,6 +76,10 @@ async function spawnCLI(args, timeout = 60000) {
         // Set timeout
         const timer = setTimeout(() => {
             if (proc && !proc.killed) {
+                // Destroy streams before killing to prevent memory leaks
+                proc.stdout?.destroy();
+                proc.stderr?.destroy();
+                proc.stdin?.destroy();
                 proc.kill("SIGTERM");
                 exitCode = -1; // Indicate timeout
             }
@@ -83,6 +87,10 @@ async function spawnCLI(args, timeout = 60000) {
         // Handle process exit
         proc.on("close", (code) => {
             clearTimeout(timer);
+            // Destroy streams to prevent memory leaks
+            proc?.stdout?.destroy();
+            proc?.stderr?.destroy();
+            proc?.stdin?.destroy();
             // Don't overwrite timeout exit code (-1)
             if (exitCode !== -1) {
                 exitCode = code;
@@ -100,6 +108,10 @@ async function spawnCLI(args, timeout = 60000) {
         // Handle errors
         proc.on("error", (err) => {
             clearTimeout(timer);
+            // Destroy streams to prevent memory leaks
+            proc?.stdout?.destroy();
+            proc?.stderr?.destroy();
+            proc?.stdin?.destroy();
             stderr += `\nProcess error: ${err.message}`;
             resolve({
                 stdout,
@@ -151,10 +163,10 @@ function parseJSONLEvents(stderr) {
  * @returns True if server responds, false otherwise
  */
 async function checkServerAvailable(url) {
+    const controller = new AbortController();
+    // Give enough time to receive initial response but not wait forever
+    const timeoutId = setTimeout(() => controller.abort(), 5000);
     try {
-        const controller = new AbortController();
-        // Give enough time to receive initial response but not wait forever
-        const timeoutId = setTimeout(() => controller.abort(), 5000);
         const response = await fetch(url, {
             method: "POST",
             headers: DEFAULT_HEADERS,
@@ -172,26 +184,22 @@ async function checkServerAvailable(url) {
         });
         // Server responded with a status code - check if it's OK
         if (response.status >= 500) {
-            clearTimeout(timeoutId);
             return false;
         }
         // For SSE responses, check if we can read any data
         // This confirms the server is actually responding
         const reader = response.body?.getReader();
         if (!reader) {
-            clearTimeout(timeoutId);
             return response.status < 500;
         }
         try {
             // Try to read the first chunk
             const { done, value } = await reader.read();
-            clearTimeout(timeoutId);
             reader.cancel(); // Cancel the stream - we don't need more data
             // If we got any data, the server is available
             return !done && value && value.length > 0;
         }
         catch {
-            clearTimeout(timeoutId);
             // If read fails after successful fetch, server still responded
             return true;
         }
@@ -199,6 +207,11 @@ async function checkServerAvailable(url) {
     catch {
         return false;
     }
+    finally {
+        // Always clean up timeout and abort controller
+        clearTimeout(timeoutId);
+        controller.abort();
+    }
 }
 /**
  * Create a temporary config file for testing
@@ -235,9 +248,22 @@ function createInvalidConfig(content, filename) {
     return configPath;
 }
 // ============================================================================
+// E2E Skip Check
+// ============================================================================
+/**
+ * Skip E2E tests unless RUN_E2E_TESTS is set.
+ * This prevents long timeouts when testbed servers aren't running.
+ *
+ * To run E2E tests: RUN_E2E_TESTS=1 npm test -- --testPathPattern="e2e"
+ */
+const describeE2E = process.env.RUN_E2E_TESTS ? describe : describe.skip;
+// ============================================================================
 // Test Setup
 // ============================================================================
-describe("CLI E2E Integration Tests", () => {
+describeE2E("CLI E2E Integration Tests", () => {
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
     let vulnerableAvailable = false;
     let hardenedAvailable = false;
     beforeAll(async () => {

package/cli/build/__tests__/assess-full.test.js

@@ -6,13 +6,16 @@
  * external dependencies. For integration testing of the full CLI, use the
  * actual CLI binary.
  */
-import { describe, it, expect } from "@jest/globals";
+import { jest, describe, it, expect, afterEach } from "@jest/globals";
 import * as path from "path";
 /**
  * Pure function tests - these test logic concepts used in the CLI
  * without needing to import the actual module (which has side effects)
  */
 describe("CLI Argument Parsing Concepts", () => {
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
     describe("Profile Flag Parsing", () => {
         const VALID_PROFILES = ["quick", "security", "compliance", "full"];
         function parseProfile(args) {

package/cli/build/__tests__/assessment-runner/assessment-executor.test.js

@@ -3,7 +3,7 @@
  *
  * Tests for runFullAssessment() orchestration logic.
  */
-import { jest, describe, it, expect, beforeEach, afterEach, } from "@jest/globals";
+import { jest, describe, it, expect, beforeEach, afterEach, afterAll, } from "@jest/globals";
 // Mock all dependencies with explicit any types for flexibility
 const mockLoadServerConfig = jest.fn();
 const mockConnectToServer = jest.fn();
@@ -137,6 +137,19 @@ describe("runFullAssessment", () => {
     afterEach(() => {
         jest.restoreAllMocks();
     });
+    afterAll(() => {
+        // Clean up module mocks to prevent memory leaks
+        jest.unmock("../../lib/assessment-runner/server-config.js");
+        jest.unmock("../../lib/assessment-runner/server-connection.js");
+        jest.unmock("../../lib/assessment-runner/source-loader.js");
+        jest.unmock("../../lib/assessment-runner/tool-wrapper.js");
+        jest.unmock("../../lib/assessment-runner/config-builder.js");
+        jest.unmock("../../../../client/lib/services/assessment/AssessmentOrchestrator.js");
+        jest.unmock("../../assessmentState.js");
+        jest.unmock("../../lib/jsonl-events.js");
+        jest.unmock("fs");
+        jest.unmock("../../../../client/lib/lib/assessmentTypes.js");
+    });
     describe("orchestration flow", () => {
         it("should load server config", async () => {
             await runFullAssessment(defaultOptions);
@@ -203,7 +216,7 @@ describe("runFullAssessment", () => {
                 ...defaultOptions,
                 sourceCodePath: "/path/to/source",
             });
-            expect(mockLoadSourceFiles).toHaveBeenCalledWith("/path/to/source");
+            expect(mockLoadSourceFiles).toHaveBeenCalledWith("/path/to/source", undefined);
         });
         it("should not load source files when path does not exist", async () => {
             const fs = await import("fs");

package/cli/build/__tests__/assessment-runner/config-builder.test.js

@@ -62,6 +62,12 @@ describe("buildConfig", () => {
     afterEach(() => {
         process.env = originalEnv;
     });
+    afterAll(() => {
+        jest.unmock("../../profiles.js");
+        jest.unmock("../../../../client/lib/lib/assessmentTypes.js");
+        jest.unmock("../../../../client/lib/services/assessment/lib/claudeCodeBridge.js");
+        jest.unmock("../../../../client/lib/services/assessment/config/performanceConfig.js");
+    });
     describe("default configuration", () => {
         it("should spread DEFAULT_ASSESSMENT_CONFIG", () => {
             const result = buildConfig({ serverName: "test" });

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

@@ -3,29 +3,34 @@
  *
  * Tests for the facade module exports.
  */
-import { describe, it, expect } from "@jest/globals";
+import { jest, describe, it, expect, afterEach } from "@jest/globals";
 // Import the barrel/facade module
 import * as assessmentRunner from "../../lib/assessment-runner/index.js";
 describe("assessment-runner index exports", () => {
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
     describe("function exports", () => {
-        it("should export all 6 public functions", () => {
+        it("should export all 7 public functions", () => {
             expect(typeof assessmentRunner.loadServerConfig).toBe("function");
             expect(typeof assessmentRunner.loadSourceFiles).toBe("function");
+            expect(typeof assessmentRunner.resolveSourcePath).toBe("function");
             expect(typeof assessmentRunner.connectToServer).toBe("function");
             expect(typeof assessmentRunner.createCallToolWrapper).toBe("function");
             expect(typeof assessmentRunner.buildConfig).toBe("function");
             expect(typeof assessmentRunner.runFullAssessment).toBe("function");
         });
-        it("should export exactly 6 functions", () => {
+        it("should export exactly 7 functions", () => {
             const functionNames = Object.keys(assessmentRunner).filter((key) => typeof assessmentRunner[key] ===
                 "function");
-            expect(functionNames).toHaveLength(6);
+            expect(functionNames).toHaveLength(7);
             expect(functionNames.sort()).toEqual([
                 "buildConfig",
                 "connectToServer",
                 "createCallToolWrapper",
                 "loadServerConfig",
                 "loadSourceFiles",
+                "resolveSourcePath",
                 "runFullAssessment",
             ]);
         });

package/cli/build/__tests__/assessment-runner/path-resolver.test.js

@@ -0,0 +1,112 @@
+/**
+ * Path Resolver Unit Tests
+ *
+ * Tests for resolveSourcePath() that handles path normalization.
+ */
+import { jest, describe, it, expect, beforeEach, afterAll, } from "@jest/globals";
+import * as path from "path";
+import * as os from "os";
+// Mock fs module
+jest.unstable_mockModule("fs", () => ({
+    existsSync: jest.fn(),
+    realpathSync: jest.fn(),
+}));
+// Import after mocking
+const fs = await import("fs");
+const { resolveSourcePath } = await import("../../lib/assessment-runner/path-resolver.js");
+describe("resolveSourcePath", () => {
+    const mockExistsSync = fs.existsSync;
+    const mockRealpathSync = fs.realpathSync;
+    beforeEach(() => {
+        mockExistsSync.mockReturnValue(false);
+        mockRealpathSync.mockReturnValue("");
+    });
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    afterAll(() => {
+        jest.unmock("fs");
+    });
+    describe("tilde expansion", () => {
+        it("should expand ~ to home directory", () => {
+            mockExistsSync.mockReturnValue(false);
+            const result = resolveSourcePath("~/project");
+            expect(result).toBe(path.join(os.homedir(), "project"));
+        });
+        it("should expand ~/subdir/path correctly", () => {
+            mockExistsSync.mockReturnValue(false);
+            const result = resolveSourcePath("~/foo/bar/baz");
+            expect(result).toBe(path.join(os.homedir(), "foo/bar/baz"));
+        });
+        it("should not modify paths without tilde", () => {
+            mockExistsSync.mockReturnValue(false);
+            const result = resolveSourcePath("/absolute/path");
+            expect(result).toBe("/absolute/path");
+        });
+    });
+    describe("relative path resolution", () => {
+        it("should resolve relative paths to absolute", () => {
+            mockExistsSync.mockReturnValue(false);
+            const cwd = process.cwd();
+            const result = resolveSourcePath("./src");
+            expect(result).toBe(path.resolve(cwd, "./src"));
+        });
+        it("should resolve parent directory references", () => {
+            mockExistsSync.mockReturnValue(false);
+            const cwd = process.cwd();
+            const result = resolveSourcePath("../sibling");
+            expect(result).toBe(path.resolve(cwd, "../sibling"));
+        });
+        it("should handle bare directory names", () => {
+            mockExistsSync.mockReturnValue(false);
+            const cwd = process.cwd();
+            const result = resolveSourcePath("mydir");
+            expect(result).toBe(path.resolve(cwd, "mydir"));
+        });
+    });
+    describe("symlink resolution", () => {
+        it("should follow symlinks when path exists", () => {
+            const symlinkPath = "/tmp/symlink";
+            const realPath = "/actual/target/path";
+            mockExistsSync.mockImplementation((p) => p === symlinkPath);
+            mockRealpathSync.mockReturnValue(realPath);
+            const result = resolveSourcePath(symlinkPath);
+            expect(mockRealpathSync).toHaveBeenCalledWith(symlinkPath);
+            expect(result).toBe(realPath);
+        });
+        it("should not call realpathSync when path does not exist", () => {
+            mockExistsSync.mockReturnValue(false);
+            resolveSourcePath("/nonexistent/path");
+            expect(mockRealpathSync).not.toHaveBeenCalled();
+        });
+        it("should handle broken symlinks gracefully", () => {
+            const brokenSymlink = "/tmp/broken-symlink";
+            mockExistsSync.mockReturnValue(true);
+            mockRealpathSync.mockImplementation(() => {
+                throw new Error("ENOENT: no such file or directory");
+            });
+            // Should not throw, should return the resolved path without realpath
+            const result = resolveSourcePath(brokenSymlink);
+            expect(result).toBe(brokenSymlink);
+        });
+    });
+    describe("combined scenarios", () => {
+        it("should handle ~ with symlink resolution", () => {
+            const tildePathExpanded = path.join(os.homedir(), "project");
+            const realPath = "/real/project/path";
+            mockExistsSync.mockImplementation((p) => p === tildePathExpanded);
+            mockRealpathSync.mockReturnValue(realPath);
+            const result = resolveSourcePath("~/project");
+            expect(result).toBe(realPath);
+        });
+        it("should handle relative path with symlink resolution", () => {
+            const cwd = process.cwd();
+            const resolvedRelative = path.resolve(cwd, "./src");
+            const realPath = "/real/src/path";
+            mockExistsSync.mockImplementation((p) => p === resolvedRelative);
+            mockRealpathSync.mockReturnValue(realPath);
+            const result = resolveSourcePath("./src");
+            expect(result).toBe(realPath);
+        });
+    });
+});

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

@@ -22,6 +22,9 @@ describe("loadServerConfig", () => {
         jest.clearAllMocks();
         mockExistsSync.mockReturnValue(false);
     });
+    afterAll(() => {
+        jest.unmock("fs");
+    });
     describe("config path resolution", () => {
         it("should search explicit configPath first when provided", () => {
             const configPath = "/custom/path/config.json";

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

@@ -39,10 +39,18 @@ const { StreamableHTTPClientTransport } = await import("@modelcontextprotocol/sd
 const { connectToServer } = await import("../../lib/assessment-runner/server-connection.js");
 describe("connectToServer", () => {
     beforeEach(() => {
-        jest.clearAllMocks();
         mockConnect.mockResolvedValue(undefined);
         mockStdioTransport.stderr.on.mockClear();
     });
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    afterAll(() => {
+        jest.unmock("@modelcontextprotocol/sdk/client/index.js");
+        jest.unmock("@modelcontextprotocol/sdk/client/stdio.js");
+        jest.unmock("@modelcontextprotocol/sdk/client/sse.js");
+        jest.unmock("@modelcontextprotocol/sdk/client/streamableHttp.js");
+    });
     describe("HTTP transport", () => {
         it("should create StreamableHTTPClientTransport for transport:http", async () => {
             const config = {

package/cli/build/__tests__/assessment-runner/source-loader.test.js

@@ -34,10 +34,15 @@ describe("loadSourceFiles", () => {
     const mockReadFileSync = fs.readFileSync;
     const mockReaddirSync = fs.readdirSync;
     beforeEach(() => {
-        jest.clearAllMocks();
         mockExistsSync.mockReturnValue(false);
         mockReaddirSync.mockReturnValue([]);
     });
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    afterAll(() => {
+        jest.unmock("fs");
+    });
     describe("README discovery", () => {
         it("should find README.md in source directory", () => {
             const sourcePath = "/project";
@@ -75,6 +80,98 @@ describe("loadSourceFiles", () => {
             const result = loadSourceFiles(sourcePath);
             expect(result.readmeContent).toBeUndefined();
         });
+        // Issue #151: Extended README patterns
+        it("should find README.markdown", () => {
+            const sourcePath = "/project";
+            mockExistsSync.mockImplementation((p) => p === path.join(sourcePath, "README.markdown"));
+            mockReadFileSync.mockReturnValue("# Markdown README");
+            const result = loadSourceFiles(sourcePath);
+            expect(result.readmeContent).toBe("# Markdown README");
+        });
+        it("should find README.txt", () => {
+            const sourcePath = "/project";
+            mockExistsSync.mockImplementation((p) => p === path.join(sourcePath, "README.txt"));
+            mockReadFileSync.mockReturnValue("Text README content");
+            const result = loadSourceFiles(sourcePath);
+            expect(result.readmeContent).toBe("Text README content");
+        });
+        it("should find README without extension", () => {
+            const sourcePath = "/project";
+            mockExistsSync.mockImplementation((p) => p === path.join(sourcePath, "README"));
+            mockReadFileSync.mockReturnValue("No extension README");
+            const result = loadSourceFiles(sourcePath);
+            expect(result.readmeContent).toBe("No extension README");
+        });
+        it("should prioritize README.md over other variants", () => {
+            const sourcePath = "/project";
+            // Multiple README files exist - README.md should be found first
+            mockExistsSync.mockImplementation((p) => {
+                return (p === path.join(sourcePath, "README.md") ||
+                    p === path.join(sourcePath, "README.txt") ||
+                    p === path.join(sourcePath, "README"));
+            });
+            mockReadFileSync.mockImplementation((p) => {
+                if (p.endsWith("README.md"))
+                    return "# MD README";
+                if (p.endsWith("README.txt"))
+                    return "TXT README";
+                if (p.endsWith("README"))
+                    return "Plain README";
+                return "";
+            });
+            const result = loadSourceFiles(sourcePath);
+            expect(result.readmeContent).toBe("# MD README");
+        });
+    });
+    describe("debug logging", () => {
+        it("should log debug output when debug flag is true", () => {
+            const sourcePath = "/project";
+            const consoleSpy = jest
+                .spyOn(console, "log")
+                .mockImplementation(() => { });
+            try {
+                mockExistsSync.mockReturnValue(false);
+                mockReaddirSync.mockReturnValue([]);
+                loadSourceFiles(sourcePath, true);
+                // Verify debug logging was called
+                expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("[source-loader]"));
+            }
+            finally {
+                consoleSpy.mockRestore();
+            }
+        });
+        it("should not log debug output when debug flag is false", () => {
+            const sourcePath = "/project";
+            const consoleSpy = jest
+                .spyOn(console, "log")
+                .mockImplementation(() => { });
+            try {
+                mockExistsSync.mockReturnValue(false);
+                mockReaddirSync.mockReturnValue([]);
+                loadSourceFiles(sourcePath, false);
+                // Verify debug logging was NOT called
+                expect(consoleSpy).not.toHaveBeenCalledWith(expect.stringContaining("[source-loader]"));
+            }
+            finally {
+                consoleSpy.mockRestore();
+            }
+        });
+        it("should not log debug output by default", () => {
+            const sourcePath = "/project";
+            const consoleSpy = jest
+                .spyOn(console, "log")
+                .mockImplementation(() => { });
+            try {
+                mockExistsSync.mockReturnValue(false);
+                mockReaddirSync.mockReturnValue([]);
+                loadSourceFiles(sourcePath);
+                // Verify debug logging was NOT called by default
+                expect(consoleSpy).not.toHaveBeenCalledWith(expect.stringContaining("[source-loader]"));
+            }
+            finally {
+                consoleSpy.mockRestore();
+            }
+        });
     });
     describe("package.json parsing", () => {
         it("should parse package.json when present", () => {
@@ -118,13 +215,17 @@ describe("loadSourceFiles", () => {
             const consoleSpy = jest
                 .spyOn(console, "warn")
                 .mockImplementation(() => { });
-            mockExistsSync.mockImplementation((p) => p === path.join(sourcePath, "manifest.json"));
-            mockReadFileSync.mockReturnValue("{ invalid json }");
-            const result = loadSourceFiles(sourcePath);
-            expect(result.manifestRaw).toBe("{ invalid json }");
-            expect(result.manifestJson).toBeUndefined();
-            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Failed to parse manifest.json"));
-            consoleSpy.mockRestore();
+            try {
+                mockExistsSync.mockImplementation((p) => p === path.join(sourcePath, "manifest.json"));
+                mockReadFileSync.mockReturnValue("{ invalid json }");
+                const result = loadSourceFiles(sourcePath);
+                expect(result.manifestRaw).toBe("{ invalid json }");
+                expect(result.manifestJson).toBeUndefined();
+                expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Failed to parse manifest.json"));
+            }
+            finally {
+                consoleSpy.mockRestore();
+            }
         });
     });
     describe("source file collection", () => {
@@ -276,14 +377,18 @@ describe("loadSourceFiles", () => {
             const consoleSpy = jest
                 .spyOn(console, "warn")
                 .mockImplementation(() => { });
-            mockExistsSync.mockReturnValue(false);
-            mockReaddirSync.mockImplementation(() => {
-                throw new Error("Permission denied");
-            });
-            const result = loadSourceFiles(sourcePath);
-            expect(result.sourceCodeFiles?.size).toBe(0);
-            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Could not load source files"), expect.any(Error));
-            consoleSpy.mockRestore();
+            try {
+                mockExistsSync.mockReturnValue(false);
+                mockReaddirSync.mockImplementation(() => {
+                    throw new Error("Permission denied");
+                });
+                const result = loadSourceFiles(sourcePath);
+                expect(result.sourceCodeFiles?.size).toBe(0);
+                expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Could not load source files"), expect.any(Error));
+            }
+            finally {
+                consoleSpy.mockRestore();
+            }
         });
         it("should skip unreadable files silently", () => {
             const sourcePath = "/project";

package/cli/build/__tests__/assessment-runner/tool-wrapper.test.js

@@ -15,6 +15,9 @@ describe("createCallToolWrapper", () => {
             callTool: mockCallTool,
         };
     });
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
     describe("successful tool calls", () => {
         it("should wrap successful tool response with content array", async () => {
             mockCallTool.mockResolvedValue({

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

@@ -6,12 +6,15 @@
  *
  * @see https://github.com/triepod-ai/inspector-assessment/issues/96
  */
-import { describe, it, expect } from "@jest/globals";
+import { jest, describe, it, expect, afterEach } from "@jest/globals";
 // Test named imports (the primary consumer pattern)
 import { loadServerConfig, loadSourceFiles, connectToServer, createCallToolWrapper, buildConfig, runFullAssessment, } from "../lib/assessment-runner.js";
 // Test namespace import
 import * as AssessmentRunner from "../lib/assessment-runner.js";
 describe("Assessment Runner Facade", () => {
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
     describe("Function Exports", () => {
         it("should export loadServerConfig function", () => {
             expect(typeof loadServerConfig).toBe("function");
@@ -81,13 +84,14 @@ describe("Assessment Runner Facade", () => {
     describe("Export Completeness", () => {
         it("should export exactly 6 functions", () => {
             const exportedFunctions = Object.entries(AssessmentRunner).filter(([, value]) => typeof value === "function");
-            expect(exportedFunctions.length).toBe(6);
+            expect(exportedFunctions.length).toBe(7);
             expect(exportedFunctions.map(([name]) => name).sort()).toEqual([
                 "buildConfig",
                 "connectToServer",
                 "createCallToolWrapper",
                 "loadServerConfig",
                 "loadSourceFiles",
+                "resolveSourcePath",
                 "runFullAssessment",
             ]);
         });
@@ -96,6 +100,7 @@ describe("Assessment Runner Facade", () => {
             const expectedExports = [
                 "loadServerConfig",
                 "loadSourceFiles",
+                "resolveSourcePath",
                 "connectToServer",
                 "createCallToolWrapper",
                 "buildConfig",

package/cli/build/__tests__/cli-build-fixes.test.js

@@ -8,9 +8,12 @@
  * @see https://github.com/triepod-ai/inspector-assessment/issues/33
  * @see https://github.com/triepod-ai/inspector-assessment/issues/37
  */
-import { describe, it, expect } from "@jest/globals";
+import { jest, describe, it, expect, afterEach } from "@jest/globals";
 import { ScopedListenerConfig } from "../lib/event-config.js";
 describe("CLI Build Fixes Regression Tests", () => {
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
     describe("event-config.ts - CLI_DEFAULT_MAX_LISTENERS constant", () => {
         it("should use local constant instead of cross-workspace import", () => {
             // Fix: Replaced DEFAULT_PERFORMANCE_CONFIG.eventEmitterMaxListeners

package/cli/build/__tests__/flag-parsing.test.js

@@ -669,8 +669,9 @@ describe("parseArgs Zod Schema Integration", () => {
         // Run any pending timers and restore
         jest.runAllTimers();
         jest.useRealTimers();
-        processExitSpy.mockRestore();
-        consoleErrorSpy.mockRestore();
+        // Use optional chaining in case spies weren't created (prevents memory leaks)
+        processExitSpy?.mockRestore();
+        consoleErrorSpy?.mockRestore();
     });
     describe("LogLevelSchema integration", () => {
         it("parseArgs validates log level with LogLevelSchema", () => {