mindsim 0.1.5 → 0.1.7

package/tests/service-json.test.ts

@@ -0,0 +1,567 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import * as configModule from "../src/config";
+import { isBrowserEnvironment, isNodeEnvironment, MindSim } from "../src/index";
+import type { MindsimServiceJson } from "../src/types";
+
+// =============================================================================
+// Test Data
+// =============================================================================
+
+const VALID_SERVICE_JSON: MindsimServiceJson = {
+  type: "mindsim_service_account",
+  version: "1",
+  project_id: "test-app",
+  project_name: "Test App",
+  environment: "production",
+  client_email: "test-app@mindsim.reasoner.com",
+  client_id: "550e8400-e29b-41d4-a716-446655440000",
+  api_key: "ms_prod_testkey123456789",
+  api_base_url: "https://api.reasoner.com/api/mindsim",
+  scopes: ["minds:read", "simulate:run"],
+  app_metadata: {
+    app_id: "550e8400-e29b-41d4-a716-446655440001",
+    workspace_id: "550e8400-e29b-41d4-a716-446655440002",
+    mindsim_org_id: "550e8400-e29b-41d4-a716-446655440003",
+    use_case: "internal-workflow",
+  },
+  created_at: "2025-12-21T00:00:00.000Z",
+};
+
+// =============================================================================
+// Mock Setup
+// =============================================================================
+
+// Mock the config module to control loadApiKey and loadServiceJson
+vi.mock("../src/config", async (importOriginal) => {
+  const actual = await importOriginal<typeof configModule>();
+  return {
+    ...actual,
+    loadApiKey: vi.fn(),
+    loadServiceJson: vi.fn(),
+  };
+});
+
+// Mock version check to prevent network calls
+vi.mock("../src/version", () => ({
+  checkForUpdates: vi.fn().mockResolvedValue(undefined),
+  getPackageVersion: vi.fn().mockReturnValue("1.0.0-test"),
+}));
+
+// =============================================================================
+// Environment Detection Tests
+// =============================================================================
+
+describe("Environment Detection", () => {
+  describe("isNodeEnvironment()", () => {
+    it("should return true in Node.js environment", () => {
+      // In the test environment (Node.js), this should be true
+      expect(isNodeEnvironment()).toBe(true);
+    });
+
+    it("should check for process.versions.node", () => {
+      // Verify the function checks the right property
+      expect(typeof process.versions.node).toBe("string");
+      expect(isNodeEnvironment()).toBe(true);
+    });
+  });
+
+  describe("isBrowserEnvironment()", () => {
+    it("should return false in Node.js environment", () => {
+      // In Node.js test environment, there's no window/document
+      expect(isBrowserEnvironment()).toBe(false);
+    });
+  });
+});
+
+// =============================================================================
+// MindSim Constructor with Service JSON Tests
+// =============================================================================
+
+describe("MindSim Constructor with Service JSON", () => {
+  beforeEach(() => {
+    vi.resetModules();
+    vi.mocked(configModule.loadApiKey).mockReturnValue(null);
+    vi.mocked(configModule.loadServiceJson).mockReturnValue(null);
+  });
+
+  afterEach(() => {
+    vi.unstubAllEnvs();
+  });
+
+  describe("serviceJson via constructor options", () => {
+    it("should accept valid serviceJson passed via options", () => {
+      const mindsim = new MindSim(undefined, { serviceJson: VALID_SERVICE_JSON });
+      expect(mindsim).toBeInstanceOf(MindSim);
+      expect(mindsim.getServiceJson()).toEqual(VALID_SERVICE_JSON);
+    });
+
+    it("should use api_key from serviceJson", () => {
+      const mindsim = new MindSim(undefined, { serviceJson: VALID_SERVICE_JSON });
+      expect(mindsim).toBeInstanceOf(MindSim);
+      // The constructor should have used the api_key from service JSON
+      expect(mindsim.getAuthMethod()).toBe("service_json");
+    });
+
+    it("should set authMethod to service_json", () => {
+      const mindsim = new MindSim(undefined, { serviceJson: VALID_SERVICE_JSON });
+      expect(mindsim.getAuthMethod()).toBe("service_json");
+    });
+
+    it("should throw on invalid serviceJson", () => {
+      const invalidServiceJson = {
+        ...VALID_SERVICE_JSON,
+        type: "invalid_type" as const, // Invalid type
+      };
+
+      expect(() => {
+        new MindSim(undefined, { serviceJson: invalidServiceJson as MindsimServiceJson });
+      }).toThrow("Invalid serviceJson");
+    });
+
+    it("should throw with detailed validation errors", () => {
+      const invalidServiceJson = {
+        ...VALID_SERVICE_JSON,
+        client_id: "not-a-uuid", // Invalid UUID
+      };
+
+      expect(() => {
+        new MindSim(undefined, { serviceJson: invalidServiceJson as MindsimServiceJson });
+      }).toThrow("client_id");
+    });
+
+    it("should validate email format in serviceJson", () => {
+      const invalidServiceJson = {
+        ...VALID_SERVICE_JSON,
+        client_email: "invalid-email", // Missing @ and domain
+      };
+
+      expect(() => {
+        new MindSim(undefined, { serviceJson: invalidServiceJson as MindsimServiceJson });
+      }).toThrow("client_email");
+    });
+
+    it("should validate api_base_url as HTTPS", () => {
+      const invalidServiceJson = {
+        ...VALID_SERVICE_JSON,
+        api_base_url: "http://insecure.com", // HTTP instead of HTTPS
+      };
+
+      expect(() => {
+        new MindSim(undefined, { serviceJson: invalidServiceJson as MindsimServiceJson });
+      }).toThrow("api_base_url");
+    });
+
+    it("should validate scopes array", () => {
+      const invalidServiceJson = {
+        ...VALID_SERVICE_JSON,
+        scopes: ["minds:read", "invalid:scope"] as any[], // Invalid scope
+      };
+
+      expect(() => {
+        new MindSim(undefined, { serviceJson: invalidServiceJson as MindsimServiceJson });
+      }).toThrow("scopes");
+    });
+
+    it("should use api_base_url from serviceJson", () => {
+      const customServiceJson = {
+        ...VALID_SERVICE_JSON,
+        api_base_url: "https://custom.api.example.com/v1",
+      };
+
+      const mindsim = new MindSim(undefined, { serviceJson: customServiceJson });
+      expect(mindsim).toBeInstanceOf(MindSim);
+      // The client should be configured with the custom base URL
+    });
+  });
+
+  describe("serviceJson via environment (loadServiceJson)", () => {
+    it("should load serviceJson from environment when no constructor args", () => {
+      vi.mocked(configModule.loadServiceJson).mockReturnValue(VALID_SERVICE_JSON);
+
+      const mindsim = new MindSim();
+      expect(mindsim).toBeInstanceOf(MindSim);
+      expect(mindsim.getServiceJson()).toEqual(VALID_SERVICE_JSON);
+      expect(mindsim.getAuthMethod()).toBe("service_json");
+    });
+
+    it("should use api_key from loaded serviceJson", () => {
+      vi.mocked(configModule.loadServiceJson).mockReturnValue(VALID_SERVICE_JSON);
+
+      const mindsim = new MindSim();
+      expect(mindsim.isUsingServiceJsonAuth()).toBe(true);
+    });
+  });
+
+  describe("credential priority", () => {
+    it("should prioritize constructor apiKey over serviceJson option", () => {
+      const mindsim = new MindSim("direct-api-key", { serviceJson: VALID_SERVICE_JSON });
+
+      expect(mindsim.getAuthMethod()).toBe("api_key_constructor");
+      expect(mindsim.getServiceJson()).toBeNull();
+      expect(mindsim.isUsingServiceJsonAuth()).toBe(false);
+    });
+
+    it("should prioritize constructor apiKey over environment serviceJson", () => {
+      vi.mocked(configModule.loadServiceJson).mockReturnValue(VALID_SERVICE_JSON);
+
+      const mindsim = new MindSim("direct-api-key");
+
+      expect(mindsim.getAuthMethod()).toBe("api_key_constructor");
+      expect(mindsim.isUsingServiceJsonAuth()).toBe(false);
+    });
+
+    it("should prioritize constructor serviceJson over environment serviceJson", () => {
+      const envServiceJson = {
+        ...VALID_SERVICE_JSON,
+        project_id: "env-app",
+        api_key: "ms_prod_env_key",
+      };
+
+      const constructorServiceJson = {
+        ...VALID_SERVICE_JSON,
+        project_id: "constructor-app",
+        api_key: "ms_prod_constructor_key",
+      };
+
+      vi.mocked(configModule.loadServiceJson).mockReturnValue(envServiceJson);
+
+      const mindsim = new MindSim(undefined, { serviceJson: constructorServiceJson });
+
+      expect(mindsim.getServiceJson()?.project_id).toBe("constructor-app");
+    });
+
+    it("should fallback to loadApiKey if no serviceJson", () => {
+      vi.mocked(configModule.loadApiKey).mockReturnValue("env-api-key");
+
+      const mindsim = new MindSim();
+
+      expect(mindsim).toBeInstanceOf(MindSim);
+      expect(mindsim.isUsingServiceJsonAuth()).toBe(false);
+    });
+  });
+
+  describe("custom apiBaseUrl option", () => {
+    it("should override serviceJson api_base_url when explicitly provided", () => {
+      const mindsim = new MindSim(undefined, {
+        serviceJson: VALID_SERVICE_JSON,
+        apiBaseUrl: "https://override.api.com/v2",
+      });
+
+      expect(mindsim).toBeInstanceOf(MindSim);
+      // The apiBaseUrl option should take precedence over serviceJson.api_base_url
+    });
+
+    it("should use serviceJson api_base_url when no explicit override", () => {
+      const mindsim = new MindSim(undefined, {
+        serviceJson: VALID_SERVICE_JSON,
+      });
+
+      expect(mindsim).toBeInstanceOf(MindSim);
+      // Should use VALID_SERVICE_JSON.api_base_url
+    });
+  });
+});
+
+// =============================================================================
+// Auth Method Detection Tests
+// =============================================================================
+
+describe("Auth Method Detection", () => {
+  beforeEach(() => {
+    vi.resetModules();
+    vi.mocked(configModule.loadApiKey).mockReturnValue(null);
+    vi.mocked(configModule.loadServiceJson).mockReturnValue(null);
+  });
+
+  afterEach(() => {
+    vi.unstubAllEnvs();
+  });
+
+  describe("getAuthMethod()", () => {
+    it("should return api_key_constructor when apiKey passed to constructor", () => {
+      const mindsim = new MindSim("test-key");
+      expect(mindsim.getAuthMethod()).toBe("api_key_constructor");
+    });
+
+    it("should return service_json when using serviceJson", () => {
+      const mindsim = new MindSim(undefined, { serviceJson: VALID_SERVICE_JSON });
+      expect(mindsim.getAuthMethod()).toBe("service_json");
+    });
+
+    it("should return api_key_env when MINDSIM_API_KEY is set", () => {
+      vi.stubEnv("MINDSIM_API_KEY", "env-key");
+      vi.mocked(configModule.loadApiKey).mockReturnValue("env-key");
+
+      const mindsim = new MindSim();
+      expect(mindsim.getAuthMethod()).toBe("api_key_env");
+    });
+
+    it("should return config_file when using config file", () => {
+      vi.mocked(configModule.loadApiKey).mockReturnValue("config-file-key");
+
+      const mindsim = new MindSim();
+      expect(mindsim.getAuthMethod()).toBe("config_file");
+    });
+  });
+
+  describe("isUsingServiceJsonAuth()", () => {
+    it("should return true when using serviceJson", () => {
+      const mindsim = new MindSim(undefined, { serviceJson: VALID_SERVICE_JSON });
+      expect(mindsim.isUsingServiceJsonAuth()).toBe(true);
+    });
+
+    it("should return false when using direct apiKey", () => {
+      const mindsim = new MindSim("test-key");
+      expect(mindsim.isUsingServiceJsonAuth()).toBe(false);
+    });
+
+    it("should return false when using env apiKey", () => {
+      vi.mocked(configModule.loadApiKey).mockReturnValue("env-key");
+      const mindsim = new MindSim();
+      expect(mindsim.isUsingServiceJsonAuth()).toBe(false);
+    });
+  });
+
+  describe("getAuthInfo()", () => {
+    it("should return complete auth info for serviceJson auth", () => {
+      const mindsim = new MindSim(undefined, { serviceJson: VALID_SERVICE_JSON });
+      const authInfo = mindsim.getAuthInfo();
+
+      expect(authInfo).toEqual({
+        method: "service_json",
+        isServiceJson: true,
+        projectId: VALID_SERVICE_JSON.project_id,
+        projectName: VALID_SERVICE_JSON.project_name,
+        environment: VALID_SERVICE_JSON.environment,
+      });
+    });
+
+    it("should return null project info for non-serviceJson auth", () => {
+      const mindsim = new MindSim("test-key");
+      const authInfo = mindsim.getAuthInfo();
+
+      expect(authInfo).toEqual({
+        method: "api_key_constructor",
+        isServiceJson: false,
+        projectId: null,
+        projectName: null,
+        environment: null,
+      });
+    });
+
+    it("should not expose the API key", () => {
+      const mindsim = new MindSim(undefined, { serviceJson: VALID_SERVICE_JSON });
+      const authInfo = mindsim.getAuthInfo();
+
+      // Ensure no api_key in the returned object
+      expect(authInfo).not.toHaveProperty("apiKey");
+      expect(authInfo).not.toHaveProperty("api_key");
+      expect(JSON.stringify(authInfo)).not.toContain(VALID_SERVICE_JSON.api_key);
+    });
+  });
+});
+
+// =============================================================================
+// Service JSON Getter Tests
+// =============================================================================
+
+describe("getServiceJson()", () => {
+  beforeEach(() => {
+    vi.resetModules();
+    vi.mocked(configModule.loadApiKey).mockReturnValue(null);
+    vi.mocked(configModule.loadServiceJson).mockReturnValue(null);
+  });
+
+  afterEach(() => {
+    vi.unstubAllEnvs();
+  });
+
+  it("should return the loaded serviceJson", () => {
+    const mindsim = new MindSim(undefined, { serviceJson: VALID_SERVICE_JSON });
+    expect(mindsim.getServiceJson()).toEqual(VALID_SERVICE_JSON);
+  });
+
+  it("should return null when not using serviceJson", () => {
+    const mindsim = new MindSim("test-key");
+    expect(mindsim.getServiceJson()).toBeNull();
+  });
+
+  it("should return the full serviceJson object with all fields", () => {
+    const mindsim = new MindSim(undefined, { serviceJson: VALID_SERVICE_JSON });
+    const serviceJson = mindsim.getServiceJson();
+
+    expect(serviceJson).toHaveProperty("type", "mindsim_service_account");
+    expect(serviceJson).toHaveProperty("version");
+    expect(serviceJson).toHaveProperty("project_id");
+    expect(serviceJson).toHaveProperty("project_name");
+    expect(serviceJson).toHaveProperty("environment", "production");
+    expect(serviceJson).toHaveProperty("client_email");
+    expect(serviceJson).toHaveProperty("client_id");
+    expect(serviceJson).toHaveProperty("api_key");
+    expect(serviceJson).toHaveProperty("api_base_url");
+    expect(serviceJson).toHaveProperty("scopes");
+    expect(serviceJson).toHaveProperty("app_metadata");
+    expect(serviceJson).toHaveProperty("created_at");
+  });
+
+  it("should return serviceJson with app_metadata containing all required fields", () => {
+    const mindsim = new MindSim(undefined, { serviceJson: VALID_SERVICE_JSON });
+    const serviceJson = mindsim.getServiceJson();
+
+    expect(serviceJson?.app_metadata).toHaveProperty("app_id");
+    expect(serviceJson?.app_metadata).toHaveProperty("workspace_id");
+    expect(serviceJson?.app_metadata).toHaveProperty("mindsim_org_id");
+    expect(serviceJson?.app_metadata).toHaveProperty("use_case");
+  });
+});
+
+// =============================================================================
+// Error Handling Tests
+// =============================================================================
+
+describe("Error Handling", () => {
+  beforeEach(() => {
+    vi.resetModules();
+    vi.mocked(configModule.loadApiKey).mockReturnValue(null);
+    vi.mocked(configModule.loadServiceJson).mockReturnValue(null);
+  });
+
+  afterEach(() => {
+    vi.unstubAllEnvs();
+  });
+
+  it("should throw helpful error when no credentials found", () => {
+    expect(() => {
+      new MindSim();
+    }).toThrow("API Key not found");
+  });
+
+  it("should mention serviceJson in error message", () => {
+    expect(() => {
+      new MindSim();
+    }).toThrow(/MINDSIM_SERVICE_JSON/);
+  });
+
+  it("should throw for serviceJson with missing required fields", () => {
+    const incompleteServiceJson = {
+      type: "mindsim_service_account" as const,
+      // Missing most required fields
+    };
+
+    expect(() => {
+      new MindSim(undefined, { serviceJson: incompleteServiceJson as MindsimServiceJson });
+    }).toThrow("Invalid serviceJson");
+  });
+
+  it("should throw for serviceJson with wrong type", () => {
+    const wrongTypeServiceJson = {
+      ...VALID_SERVICE_JSON,
+      type: "google_service_account" as const, // Wrong type
+    };
+
+    expect(() => {
+      new MindSim(undefined, { serviceJson: wrongTypeServiceJson as MindsimServiceJson });
+    }).toThrow();
+  });
+});
+
+// =============================================================================
+// Optional Fields Tests
+// =============================================================================
+
+describe("Optional Service JSON Fields", () => {
+  beforeEach(() => {
+    vi.resetModules();
+    vi.mocked(configModule.loadApiKey).mockReturnValue(null);
+    vi.mocked(configModule.loadServiceJson).mockReturnValue(null);
+  });
+
+  afterEach(() => {
+    vi.unstubAllEnvs();
+  });
+
+  it("should accept serviceJson with expires_at", () => {
+    const serviceJsonWithExpiry = {
+      ...VALID_SERVICE_JSON,
+      expires_at: "2026-12-21T00:00:00.000Z",
+    };
+
+    const mindsim = new MindSim(undefined, { serviceJson: serviceJsonWithExpiry });
+    expect(mindsim.getServiceJson()?.expires_at).toBe("2026-12-21T00:00:00.000Z");
+  });
+
+  it("should accept serviceJson with issued_at", () => {
+    const serviceJsonWithIssuedAt = {
+      ...VALID_SERVICE_JSON,
+      issued_at: "2025-12-21T00:00:00.000Z",
+    };
+
+    const mindsim = new MindSim(undefined, { serviceJson: serviceJsonWithIssuedAt });
+    expect(mindsim.getServiceJson()?.issued_at).toBe("2025-12-21T00:00:00.000Z");
+  });
+
+  it("should accept serviceJson without optional fields", () => {
+    // VALID_SERVICE_JSON doesn't have expires_at or issued_at
+    const mindsim = new MindSim(undefined, { serviceJson: VALID_SERVICE_JSON });
+    expect(mindsim.getServiceJson()?.expires_at).toBeUndefined();
+    expect(mindsim.getServiceJson()?.issued_at).toBeUndefined();
+  });
+});
+
+// =============================================================================
+// Type Safety Tests
+// =============================================================================
+
+describe("Type Safety", () => {
+  beforeEach(() => {
+    vi.resetModules();
+    vi.mocked(configModule.loadApiKey).mockReturnValue(null);
+    vi.mocked(configModule.loadServiceJson).mockReturnValue(null);
+  });
+
+  afterEach(() => {
+    vi.unstubAllEnvs();
+  });
+
+  it("should accept all valid scopes", () => {
+    const allScopes: MindsimServiceJson["scopes"] = [
+      "minds:read",
+      "minds:write",
+      "simulate:run",
+      "simulate:read",
+      "users:read",
+      "users:write",
+      "org:admin",
+    ];
+
+    const serviceJsonWithAllScopes = {
+      ...VALID_SERVICE_JSON,
+      scopes: allScopes,
+    };
+
+    const mindsim = new MindSim(undefined, { serviceJson: serviceJsonWithAllScopes });
+    expect(mindsim.getServiceJson()?.scopes).toEqual(allScopes);
+  });
+
+  it("should accept all valid use_case values", () => {
+    const useCases = ["internal-workflow", "customer-facing", "agentic-ai"] as const;
+
+    for (const useCase of useCases) {
+      const serviceJson = {
+        ...VALID_SERVICE_JSON,
+        app_metadata: {
+          ...VALID_SERVICE_JSON.app_metadata,
+          use_case: useCase,
+        },
+      };
+
+      const mindsim = new MindSim(undefined, { serviceJson });
+      expect(mindsim.getServiceJson()?.app_metadata.use_case).toBe(useCase);
+    }
+  });
+
+  it("should enforce environment as production", () => {
+    const mindsim = new MindSim(undefined, { serviceJson: VALID_SERVICE_JSON });
+    expect(mindsim.getServiceJson()?.environment).toBe("production");
+  });
+});

