@aifabrix/builder 2.11.0 → 2.20.0

package/lib/datasource-deploy.js

@@ -12,7 +12,8 @@
 const fs = require('fs');
 const chalk = require('chalk');
 const { getDeploymentAuth } = require('./utils/token-manager');
-const { authenticatedApiCall } = require('./utils/api');
+const { getEnvironmentApplication } = require('./api/environments.api');
+const { publishDatasourceViaPipeline } = require('./api/pipeline.api');
 const { formatApiError } = require('./utils/api-error-handler');
 const logger = require('./utils/logger');
 const { validateDatasourceFile } = require('./datasource-validate');
@@ -30,18 +31,8 @@ const { validateDatasourceFile } = require('./datasource-validate');
  * @throws {Error} If dataplane URL cannot be retrieved
  */
 async function getDataplaneUrl(controllerUrl, appKey, environment, authConfig) {
-  // Call controller API to get application details
-  // Expected: GET /api/v1/environments/{env}/applications/{appKey}
-  const endpoint = `${controllerUrl}/api/v1/environments/${environment}/applications/${appKey}`;
-
-  let response;
-  if (authConfig.type === 'bearer' && authConfig.token) {
-    response = await authenticatedApiCall(endpoint, {}, authConfig.token);
-  } else {
-    // For credentials, we'd need to use a different API call method
-    // For now, use bearer token approach
-    throw new Error('Bearer token authentication required for getting dataplane URL');
-  }
+  // Call controller API to get application details using centralized API client
+  const response = await getEnvironmentApplication(controllerUrl, environment, appKey, authConfig);
 
   if (!response.success || !response.data) {
     const formattedError = response.formattedError || formatApiError(response);
@@ -129,24 +120,10 @@ async function deployDatasource(appKey, filePath, options) {
   const dataplaneUrl = await getDataplaneUrl(options.controller, appKey, options.environment, authConfig);
   logger.log(chalk.green(`✓ Dataplane URL: ${dataplaneUrl}`));
 
-  // Publish to dataplane (using publish endpoint)
+  // Publish to dataplane using pipeline workflow endpoint
   logger.log(chalk.blue('\n🚀 Publishing datasource to dataplane...'));
-  const publishEndpoint = `${dataplaneUrl}/api/v1/pipeline/${systemKey}/publish`;
-
-  // Prepare publish request - send datasource configuration directly
-  let publishResponse;
-  if (authConfig.type === 'bearer' && authConfig.token) {
-    publishResponse = await authenticatedApiCall(
-      publishEndpoint,
-      {
-        method: 'POST',
-        body: JSON.stringify(datasourceConfig)
-      },
-      authConfig.token
-    );
-  } else {
-    throw new Error('Bearer token authentication required for dataplane publish');
-  }
+
+  const publishResponse = await publishDatasourceViaPipeline(dataplaneUrl, systemKey, authConfig, datasourceConfig);
 
   if (!publishResponse.success) {
     const formattedError = publishResponse.formattedError || formatApiError(publishResponse);

package/lib/datasource-list.js

@@ -11,7 +11,7 @@
 const chalk = require('chalk');
 const { getConfig } = require('./config');
 const { getOrRefreshDeviceToken } = require('./utils/token-manager');
-const { authenticatedApiCall } = require('./utils/api');
+const { listEnvironmentDatasources } = require('./api/environments.api');
 const { formatApiError } = require('./utils/api-error-handler');
 const logger = require('./utils/logger');
 
@@ -20,11 +20,15 @@ const logger = require('./utils/logger');
  * Handles multiple response formats similar to applications list
  *
  * @function extractDatasources
- * @param {Object} response - API response from authenticatedApiCall
+ * @param {Object} response - API response from centralized API client
  * @returns {Array} Array of datasources
  * @throws {Error} If response format is invalid
  */
 function extractDatasources(response) {
+  if (!response.success || !response.data) {
+    throw new Error('Invalid API response: missing success or data');
+  }
+
   const apiResponse = response.data;
   let datasources;
 
@@ -112,10 +116,9 @@ async function listDatasources(options) {
     process.exit(1);
   }
 
-  // Call controller API - using placeholder endpoint until full specs available
-  // Expected: GET /api/v1/environments/{env}/datasources
-  const endpoint = `${controllerUrl}/api/v1/environments/${options.environment}/datasources`;
-  const response = await authenticatedApiCall(endpoint, {}, token);
+  // Call controller API using centralized API client
+  const authConfig = { type: 'bearer', token };
+  const response = await listEnvironmentDatasources(controllerUrl, options.environment, authConfig);
 
   if (!response.success || !response.data) {
     const formattedError = response.formattedError || formatApiError(response);

package/lib/deployer.js

@@ -9,84 +9,12 @@
  * @version 2.0.0
  */
 
-const axios = require('axios');
 const chalk = require('chalk');
 const auditLogger = require('./audit-logger');
 const logger = require('./utils/logger');
-const { createAuthHeaders } = require('./utils/auth-headers');
 const { validateControllerUrl, validateEnvironmentKey } = require('./utils/deployment-validation');
 const { handleDeploymentError, handleDeploymentErrors } = require('./utils/deployment-errors');
-
-/**
- * Handles deployment request retry logic
- * @async
- * @function handleDeploymentRetry
- * @param {string} endpoint - API endpoint
- * @param {Object} manifest - Deployment manifest
- * @param {Object} requestConfig - Request configuration
- * @param {number} maxRetries - Maximum retry attempts
- * @returns {Promise<Object>} Deployment result
- * @throws {Error} If deployment fails after retries
- */
-async function handleDeploymentRetry(endpoint, manifest, requestConfig, maxRetries) {
-  let lastError;
-
-  // Validate manifest before sending
-  if (!manifest || typeof manifest !== 'object') {
-    throw new Error('Deployment manifest is required and must be an object');
-  }
-
-  for (let attempt = 1; attempt <= maxRetries; attempt++) {
-    try {
-      // Axios automatically serializes objects to JSON when Content-Type is application/json
-      const response = await axios.post(endpoint, manifest, requestConfig);
-
-      if (response.status >= 400) {
-        const error = new Error(`Controller returned error: ${response.status} ${response.statusText}`);
-        error.status = response.status;
-        error.response = {
-          status: response.status,
-          statusText: response.statusText,
-          data: response.data
-        };
-        error.data = response.data;
-        throw error;
-      }
-
-      // OpenAPI spec: Response 202 structure { success: boolean, deploymentId: string, status: string, deploymentUrl?: string, healthCheckUrl?: string, message?: string }
-      // Handle both OpenAPI format and legacy format for backward compatibility
-      const responseData = response.data;
-      if (responseData && typeof responseData === 'object') {
-        // OpenAPI format: { success, deploymentId, status, deploymentUrl, healthCheckUrl, message }
-        return responseData;
-      }
-
-      return response.data;
-    } catch (error) {
-      lastError = error;
-
-      if (attempt < maxRetries) {
-        const delay = Math.min(1000 * Math.pow(2, attempt - 1), 5000);
-        logger.log(chalk.yellow(`⚠️  Deployment attempt ${attempt} failed, retrying in ${delay}ms...`));
-        await new Promise(resolve => setTimeout(resolve, delay));
-      }
-    }
-  }
-
-  // Preserve formatted error if available
-  const errorMessage = lastError.formatted || lastError.message;
-  const error = new Error(`Deployment failed after ${maxRetries} attempts: ${errorMessage}`);
-  if (lastError.formatted) {
-    error.formatted = lastError.formatted;
-  }
-  if (lastError.status) {
-    error.status = lastError.status;
-  }
-  if (lastError.data) {
-    error.data = lastError.data;
-  }
-  throw error;
-}
+const { validatePipeline, deployPipeline, getPipelineDeployment } = require('./api/pipeline.api');
 
 /**
  * Validates deployment configuration via validate endpoint
@@ -103,8 +31,6 @@ async function handleDeploymentRetry(endpoint, manifest, requestConfig, maxRetri
  */
 async function validateDeployment(url, envKey, manifest, authConfig, options = {}) {
   const validatedEnvKey = validateEnvironmentKey(envKey);
-  const endpoint = `${url}/api/v1/pipeline/${validatedEnvKey}/validate`;
-  const timeout = options.timeout || 30000;
   const maxRetries = options.maxRetries || 3;
 
   // Extract clientId and clientSecret
@@ -118,58 +44,68 @@ async function validateDeployment(url, envKey, manifest, authConfig, options = {
 
   // Build validation request
   const repositoryUrl = options.repositoryUrl || `https://github.com/aifabrix/${manifest.key}`;
-  const validationRequest = {
+  const validationData = {
     clientId: clientId,
     clientSecret: clientSecret,
     repositoryUrl: repositoryUrl,
     applicationConfig: manifest
   };
 
-  // Create request config with client credentials headers
-  const requestConfig = {
-    headers: {
-      'Content-Type': 'application/json',
-      'User-Agent': 'aifabrix-builder/2.0.0',
-      'x-client-id': clientId,
-      'x-client-secret': clientSecret
-    },
-    timeout,
-    validateStatus: (status) => status < 600 // Don't throw on any status
+  // Use centralized API client with retry logic
+  const pipelineAuthConfig = {
+    type: 'client-credentials',
+    clientId: clientId,
+    clientSecret: clientSecret
   };
 
   let lastError;
   for (let attempt = 1; attempt <= maxRetries; attempt++) {
     try {
-      const response = await axios.post(endpoint, validationRequest, requestConfig);
+      const response = await validatePipeline(url, validatedEnvKey, pipelineAuthConfig, validationData);
 
       // Handle successful validation (200 OK with valid: true)
-      if (response.status === 200 && response.data.valid === true) {
-        return {
-          success: true,
-          validateToken: response.data.validateToken,
-          draftDeploymentId: response.data.draftDeploymentId,
-          imageServer: response.data.imageServer,
-          imageUsername: response.data.imageUsername,
-          imagePassword: response.data.imagePassword,
-          expiresAt: response.data.expiresAt
-        };
+      if (response.success && response.data) {
+        const responseData = response.data.data || response.data;
+        if (responseData.valid === true) {
+          return {
+            success: true,
+            validateToken: responseData.validateToken,
+            draftDeploymentId: responseData.draftDeploymentId,
+            imageServer: responseData.imageServer,
+            imageUsername: responseData.imageUsername,
+            imagePassword: responseData.imagePassword,
+            expiresAt: responseData.expiresAt
+          };
+        }
+        // Handle validation failure (valid: false)
+        if (responseData.valid === false) {
+          const errorMessage = responseData.errors && responseData.errors.length > 0
+            ? `Validation failed: ${responseData.errors.join(', ')}`
+            : 'Validation failed: Invalid configuration';
+          const error = new Error(errorMessage);
+          error.status = 400;
+          error.data = responseData;
+          throw error;
+        }
       }
 
-      // Handle validation errors
-      if (response.status >= 400) {
-        const error = new Error(`Validation request failed: ${response.status} ${response.statusText}`);
-        error.status = response.status;
-        error.response = {
-          status: response.status,
-          statusText: response.statusText,
-          data: response.data
-        };
+      // Handle validation errors (non-success responses)
+      if (!response.success) {
+        const error = new Error(`Validation request failed: ${response.formattedError || response.error || 'Unknown error'}`);
+        error.status = response.status || 400;
         error.data = response.data;
         throw error;
       }
+
+      // If we get here, response.success is true but valid is not true and not false
+      // This is an unexpected state, throw an error
+      const error = new Error('Validation response is in an unexpected state');
+      error.status = 400;
+      error.data = response.data;
+      throw error;
     } catch (error) {
       lastError = error;
-      const shouldRetry = attempt < maxRetries && error.response && error.response.status >= 500;
+      const shouldRetry = attempt < maxRetries && error.status && error.status >= 500;
       if (shouldRetry) {
         const delay = Math.min(1000 * Math.pow(2, attempt - 1), 5000);
         logger.log(chalk.yellow(`⚠️  Validation attempt ${attempt} failed, retrying in ${delay}ms...`));
@@ -198,8 +134,6 @@ async function validateDeployment(url, envKey, manifest, authConfig, options = {
  */
 async function sendDeploymentRequest(url, envKey, validateToken, authConfig, options = {}) {
   const validatedEnvKey = validateEnvironmentKey(envKey);
-  const endpoint = `${url}/api/v1/pipeline/${validatedEnvKey}/deploy`;
-  const timeout = options.timeout || 30000;
   const maxRetries = options.maxRetries || 3;
 
   // Extract clientId and clientSecret for deploy endpoint
@@ -212,24 +146,58 @@ async function sendDeploymentRequest(url, envKey, validateToken, authConfig, opt
 
   // Build deployment request
   const imageTag = options.imageTag || 'latest';
-  const deployRequest = {
+  const deployData = {
     validateToken: validateToken,
     imageTag: imageTag
   };
 
-  // Create request config with client credentials headers
-  const requestConfig = {
-    headers: {
-      'Content-Type': 'application/json',
-      'User-Agent': 'aifabrix-builder/2.0.0',
-      'x-client-id': clientId,
-      'x-client-secret': clientSecret
-    },
-    timeout,
-    validateStatus: (status) => status < 500
+  // Use centralized API client with retry logic
+  const pipelineAuthConfig = {
+    type: 'client-credentials',
+    clientId: clientId,
+    clientSecret: clientSecret
   };
 
-  return handleDeploymentRetry(endpoint, deployRequest, requestConfig, maxRetries);
+  // Wrap API call with retry logic
+  let lastError;
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    try {
+      const response = await deployPipeline(url, validatedEnvKey, pipelineAuthConfig, deployData);
+
+      if (response.success) {
+        return response.data.data || response.data;
+      }
+
+      // Handle deployment errors
+      if (response.status >= 400) {
+        const error = new Error(`Deployment request failed: ${response.formattedError || response.error || 'Unknown error'}`);
+        error.status = response.status;
+        error.data = response.data;
+        throw error;
+      }
+    } catch (error) {
+      lastError = error;
+      if (attempt < maxRetries) {
+        const delay = Math.min(1000 * Math.pow(2, attempt - 1), 5000);
+        logger.log(chalk.yellow(`⚠️  Deployment attempt ${attempt} failed, retrying in ${delay}ms...`));
+        await new Promise(resolve => setTimeout(resolve, delay));
+      }
+    }
+  }
+
+  // Preserve formatted error if available
+  const errorMessage = lastError.formatted || lastError.message;
+  const error = new Error(`Deployment failed after ${maxRetries} attempts: ${errorMessage}`);
+  if (lastError.formatted) {
+    error.formatted = lastError.formatted;
+  }
+  if (lastError.status) {
+    error.status = lastError.status;
+  }
+  if (lastError.data) {
+    error.data = lastError.data;
+  }
+  throw error;
 }
 
 /**
@@ -259,20 +227,17 @@ async function pollDeploymentStatus(deploymentId, controllerUrl, envKey, authCon
   const maxAttempts = options.maxAttempts || 60;
 
   const validatedEnvKey = validateEnvironmentKey(envKey);
-  const statusEndpoint = `${controllerUrl}/api/v1/pipeline/${validatedEnvKey}/deployments/${deploymentId}`;
+
+  // Convert authConfig to format expected by API client
+  const pipelineAuthConfig = authConfig.type === 'bearer'
+    ? { type: 'bearer', token: authConfig.token }
+    : { type: 'client-credentials', clientId: authConfig.clientId, clientSecret: authConfig.clientSecret };
 
   for (let attempt = 0; attempt < maxAttempts; attempt++) {
     try {
-      const response = await axios.get(statusEndpoint, {
-        headers: {
-          'Content-Type': 'application/json',
-          ...createAuthHeaders(authConfig)
-        },
-        timeout: 10000,
-        validateStatus: (status) => status < 500
-      });
-
-      if (response.status === 200) {
+      const response = await getPipelineDeployment(controllerUrl, validatedEnvKey, deploymentId, pipelineAuthConfig);
+
+      if (response.success && response.data) {
         // OpenAPI spec: Response structure { success: boolean, data: { status, progress, ... }, timestamp: string }
         const responseData = response.data;
         const deploymentData = responseData.data || responseData;
@@ -289,11 +254,14 @@ async function pollDeploymentStatus(deploymentId, controllerUrl, envKey, authCon
           await new Promise(resolve => setTimeout(resolve, interval));
         }
       } else {
-        throw new Error(`Status check failed: ${response.status}`);
+        if (response.status === 404) {
+          throw new Error(`Deployment ${deploymentId} not found`);
+        }
+        throw new Error(`Status check failed: ${response.formattedError || response.error || 'Unknown error'}`);
       }
     } catch (error) {
-      if (error.response && error.response.status === 404) {
-        throw new Error(`Deployment ${deploymentId} not found`);
+      if (error.message && error.message.includes('not found')) {
+        throw error;
       }
       throw error;
     }

package/lib/environment-deploy.js

@@ -14,7 +14,8 @@ const logger = require('./utils/logger');
 const config = require('./config');
 const { validateControllerUrl, validateEnvironmentKey } = require('./utils/deployment-validation');
 const { getOrRefreshDeviceToken } = require('./utils/token-manager');
-const { authenticatedApiCall } = require('./utils/api');
+const { getEnvironmentStatus } = require('./api/environments.api');
+const { deployEnvironment: deployEnvironmentInfra } = require('./api/deployments.api');
 const { handleDeploymentErrors } = require('./utils/deployment-errors');
 const auditLogger = require('./audit-logger');
 
@@ -93,32 +94,23 @@ async function sendEnvironmentDeployment(controllerUrl, envKey, authConfig, opti
     deploymentRequest.description += ` (config: ${options.config})`;
   }
 
-  // API endpoint: POST /api/v1/environments/{env}/deploy
-  // Alternative: POST /api/v1/environments/deploy with environment in body
-  const endpoint = `${validatedUrl}/api/v1/environments/${validatedEnvKey}/deploy`;
-
   // Log deployment attempt for audit
   await auditLogger.logDeploymentAttempt(validatedEnvKey, validatedUrl, options);
 
   try {
-    const response = await authenticatedApiCall(
-      endpoint,
-      {
-        method: 'POST',
-        body: JSON.stringify(deploymentRequest)
-      },
-      authConfig.token
-    );
+    // Use centralized API client
+    const apiAuthConfig = { type: 'bearer', token: authConfig.token };
+    const response = await deployEnvironmentInfra(validatedUrl, validatedEnvKey, apiAuthConfig, deploymentRequest);
 
     if (!response.success) {
       const error = new Error(response.formattedError || response.error || 'Environment deployment failed');
       error.status = response.status;
-      error.data = response.errorData;
+      error.data = response.errorData || response.data;
       throw error;
     }
 
     // Handle response structure
-    const responseData = response.data || {};
+    const responseData = response.data.data || response.data || {};
     return {
       success: true,
       environment: validatedEnvKey,
@@ -150,25 +142,22 @@ async function pollEnvironmentStatus(deploymentId, controllerUrl, envKey, authCo
 
   const pollInterval = options.pollInterval || 5000;
   const maxAttempts = options.maxAttempts || 60;
-  const statusEndpoint = `${validatedUrl}/api/v1/environments/${validatedEnvKey}/status`;
 
   logger.log(chalk.blue(`⏳ Polling environment status (${pollInterval}ms intervals)...`));
 
+  // Use centralized API client
+  const apiAuthConfig = { type: 'bearer', token: authConfig.token };
+
   for (let attempt = 1; attempt <= maxAttempts; attempt++) {
     try {
       await new Promise(resolve => setTimeout(resolve, pollInterval));
 
-      const response = await authenticatedApiCall(
-        statusEndpoint,
-        {
-          method: 'GET'
-        },
-        authConfig.token
-      );
+      const response = await getEnvironmentStatus(validatedUrl, validatedEnvKey, apiAuthConfig);
 
       if (response.success && response.data) {
-        const status = response.data.status || response.data.ready;
-        const isReady = status === 'ready' || status === 'completed' || response.data.ready === true;
+        const responseData = response.data.data || response.data;
+        const status = responseData.status || responseData.ready;
+        const isReady = status === 'ready' || status === 'completed' || responseData.ready === true;
 
         if (isReady) {
           return {
@@ -181,7 +170,7 @@ async function pollEnvironmentStatus(deploymentId, controllerUrl, envKey, authCo
 
         // Check for terminal failure states
         if (status === 'failed' || status === 'error') {
-          throw new Error(`Environment deployment failed: ${response.data.message || 'Unknown error'}`);
+          throw new Error(`Environment deployment failed: ${responseData.message || 'Unknown error'}`);
         }
       }
     } catch (error) {

package/lib/external-system-deploy.js

@@ -14,7 +14,13 @@ const fsSync = require('fs');
 const path = require('path');
 const yaml = require('js-yaml');
 const chalk = require('chalk');
-const { authenticatedApiCall } = require('./utils/api');
+const {
+  deployExternalSystemViaPipeline,
+  deployDatasourceViaPipeline,
+  uploadApplicationViaPipeline,
+  validateUploadViaPipeline,
+  publishUploadViaPipeline
+} = require('./api/pipeline.api');
 const { getDeploymentAuth } = require('./utils/token-manager');
 const { getConfig } = require('./config');
 const logger = require('./utils/logger');
@@ -155,14 +161,7 @@ async function buildExternalSystem(appName, options = {}) {
     const systemContent = await fs.readFile(systemFiles[0], 'utf8');
     const systemJson = JSON.parse(systemContent);
 
-    const systemResponse = await authenticatedApiCall(
-      `${dataplaneUrl}/api/v1/pipeline/deploy`,
-      {
-        method: 'POST',
-        body: JSON.stringify(systemJson)
-      },
-      authConfig.token
-    );
+    const systemResponse = await deployExternalSystemViaPipeline(dataplaneUrl, authConfig, systemJson);
 
     if (!systemResponse.success) {
       throw new Error(`Failed to deploy external system: ${systemResponse.error || systemResponse.formattedError}`);
@@ -178,14 +177,7 @@ async function buildExternalSystem(appName, options = {}) {
       const datasourceContent = await fs.readFile(datasourceFile, 'utf8');
       const datasourceJson = JSON.parse(datasourceContent);
 
-      const datasourceResponse = await authenticatedApiCall(
-        `${dataplaneUrl}/api/v1/pipeline/${systemKey}/deploy`,
-        {
-          method: 'POST',
-          body: JSON.stringify(datasourceJson)
-        },
-        authConfig.token
-      );
+      const datasourceResponse = await deployDatasourceViaPipeline(dataplaneUrl, systemKey, authConfig, datasourceJson);
 
       if (!datasourceResponse.success) {
         throw new Error(`Failed to deploy datasource ${datasourceName}: ${datasourceResponse.error || datasourceResponse.formattedError}`);
@@ -245,14 +237,7 @@ async function deployExternalSystem(appName, options = {}) {
 
     // Step 1: Upload application
     logger.log(chalk.blue('📤 Uploading application configuration...'));
-    const uploadResponse = await authenticatedApiCall(
-      `${dataplaneUrl}/api/v1/pipeline/upload`,
-      {
-        method: 'POST',
-        body: JSON.stringify(applicationSchema)
-      },
-      authConfig.token
-    );
+    const uploadResponse = await uploadApplicationViaPipeline(dataplaneUrl, authConfig, applicationSchema);
 
     if (!uploadResponse.success || !uploadResponse.data) {
       throw new Error(`Failed to upload application: ${uploadResponse.error || uploadResponse.formattedError || 'Unknown error'}`);
@@ -270,13 +255,7 @@ async function deployExternalSystem(appName, options = {}) {
     // Step 2: Validate upload (optional, can be skipped)
     if (!options.skipValidation) {
       logger.log(chalk.blue('🔍 Validating upload...'));
-      const validateResponse = await authenticatedApiCall(
-        `${dataplaneUrl}/api/v1/pipeline/upload/${uploadId}/validate`,
-        {
-          method: 'POST'
-        },
-        authConfig.token
-      );
+      const validateResponse = await validateUploadViaPipeline(dataplaneUrl, uploadId, authConfig);
 
       if (!validateResponse.success || !validateResponse.data) {
         throw new Error(`Validation failed: ${validateResponse.error || validateResponse.formattedError || 'Unknown error'}`);
@@ -308,13 +287,7 @@ async function deployExternalSystem(appName, options = {}) {
     const generateMcpContract = options.generateMcpContract !== false; // Default to true
     logger.log(chalk.blue(`📢 Publishing application (MCP contract: ${generateMcpContract ? 'enabled' : 'disabled'})...`));
 
-    const publishResponse = await authenticatedApiCall(
-      `${dataplaneUrl}/api/v1/pipeline/upload/${uploadId}/publish?generateMcpContract=${generateMcpContract}`,
-      {
-        method: 'POST'
-      },
-      authConfig.token
-    );
+    const publishResponse = await publishUploadViaPipeline(dataplaneUrl, uploadId, authConfig, { generateMcpContract });
 
     if (!publishResponse.success || !publishResponse.data) {
       throw new Error(`Failed to publish application: ${publishResponse.error || publishResponse.formattedError || 'Unknown error'}`);

package/lib/external-system-download.js

@@ -14,7 +14,7 @@ const path = require('path');
 const os = require('os');
 const yaml = require('js-yaml');
 const chalk = require('chalk');
-const { authenticatedApiCall } = require('./utils/api');
+const { getExternalSystemConfig } = require('./api/external-systems.api');
 const { getDeploymentAuth } = require('./utils/token-manager');
 const { getDataplaneUrl } = require('./datasource-deploy');
 const { getConfig } = require('./config');
@@ -284,14 +284,12 @@ async function downloadExternalSystem(systemKey, options = {}) {
     const dataplaneUrl = await getDataplaneUrl(controllerUrl, systemKey, environment, authConfig);
     logger.log(chalk.green(`✓ Dataplane URL: ${dataplaneUrl}`));
 
-    // Download system configuration
-    // Note: Verify this endpoint exists. Alternative: GET /api/v1/pipeline/{systemIdOrKey}
-    const downloadEndpoint = `${dataplaneUrl}/api/v1/external/systems/${systemKey}/config`;
-    logger.log(chalk.blue(`📡 Downloading from: ${downloadEndpoint}`));
+    // Download system configuration using centralized API client
+    logger.log(chalk.blue(`📡 Downloading system configuration: ${systemKey}`));
 
     if (options.dryRun) {
       logger.log(chalk.yellow('🔍 Dry run mode - would download from:'));
-      logger.log(chalk.gray(`  ${downloadEndpoint}`));
+      logger.log(chalk.gray(`  ${dataplaneUrl}/api/v1/external/systems/${systemKey}/config`));
       logger.log(chalk.yellow('\nWould create:'));
       logger.log(chalk.gray(`  integration/${systemKey}/`));
       logger.log(chalk.gray(`  integration/${systemKey}/variables.yaml`));
@@ -301,13 +299,7 @@ async function downloadExternalSystem(systemKey, options = {}) {
       return;
     }
 
-    const response = await authenticatedApiCall(
-      downloadEndpoint,
-      {
-        method: 'GET'
-      },
-      authConfig.token
-    );
+    const response = await getExternalSystemConfig(dataplaneUrl, systemKey, authConfig);
 
     if (!response.success || !response.data) {
       throw new Error(`Failed to download system configuration: ${response.error || response.formattedError || 'Unknown error'}`);