mindsim 0.1.6 → 0.1.7

package/src/logger.ts

@@ -0,0 +1,111 @@
+/**
+ * MindSim SDK Logger Interface
+ *
+ * Provides a configurable logging interface so users can control
+ * how SDK messages are logged (or suppressed).
+ *
+ * Gap 8 Fix: Replaces hardcoded console.error with configurable interface.
+ *
+ * Usage:
+ *   import { setLogger, createSilentLogger } from 'mindsim';
+ *
+ *   // Use silent logger to suppress all SDK logs
+ *   setLogger(createSilentLogger());
+ *
+ *   // Use custom logger
+ *   setLogger({
+ *     debug: (msg) => myLogger.debug(`[MindSim] ${msg}`),
+ *     info: (msg) => myLogger.info(`[MindSim] ${msg}`),
+ *     warn: (msg) => myLogger.warn(`[MindSim] ${msg}`),
+ *     error: (msg) => myLogger.error(`[MindSim] ${msg}`),
+ *   });
+ */
+
+/**
+ * Logger interface for the MindSim SDK.
+ * Implement this interface to customize SDK logging behavior.
+ */
+export interface MindSimLogger {
+  /** Debug-level messages (not shown by default) */
+  debug: (message: string, ...args: unknown[]) => void;
+  /** Informational messages */
+  info: (message: string, ...args: unknown[]) => void;
+  /** Warning messages */
+  warn: (message: string, ...args: unknown[]) => void;
+  /** Error messages */
+  error: (message: string, ...args: unknown[]) => void;
+}
+
+/**
+ * Default logger that uses console methods.
+ * Debug is disabled by default.
+ */
+export const defaultLogger: MindSimLogger = {
+  debug: () => {
+    // Debug disabled by default
+  },
+  info: (message: string, ...args: unknown[]) => {
+    console.info(`[MindSim] ${message}`, ...args);
+  },
+  warn: (message: string, ...args: unknown[]) => {
+    console.warn(`[MindSim] ${message}`, ...args);
+  },
+  error: (message: string, ...args: unknown[]) => {
+    console.error(`[MindSim] ${message}`, ...args);
+  },
+};
+
+/**
+ * Create a silent logger that suppresses all SDK logs.
+ * Useful for production environments where you want no SDK output.
+ */
+export function createSilentLogger(): MindSimLogger {
+  const noop = () => {};
+  return {
+    debug: noop,
+    info: noop,
+    warn: noop,
+    error: noop,
+  };
+}
+
+/**
+ * Create a logger with all levels enabled (including debug).
+ * Useful for development and debugging.
+ */
+export function createVerboseLogger(): MindSimLogger {
+  return {
+    debug: (message: string, ...args: unknown[]) => {
+      console.debug(`[MindSim:DEBUG] ${message}`, ...args);
+    },
+    info: (message: string, ...args: unknown[]) => {
+      console.info(`[MindSim] ${message}`, ...args);
+    },
+    warn: (message: string, ...args: unknown[]) => {
+      console.warn(`[MindSim] ${message}`, ...args);
+    },
+    error: (message: string, ...args: unknown[]) => {
+      console.error(`[MindSim] ${message}`, ...args);
+    },
+  };
+}
+
+// Global logger instance
+let currentLogger: MindSimLogger = defaultLogger;
+
+/**
+ * Set the global logger for the SDK.
+ *
+ * @param logger - The logger implementation to use
+ */
+export function setLogger(logger: MindSimLogger): void {
+  currentLogger = logger;
+}
+
+/**
+ * Get the current logger.
+ * Used internally by the SDK.
+ */
+export function getLogger(): MindSimLogger {
+  return currentLogger;
+}

package/src/types.ts

@@ -55,6 +55,65 @@ export interface SdkKeyDetailResponse {
   };
 }
 
+/**
+ * Valid MindSim scopes for API access.
+ * Matches rainmaker's MindsimScope type (lib/types/developer-portal.ts).
+ */
+export type MindsimScope =
+  | "minds:read" // List/read digital twins
+  | "minds:write" // Create/update digital twins
+  | "simulate:run" // Run simulations
+  | "simulate:read" // Read simulation history
+  | "users:read" // Read org users
+  | "users:write" // Manage org users
+  | "org:admin"; // Full org administration
+
+/**
+ * Valid use cases for developer apps.
+ * Matches rainmaker's DeveloperUseCase type.
+ */
+export type DeveloperUseCase = "internal-workflow" | "customer-facing" | "agentic-ai";
+
+/**
+ * MindSim Service JSON credential format.
+ * Google Cloud-style service account JSON for production deployments.
+ */
+export interface MindsimServiceJson {
+  /** Must be "mindsim_service_account" to identify this as a service JSON */
+  type: "mindsim_service_account";
+  /** Service JSON schema version */
+  version: string;
+  /** App slug (human-readable identifier) */
+  project_id: string;
+  /** App display name */
+  project_name: string;
+  /** Environment (always "production" for service JSON) */
+  environment: "production";
+  /** Service account email (service@{slug}.mindsim.io) */
+  client_email: string;
+  /** API key UUID */
+  client_id: string;
+  /** The actual API key secret */
+  api_key: string;
+  /** API endpoint base URL */
+  api_base_url: string;
+  /** Granted API scopes */
+  scopes: MindsimScope[];
+  /** Application metadata */
+  app_metadata: {
+    app_id: string;
+    workspace_id: string;
+    mindsim_org_id: string;
+    use_case: DeveloperUseCase;
+  };
+  /** ISO 8601 timestamp when credentials were created */
+  created_at: string;
+  /** Optional: ISO 8601 timestamp when credentials expire */
+  expires_at?: string;
+  /** Optional: ISO 8601 timestamp when credentials were issued (same as created_at for new keys) */
+  issued_at?: string;
+}
+
 export interface Tag {
   id: string;
   name: string;

package/src/version.ts

@@ -4,6 +4,7 @@ import path from "node:path";
 import { promisify } from "node:util";
 import axios from "axios";
 import semver from "semver";
+import { getLogger } from "./logger";
 
 const execAsync = promisify(exec);
 
@@ -65,7 +66,7 @@ export const getPackageVersion = (): string => {
     const pkg = JSON.parse(content);
     return pkg.version;
   } catch (error) {
-    console.warn("MindSim SDK: Unable to determine current package version.", error);
+    getLogger().warn("Unable to determine current package version.", error);
     return "0.0.0";
   }
 };

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
+    });
   });
 });