@aifabrix/builder 2.36.2 → 2.37.5

package/lib/cli/setup-app.js

@@ -0,0 +1,230 @@
+/**
+ * CLI application lifecycle command setup (create, wizard, build, run, push, deploy, dockerfile).
+ *
+ * @fileoverview Application command definitions for AI Fabrix Builder CLI
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const chalk = require('chalk');
+const path = require('path');
+const app = require('../app');
+const logger = require('../utils/logger');
+const { handleCommandError } = require('../utils/cli-utils');
+
+/**
+ * Normalize options for external system creation
+ * @param {Object} options - Raw CLI options
+ * @returns {Object} Normalized options
+ */
+function normalizeExternalOptions(options) {
+  const normalized = { ...options };
+  if (options.displayName) normalized.systemDisplayName = options.displayName;
+  if (options.description) normalized.systemDescription = options.description;
+  if (options.systemType) normalized.systemType = options.systemType;
+  if (options.authType) normalized.authType = options.authType;
+  if (options.datasources !== undefined) {
+    const parsedCount = parseInt(options.datasources, 10);
+    if (Number.isNaN(parsedCount) || parsedCount < 1 || parsedCount > 10) {
+      throw new Error('Datasources count must be a number between 1 and 10');
+    }
+    normalized.datasourceCount = parsedCount;
+  }
+  if (options.controller) {
+    normalized.controller = true;
+    normalized.controllerUrl = options.controller;
+  }
+  return normalized;
+}
+
+/**
+ * Validate required options for non-interactive external creation
+ * @param {Object} normalizedOptions - Normalized options
+ * @throws {Error} If required options are missing
+ */
+function validateNonInteractiveExternalOptions(normalizedOptions) {
+  const missing = [];
+  if (!normalizedOptions.systemDisplayName) missing.push('--display-name');
+  if (!normalizedOptions.systemDescription) missing.push('--description');
+  if (!normalizedOptions.systemType) missing.push('--system-type');
+  if (!normalizedOptions.authType) missing.push('--auth-type');
+  if (!normalizedOptions.datasourceCount) missing.push('--datasources');
+  if (missing.length > 0) {
+    throw new Error(`Missing required options for non-interactive external create: ${missing.join(', ')}`);
+  }
+  if (!Object.prototype.hasOwnProperty.call(normalizedOptions, 'github')) {
+    normalizedOptions.github = false;
+  }
+  if (!Object.prototype.hasOwnProperty.call(normalizedOptions, 'controller')) {
+    normalizedOptions.controller = false;
+  }
+}
+
+/**
+ * Handle create command execution
+ * @async
+ * @param {string} appName - Application name
+ * @param {Object} options - CLI options
+ */
+async function handleCreateCommand(appName, options) {
+  const validTypes = ['webapp', 'api', 'service', 'functionapp', 'external'];
+  if (options.type && !validTypes.includes(options.type)) {
+    throw new Error(`Invalid type: ${options.type}. Must be one of: ${validTypes.join(', ')}`);
+  }
+
+  const wizardOptions = { app: appName, ...options };
+  const normalizedOptions = normalizeExternalOptions(options);
+
+  const isExternalType = options.type === 'external';
+  const isNonInteractive = process.stdin && process.stdin.isTTY === false;
+
+  if (isExternalType && !options.wizard && isNonInteractive) {
+    validateNonInteractiveExternalOptions(normalizedOptions);
+  }
+
+  const shouldUseWizard = options.wizard && (options.type === 'external' || (!options.type && validTypes.includes('external')));
+  if (shouldUseWizard) {
+    const { handleWizard } = require('../commands/wizard');
+    await handleWizard(wizardOptions);
+  } else {
+    await app.createApp(appName, normalizedOptions);
+  }
+}
+
+/**
+ * Sets up application lifecycle commands
+ * @param {Command} program - Commander program instance
+ */
+function setupAppCommands(program) {
+  program.command('create <app>')
+    .description('Create new application with configuration files')
+    .option('-p, --port <port>', 'Application port', '3000')
+    .option('-d, --database', 'Requires database')
+    .option('-r, --redis', 'Requires Redis')
+    .option('-s, --storage', 'Requires file storage')
+    .option('-a, --authentication', 'Requires authentication/RBAC')
+    .option('-l, --language <lang>', 'Runtime language (typescript/python)')
+    .option('-t, --template <name>', 'Template to use (e.g., miso-controller, keycloak)')
+    .option('--type <type>', 'Application type (webapp, api, service, functionapp, external)', 'webapp')
+    .option('--app', 'Generate minimal application files (package.json, index.ts or requirements.txt, main.py)')
+    .option('-g, --github', 'Generate GitHub Actions workflows')
+    .option('--github-steps <steps>', 'Extra GitHub workflow steps (comma-separated, e.g., npm,test)')
+    .option('--main-branch <branch>', 'Main branch name for workflows', 'main')
+    .option('--wizard', 'Use interactive wizard for external system creation')
+    .option('--display-name <name>', 'External system display name')
+    .option('--description <desc>', 'External system description')
+    .option('--system-type <type>', 'External system type (openapi, mcp, custom)')
+    .option('--auth-type <type>', 'External system auth type (oauth2, apikey, basic)')
+    .option('--datasources <count>', 'Number of datasources to create')
+    .action(async(appName, options) => {
+      try {
+        await handleCreateCommand(appName, options);
+      } catch (error) {
+        handleCommandError(error, 'create');
+        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', `
+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
+  $ aifabrix wizard my-integration --silent  Run headless with integration/my-integration/wizard.yaml (no prompts)
+  $ aifabrix wizard -a my-integration   Same as above (app name set)
+  $ aifabrix wizard --config wizard.yaml  Run headless from a wizard config file
+
+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.`)
+    .action(async(positionalAppName, options) => {
+      try {
+        const appName = positionalAppName || options.app;
+        const configPath = appName ? path.join(process.cwd(), 'integration', appName, 'wizard.yaml') : null;
+        const { handleWizard } = require('../commands/wizard');
+        await handleWizard({ ...options, app: appName, config: options.config, configPath });
+      } catch (error) {
+        handleCommandError(error, 'wizard');
+        process.exit(1);
+      }
+    });
+
+  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.')
+    .action(async(appName, options) => {
+      try {
+        const imageTag = await app.buildApp(appName, options);
+        logger.log(`✅ Built image: ${imageTag}`);
+      } catch (error) {
+        handleCommandError(error, 'build');
+        process.exit(1);
+      }
+    });
+
+  program.command('run <app>')
+    .description('Run application locally')
+    .option('-p, --port <port>', 'Override local port')
+    .option('-d, --debug', 'Enable debug output with detailed container information')
+    .action(async(appName, options) => {
+      try {
+        await app.runApp(appName, options);
+      } catch (error) {
+        handleCommandError(error, 'run');
+        process.exit(1);
+      }
+    });
+
+  program.command('push <app>')
+    .description('Push image to Azure Container Registry')
+    .option('-r, --registry <registry>', 'ACR registry URL (overrides variables.yaml)')
+    .option('-t, --tag <tag>', 'Image tag(s) - comma-separated for multiple (default: latest)')
+    .action(async(appName, options) => {
+      try {
+        await app.pushApp(appName, options);
+      } catch (error) {
+        handleCommandError(error, 'push');
+        process.exit(1);
+      }
+    });
+
+  program.command('deploy <app>')
+    .description('Deploy to Azure via Miso Controller')
+    .option('--type <type>', 'Application type: external to deploy from integration/<app> (no app register needed)')
+    .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 {
+        await app.deployApp(appName, options);
+      } catch (error) {
+        handleCommandError(error, 'deploy');
+        process.exit(1);
+      }
+    });
+
+  program.command('dockerfile <app>')
+    .description('Generate Dockerfile for an application')
+    .option('-l, --language <lang>', 'Override language detection')
+    .option('-f, --force', 'Overwrite existing Dockerfile')
+    .action(async(appName, options) => {
+      try {
+        const dockerfilePath = await app.generateDockerfileForApp(appName, options);
+        logger.log(chalk.green('\n✅ Dockerfile generated successfully!'));
+        logger.log(chalk.gray(`Location: ${dockerfilePath}`));
+      } catch (error) {
+        handleCommandError(error, 'dockerfile');
+        process.exit(1);
+      }
+    });
+}
+
+module.exports = { setupAppCommands };

package/lib/cli/setup-auth.js

@@ -0,0 +1,88 @@
+/**
+ * CLI authentication command setup (login, logout, auth status/config).
+ *
+ * @fileoverview Authentication command definitions for AI Fabrix Builder CLI
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const chalk = require('chalk');
+const logger = require('../utils/logger');
+const { handleCommandError } = require('../utils/cli-utils');
+const { handleLogin } = require('../commands/login');
+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) {
+  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)')
+    .option('-m, --method <method>', 'Authentication method (device|credentials)', 'device')
+    .option('-a, --app <app>', 'Application name (required for credentials method, reads from secrets.local.yaml)')
+    .option('--client-id <id>', 'Client ID (for credentials method, overrides secrets.local.yaml)')
+    .option('--client-secret <secret>', 'Client Secret (for credentials method, overrides secrets.local.yaml)')
+    .option('-e, --environment <env>', 'Environment key (updates root-level environment in config.yaml, e.g., miso, dev, tst, pro)')
+    .option('--online', 'Request online-only token (excludes offline_access scope, device flow only)')
+    .option('--scope <scopes>', 'Custom OAuth2 scope string (device flow only, default: "openid profile email offline_access")')
+    .action(async(options) => {
+      try {
+        await handleLogin(options);
+      } catch (error) {
+        logger.error(chalk.red('\n❌ Login failed:'), error.message);
+        process.exit(1);
+      }
+    });
+
+  program.command('logout')
+    .description('Clear authentication tokens')
+    .option('-c, --controller <url>', 'Clear device tokens for specific controller')
+    .option('-e, --environment <env>', 'Clear client tokens for specific environment')
+    .option('-a, --app <app>', 'Clear client tokens for specific app (requires --environment)')
+    .action(async(options) => {
+      try {
+        await handleLogout(options);
+      } catch (error) {
+        handleCommandError(error, 'logout');
+        process.exit(1);
+      }
+    });
+
+  const authStatusHandler = async(options) => {
+    try {
+      await handleAuthStatus(options);
+    } catch (error) {
+      handleCommandError(error, 'auth status');
+      process.exit(1);
+    }
+  };
+
+  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')
+    .description('Configure authentication settings (controller, environment)')
+    .option('--set-controller <url>', 'Set default controller URL')
+    .option('--set-environment <env>', 'Set default environment')
+    .action(async(options) => {
+      try {
+        await handleAuthConfig(options);
+      } catch (error) {
+        handleCommandError(error, 'auth config');
+        process.exit(1);
+      }
+    });
+}
+
+module.exports = { setupAuthCommands };

package/lib/cli/setup-dev.js

@@ -0,0 +1,101 @@
+/**
+ * CLI developer configuration command setup (dev config, dev set-id).
+ *
+ * @fileoverview Developer command definitions for AI Fabrix Builder CLI
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const chalk = require('chalk');
+const config = require('../core/config');
+const devConfig = require('../utils/dev-config');
+const logger = require('../utils/logger');
+const { handleCommandError } = require('../utils/cli-utils');
+
+/**
+ * Display developer configuration
+ * @param {string} devId - Developer ID
+ * @returns {Promise<void>}
+ */
+async function displayDevConfig(devId) {
+  const devIdNum = parseInt(devId, 10);
+  const ports = devConfig.getDevPorts(devIdNum);
+  const configVars = [
+    { key: 'aifabrix-home', value: await config.getAifabrixHomeOverride() },
+    { key: 'aifabrix-secrets', value: await config.getAifabrixSecretsPath() },
+    { key: 'aifabrix-env-config', value: await config.getAifabrixEnvConfigPath() }
+  ].filter(v => v.value);
+
+  logger.log('\n🔧 Developer Configuration\n');
+  logger.log(`Developer ID: ${devId}`);
+  logger.log('\nPorts:');
+  logger.log(`  App: ${ports.app}`);
+  logger.log(`  Postgres: ${ports.postgres}`);
+  logger.log(`  Redis: ${ports.redis}`);
+  logger.log(`  pgAdmin: ${ports.pgadmin}`);
+  logger.log(`  Redis Commander: ${ports.redisCommander}`);
+
+  if (configVars.length > 0) {
+    logger.log('\nConfiguration:');
+    configVars.forEach(v => logger.log(`  ${v.key}: ${v.value}`));
+  }
+  logger.log('');
+}
+
+/**
+ * Sets up developer configuration commands
+ * @param {Command} program - Commander program instance
+ */
+function setupDevCommands(program) {
+  const dev = program
+    .command('dev')
+    .description('Developer configuration and isolation');
+
+  dev
+    .command('config')
+    .description('Show or set developer configuration')
+    .option('--set-id <id>', 'Set developer ID')
+    .action(async(options) => {
+      try {
+        const setIdValue = options.setId || options['set-id'];
+        if (setIdValue) {
+          const digitsOnly = /^[0-9]+$/.test(setIdValue);
+          if (!digitsOnly) {
+            throw new Error('Developer ID must be a non-negative digit string (0 = default infra, > 0 = developer-specific)');
+          }
+          await config.setDeveloperId(setIdValue);
+          process.env.AIFABRIX_DEVELOPERID = setIdValue;
+          logger.log(chalk.green(`✓ Developer ID set to ${setIdValue}`));
+          await displayDevConfig(setIdValue);
+          return;
+        }
+
+        const devId = await config.getDeveloperId();
+        await displayDevConfig(devId);
+      } catch (error) {
+        handleCommandError(error, 'dev config');
+        process.exit(1);
+      }
+    });
+
+  dev
+    .command('set-id <id>')
+    .description('Set developer ID (convenience alias for "dev config --set-id")')
+    .action(async(id) => {
+      try {
+        const digitsOnly = /^[0-9]+$/.test(id);
+        if (!digitsOnly) {
+          throw new Error('Developer ID must be a non-negative digit string (0 = default infra, > 0 = developer-specific)');
+        }
+        await config.setDeveloperId(id);
+        process.env.AIFABRIX_DEVELOPERID = id;
+        logger.log(chalk.green(`✓ Developer ID set to ${id}`));
+        await displayDevConfig(id);
+      } catch (error) {
+        handleCommandError(error, 'dev set-id');
+        process.exit(1);
+      }
+    });
+}
+
+module.exports = { setupDevCommands };

package/lib/cli/setup-environment.js

@@ -0,0 +1,53 @@
+/**
+ * CLI environment deployment command setup (environment deploy, env deploy).
+ *
+ * @fileoverview Environment command definitions for AI Fabrix Builder CLI
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const { handleCommandError } = require('../utils/cli-utils');
+
+/**
+ * Sets up environment deployment commands
+ * @param {Command} program - Commander program instance
+ */
+function setupEnvironmentCommands(program) {
+  const deployEnvHandler = async(envKey, options) => {
+    try {
+      const environmentDeploy = require('../deployment/environment');
+      await environmentDeploy.deployEnvironment(envKey, options);
+    } catch (error) {
+      handleCommandError(error, 'environment deploy');
+      process.exit(1);
+    }
+  };
+
+  const environment = program
+    .command('environment')
+    .description('Manage environments');
+
+  environment
+    .command('deploy <env>')
+    .description('Deploy/setup environment in Miso Controller')
+    .option('--config <file>', 'Environment configuration file')
+    .option('--skip-validation', 'Skip environment validation')
+    .option('--poll', 'Poll for deployment status', true)
+    .option('--no-poll', 'Do not poll for status')
+    .action(deployEnvHandler);
+
+  const env = program
+    .command('env')
+    .description('Environment management (alias for environment)');
+
+  env
+    .command('deploy <env>')
+    .description('Deploy/setup environment in Miso Controller')
+    .option('--config <file>', 'Environment configuration file')
+    .option('--skip-validation', 'Skip environment validation')
+    .option('--poll', 'Poll for deployment status', true)
+    .option('--no-poll', 'Do not poll for status')
+    .action(deployEnvHandler);
+}
+
+module.exports = { setupEnvironmentCommands };

package/lib/cli/setup-external-system.js

@@ -0,0 +1,87 @@
+/**
+ * CLI external system command setup (download, delete, test, test-integration).
+ *
+ * @fileoverview External system command definitions for AI Fabrix Builder CLI
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const { handleCommandError } = require('../utils/cli-utils');
+
+/**
+ * Sets up external system commands
+ * @param {Command} program - Commander program instance
+ */
+function setupExternalSystemCommands(program) {
+  program.command('download <system-key>')
+    .description('Download external system from dataplane to local development structure')
+    .option('--dry-run', 'Show what would be downloaded without actually downloading')
+    .action(async(systemKey, options) => {
+      try {
+        const download = require('../external-system/download');
+        await download.downloadExternalSystem(systemKey, options);
+      } catch (error) {
+        handleCommandError(error, 'download');
+        process.exit(1);
+      }
+    });
+
+  program.command('delete <system-key>')
+    .description('Delete external system from dataplane (also deletes all associated datasources)')
+    .option('--type <type>', 'Application type (external) - required for external systems')
+    .option('--yes', 'Skip confirmation prompt')
+    .option('--force', 'Skip confirmation prompt (alias for --yes)')
+    .action(async(systemKey, options) => {
+      try {
+        if (options.type !== 'external') {
+          throw new Error('Delete command for external systems requires --type external');
+        }
+        const externalDelete = require('../external-system/delete');
+        await externalDelete.deleteExternalSystem(systemKey, options);
+      } catch (error) {
+        handleCommandError(error, 'delete');
+        process.exit(1);
+      }
+    });
+
+  program.command('test <app>')
+    .description('Run unit tests for external system (local validation, no API calls)')
+    .option('-d, --datasource <key>', 'Test specific datasource only')
+    .option('-v, --verbose', 'Show detailed validation output')
+    .action(async(appName, options) => {
+      try {
+        const test = require('../external-system/test');
+        const results = await test.testExternalSystem(appName, options);
+        test.displayTestResults(results, options.verbose);
+        if (!results.valid) {
+          process.exit(1);
+        }
+      } catch (error) {
+        handleCommandError(error, 'test');
+        process.exit(1);
+      }
+    });
+
+  program.command('test-integration <app>')
+    .description('Run integration tests via dataplane pipeline API')
+    .option('-d, --datasource <key>', 'Test specific datasource only')
+    .option('-p, --payload <file>', 'Path to custom test payload file')
+    .option('--dataplane <url>', 'Dataplane URL (default: discovered from controller)')
+    .option('-v, --verbose', 'Show detailed test output')
+    .option('--timeout <ms>', 'Request timeout in milliseconds', '30000')
+    .action(async(appName, options) => {
+      try {
+        const test = require('../external-system/test');
+        const results = await test.testExternalSystemIntegration(appName, options);
+        test.displayIntegrationTestResults(results, options.verbose);
+        if (!results.success) {
+          process.exit(1);
+        }
+      } catch (error) {
+        handleCommandError(error, 'test-integration');
+        process.exit(1);
+      }
+    });
+}
+
+module.exports = { setupExternalSystemCommands };