package/tests/version.test.ts

@@ -165,17 +165,27 @@ describe("Version Module", () => {
   });
 
   describe("updateSdk", () => {
+    const MOCK_CWD = "/mock/project";
+
     beforeEach(() => {
       // Default local version
       mockedFs.existsSync.mockReturnValue(true);
       mockedFs.readFileSync.mockReturnValue(JSON.stringify({ version: "1.0.0" }));
+      // Mock process.cwd for package manager detection
+      vi.spyOn(process, "cwd").mockReturnValue(MOCK_CWD);
+      // Mock path.join to return predictable paths for lockfile checks
+      mockedPath.join.mockImplementation((...args) => args.join("/"));
     });
 
-    it("should run npm install if update available", async () => {
+    it("should use npm install when no lockfile is found", async () => {
+      // No lockfiles found - defaults to npm
+      mockedFs.existsSync.mockImplementation((p) => {
+        if (p === MOCK_PACKAGE_PATH) return true; // package.json exists
+        return false; // no lockfiles
+      });
       mockedAxios.get.mockResolvedValue({
         data: { "dist-tags": { latest: "2.0.0" } },
       });
-      // Mock the execAsync resolution
       mockExecAsync.mockResolvedValue({ stdout: "ok", stderr: "" });
 
       const consoleLogSpy = vi.spyOn(console, "log").mockImplementation(() => {});
@@ -186,7 +196,49 @@ describe("Version Module", () => {
       expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining("Update complete"));
     });
 
+    it("should use pnpm add when pnpm-lock.yaml is found", async () => {
+      mockedFs.existsSync.mockImplementation((p) => {
+        if (p === MOCK_PACKAGE_PATH) return true;
+        if (p === `${MOCK_CWD}/pnpm-lock.yaml`) return true;
+        return false;
+      });
+      mockedAxios.get.mockResolvedValue({
+        data: { "dist-tags": { latest: "2.0.0" } },
+      });
+      mockExecAsync.mockResolvedValue({ stdout: "ok", stderr: "" });
+
+      const consoleLogSpy = vi.spyOn(console, "log").mockImplementation(() => {});
+
+      await updateSdk();
+
+      expect(mockExecAsync).toHaveBeenCalledWith("pnpm add mindsim@latest");
+      expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining("Update complete"));
+    });
+
+    it("should use yarn add when yarn.lock is found", async () => {
+      mockedFs.existsSync.mockImplementation((p) => {
+        if (p === MOCK_PACKAGE_PATH) return true;
+        if (p === `${MOCK_CWD}/yarn.lock`) return true;
+        return false;
+      });
+      mockedAxios.get.mockResolvedValue({
+        data: { "dist-tags": { latest: "2.0.0" } },
+      });
+      mockExecAsync.mockResolvedValue({ stdout: "ok", stderr: "" });
+
+      const consoleLogSpy = vi.spyOn(console, "log").mockImplementation(() => {});
+
+      await updateSdk();
+
+      expect(mockExecAsync).toHaveBeenCalledWith("yarn add mindsim@latest");
+      expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining("Update complete"));
+    });
+
     it("should do nothing if already on latest", async () => {
+      mockedFs.existsSync.mockImplementation((p) => {
+        if (p === MOCK_PACKAGE_PATH) return true;
+        return false;
+      });
       mockedAxios.get.mockResolvedValue({
         data: { "dist-tags": { latest: "1.0.0" } },
       });
@@ -201,11 +253,15 @@ describe("Version Module", () => {
       );
     });
 
-    it("should handle exec errors", async () => {
+    it("should handle exec errors and show correct manual command", async () => {
+      mockedFs.existsSync.mockImplementation((p) => {
+        if (p === MOCK_PACKAGE_PATH) return true;
+        if (p === `${MOCK_CWD}/pnpm-lock.yaml`) return true;
+        return false;
+      });
       mockedAxios.get.mockResolvedValue({
         data: { "dist-tags": { latest: "2.0.0" } },
       });
-      // Mock execAsync rejection
       mockExecAsync.mockRejectedValue(new Error("Permission denied"));
 
       const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
@@ -214,6 +270,9 @@ describe("Version Module", () => {
 
       expect(consoleErrorSpy).toHaveBeenCalledWith("❌ Failed to update MindSim SDK.");
       expect(consoleErrorSpy).toHaveBeenCalledWith("Permission denied");
+      expect(consoleErrorSpy).toHaveBeenCalledWith(
+        "Please try running manually: pnpm add mindsim@latest",
+      );
     });
   });
 });