@aifabrix/builder 2.1.6 → 2.2.0

package/lib/config.js

@@ -17,17 +17,53 @@ const yaml = require('js-yaml');
 const CONFIG_DIR = path.join(os.homedir(), '.aifabrix');
 const CONFIG_FILE = path.join(CONFIG_DIR, 'config.yaml');
 
+// Cache for developer ID - loaded when getConfig() is first called
+let cachedDeveloperId = null;
+
 /**
  * Get stored configuration
- * @returns {Promise<Object>} Configuration object with apiUrl and token
+ * Loads developer ID and caches it as a property for easy access
+ * @returns {Promise<Object>} Configuration object with new structure
  */
 async function getConfig() {
   try {
     const configContent = await fs.readFile(CONFIG_FILE, 'utf8');
-    return yaml.load(configContent);
+    let config = yaml.load(configContent);
+
+    // Handle empty file or null/undefined result from yaml.load
+    if (!config || typeof config !== 'object') {
+      config = {};
+    }
+
+    // Ensure developerId defaults to 0 if not set
+    if (typeof config['developer-id'] === 'undefined') {
+      config['developer-id'] = 0;
+    }
+    // Ensure environment defaults to 'dev' if not set
+    if (typeof config.environment === 'undefined') {
+      config.environment = 'dev';
+    }
+    // Ensure environments object exists
+    if (typeof config.environments !== 'object' || config.environments === null) {
+      config.environments = {};
+    }
+    // Ensure device object exists at root level
+    if (typeof config.device !== 'object' || config.device === null) {
+      config.device = {};
+    }
+    // Cache developer ID as property for easy access (use nullish coalescing to allow 0)
+    cachedDeveloperId = config['developer-id'] !== undefined ? config['developer-id'] : 0;
+    return config;
   } catch (error) {
     if (error.code === 'ENOENT') {
-      return { apiUrl: null, token: null };
+      // Default developer ID is 0, default environment is 'dev'
+      cachedDeveloperId = 0;
+      return {
+        'developer-id': 0,
+        environment: 'dev',
+        environments: {},
+        device: {}
+      };
     }
     throw new Error(`Failed to read config: ${error.message}`);
   }
@@ -45,10 +81,19 @@ async function saveConfig(data) {
 
     // Set secure permissions
     const configContent = yaml.dump(data);
+    // Write file first
     await fs.writeFile(CONFIG_FILE, configContent, {
       mode: 0o600,
       flag: 'w'
     });
+    // Open file descriptor and fsync to ensure write is flushed to disk
+    // This is critical on Windows where file writes may be cached
+    const fd = await fs.open(CONFIG_FILE, 'r+');
+    try {
+      await fd.sync();
+    } finally {
+      await fd.close();
+    }
   } catch (error) {
     throw new Error(`Failed to save config: ${error.message}`);
   }
@@ -68,11 +113,219 @@ async function clearConfig() {
   }
 }
 
