mindsim 0.1.6 → 0.1.8

package/tests/config.test.ts

@@ -2,7 +2,15 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { afterEach, beforeEach, describe, expect, it, type Mocked, vi } from "vitest";
-import { getApiBaseUrl, getDeviceAuthConfig, loadApiKey, saveApiKey } from "../src/config";
+import {
+  getApiBaseUrl,
+  getDeviceAuthConfig,
+  loadApiKey,
+  loadServiceJson,
+  loadServiceJsonFromBase64,
+  saveApiKey,
+  validateServiceJson,
+} from "../src/config";
 
 // Mock Node built-ins
 vi.mock("node:fs");
@@ -130,5 +138,461 @@ describe("Config Module", () => {
       vi.stubEnv("MIND_SIM_API_BASE_URL", "https://staging.api.mindsim.com");
       expect(getApiBaseUrl()).toBe("https://staging.api.mindsim.com");
     });
+
+    it("should prioritize MINDSIM_API_BASE_URL over deprecated MIND_SIM_API_BASE_URL", () => {
+      vi.stubEnv("MINDSIM_API_BASE_URL", "https://new-api.reasoner.com");
+      vi.stubEnv("MIND_SIM_API_BASE_URL", "https://old-api.reasoner.com");
+      expect(getApiBaseUrl()).toBe("https://new-api.reasoner.com");
+    });
+  });
+
+  describe("validateServiceJson", () => {
+    // Valid service JSON fixture
+    const createValidServiceJson = (overrides?: Record<string, unknown>) => ({
+      type: "mindsim_service_account",
+      version: "1",
+      project_id: "my-app",
+      project_name: "My App",
+      environment: "production",
+      client_email: "service@my-app.mindsim.io",
+      client_id: "550e8400-e29b-41d4-a716-446655440000",
+      api_key: "ms_prod_abc123xyz789",
+      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",
+      ...overrides,
+    });
+
+    describe("basic validation", () => {
+      it("should accept valid service JSON", () => {
+        const result = validateServiceJson(createValidServiceJson());
+        expect(result.valid).toBe(true);
+        expect(result.errors).toHaveLength(0);
+        expect(result.serviceJson).toBeDefined();
+      });
+
+      it("should reject non-object input", () => {
+        const result = validateServiceJson(null);
+        expect(result.valid).toBe(false);
+        expect(result.errors).toContain("Service JSON must be a valid object");
+      });
+
+      it("should reject undefined input", () => {
+        const result = validateServiceJson(undefined);
+        expect(result.valid).toBe(false);
+      });
+
+      it("should reject string input", () => {
+        const result = validateServiceJson("not an object");
+        expect(result.valid).toBe(false);
+      });
+    });
+
+    describe("required fields validation", () => {
+      it("should require type field", () => {
+        const result = validateServiceJson(createValidServiceJson({ type: undefined }));
+        expect(result.valid).toBe(false);
+        expect(result.errors.some((e) => e.includes("type"))).toBe(true);
+      });
+
+      it("should require version field", () => {
+        const result = validateServiceJson(createValidServiceJson({ version: undefined }));
+        expect(result.valid).toBe(false);
+        expect(result.errors.some((e) => e.includes("version"))).toBe(true);
+      });
+
+      it("should require project_id field", () => {
+        const result = validateServiceJson(createValidServiceJson({ project_id: undefined }));
+        expect(result.valid).toBe(false);
+        expect(result.errors.some((e) => e.includes("project_id"))).toBe(true);
+      });
+
+      it("should require api_key field", () => {
+        const result = validateServiceJson(createValidServiceJson({ api_key: undefined }));
+        expect(result.valid).toBe(false);
+        expect(result.errors.some((e) => e.includes("api_key"))).toBe(true);
+      });
+    });
+
+    describe("type field validation", () => {
+      it('should require type to be "mindsim_service_account"', () => {
+        const result = validateServiceJson(createValidServiceJson({ type: "other_type" }));
+        expect(result.valid).toBe(false);
+        expect(result.errors.some((e) => e.includes("mindsim_service_account"))).toBe(true);
+      });
+    });
+
+    describe("environment field validation", () => {
+      it('should require environment to be "production"', () => {
+        const result = validateServiceJson(createValidServiceJson({ environment: "development" }));
+        expect(result.valid).toBe(false);
+        expect(result.errors.some((e) => e.includes("production"))).toBe(true);
+      });
+    });
+
+    describe("email validation (Gap 8)", () => {
+      it("should accept valid email addresses", () => {
+        const result = validateServiceJson(
+          createValidServiceJson({ client_email: "service@my-app.mindsim.io" }),
+        );
+        expect(result.valid).toBe(true);
+      });
+
+      it("should reject email without @", () => {
+        const result = validateServiceJson(
+          createValidServiceJson({ client_email: "invalid-email" }),
+        );
+        expect(result.valid).toBe(false);
+        expect(result.errors.some((e) => e.includes("valid email"))).toBe(true);
+      });
+
+      it("should reject email without domain", () => {
+        const result = validateServiceJson(createValidServiceJson({ client_email: "user@" }));
+        expect(result.valid).toBe(false);
+        expect(result.errors.some((e) => e.includes("valid email"))).toBe(true);
+      });
+
+      it("should reject email with spaces", () => {
+        const result = validateServiceJson(
+          createValidServiceJson({ client_email: "user @domain.com" }),
+        );
+        expect(result.valid).toBe(false);
+      });
+    });
+
+    describe("UUID validation", () => {
+      it("should validate client_id as UUID", () => {
+        const result = validateServiceJson(
+          createValidServiceJson({ client_id: "not-a-valid-uuid" }),
+        );
+        expect(result.valid).toBe(false);
+        expect(result.errors.some((e) => e.includes("client_id") && e.includes("UUID"))).toBe(true);
+      });
+
+      it("should validate app_metadata.app_id as UUID", () => {
+        const result = validateServiceJson(
+          createValidServiceJson({
+            app_metadata: {
+              app_id: "invalid",
+              workspace_id: "550e8400-e29b-41d4-a716-446655440000",
+              mindsim_org_id: "550e8400-e29b-41d4-a716-446655440000",
+              use_case: "internal-workflow",
+            },
+          }),
+        );
+        expect(result.valid).toBe(false);
+        expect(result.errors.some((e) => e.includes("app_id") && e.includes("UUID"))).toBe(true);
+      });
+
+      it("should validate app_metadata.workspace_id as UUID", () => {
+        const result = validateServiceJson(
+          createValidServiceJson({
+            app_metadata: {
+              app_id: "550e8400-e29b-41d4-a716-446655440000",
+              workspace_id: "not-uuid",
+              mindsim_org_id: "550e8400-e29b-41d4-a716-446655440000",
+              use_case: "internal-workflow",
+            },
+          }),
+        );
+        expect(result.valid).toBe(false);
+        expect(result.errors.some((e) => e.includes("workspace_id") && e.includes("UUID"))).toBe(
+          true,
+        );
+      });
+
+      it("should validate app_metadata.mindsim_org_id as UUID", () => {
+        const result = validateServiceJson(
+          createValidServiceJson({
+            app_metadata: {
+              app_id: "550e8400-e29b-41d4-a716-446655440000",
+              workspace_id: "550e8400-e29b-41d4-a716-446655440000",
+              mindsim_org_id: "bad-uuid",
+              use_case: "internal-workflow",
+            },
+          }),
+        );
+        expect(result.valid).toBe(false);
+        expect(result.errors.some((e) => e.includes("mindsim_org_id") && e.includes("UUID"))).toBe(
+          true,
+        );
+      });
+    });
+
+    describe("URL validation", () => {
+      it("should validate api_base_url as HTTPS URL", () => {
+        const result = validateServiceJson(
+          createValidServiceJson({ api_base_url: "http://insecure.com" }),
+        );
+        expect(result.valid).toBe(false);
+        expect(result.errors.some((e) => e.includes("api_base_url") && e.includes("HTTPS"))).toBe(
+          true,
+        );
+      });
+
+      it("should accept valid HTTPS URL", () => {
+        const result = validateServiceJson(
+          createValidServiceJson({ api_base_url: "https://api.example.com/v1" }),
+        );
+        expect(result.valid).toBe(true);
+      });
+
+      it("should reject invalid URL format", () => {
+        const result = validateServiceJson(createValidServiceJson({ api_base_url: "not-a-url" }));
+        expect(result.valid).toBe(false);
+      });
+    });
+
+    describe("timestamp validation", () => {
+      it("should validate created_at as ISO 8601", () => {
+        const result = validateServiceJson(
+          createValidServiceJson({ created_at: "not-a-timestamp" }),
+        );
+        expect(result.valid).toBe(false);
+        expect(result.errors.some((e) => e.includes("created_at") && e.includes("ISO 8601"))).toBe(
+          true,
+        );
+      });
+
+      it("should accept valid ISO 8601 timestamp", () => {
+        const result = validateServiceJson(
+          createValidServiceJson({ created_at: "2025-12-21T12:30:45.123Z" }),
+        );
+        expect(result.valid).toBe(true);
+      });
+
+      it("should validate expires_at if present", () => {
+        const result = validateServiceJson(createValidServiceJson({ expires_at: "bad-date" }));
+        expect(result.valid).toBe(false);
+        expect(result.errors.some((e) => e.includes("expires_at"))).toBe(true);
+      });
+    });
+
+    describe("scopes validation", () => {
+      it("should require scopes to be an array", () => {
+        const result = validateServiceJson(createValidServiceJson({ scopes: "not-array" }));
+        expect(result.valid).toBe(false);
+        expect(result.errors.some((e) => e.includes("scopes") && e.includes("array"))).toBe(true);
+      });
+
+      it("should reject empty scopes array", () => {
+        const result = validateServiceJson(createValidServiceJson({ scopes: [] }));
+        expect(result.valid).toBe(false);
+        expect(result.errors.some((e) => e.includes("scopes") && e.includes("empty"))).toBe(true);
+      });
+
+      it("should reject invalid scope values", () => {
+        const result = validateServiceJson(
+          createValidServiceJson({ scopes: ["minds:read", "invalid:scope"] }),
+        );
+        expect(result.valid).toBe(false);
+        expect(result.errors.some((e) => e.includes("invalid:scope"))).toBe(true);
+      });
+
+      it("should accept all valid scopes", () => {
+        const validScopes = [
+          "minds:read",
+          "minds:write",
+          "simulate:run",
+          "simulate:read",
+          "users:read",
+          "users:write",
+          "org:admin",
+        ];
+        const result = validateServiceJson(createValidServiceJson({ scopes: validScopes }));
+        expect(result.valid).toBe(true);
+      });
+    });
+
+    describe("app_metadata validation", () => {
+      it("should require app_metadata object", () => {
+        const result = validateServiceJson(createValidServiceJson({ app_metadata: undefined }));
+        expect(result.valid).toBe(false);
+        expect(result.errors.some((e) => e.includes("app_metadata"))).toBe(true);
+      });
+
+      it("should require use_case in app_metadata", () => {
+        const result = validateServiceJson(
+          createValidServiceJson({
+            app_metadata: {
+              app_id: "550e8400-e29b-41d4-a716-446655440000",
+              workspace_id: "550e8400-e29b-41d4-a716-446655440000",
+              mindsim_org_id: "550e8400-e29b-41d4-a716-446655440000",
+              use_case: "invalid-use-case",
+            },
+          }),
+        );
+        expect(result.valid).toBe(false);
+        expect(result.errors.some((e) => e.includes("use_case"))).toBe(true);
+      });
+
+      it("should accept valid use_case values", () => {
+        for (const useCase of ["internal-workflow", "customer-facing", "agentic-ai"]) {
+          const result = validateServiceJson(
+            createValidServiceJson({
+              app_metadata: {
+                app_id: "550e8400-e29b-41d4-a716-446655440000",
+                workspace_id: "550e8400-e29b-41d4-a716-446655440000",
+                mindsim_org_id: "550e8400-e29b-41d4-a716-446655440000",
+                use_case: useCase,
+              },
+            }),
+          );
+          expect(result.valid).toBe(true);
+        }
+      });
+    });
+  });
+
+  describe("loadServiceJsonFromBase64", () => {
+    const validServiceJson = {
+      type: "mindsim_service_account",
+      version: "1",
+      project_id: "test-app",
+      project_name: "Test App",
+      environment: "production",
+      client_email: "service@test-app.mindsim.io",
+      client_id: "550e8400-e29b-41d4-a716-446655440000",
+      api_key: "ms_prod_abc123",
+      api_base_url: "https://api.reasoner.com/api/mindsim",
+      scopes: ["minds:read"],
+      app_metadata: {
+        app_id: "550e8400-e29b-41d4-a716-446655440000",
+        workspace_id: "550e8400-e29b-41d4-a716-446655440000",
+        mindsim_org_id: "550e8400-e29b-41d4-a716-446655440000",
+        use_case: "internal-workflow",
+      },
+      created_at: "2025-12-21T00:00:00.000Z",
+    };
+
+    it("should decode valid base64 service JSON", () => {
+      const base64 = Buffer.from(JSON.stringify(validServiceJson)).toString("base64");
+      const result = loadServiceJsonFromBase64(base64);
+      expect(result).not.toBeNull();
+      expect(result?.project_id).toBe("test-app");
+    });
+
+    it("should return null for empty base64 string", () => {
+      const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+      const result = loadServiceJsonFromBase64("");
+      expect(result).toBeNull();
+      consoleSpy.mockRestore();
+    });
+
+    it("should return null for invalid base64", () => {
+      const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+      const result = loadServiceJsonFromBase64("not-valid-base64!!!");
+      expect(result).toBeNull();
+      consoleSpy.mockRestore();
+    });
+
+    it("should return null for base64 with invalid JSON", () => {
+      const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+      const base64 = Buffer.from("not valid json").toString("base64");
+      const result = loadServiceJsonFromBase64(base64);
+      expect(result).toBeNull();
+      consoleSpy.mockRestore();
+    });
+  });
+
+  describe("loadServiceJson", () => {
+    it("should load from MINDSIM_SERVICE_JSON file path", () => {
+      const validServiceJson = {
+        type: "mindsim_service_account",
+        version: "1",
+        project_id: "test-app",
+        project_name: "Test App",
+        environment: "production",
+        client_email: "service@test-app.mindsim.io",
+        client_id: "550e8400-e29b-41d4-a716-446655440000",
+        api_key: "ms_prod_abc123",
+        api_base_url: "https://api.reasoner.com/api/mindsim",
+        scopes: ["minds:read"],
+        app_metadata: {
+          app_id: "550e8400-e29b-41d4-a716-446655440000",
+          workspace_id: "550e8400-e29b-41d4-a716-446655440000",
+          mindsim_org_id: "550e8400-e29b-41d4-a716-446655440000",
+          use_case: "internal-workflow",
+        },
+        created_at: "2025-12-21T00:00:00.000Z",
+      };
+
+      vi.stubEnv("MINDSIM_SERVICE_JSON", "/path/to/service.json");
+      mockedFs.existsSync.mockReturnValue(true);
+      mockedFs.readFileSync.mockReturnValue(JSON.stringify(validServiceJson));
+
+      const result = loadServiceJson();
+      expect(result).not.toBeNull();
+      expect(result?.project_id).toBe("test-app");
+    });
+
+    it("should load from MINDSIM_SERVICE_JSON_BASE64", () => {
+      const validServiceJson = {
+        type: "mindsim_service_account",
+        version: "1",
+        project_id: "base64-app",
+        project_name: "Base64 App",
+        environment: "production",
+        client_email: "service@base64-app.mindsim.io",
+        client_id: "550e8400-e29b-41d4-a716-446655440000",
+        api_key: "ms_prod_abc123",
+        api_base_url: "https://api.reasoner.com/api/mindsim",
+        scopes: ["minds:read"],
+        app_metadata: {
+          app_id: "550e8400-e29b-41d4-a716-446655440000",
+          workspace_id: "550e8400-e29b-41d4-a716-446655440000",
+          mindsim_org_id: "550e8400-e29b-41d4-a716-446655440000",
+          use_case: "internal-workflow",
+        },
+        created_at: "2025-12-21T00:00:00.000Z",
+      };
+
+      const base64 = Buffer.from(JSON.stringify(validServiceJson)).toString("base64");
+      vi.stubEnv("MINDSIM_SERVICE_JSON_BASE64", base64);
+      mockedFs.existsSync.mockReturnValue(false); // No file
+
+      const result = loadServiceJson();
+      expect(result).not.toBeNull();
+      expect(result?.project_id).toBe("base64-app");
+    });
+
+    it("should prioritize file path over base64", () => {
+      const fileServiceJson = {
+        type: "mindsim_service_account",
+        version: "1",
+        project_id: "file-app",
+        project_name: "File App",
+        environment: "production",
+        client_email: "service@file-app.mindsim.io",
+        client_id: "550e8400-e29b-41d4-a716-446655440000",
+        api_key: "ms_prod_abc123",
+        api_base_url: "https://api.reasoner.com/api/mindsim",
+        scopes: ["minds:read"],
+        app_metadata: {
+          app_id: "550e8400-e29b-41d4-a716-446655440000",
+          workspace_id: "550e8400-e29b-41d4-a716-446655440000",
+          mindsim_org_id: "550e8400-e29b-41d4-a716-446655440000",
+          use_case: "internal-workflow",
+        },
+        created_at: "2025-12-21T00:00:00.000Z",
+      };
+
+      const base64ServiceJson = { ...fileServiceJson, project_id: "base64-app" };
+      const base64 = Buffer.from(JSON.stringify(base64ServiceJson)).toString("base64");
+
+      vi.stubEnv("MINDSIM_SERVICE_JSON", "/path/to/service.json");
+      vi.stubEnv("MINDSIM_SERVICE_JSON_BASE64", base64);
+      mockedFs.existsSync.mockReturnValue(true);
+      mockedFs.readFileSync.mockReturnValue(JSON.stringify(fileServiceJson));
+
+      const result = loadServiceJson();
+      expect(result?.project_id).toBe("file-app"); // File takes priority
+    });
   });
 });