@aifabrix/builder 2.39.3 → 2.40.0

package/lib/app/show.js

@@ -13,10 +13,9 @@
 'use strict';
 
 const path = require('path');
-const fs = require('fs');
-const yaml = require('js-yaml');
 const logger = require('../utils/logger');
-const { detectAppType } = require('../utils/paths');
+const { detectAppType, resolveApplicationConfigPath } = require('../utils/paths');
+const { loadConfigFile } = require('../utils/config-format');
 const generator = require('../generator');
 const { getConfig, normalizeControllerUrl } = require('../core/config');
 const { getOrRefreshDeviceToken } = require('../utils/token-manager');
@@ -24,6 +23,7 @@ const { resolveControllerUrl } = require('../utils/controller-url');
 const { resolveEnvironment } = require('../core/config');
 const { getApplication } = require('../api/applications.api');
 const {
+  getExternalSystem,
   getExternalSystemConfig,
   listOpenAPIFiles,
   listOpenAPIEndpoints
@@ -37,26 +37,23 @@ const { display: displayShow } = require('./show-display');
 const DEPLOYMENT_KEY_TRUNCATE_LEN = 12;
 
 /**
- * Load and parse variables.yaml from app path (no validation).
+ * Load application config from app path (no validation).
+ * Uses resolver + converter; supports application.yaml, application.json, or legacy variables.yaml.
  * @param {string} appPath - Application directory path
- * @returns {Object} Parsed variables
- * @throws {Error} If file not found or invalid YAML
+ * @returns {Object} Parsed config object
+ * @throws {Error} If config not found or invalid
  */
 function loadVariablesFromPath(appPath) {
-  const variablesPath = path.join(appPath, 'variables.yaml');
-  if (!fs.existsSync(variablesPath)) {
-    throw new Error(`variables.yaml not found for app (path: ${variablesPath}). Use aifabrix validate to check.`);
-  }
-  const content = fs.readFileSync(variablesPath, 'utf8');
+  const configPath = resolveApplicationConfigPath(appPath);
   try {
-    const parsed = yaml.load(content);
+    const parsed = loadConfigFile(configPath);
     if (!parsed || typeof parsed !== 'object') {
-      throw new Error('variables.yaml is empty or invalid');
+      throw new Error('Application config is empty or invalid');
     }
     return parsed;
   } catch (error) {
-    if (error.message.includes('variables.yaml')) throw error;
-    throw new Error(`Invalid YAML syntax in variables.yaml: ${error.message}`);
+    if (error.message.includes('Application config') || error.message.includes('not found')) throw error;
+    throw new Error(`Invalid application config: ${error.message}`);
   }
 }
 
@@ -207,9 +204,9 @@ function buildApplicationFromVariables(variables) {
 }
 
 /**
- * Build offline summary object from variables (for display and JSON).
- * @param {Object} variables - Parsed variables.yaml
- * @param {string} sourcePath - Path to variables.yaml for display
+ * Build offline summary object from application config (for display and JSON).
+ * @param {Object} variables - Parsed application config (application.yaml/application.json)
+ * @param {string} sourcePath - Path to application config for display
  * @returns {Object} Summary with application, roles, permissions, etc.
  */
 function buildOfflineSummary(variables, sourcePath) {
@@ -294,17 +291,57 @@ async function fetchOpenApiLists(dataplaneUrl, appKey, authConfig) {
   return { openapiFiles, openapiEndpoints };
 }
 
-function buildExternalSystemResult(configData, appKey, openapiFiles, openapiEndpoints) {
+/**
+ * Normalize GET /api/v1/external/systems/{id} response to the entity object.
+ * Handles: (1) our API client shape { success, data }; (2) body wrapped in .data by dataplane.
+ * @param {Object} systemResponse - Raw response from getExternalSystem
+ * @returns {Object|null} Entity object (id, key, displayName, status, config, ...) or null
+ */
+function normalizeExternalSystemResponse(systemResponse) {
+  if (!systemResponse) return null;
+  const body = systemResponse.data ?? systemResponse;
+  if (!body || typeof body !== 'object') return null;
+  return body.data ?? body;
+}
+
+function pickExternalDisplayName(res, system, application, appKey) {
+  return (res && res.displayName) || system.displayName || application.displayName || appKey;
+}
+
+function pickExternalType(res, config, system, application) {
+  return (res && res.type) || config.type || system.type || application.type || '—';
+}
+
+function pickExternalStatus(system, res) {
+  return system.status || (res && res.status) || '—';
+}
+
+function pickExternalVersion(res, config, system) {
+  return (res && res.version) ?? config.version ?? system.version ?? '—';
+}
+
+function resolveExternalSystemMeta(res, config, system, application, appKey) {
+  return {
+    displayName: pickExternalDisplayName(res, system, application, appKey),
+    type: pickExternalType(res, config, system, application),
+    status: pickExternalStatus(system, res),
+    version: pickExternalVersion(res, config, system)
+  };
+}
+
+function buildBaseExternalResult(configData, appKey, openapiFiles, openapiEndpoints, res) {
   const system = configData.system || configData;
   const dataSources = configData.dataSources || configData.dataSources || [];
   const application = configData.application || configData.app || {};
+  const config = res && res.config && typeof res.config === 'object' ? res.config : {};
+  const meta = resolveExternalSystemMeta(res, config, system, application, appKey);
   return {
     dataplaneUrl: null,
     systemKey: appKey,
-    displayName: system.displayName || application.displayName || appKey,
-    type: system.type || application.type || '—',
-    status: system.status || '—',
-    version: system.version || '—',
+    displayName: meta.displayName,
+    type: meta.type,
+    status: meta.status,
+    version: meta.version,
     dataSources: dataSources.map((ds) => ({
       key: ds.key,
       displayName: ds.displayName,
@@ -322,8 +359,37 @@ function buildExternalSystemResult(configData, appKey, openapiFiles, openapiEndp
   };
 }
 
+function applySystemResponseToResult(result, res) {
+  result.dataplaneStatus = res.status;
+  if (res.credentialId !== undefined && res.credentialId !== null) result.credentialId = res.credentialId;
+  if (res.showOpenApiDocs !== undefined) result.showOpenApiDocs = res.showOpenApiDocs;
+  if (res.mcpServerUrl !== undefined && res.mcpServerUrl !== null) result.mcpServerUrl = res.mcpServerUrl;
+  if (res.apiDocumentUrl !== undefined && res.apiDocumentUrl !== null) result.apiDocumentUrl = res.apiDocumentUrl;
+  if (res.openApiDocsPageUrl !== undefined && res.openApiDocsPageUrl !== null) result.openApiDocsPageUrl = res.openApiDocsPageUrl;
+}
+
+/**
+ * Build external system result from config and optional ExternalSystemResponse.
+ * Dataplane GET /api/v1/external/systems/{id} returns: id, key, displayName, description,
+ * credentialId, config (optional type, description, dataSources), status, version,
+ * showOpenApiDocs, mcpServerUrl, apiDocumentUrl, openApiDocsPageUrl.
+ * @param {Object} configData - Config response (system, dataSources, application)
+ * @param {string} appKey - Application/system key
+ * @param {Array} openapiFiles - OpenAPI files list
+ * @param {Array} openapiEndpoints - OpenAPI endpoints list
+ * @param {Object} [systemResponse] - Optional GET /api/v1/external/systems/{id} response
+ * @returns {Object} Result with dataplaneStatus, credentialId, showOpenApiDocs, URLs when systemResponse present
+ */
+function buildExternalSystemResult(configData, appKey, openapiFiles, openapiEndpoints, systemResponse) {
+  const res = normalizeExternalSystemResponse(systemResponse);
+  const result = buildBaseExternalResult(configData, appKey, openapiFiles, openapiEndpoints, res);
+  if (res) applySystemResponseToResult(result, res);
+  return result;
+}
+
 /**
  * Fetch external system section from dataplane (for --online and type external).
+ * Calls getExternalSystem (ExternalSystemResponse) and getExternalSystemConfig, then merges into one result.
  * @param {string} dataplaneUrl - Dataplane URL
  * @param {string} appKey - Application key (system key)
  * @param {Object} authConfig - Auth config
@@ -331,11 +397,19 @@ function buildExternalSystemResult(configData, appKey, openapiFiles, openapiEndp
  */
 async function fetchExternalSystemFromDataplane(dataplaneUrl, appKey, authConfig) {
   try {
+    let systemResponse = null;
+    try {
+      systemResponse = await getExternalSystem(dataplaneUrl, appKey, authConfig);
+    } catch {
+      // optional: continue with config only
+    }
     const configRes = await getExternalSystemConfig(dataplaneUrl, appKey, authConfig);
     const data = configRes.data || configRes;
     const configData = data.data || data;
     const { openapiFiles, openapiEndpoints } = await fetchOpenApiLists(dataplaneUrl, appKey, authConfig);
-    const result = buildExternalSystemResult(configData, appKey, openapiFiles, openapiEndpoints);
+    const result = buildExternalSystemResult(
+      configData, appKey, openapiFiles, openapiEndpoints, systemResponse
+    );
     result.dataplaneUrl = dataplaneUrl;
     return result;
   } catch (error) {
@@ -405,6 +479,7 @@ function pickAppCfg(key, app, cfg, fallback) {
 function buildApplicationFromAppCfg(app, cfg, portalInputConfigurations) {
   const deploymentKey = cfg.deploymentKey ?? app.deploymentKey;
   const truncatedDeploy = truncateDeploymentKey(deploymentKey) || (deploymentKey ?? '—');
+  const version = pickAppCfg('version', app, cfg, undefined);
   const application = {
     key: pickAppCfg('key', app, cfg, '—'),
     displayName: pickAppCfg('displayName', app, cfg, '—'),
@@ -425,6 +500,7 @@ function buildApplicationFromAppCfg(app, cfg, portalInputConfigurations) {
     portalInputConfigurations,
     databases: resolveDatabasesFromAppCfg(app, cfg)
   };
+  if (version !== undefined && version !== null) application.version = version;
   return application;
 }
 
@@ -483,11 +559,11 @@ function buildOnlineSummary(apiApp, controllerUrl, externalSystem) {
 }
 
 /**
- * Run show in offline mode: generate manifest (same as aifabrix json) and use it; else fall back to variables.yaml.
+ * Run show in offline mode: generate manifest (same as aifabrix json) and use it; else fall back to application config.
  * @param {string} appKey - Application key
  * @param {boolean} json - Output as JSON
  * @param {boolean} [permissionsOnly] - When true, output only permissions
- * @throws {Error} If variables.yaml not found or invalid YAML
+ * @throws {Error} If application config not found or invalid
  */
 async function runOffline(appKey, json, permissionsOnly) {
   let summary;
@@ -498,9 +574,9 @@ async function runOffline(appKey, json, permissionsOnly) {
     summary = buildOfflineSummaryFromDeployJson(deployment, sourcePath);
   } catch (_err) {
     const { appPath } = await detectAppType(appKey);
-    const variablesPath = path.join(appPath, 'variables.yaml');
+    const configPath = resolveApplicationConfigPath(appPath);
     const variables = loadVariablesFromPath(appPath);
-    const sourcePath = path.relative(process.cwd(), variablesPath) || variablesPath;
+    const sourcePath = path.relative(process.cwd(), configPath) || configPath;
     summary = buildOfflineSummary(variables, sourcePath);
   }
 
@@ -573,27 +649,29 @@ function outputOnlineJson(summary, permissionsOnly) {
     logger.log(JSON.stringify(out, null, 2));
     return;
   }
+  const app = summary.application;
   const out = {
     source: summary.source,
     controllerUrl: summary.controllerUrl,
     appKey: summary.appKey,
     application: {
-      key: summary.application.key,
-      displayName: summary.application.displayName,
-      description: summary.application.description,
-      type: summary.application.type,
-      status: summary.application.status,
-      url: summary.application.url,
-      internalUrl: summary.application.internalUrl,
-      port: summary.application.port,
-      configuration: summary.application.configuration,
-      roles: summary.application.roles,
-      permissions: summary.application.permissions,
-      authentication: summary.application.authentication,
-      portalInputConfigurations: summary.application.portalInputConfigurations,
-      databases: summary.application.databases
+      key: app.key,
+      displayName: app.displayName,
+      description: app.description,
+      type: app.type,
+      status: app.status,
+      url: app.url,
+      internalUrl: app.internalUrl,
+      port: app.port,
+      configuration: app.configuration,
+      roles: app.roles,
+      permissions: app.permissions,
+      authentication: app.authentication,
+      portalInputConfigurations: app.portalInputConfigurations,
+      databases: app.databases
     }
   };
+  if (app.version !== undefined && app.version !== null) out.application.version = app.version;
   if (summary.externalSystem !== undefined && summary.externalSystem !== null) {
     out.externalSystem = summary.externalSystem && summary.externalSystem.error
       ? { error: summary.externalSystem.error }
@@ -618,7 +696,9 @@ async function runOnline(appKey, json, permissionsOnly) {
   const response = await getApplication(controllerUrl, appKey, authConfig);
   const apiApp = ensureApplicationResponse(response, appKey, authResult);
   const appData = apiApp.data || apiApp;
-  const externalSystem = appData.type === 'external'
+  const cfg = appData.configuration && typeof appData.configuration === 'object' ? appData.configuration : {};
+  const isExternalApp = appData.type === 'external' || cfg.type === 'external';
+  const externalSystem = isExternalApp
     ? await fetchExternalSystemForOnline(controllerUrl, appKey, authConfig)
     : null;
   const summary = buildOnlineSummary(apiApp, authResult.actualControllerUrl, externalSystem);

package/lib/build/index.js

@@ -15,8 +15,9 @@ const fsSync = require('fs');
 const path = require('path');
 const paths = require('../utils/paths');
 const { detectAppType, getProjectRoot } = require('../utils/paths');
+const { resolveApplicationConfigPath } = require('../utils/app-config-resolver');
+const { loadConfigFile } = require('../utils/config-format');
 const chalk = require('chalk');
-const yaml = require('js-yaml');
 const secrets = require('../core/secrets');
 const config = require('../core/config');
 const logger = require('../utils/logger');
@@ -27,30 +28,22 @@ const { buildDevImageName } = require('../utils/image-name');
 const buildHelpers = require('../utils/build-helpers');
 
 /**
- * Loads variables.yaml configuration for an application
+ * Loads application config for an application
  * @param {string} appName - Application name
  * @returns {Promise<Object>} Configuration object
  * @throws {Error} If file cannot be loaded or parsed
  */
 async function loadVariablesYaml(appName) {
-  // Detect app type and get correct path (integration or builder)
   const { appPath } = await detectAppType(appName);
-  const variablesPath = path.join(appPath, 'variables.yaml');
-
-  if (!fsSync.existsSync(variablesPath)) {
-    throw new Error(`Configuration not found. Run 'aifabrix create ${appName}' first.`);
-  }
-
-  const content = fsSync.readFileSync(variablesPath, 'utf8');
-  let variables;
-
   try {
-    variables = yaml.load(content);
+    const configPath = resolveApplicationConfigPath(appPath);
+    return loadConfigFile(configPath);
   } catch (error) {
-    throw new Error(`Invalid YAML syntax in variables.yaml: ${error.message}`);
+    if (error.message && error.message.includes('not found')) {
+      throw new Error(`Configuration not found. Run 'aifabrix create ${appName}' first.`);
+    }
+    throw new Error(`Invalid application config: ${error.message}`);
   }
-
-  return variables;
 }
 
 /**
@@ -115,7 +108,7 @@ function detectLanguage(appPath) {
  * @function generateDockerfile
  * @param {string} appNameOrPath - Application name or path (backward compatibility)
  * @param {string} language - Target language ('typescript', 'python')
- * @param {Object} config - Application configuration from variables.yaml
+ * @param {Object} config - Application configuration from application.yaml
  * @returns {Promise<string>} Path to generated Dockerfile
  * @throws {Error} If template generation fails
  *
@@ -326,7 +319,7 @@ function prepareBuildContext(buildConfig, devDir) {
     throw new Error(
       `Build context path does not exist: ${contextPath}\n` +
       `Expected dev directory: ${devDir}\n` +
-      'Please ensure files were copied correctly or update the context in variables.yaml.'
+      'Please ensure files were copied correctly or update the context in application.yaml.'
     );
   }
 

package/lib/cli/setup-app.js

@@ -91,11 +91,7 @@ async function handleCreateCommand(appName, options) {
   }
 }
 
-/**
- * Sets up application lifecycle commands
- * @param {Command} program - Commander program instance
- */
-function setupAppCommands(program) {
+function setupCreateCommand(program) {
   program.command('create <app>')
     .description('Create new application with configuration files')
     .option('-p, --port <port>', 'Application port', '3000')
@@ -124,13 +120,10 @@ function setupAppCommands(program) {
         process.exit(1);
       }
     });
+}
 
-  program.command('wizard [appName]')
-    .description('Create or extend external systems (OpenAPI, MCP, or known platforms like HubSpot) via guided steps or a config file')
-    .option('-a, --app <app>', 'Application name (synonym for positional appName)')
-    .option('--config <file>', 'Run headless using a wizard.yaml file (appName, mode, source, credential, preferences)')
-    .option('--silent', 'Run with saved integration/<app>/wizard.yaml only; no prompts (requires app name and existing wizard.yaml)')
-    .addHelpText('after', `
+function setupWizardCommand(program) {
+  const wizardHelp = `
 Examples:
   $ aifabrix wizard                    Run interactively (mode first, then prompts)
   $ aifabrix wizard my-integration      Load wizard.yaml if present → show summary → "Run with saved config?" or start from step 1
@@ -141,7 +134,13 @@ Examples:
 Config path: When appName is provided, integration/<appName>/wizard.yaml is used for load/save and error.log.
 To change settings after a run, edit that file and run "aifabrix wizard <app>" again.
 Headless config must include: appName, mode (create-system|add-datasource), source (type + filePath/url/platform).
-See integration/hubspot/wizard-hubspot-e2e.yaml for an example.`)
+See integration/hubspot/wizard-hubspot-e2e.yaml for an example.`;
+  program.command('wizard [appName]')
+    .description('Create or extend external systems (OpenAPI, MCP, or known platforms like HubSpot) via guided steps or a config file')
+    .option('-a, --app <app>', 'Application name (synonym for positional appName)')
+    .option('--config <file>', 'Run headless using a wizard.yaml file (appName, mode, source, credential, preferences)')
+    .option('--silent', 'Run with saved integration/<app>/wizard.yaml only; no prompts (requires app name and existing wizard.yaml)')
+    .addHelpText('after', wizardHelp)
     .action(async(positionalAppName, options) => {
       try {
         const appName = positionalAppName || options.app;
@@ -153,12 +152,14 @@ See integration/hubspot/wizard-hubspot-e2e.yaml for an example.`)
         process.exit(1);
       }
     });
+}
 
+function setupBuildRunLogsDownCommands(program) {
   program.command('build <app>')
     .description('Build container image (auto-detects runtime)')
     .option('-l, --language <lang>', 'Override language detection')
     .option('-f, --force-template', 'Force rebuild from template')
-    .option('-t, --tag <tag>', 'Image tag (default: latest). Set image.tag in variables.yaml to match for deploy.')
+    .option('-t, --tag <tag>', 'Image tag (default: latest). Set image.tag in application.yaml to match for deploy.')
     .action(async(appName, options) => {
       try {
         const imageTag = await app.buildApp(appName, options);
@@ -173,7 +174,7 @@ See integration/hubspot/wizard-hubspot-e2e.yaml for an example.`)
     .description('Run application locally')
     .option('-p, --port <port>', 'Override local port')
     .option('-d, --debug', 'Enable debug output with detailed container information')
-    .option('-t, --tag <tag>', 'Image tag to run (e.g. v1.0.0); overrides variables.yaml image.tag')
+    .option('-t, --tag <tag>', 'Image tag to run (e.g. v1.0.0); overrides application.yaml image.tag')
     .action(async(appName, options) => {
       try {
         await app.runApp(appName, options);
@@ -193,11 +194,7 @@ See integration/hubspot/wizard-hubspot-e2e.yaml for an example.`)
         const { runAppLogs } = require('../commands/app-logs');
         const tailNum = parseInt(options.tail, 10);
         const level = options.level !== undefined && options.level !== null && options.level !== '' ? String(options.level).trim() : undefined;
-        await runAppLogs(appName, {
-          follow: options.f,
-          tail: Number.isNaN(tailNum) ? 100 : tailNum,
-          level
-        });
+        await runAppLogs(appName, { follow: options.f, tail: Number.isNaN(tailNum) ? 100 : tailNum, level });
       } catch (error) {
         handleCommandError(error, 'logs');
         process.exit(1);
@@ -216,10 +213,12 @@ See integration/hubspot/wizard-hubspot-e2e.yaml for an example.`)
         process.exit(1);
       }
     });
+}
 
+function setupPushDeployDockerfileCommands(program) {
   program.command('push <app>')
     .description('Push image to Azure Container Registry')
-    .option('-r, --registry <registry>', 'ACR registry URL (overrides variables.yaml)')
+    .option('-r, --registry <registry>', 'ACR registry URL (overrides application.yaml)')
     .option('-t, --tag <tag>', 'Image tag(s) - comma-separated for multiple (default: latest)')
     .action(async(appName, options) => {
       try {
@@ -232,21 +231,18 @@ See integration/hubspot/wizard-hubspot-e2e.yaml for an example.`)
 
   program.command('deploy <app>')
     .description('Deploy to Azure via Miso Controller')
-    .option('--deployment <target>', 'Deployment target: \'local\' (send manifest to controller, then run app locally) or \'cloud\' (deploy via Miso Controller only)', 'cloud')
-    .option('--type <type>', 'Application type: external to deploy from integration/<app> (no app register needed)')
+    .option('--local', 'Send manifest to controller then run app locally (app: same as aifabrix run <app>; external: restart dataplane)')
     .option('--client-id <id>', 'Client ID (overrides config)')
     .option('--client-secret <secret>', 'Client Secret (overrides config)')
     .option('--poll', 'Poll for deployment status', true)
     .option('--no-poll', 'Do not poll for status')
     .action(async(appName, options) => {
       try {
-        const target = (options.deployment || 'cloud').toLowerCase();
-        if (target !== 'local' && target !== 'cloud') {
-          throw new Error('Deployment target must be \'local\' or \'cloud\'');
-        }
-        await app.deployApp(appName, options);
-        if (target === 'local') {
-          await app.runApp(appName, options);
+        const opts = { ...options, local: !!options.local };
+        const outcome = await app.deployApp(appName, opts);
+        if (opts.local && outcome) {
+          if (outcome.usedExternalDeploy) await app.restartApp('dataplane');
+          else await app.runApp(appName, opts);
         }
       } catch (error) {
         handleCommandError(error, 'deploy');
@@ -270,4 +266,15 @@ See integration/hubspot/wizard-hubspot-e2e.yaml for an example.`)
     });
 }
 
+/**
+ * Sets up application lifecycle commands
+ * @param {Command} program - Commander program instance
+ */
+function setupAppCommands(program) {
+  setupCreateCommand(program);
+  setupWizardCommand(program);
+  setupBuildRunLogsDownCommands(program);
+  setupPushDeployDockerfileCommands(program);
+}
+
 module.exports = { setupAppCommands };

package/lib/cli/setup-auth.js

@@ -14,11 +14,7 @@ const { handleLogout } = require('../commands/logout');
 const { handleAuthStatus } = require('../commands/auth-status');
 const { handleAuthConfig } = require('../commands/auth-config');
 
-/**
- * Sets up authentication commands
- * @param {Command} program - Commander program instance
- */
-function setupAuthCommands(program) {
+function setupLoginCommand(program) {
   program.command('login')
     .description('Authenticate with Miso Controller')
     .option('-c, --controller <url>', 'Controller URL (default: from config or developer ID, e.g. http://localhost:3000)')
@@ -37,7 +33,9 @@ function setupAuthCommands(program) {
         process.exit(1);
       }
     });
+}
 
+function setupLogoutCommand(program) {
   program.command('logout')
     .description('Clear authentication tokens')
     .option('-c, --controller <url>', 'Clear device tokens for specific controller')
@@ -51,7 +49,9 @@ function setupAuthCommands(program) {
         process.exit(1);
       }
     });
+}
 
+function setupAuthSubcommands(program) {
   const authStatusHandler = async(options) => {
     try {
       await handleAuthStatus(options);
@@ -60,18 +60,11 @@ function setupAuthCommands(program) {
       process.exit(1);
     }
   };
-
-  const auth = program
-    .command('auth')
-    .description('Authentication commands');
-
-  auth
-    .command('status')
+  const auth = program.command('auth').description('Authentication commands');
+  auth.command('status')
     .description('Display authentication status for current controller and environment')
     .action(authStatusHandler);
-
-  auth
-    .command('config')
+  auth.command('config')
     .description('Configure authentication settings (controller, environment)')
     .option('--set-controller <url>', 'Set default controller URL')
     .option('--set-environment <env>', 'Set default environment')
@@ -85,4 +78,14 @@ function setupAuthCommands(program) {
     });
 }
 
+/**
+ * Sets up authentication commands
+ * @param {Command} program - Commander program instance
+ */
+function setupAuthCommands(program) {
+  setupLoginCommand(program);
+  setupLogoutCommand(program);
+  setupAuthSubcommands(program);
+}
+
 module.exports = { setupAuthCommands };

package/lib/cli/setup-credential-deployment.js

@@ -24,14 +24,16 @@ function setupCredentialDeploymentCommands(program) {
 
   credential
     .command('list')
-    .description('List credentials from controller/dataplane (GET /api/v1/credential)')
+    .description('List credentials from Dataplane (GET /api/v1/credential). Controller does not expose this endpoint.')
     .option('--controller <url>', 'Controller URL (default: from config)')
+    .option('--dataplane <url>', 'Dataplane URL (default: resolved from controller + environment)')
     .option('--active-only', 'List only active credentials')
     .option('--page-size <n>', 'Items per page', '50')
     .action(async(options) => {
       try {
         const opts = {
           controller: options.controller,
+          dataplane: options.dataplane,
           activeOnly: options.activeOnly,
           pageSize: parseInt(options.pageSize, 10) || 50
         };