-module.exports = {
+/**
+ * Get developer ID from configuration
+ * Loads config if not already cached, then returns cached developer ID
+ * Developer ID: 0 = default infra, > 0 = developer-specific
+ * @returns {Promise<number>} Developer ID (defaults to 0)
+ */
+async function getDeveloperId() {
+  // Always reload from file to ensure we have the latest value
+  // This ensures the cache matches what's actually in the file
+  // Clear cache first to force a fresh read
+  cachedDeveloperId = null;
+  await getConfig();
+  return cachedDeveloperId;
+}
+
+/**
+ * Set developer ID in configuration
+ * @param {number} developerId - Developer ID to set (0 = default infra, > 0 = developer-specific)
+ * @returns {Promise<void>}
+ */
+async function setDeveloperId(developerId) {
+  if (typeof developerId !== 'number' || developerId < 0) {
+    throw new Error('Developer ID must be a non-negative number (0 = default infra, > 0 = developer-specific)');
+  }
+  // Clear cache first to ensure we get fresh data from file
+  cachedDeveloperId = null;
+  // Read file directly to avoid any caching issues
+  const config = await getConfig();
+  // Update developer ID
+  config['developer-id'] = developerId;
+  // Update cache before saving
+  cachedDeveloperId = developerId;
+  // Save the entire config object to ensure all fields are preserved
+  await saveConfig(config);
+  // Verify the file was saved correctly by reading it back
+  // This ensures the file system has written the data
+  // Add a small delay to ensure file system has flushed the write
+  await new Promise(resolve => setTimeout(resolve, 100));
+  // Read file again with fresh file handle to avoid OS caching
+  const savedContent = await fs.readFile(CONFIG_FILE, 'utf8');
+  const savedConfig = yaml.load(savedContent);
+  if (savedConfig['developer-id'] !== developerId) {
+    throw new Error(`Failed to save developer ID: expected ${developerId}, got ${savedConfig['developer-id']}. File content: ${savedContent.substring(0, 200)}`);
+  }
+  // Clear the cache to force reload from file on next getDeveloperId() call
+  // This ensures we get the value that was actually saved to disk
+  cachedDeveloperId = null;
+}
+
+/**
+ * Get current environment from root-level config
+ * @returns {Promise<string>} Current environment (defaults to 'dev')
+ */
+async function getCurrentEnvironment() {
+  const config = await getConfig();
+  return config.environment || 'dev';
+}
+
+/**
+ * Set current environment in root-level config
+ * @param {string} environment - Environment to set (e.g., 'miso', 'dev', 'tst', 'pro')
+ * @returns {Promise<void>}
+ */
+async function setCurrentEnvironment(environment) {
+  if (!environment || typeof environment !== 'string') {
+    throw new Error('Environment must be a non-empty string');
+  }
+  const config = await getConfig();
+  config.environment = environment;
+  await saveConfig(config);
+}
+
+/**
+ * Check if token is expired
+ * @param {string} expiresAt - ISO timestamp string
+ * @returns {boolean} True if token is expired
+ */
+function isTokenExpired(expiresAt) {
+  if (!expiresAt) {
+    return true;
+  }
+  const expirationTime = new Date(expiresAt).getTime();
+  const now = Date.now();
+  // Add 5 minute buffer to refresh before actual expiration
+  return now >= (expirationTime - 5 * 60 * 1000);
+}
+
+/**
+ * Get device token for controller
+ * @param {string} controllerUrl - Controller URL
+ * @returns {Promise<{controller: string, token: string, refreshToken: string, expiresAt: string}|null>} Device token info or null
+ */
+async function getDeviceToken(controllerUrl) {
+  const config = await getConfig();
+  if (!config.device || !config.device[controllerUrl]) {
+    return null;
+  }
+  const deviceToken = config.device[controllerUrl];
+  return {
+    controller: controllerUrl,
+    token: deviceToken.token,
+    refreshToken: deviceToken.refreshToken,
+    expiresAt: deviceToken.expiresAt
+  };
+}
+
+/**
+ * Get client token for environment and app
+ * @param {string} environment - Environment key
+ * @param {string} appName - Application name
+ * @returns {Promise<{controller: string, token: string, expiresAt: string}|null>} Client token info or null
+ */
+async function getClientToken(environment, appName) {
+  const config = await getConfig();
+  if (!config.environments || !config.environments[environment]) {
+    return null;
+  }
+  if (!config.environments[environment].clients || !config.environments[environment].clients[appName]) {
+    return null;
+  }
+  return config.environments[environment].clients[appName];
+}
+
+/**
+ * Save device token for controller (root level)
+ * @param {string} controllerUrl - Controller URL (used as key)
+ * @param {string} token - Device access token
+ * @param {string} refreshToken - Refresh token for token renewal
+ * @param {string} expiresAt - ISO timestamp string
+ * @returns {Promise<void>}
+ */
+async function saveDeviceToken(controllerUrl, token, refreshToken, expiresAt) {
+  const config = await getConfig();
+  if (!config.device) {
+    config.device = {};
+  }
+  config.device[controllerUrl] = {
+    token: token,
+    refreshToken: refreshToken,
+    expiresAt: expiresAt
+  };
+  await saveConfig(config);
+}
+
+/**
+ * Save client token for environment and app
+ * @param {string} environment - Environment key
+ * @param {string} appName - Application name
+ * @param {string} controllerUrl - Controller URL
+ * @param {string} token - Client token
+ * @param {string} expiresAt - ISO timestamp string
+ * @returns {Promise<void>}
+ */
+async function saveClientToken(environment, appName, controllerUrl, token, expiresAt) {
+  const config = await getConfig();
+  if (!config.environments) {
+    config.environments = {};
+  }
+  if (!config.environments[environment]) {
+    config.environments[environment] = { clients: {} };
+  }
+  if (!config.environments[environment].clients) {
+    config.environments[environment].clients = {};
+  }
+  config.environments[environment].clients[appName] = {
+    controller: controllerUrl,
+    token: token,
+    expiresAt: expiresAt
+  };
+  await saveConfig(config);
+}
+
+/**
+ * Initialize and load developer ID
+ * Call this to ensure developerId is loaded and cached
+ * @returns {Promise<number>} Developer ID
+ */
+async function loadDeveloperId() {
+  if (cachedDeveloperId === null) {
+    await getConfig();
+  }
+  return cachedDeveloperId;
+}
+
+// Create exports object
+const exportsObj = {
   getConfig,
   saveConfig,
   clearConfig,
+  getDeveloperId,
+  setDeveloperId,
+  loadDeveloperId,
+  getCurrentEnvironment,
+  setCurrentEnvironment,
+  isTokenExpired,
+  getDeviceToken,
+  getClientToken,
+  saveDeviceToken,
+  saveClientToken,
   CONFIG_DIR,
   CONFIG_FILE
 };
 
+// Add developerId as a property getter for direct access
+// After getConfig() or getDeveloperId() is called, config.developerId will be available
+// Developer ID: 0 = default infra, > 0 = developer-specific
+Object.defineProperty(exportsObj, 'developerId', {
+  get() {
+    return cachedDeveloperId !== null ? cachedDeveloperId : 0; // Default to 0 if not loaded yet
+  },
+  enumerable: true,
+  configurable: true
+});
+
+module.exports = exportsObj;
+