@aifabrix/builder 2.31.0 → 2.31.1

package/lib/app-rotate-secret.js

@@ -61,20 +61,83 @@ function validateEnvironment(environment) {
   }
 }
 
+/**
+ * Validate credentials object structure
+ * @param {Object} credentials - Credentials object to validate
+ * @returns {boolean} True if credentials are valid
+ */
+function isValidCredentials(credentials) {
+  return credentials &&
+    typeof credentials === 'object' &&
+    typeof credentials.clientId === 'string' &&
+    typeof credentials.clientSecret === 'string';
+}
+
+/**
+ * Extract credentials from API response
+ * Handles multiple response formats:
+ * 1. Direct format: { success: true, data: { credentials: {...} } }
+ * 2. Wrapped format: { success: true, data: { success: true, data: { credentials: {...} } } }
+ * @param {Object} response - API response from centralized API client
+ * @returns {Object|null} Object with credentials and message, or null if not found
+ */
+function extractCredentials(response) {
+  // Note: response.data is already validated in validateResponse
+  const apiResponse = response.data;
+
+  // Try wrapped format first: response.data.data.credentials
+  if (apiResponse.data && apiResponse.data.credentials) {
+    const credentials = apiResponse.data.credentials;
+    if (isValidCredentials(credentials)) {
+      return {
+        credentials: credentials,
+        message: apiResponse.data.message || apiResponse.message
+      };
+    }
+  }
+
+  // Try direct format: response.data.credentials
+  if (apiResponse.credentials) {
+    const credentials = apiResponse.credentials;
+    if (isValidCredentials(credentials)) {
+      return {
+        credentials: credentials,
+        message: apiResponse.message
+      };
+    }
+  }
+
+  return null;
+}
+
 /**
  * Validate API response structure
  * @param {Object} response - API response
+ * @returns {Object} Object with credentials and message
  * @throws {Error} If response structure is invalid
  */
 function validateResponse(response) {
   if (!response.data || typeof response.data !== 'object') {
+    logger.error(chalk.red('❌ Invalid response: missing data'));
+    logger.error(chalk.gray('\nAPI response type:'), typeof response.data);
+    logger.error(chalk.gray('API response:'), JSON.stringify(response.data, null, 2));
+    logger.error(chalk.gray('\nFull response for debugging:'));
+    logger.error(chalk.gray(JSON.stringify(response, null, 2)));
     throw new Error('Invalid response: missing data');
   }
 
-  const credentials = response.data.credentials;
-  if (!credentials || typeof credentials !== 'object' || typeof credentials.clientId !== 'string' || typeof credentials.clientSecret !== 'string') {
+  const result = extractCredentials(response);
+
+  if (!result) {
+    logger.error(chalk.red('❌ Invalid response: missing or invalid credentials'));
+    logger.error(chalk.gray('\nAPI response type:'), typeof response.data);
+    logger.error(chalk.gray('API response:'), JSON.stringify(response.data, null, 2));
+    logger.error(chalk.gray('\nFull response for debugging:'));
+    logger.error(chalk.gray(JSON.stringify(response, null, 2)));
     throw new Error('Invalid response: missing or invalid credentials');
   }
+
+  return result;
 }
 
 /**
@@ -108,6 +171,47 @@ function displayRotationResults(appKey, environment, credentials, apiUrl, messag
   }
 }
 
+/**
+ * Get device token from provided controller URL
+ * @async
+ * @param {string} controllerUrl - Controller URL
+ * @returns {Promise<Object|null>} Object with token and controllerUrl, or null if failed
+ */
+async function getTokenFromUrl(controllerUrl) {
+  try {
+    const normalizedUrl = normalizeControllerUrl(controllerUrl);
+    const deviceToken = await getOrRefreshDeviceToken(normalizedUrl);
+    if (deviceToken && deviceToken.token) {
+      return {
+        token: deviceToken.token,
+        controllerUrl: deviceToken.controller || normalizedUrl
+      };
+    }
+  } catch (error) {
+    logger.error(chalk.red(`❌ Failed to authenticate with controller: ${controllerUrl}`));
+    logger.error(chalk.gray(`Error: ${error.message}`));
+    process.exit(1);
+  }
+  return null;
+}
+
+/**
+ * Validate and handle missing authentication token
+ * @param {string|null} token - Authentication token
+ * @param {string|null} controllerUrl - Controller URL
+ * @param {string} [providedUrl] - Original provided URL for error context
+ */
+function validateAuthToken(token, controllerUrl, providedUrl) {
+  if (!token || !controllerUrl) {
+    const formattedError = formatAuthenticationError({
+      controllerUrl: providedUrl || undefined,
+      message: 'No valid authentication found'
+    });
+    logger.error(formattedError);
+    process.exit(1);
+  }
+}
+
 /**
  * Get authentication token for rotation
  * @async
@@ -122,17 +226,10 @@ async function getRotationAuthToken(controllerUrl, config) {
 
   // If controller URL provided, try to get device token
   if (controllerUrl) {
-    try {
-      const normalizedUrl = normalizeControllerUrl(controllerUrl);
-      const deviceToken = await getOrRefreshDeviceToken(normalizedUrl);
-      if (deviceToken && deviceToken.token) {
-        token = deviceToken.token;
-        actualControllerUrl = deviceToken.controller || normalizedUrl;
-      }
-    } catch (error) {
-      logger.error(chalk.red(`❌ Failed to authenticate with controller: ${controllerUrl}`));
-      logger.error(chalk.gray(`Error: ${error.message}`));
-      process.exit(1);
+    const tokenResult = await getTokenFromUrl(controllerUrl);
+    if (tokenResult) {
+      token = tokenResult.token;
+      actualControllerUrl = tokenResult.controllerUrl;
     }
   }
 
@@ -145,15 +242,7 @@ async function getRotationAuthToken(controllerUrl, config) {
     }
   }
 
-  if (!token || !actualControllerUrl) {
-    const formattedError = formatAuthenticationError({
-      controllerUrl: controllerUrl || undefined,
-      message: 'No valid authentication found'
-    });
-    logger.error(formattedError);
-    process.exit(1);
-  }
-
+  validateAuthToken(token, actualControllerUrl, controllerUrl);
   return { token, actualControllerUrl };
 }
 
@@ -228,11 +317,8 @@ async function rotateSecret(appKey, options) {
       process.exit(1);
     }
 
-    // Validate response structure
-    validateResponse(response);
-
-    const credentials = response.data.credentials;
-    const message = response.data.message;
+    // Validate response structure and extract credentials
+    const { credentials, message } = validateResponse(response);
 
     // Save credentials locally
     await saveCredentialsLocally(appKey, credentials, actualControllerUrl);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aifabrix/builder",
-  "version": "2.31.0",
+  "version": "2.31.1",
   "description": "AI Fabrix Local Fabric & Deployment SDK",
   "main": "lib/index.js",
   "bin": {
@@ -21,7 +21,9 @@
     "pack": "npm run build && npm pack",
     "validate": "npm run build",
     "prepublishOnly": "npm run validate",
-    "precommit": "npm run lint:fix && npm run test"
+    "precommit": "npm run lint:fix && npm run test",
+    "install:local": "node scripts/install-local.js",
+    "uninstall:local": "node scripts/install-local.js uninstall"
   },
   "keywords": [
     "aifabrix",

package/scripts/install-local.js

@@ -0,0 +1,210 @@
+#!/usr/bin/env node
+/* eslint-disable no-console */
+
+/**
+ * Install local package globally using npm link or pnpm link
+ * Automatically detects which package manager is being used
+ *
+ * @fileoverview Local installation script for @aifabrix/builder
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Detect which package manager is being used (pnpm or npm)
+ * @returns {string} 'pnpm' or 'npm'
+ */
+function detectPackageManager() {
+  try {
+    // Check if pnpm is available
+    execSync('which pnpm', { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+    return 'pnpm';
+  } catch {
+    // Fall back to npm
+    return 'npm';
+  }
+}
+
+/**
+ * Get currently installed version of aifabrix CLI
+ * @returns {string|null} Version string or null if not installed
+ */
+function getCurrentVersion() {
+  try {
+    const version = execSync('aifabrix --version', { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+    return version;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Get version from local package.json
+ * @returns {string|null} Version string or null if not found
+ */
+function getPackageVersion() {
+  try {
+    const packageJsonPath = path.join(__dirname, '..', 'package.json');
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+    return packageJson.version;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Display version comparison information
+ * @param {string|null} currentVersion - Currently installed version
+ * @param {string|null} packageVersion - Version being linked
+ * @returns {void}
+ */
+function displayVersionInfo(currentVersion, packageVersion) {
+  if (currentVersion) {
+    console.log(`📦 Current installed version: ${currentVersion}`);
+  } else {
+    console.log('📦 No previous version detected (first install)');
+  }
+
+  if (packageVersion) {
+    if (currentVersion && currentVersion !== packageVersion) {
+      console.log(`🔄 Linking new version: ${packageVersion}`);
+      console.log(`   Version change: ${currentVersion} → ${packageVersion}\n`);
+    } else if (currentVersion && currentVersion === packageVersion) {
+      console.log(`🔄 Linking version: ${packageVersion} (same version)\n`);
+    } else {
+      console.log(`🔄 Linking version: ${packageVersion}\n`);
+    }
+  }
+}
+
+/**
+ * Display success message with version information
+ * @param {string|null} currentVersion - Version before linking
+ * @param {string|null} newVersion - Version after linking
+ * @returns {void}
+ */
+function displaySuccessMessage(currentVersion, newVersion) {
+  console.log('\n✅ Successfully linked!');
+  if (currentVersion && newVersion && currentVersion !== newVersion) {
+    console.log(`📊 Version updated: ${currentVersion} → ${newVersion}`);
+  } else if (newVersion) {
+    console.log(`📊 Installed version: ${newVersion}`);
+  }
+  console.log('Run "aifabrix --version" to verify.');
+}
+
+/**
+ * Install local package globally
+ * @returns {void}
+ */
+function installLocal() {
+  const pm = detectPackageManager();
+  const packageVersion = getPackageVersion();
+  const currentVersion = getCurrentVersion();
+
+  console.log(`Detected package manager: ${pm}\n`);
+
+  // Show version comparison
+  displayVersionInfo(currentVersion, packageVersion);
+
+  console.log('Linking @aifabrix/builder globally...\n');
+
+  try {
+    if (pm === 'pnpm') {
+      execSync('pnpm link --global', { stdio: 'inherit' });
+    } else {
+      execSync('npm link', { stdio: 'inherit' });
+    }
+
+    // Get new version after linking
+    const newVersion = getCurrentVersion();
+
+    displaySuccessMessage(currentVersion, newVersion);
+  } catch (error) {
+    console.error('\n❌ Failed to link package:', error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * Display version information before unlinking
+ * @param {string|null} currentVersion - Currently installed version
+ * @param {string|null} packageVersion - Local package version
+ * @returns {void}
+ */
+function displayUninstallVersionInfo(currentVersion, packageVersion) {
+  if (currentVersion) {
+    console.log(`📦 Current installed version: ${currentVersion}`);
+  } else {
+    console.log('📦 No installed version detected');
+  }
+
+  if (packageVersion) {
+    console.log(`📋 Local package version: ${packageVersion}`);
+    if (currentVersion && currentVersion === packageVersion) {
+      console.log('   (matches installed version)\n');
+    } else if (currentVersion && currentVersion !== packageVersion) {
+      console.log(`   (installed: ${currentVersion}, local: ${packageVersion})\n`);
+    } else {
+      console.log('\n');
+    }
+  } else {
+    console.log('\n');
+  }
+}
+
+/**
+ * Display success message after unlinking
+ * @param {string} pm - Package manager ('pnpm' or 'npm')
+ * @param {string|null} currentVersion - Version that was uninstalled
+ * @returns {void}
+ */
+function displayUninstallSuccess(pm, currentVersion) {
+  console.log(`\n✅ Successfully unlinked with ${pm}!`);
+  if (currentVersion) {
+    console.log(`📊 Uninstalled version: ${currentVersion}`);
+  }
+}
+
+/**
+ * Uninstall local package from global installation
+ * @returns {void}
+ */
+function uninstallLocal() {
+  const pm = detectPackageManager();
+  const currentVersion = getCurrentVersion();
+  const packageVersion = getPackageVersion();
+
+  console.log(`Detected package manager: ${pm}\n`);
+
+  // Show version information before unlinking
+  displayUninstallVersionInfo(currentVersion, packageVersion);
+
+  console.log('Unlinking @aifabrix/builder globally...\n');
+
+  try {
+    if (pm === 'pnpm') {
+      execSync('pnpm unlink --global @aifabrix/builder', { stdio: 'inherit' });
+      displayUninstallSuccess(pm, currentVersion);
+    } else {
+      execSync('npm unlink -g @aifabrix/builder', { stdio: 'inherit' });
+      displayUninstallSuccess(pm, currentVersion);
+    }
+  } catch (error) {
+    console.error('\n❌ Failed to unlink package:', error.message);
+    process.exit(1);
+  }
+}
+
+// Main execution
+const command = process.argv[2];
+
+if (command === 'uninstall' || command === 'unlink') {
+  uninstallLocal();
+} else {
+  installLocal();
+}