@aifabrix/builder 2.36.1 → 2.36.2

package/integration/hubspot/test.js

@@ -728,7 +728,7 @@ async function runCommandWithErrorHandling(command, args, options, appName) {
     const errorOutput = `${result.stdout}\n${result.stderr}`;
     if (appName && (errorOutput.includes('not found') ||
         (errorOutput.includes('External system') && errorOutput.includes('not found')))) {
-      logWarn(`System ${appName} not deployed, skipping download test`);
+      logInfo(`System ${appName} not deployed on dataplane; download step omitted (optional).`);
       return { skipped: true };
     }
     throw new Error(`${command} failed: ${result.stderr || result.stdout}`);

package/lib/api/pipeline.api.js

@@ -81,9 +81,33 @@ async function getPipelineHealth(controllerUrl, envKey) {
   return await client.get(`/api/v1/pipeline/${envKey}/health`);
 }
 
+/**
+ * Publish one external system via dataplane pipeline endpoint
+ * POST /api/v1/pipeline/publish
+ * Request body: external system JSON (external-system.schema.json). Optional field in body:
+ * generateMcpContract (boolean, default true). Optional: generateOpenApiContract (boolean).
+ * Do not use query parameters for MCP; use the field in the body only.
+ *
+ * @async
+ * @function publishSystemViaPipeline
+ * @param {string} dataplaneUrl - Dataplane base URL
+ * @param {Object} authConfig - Authentication configuration
+ * @param {Object} systemConfig - External system configuration (conforms to external-system.schema.json)
+ * @returns {Promise<Object>} Published external system response
+ * @throws {Error} If publish fails
+ */
+async function publishSystemViaPipeline(dataplaneUrl, authConfig, systemConfig) {
+  const client = new ApiClient(dataplaneUrl, authConfig);
+  return await client.post('/api/v1/pipeline/publish', {
+    body: systemConfig
+  });
+}
+
 /**
  * Publish datasource via dataplane pipeline endpoint
  * POST /api/v1/pipeline/{systemKey}/publish
+ * No generateMcpContract for this endpoint; dataplane always uses default (MCP generated).
+ *
  * @async
  * @function publishDatasourceViaPipeline
  * @param {string} dataplaneUrl - Dataplane base URL
@@ -169,11 +193,15 @@ async function deployDatasourceViaPipeline(dataplaneUrl, systemKey, authConfig,
 /**
  * Upload application configuration via dataplane pipeline endpoint
  * POST /api/v1/pipeline/upload
+ * Body: { version, application, dataSources }. Include application.generateMcpContract
+ * and/or application.generateOpenApiContract to control contract generation when
+ * publishing this upload (publish reads from stored config; no query param on publish).
+ *
  * @async
  * @function uploadApplicationViaPipeline
  * @param {string} dataplaneUrl - Dataplane base URL
  * @param {Object} authConfig - Authentication configuration
- * @param {Object} applicationSchema - Application schema configuration
+ * @param {Object} applicationSchema - { version, application, dataSources }; application may include generateMcpContract, generateOpenApiContract
  * @returns {Promise<Object>} Upload response with uploadId
  * @throws {Error} If upload fails
  */
@@ -203,20 +231,22 @@ async function validateUploadViaPipeline(dataplaneUrl, uploadId, authConfig) {
 /**
  * Publish upload via dataplane pipeline endpoint
  * POST /api/v1/pipeline/upload/{uploadId}/publish
+ * No body or query parameters. MCP/OpenAPI generation is taken from the application config
+ * that was uploaded (application.generateMcpContract, application.generateOpenApiContract).
+ * To control MCP/OpenAPI, include those fields in the application object when calling
+ * uploadApplicationViaPipeline.
+ *
  * @async
  * @function publishUploadViaPipeline
  * @param {string} dataplaneUrl - Dataplane base URL
  * @param {string} uploadId - Upload ID
  * @param {Object} authConfig - Authentication configuration
- * @param {Object} [options] - Publish options
- * @param {boolean} [options.generateMcpContract] - Generate MCP contract (default: true)
  * @returns {Promise<Object>} Publish response
  * @throws {Error} If publish fails
  */
-async function publishUploadViaPipeline(dataplaneUrl, uploadId, authConfig, options = {}) {
+async function publishUploadViaPipeline(dataplaneUrl, uploadId, authConfig) {
   const client = new ApiClient(dataplaneUrl, authConfig);
-  const generateMcpContract = options.generateMcpContract !== false; // Default to true
-  return await client.post(`/api/v1/pipeline/upload/${uploadId}/publish?generateMcpContract=${generateMcpContract}`);
+  return await client.post(`/api/v1/pipeline/upload/${uploadId}/publish`);
 }
 
 module.exports = {
@@ -224,6 +254,7 @@ module.exports = {
   deployPipeline,
   getPipelineDeployment,
   getPipelineHealth,
+  publishSystemViaPipeline,
   publishDatasourceViaPipeline,
   testDatasourceViaPipeline,
   deployExternalSystemViaPipeline,

package/lib/app/list.js

@@ -168,7 +168,7 @@ function displayApplications(applications, environment, controllerUrl) {
     const urlAndPort = formatUrlAndPort(app);
     logger.log(`${hasPipeline} ${chalk.cyan(app.key)} - ${app.displayName} (${app.status || 'unknown'})${urlAndPort}`);
   });
-  logger.log('');
+  logger.log(chalk.gray('  To show details for an app: aifabrix app show <appKey>\n'));
 }
 
 /**

package/lib/commands/auth-status.js

@@ -197,15 +197,15 @@ function displayTokenInfo(tokenInfo) {
   const statusIcon = tokenInfo.authenticated ? chalk.green('✓') : chalk.red('✗');
   const statusText = tokenInfo.authenticated ? 'Authenticated' : 'Not authenticated';
 
-  logger.log(`Status: ${statusIcon} ${statusText}`);
-  logger.log(`Token Type: ${chalk.cyan(tokenInfo.type)}`);
+  logger.log(`  Status: ${statusIcon} ${statusText}`);
+  logger.log(`  Token Type: ${chalk.cyan(tokenInfo.type)}`);
 
   if (tokenInfo.appName) {
-    logger.log(`Application: ${chalk.cyan(tokenInfo.appName)}`);
+    logger.log(`  Application: ${chalk.cyan(tokenInfo.appName)}`);
   }
 
   if (tokenInfo.expiresAt) {
-    logger.log(`Expires: ${chalk.gray(formatExpiration(tokenInfo.expiresAt))}`);
+    logger.log(`  Expires: ${chalk.gray(formatExpiration(tokenInfo.expiresAt))}`);
   }
 
   if (tokenInfo.error) {
@@ -241,14 +241,43 @@ async function resolveDataplaneUrlSilent(controllerUrl, environment, authConfig)
  * @param {boolean} dataplaneConnected - Whether dataplane health check passed
  */
 function displayDataplaneSection(dataplaneUrl, dataplaneConnected) {
+  logger.log('');
   if (dataplaneUrl) {
     logger.log(`Dataplane: ${chalk.cyan(dataplaneUrl)}`);
     const statusIcon = dataplaneConnected ? chalk.green('✓') : chalk.red('✗');
     const statusText = dataplaneConnected ? 'Connected' : 'Not reachable';
-    logger.log(`Status: ${statusIcon} ${statusText}`);
+    displayOpenApiDocs(null, dataplaneUrl);
+    logger.log('');
+    logger.log(`  Status: ${statusIcon} ${statusText}`);
   } else {
     logger.log(`Dataplane: ${chalk.gray('—')}`);
-    logger.log(`Status: ${chalk.gray('Not discovered')}`);
+    logger.log('');
+    logger.log(`  Status: ${chalk.gray('Not discovered')}`);
+  }
+}
+
+/**
+ * Normalize base URL (no trailing slash) for docs path
+ * @param {string} url - Base URL
+ * @returns {string} URL without trailing slash
+ */
+function normalizeBaseUrl(url) {
+  return (url || '').replace(/\/$/, '');
+}
+
+/**
+ * Display Open API documentation links (Controller and Dataplane)
+ * @param {string} controllerUrl - Controller URL
+ * @param {string|null} dataplaneUrl - Dataplane URL or null
+ */
+function displayOpenApiDocs(controllerUrl, dataplaneUrl) {
+  const controllerBase = normalizeBaseUrl(controllerUrl);
+  if (controllerBase) {
+    logger.log(`  Open API docs: ${chalk.cyan(controllerBase + '/api/docs')}`);
+  }
+  if (dataplaneUrl) {
+    const dataplaneBase = normalizeBaseUrl(dataplaneUrl);
+    logger.log(`  Open API docs: ${chalk.cyan(dataplaneBase + '/api/docs')}`);
   }
 }
 
@@ -264,11 +293,12 @@ function displayDataplaneSection(dataplaneUrl, dataplaneConnected) {
 function displayStatus(controllerUrl, environment, tokenInfo, dataplaneInfo) {
   logger.log(chalk.bold('\n🔐 Authentication Status\n'));
   logger.log(`Controller: ${chalk.cyan(controllerUrl)}`);
-  logger.log(`Environment: ${chalk.cyan(environment || 'Not specified')}\n`);
+  displayOpenApiDocs(controllerUrl, null);
+  logger.log(`  Environment: ${chalk.cyan(environment || 'Not specified')}\n`);
 
   if (!tokenInfo) {
-    logger.log(`Status: ${chalk.red('✗ Not authenticated')}`);
-    logger.log(`Token Type: ${chalk.gray('None')}\n`);
+    logger.log(`  Status: ${chalk.red('✗ Not authenticated')}`);
+    logger.log(`  Token Type: ${chalk.gray('None')}\n`);
     logger.log(chalk.yellow('💡 Run "aifabrix login" to authenticate\n'));
     return;
   }

package/lib/schema/external-system.schema.json

@@ -7,7 +7,7 @@
     "key": "external-system-schema",
     "name": "External System Configuration Schema",
     "description": "JSON schema for validating ExternalSystem configuration files",
-    "version": "1.1.0",
+    "version": "1.2.0",
     "type": "schema",
     "category": "integration",
     "author": "AI Fabrix Team",
@@ -27,6 +27,15 @@
     ],
     "dependencies": [],
     "changelog": [
+      {
+        "version": "1.2.0",
+        "date": "2025-02-01T00:00:00Z",
+        "changes": [
+          "Added generateMcpContract (boolean, default true): config-only control for MCP contract generation on publish",
+          "Added generateOpenApiContract (boolean, default true): reserved for future use"
+        ],
+        "breaking": false
+      },
       {
         "version": "1.1.0",
         "date": "2025-12-01T00:00:00Z",
@@ -407,6 +416,20 @@
       "type": "boolean",
       "description": "Master switch for all endpoints in this system. If false, no endpoints are registered regardless of individual endpoint active flags.",
       "default": true
+    },
+    "credentialIdOrKey": {
+      "type": "string",
+      "description": "Credential identifier (ID or key) to use for authenticating with this external system."
+    },
+    "generateMcpContract": {
+      "type": "boolean",
+      "description": "Whether to generate MCP contract on publish. Config only (no query parameter); default true when absent.",
+      "default": true
+    },
+    "generateOpenApiContract": {
+      "type": "boolean",
+      "description": "Reserved: whether to generate or expose OpenAPI contract on publish. Not yet implemented.",
+      "default": true
     }
   },
   "additionalProperties": false

package/lib/utils/token-manager.js

@@ -251,9 +251,8 @@ async function tryClientTokenAuth(environment, appName, controllerUrl) {
         controller: clientToken.controller
       };
     }
-  } catch (error) {
-    // Client token unavailable, continue to credentials
-    logger.warn(`Client token unavailable: ${error.message}`);
+  } catch {
+    // Client token unavailable; getDeploymentAuth will try client credentials next (no warning here to avoid misleading output when env credentials succeed)
   }
   return null;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aifabrix/builder",
-  "version": "2.36.1",
+  "version": "2.36.2",
   "description": "AI Fabrix Local Fabric & Deployment SDK",
   "main": "lib/index.js",
   "bin": {