@aifabrix/builder 2.40.2 → 2.41.0

package/lib/cli/setup-app.js

@@ -154,6 +154,31 @@ See integration/hubspot/wizard-hubspot-e2e.yaml for an example.`;
     });
 }
 
+function registerRunCommand(program) {
+  const runHelp = `
+In dev: use --reload for sync and mount (requires remote server with Mutagen, or local Docker).
+Examples:
+  $ aifabrix run myapp
+  $ aifabrix run myapp --env tst
+  $ aifabrix run myapp --reload`;
+  program.command('run <app>')
+    .description('Run application locally (or remotely on your Docker host)')
+    .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 application.yaml image.tag')
+    .option('-e, --env <env>', 'Environment: dev (default), tst, or pro', 'dev')
+    .option('--reload', 'In dev: use sync and mount (requires remote server; Mutagen or local Docker)')
+    .addHelpText('after', runHelp)
+    .action(async(appName, options) => {
+      try {
+        await app.runApp(appName, options);
+      } catch (error) {
+        handleCommandError(error, 'run');
+        process.exit(1);
+      }
+    });
+}
+
 function setupBuildRunLogsDownCommands(program) {
   program.command('build <app>')
     .description('Build container image (auto-detects runtime)')
@@ -170,19 +195,7 @@ function setupBuildRunLogsDownCommands(program) {
       }
     });
 
-  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')
-    .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);
-      } catch (error) {
-        handleCommandError(error, 'run');
-        process.exit(1);
-      }
-    });
+  registerRunCommand(program);
 
   program.command('logs <app>')
     .description('Show application container logs (and optional env summary with secrets masked)')
@@ -215,6 +228,117 @@ function setupBuildRunLogsDownCommands(program) {
     });
 }
 
+function setupShellTestStopCommands(program) {
+  program.command('stop <app>')
+    .description('Stop and remove application container (alias for down-app)')
+    .option('--volumes', 'Remove application Docker volume')
+    .action(async(appName, options) => {
+      try {
+        const { runDownAppWithImageRemoval } = require('../commands/app-down');
+        await runDownAppWithImageRemoval(appName, { volumes: options.volumes });
+      } catch (error) {
+        handleCommandError(error, 'stop');
+        process.exit(1);
+      }
+    });
+
+  program.command('shell <app>')
+    .description('Open interactive shell in the application container')
+    .option('--env <env>', 'Environment (dev|tst); dev uses running container', 'dev')
+    .action(async(appName, options) => {
+      try {
+        const { runAppShell } = require('../commands/app-shell');
+        await runAppShell(appName, { env: options.env });
+      } catch (error) {
+        handleCommandError(error, 'shell');
+        process.exit(1);
+      }
+    });
+
+  program.command('test <app>')
+    .description('Run tests (builder app: in container; external system: local validation)')
+    .option('--env <env>', 'For builder app: dev (running container) or tst (ephemeral)', 'dev')
+    .option('-d, --datasource <key>', 'For external system: test specific datasource only')
+    .option('-v, --verbose', 'Verbose output')
+    .action(async(appName, options) => {
+      try {
+        const pathsUtil = require('../utils/paths');
+        const appType = await pathsUtil.detectAppType(appName).catch(() => null);
+        if (appType && appType.baseDir === 'integration') {
+          const test = require('../external-system/test');
+          const results = await test.testExternalSystem(appName, options);
+          test.displayTestResults(results, options.verbose);
+          if (!results.valid) process.exit(1);
+        } else {
+          const { runAppTest } = require('../commands/app-test');
+          await runAppTest(appName, { env: options.env });
+        }
+      } catch (error) {
+        handleCommandError(error, 'test');
+        process.exit(1);
+      }
+    });
+}
+
+function setupInstallTestE2eLintCommands(program) {
+  program.command('install <app>')
+    .description('Install dependencies in container (builder apps only)')
+    .option('--env <env>', 'dev (running container) or tst (ephemeral with .env)', 'dev')
+    .action(async(appName, options) => {
+      try {
+        const pathsUtil = require('../utils/paths');
+        const appType = await pathsUtil.detectAppType(appName).catch(() => null);
+        if (appType && appType.baseDir === 'integration') {
+          logger.log(chalk.gray('Install is for builder applications only. Use aifabrix shell <app> to run commands in external setups.'));
+          return;
+        }
+        const { runAppInstall } = require('../commands/app-install');
+        await runAppInstall(appName, { env: options.env });
+      } catch (error) {
+        handleCommandError(error, 'install');
+        process.exit(1);
+      }
+    });
+
+  program.command('test-e2e <app>')
+    .description('Run e2e tests in container (builder apps only)')
+    .option('--env <env>', 'dev (running container) or tst (ephemeral with .env)', 'dev')
+    .action(async(appName, options) => {
+      try {
+        const pathsUtil = require('../utils/paths');
+        const appType = await pathsUtil.detectAppType(appName).catch(() => null);
+        if (appType && appType.baseDir === 'integration') {
+          logger.log(chalk.gray('test-e2e is for builder applications only. Use aifabrix shell <app> then make test:e2e or pnpm test:e2e.'));
+          return;
+        }
+        const { runAppTestE2e } = require('../commands/app-test');
+        await runAppTestE2e(appName, { env: options.env });
+      } catch (error) {
+        handleCommandError(error, 'test-e2e');
+        process.exit(1);
+      }
+    });
+
+  program.command('lint <app>')
+    .description('Run lint in container (builder apps only)')
+    .option('--env <env>', 'dev (running container) or tst (ephemeral with .env)', 'dev')
+    .action(async(appName, options) => {
+      try {
+        const pathsUtil = require('../utils/paths');
+        const appType = await pathsUtil.detectAppType(appName).catch(() => null);
+        if (appType && appType.baseDir === 'integration') {
+          logger.log(chalk.gray('lint is for builder applications only. Use aifabrix shell <app> then make lint or pnpm lint.'));
+          return;
+        }
+        const { runAppLint } = require('../commands/app-test');
+        await runAppLint(appName, { env: options.env });
+      } catch (error) {
+        handleCommandError(error, 'lint');
+        process.exit(1);
+      }
+    });
+}
+
 function setupPushDeployDockerfileCommands(program) {
   program.command('push <app>')
     .description('Push image to Azure Container Registry')
@@ -230,7 +354,7 @@ function setupPushDeployDockerfileCommands(program) {
     });
 
   program.command('deploy <app>')
-    .description('Deploy to Azure via Miso Controller')
+    .description('Deploy to Azure or locally via Miso Controller')
     .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)')
@@ -274,6 +398,8 @@ function setupAppCommands(program) {
   setupCreateCommand(program);
   setupWizardCommand(program);
   setupBuildRunLogsDownCommands(program);
+  setupShellTestStopCommands(program);
+  setupInstallTestE2eLintCommands(program);
   setupPushDeployDockerfileCommands(program);
 }
 

package/lib/cli/setup-dev.js

@@ -1,5 +1,5 @@
 /**
- * CLI developer configuration command setup (dev config, dev set-id).
+ * CLI developer configuration command setup (dev config, dev set-id, dev init, dev add/update/pin/delete/list).
  *
  * @fileoverview Developer command definitions for AI Fabrix Builder CLI
  * @author AI Fabrix Team
@@ -11,20 +11,37 @@ const config = require('../core/config');
 const devConfig = require('../utils/dev-config');
 const logger = require('../utils/logger');
 const { handleCommandError } = require('../utils/cli-utils');
+const { runDevInit, runDevRefresh } = require('../commands/dev-init');
+const {
+  handleDevList,
+  handleDevAdd,
+  handleDevUpdate,
+  handleDevPin,
+  handleDevDelete
+} = require('../commands/dev-cli-handlers');
 
 /**
- * Display developer configuration
+ * Display developer configuration (local ports and config; remote/settings keys always shown).
+ * Always shows environment, controller, and remote keys (value or "(not set)").
  * @param {string} devId - Developer ID
  * @returns {Promise<void>}
  */
 async function displayDevConfig(devId) {
   const devIdNum = parseInt(devId, 10);
   const ports = devConfig.getDevPorts(devIdNum);
-  const configVars = [
+  const environment = await config.getCurrentEnvironment();
+  const controller = await config.getControllerUrl();
+
+  const optionalConfigVars = [
     { 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);
+    { key: 'aifabrix-env-config', value: await config.getAifabrixEnvConfigPath() },
+    { key: 'remote-server', value: await config.getRemoteServer() },
+    { key: 'docker-endpoint', value: await config.getDockerEndpoint() },
+    { key: 'user-mutagen-folder', value: await config.getUserMutagenFolder() },
+    { key: 'sync-ssh-user', value: await config.getSyncSshUser() },
+    { key: 'sync-ssh-host', value: await config.getSyncSshHost() }
+  ];
 
   logger.log('\n🔧 Developer Configuration\n');
   logger.log(`Developer ID: ${devId}`);
@@ -35,22 +52,18 @@ async function displayDevConfig(devId) {
   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('\nConfiguration:');
+  logger.log(`  environment: '${environment}'`);
+  logger.log(controller ? `  controller: '${controller}'` : '  controller: (not set)');
+  optionalConfigVars.forEach(v => logger.log(`  ${v.key}: ${v.value || '(not set)'}`));
   logger.log('');
 }
 
 /**
- * Sets up developer configuration commands
- * @param {Command} program - Commander program instance
+ * Register dev config and set-id commands.
+ * @param {Command} dev - dev subcommand group
  */
-function setupDevCommands(program) {
-  const dev = program
-    .command('dev')
-    .description('Developer configuration and isolation');
-
+function setupDevConfigCommands(dev) {
   dev
     .command('config')
     .description('Show or set developer configuration')
@@ -69,7 +82,6 @@ function setupDevCommands(program) {
           await displayDevConfig(setIdValue);
           return;
         }
-
         const devId = await config.getDeveloperId();
         await displayDevConfig(devId);
       } catch (error) {
@@ -98,4 +110,155 @@ function setupDevCommands(program) {
     });
 }
 
+/**
+ * Register dev init and refresh commands.
+ * @param {Command} dev - dev subcommand group
+ */
+function setupDevInitCommand(dev) {
+  dev
+    .command('init')
+    .description('Onboard with Builder Server (issue certificate, fetch settings, register SSH key for Mutagen)')
+    .requiredOption('--developer-id <id>', 'Developer ID (same as dev add; e.g. 01)')
+    .requiredOption('--server <url>', 'Builder Server base URL (e.g. https://dev.aifabrix.dev)')
+    .requiredOption('--pin <pin>', 'One-time PIN from your admin')
+    .action(async(options) => {
+      try {
+        await runDevInit(options);
+      } catch (error) {
+        handleCommandError(error, 'dev init');
+        process.exit(1);
+      }
+    });
+
+  dev
+    .command('refresh')
+    .description('Fetch settings from Builder Server and update config; refresh certificate if expiring within 14 days or --cert')
+    .option('--cert', 'Force certificate refresh (create PIN + issue-cert) even when cert is still valid')
+    .action(async(options) => {
+      try {
+        await runDevRefresh(options);
+      } catch (error) {
+        handleCommandError(error, 'dev refresh');
+        process.exit(1);
+      }
+    });
+}
+
+/**
+ * Register dev list and add commands (remote only).
+ * @param {Command} dev - dev subcommand group
+ */
+function setupDevListAddCommands(dev) {
+  dev
+    .command('list')
+    .description('List developer users (remote Builder Server only)')
+    .action(async() => {
+      try {
+        await handleDevList();
+      } catch (error) {
+        handleCommandError(error, 'dev list');
+        process.exit(1);
+      }
+    });
+
+  dev
+    .command('add')
+    .description('Register a new developer (remote Builder Server only; admin)')
+    .requiredOption('--developer-id <id>', 'Developer ID (unique, e.g. 01)')
+    .requiredOption('--name <name>', 'Display name')
+    .requiredOption('--email <email>', 'Email address')
+    .option('--groups <items>', 'Comma-separated groups (admin, secret-manager, developer)', 'developer')
+    .action(async(options) => {
+      try {
+        await handleDevAdd(options);
+      } catch (error) {
+        handleCommandError(error, 'dev add');
+        process.exit(1);
+      }
+    });
+}
+
+/**
+ * Register dev update/pin/delete commands (remote only).
+ * @param {Command} dev - dev subcommand group
+ */
+function setupDevUpdatePinDeleteCommands(dev) {
+  dev
+    .command('update [developerId]')
+    .description('Update a developer (name, email, groups); use --developer-id like dev add')
+    .option('--developer-id <id>', 'Developer ID (same as dev add)')
+    .option('--name <name>', 'Display name')
+    .option('--email <email>', 'Email address')
+    .option('--groups <items>', 'Comma-separated groups (admin, secret-manager, developer)')
+    .action(async(developerId, options) => {
+      try {
+        await handleDevUpdate(developerId, options);
+      } catch (error) {
+        handleCommandError(error, 'dev update');
+        process.exit(1);
+      }
+    });
+
+  dev
+    .command('pin [developerId]')
+    .description('Create or regenerate one-time PIN for onboarding (admin; show once to developer)')
+    .action(async(developerId) => {
+      try {
+        await handleDevPin(developerId);
+      } catch (error) {
+        handleCommandError(error, 'dev pin');
+        process.exit(1);
+      }
+    });
+
+  dev
+    .command('delete <developerId>')
+    .description('Remove a developer (remote Builder Server only; admin)')
+    .action(async(developerId) => {
+      try {
+        await handleDevDelete(developerId);
+      } catch (error) {
+        handleCommandError(error, 'dev delete');
+        process.exit(1);
+      }
+    });
+
+  dev
+    .command('down')
+    .description('Stop Mutagen sync sessions for this developer (and optionally app containers)')
+    .option('--apps', 'Also stop running app containers for this developer')
+    .action(async(options) => {
+      try {
+        const { handleDevDown } = require('../commands/dev-down');
+        await handleDevDown(options);
+      } catch (error) {
+        handleCommandError(error, 'dev down');
+        process.exit(1);
+      }
+    });
+}
+
+/**
+ * Register dev list/add/update/pin/delete commands (remote only).
+ * @param {Command} dev - dev subcommand group
+ */
+function setupDevUserCommands(dev) {
+  setupDevListAddCommands(dev);
+  setupDevUpdatePinDeleteCommands(dev);
+}
+
+/**
+ * Sets up developer configuration commands
+ * @param {Command} program - Commander program instance
+ */
+function setupDevCommands(program) {
+  const dev = program
+    .command('dev')
+    .description('Developer configuration and isolation');
+
+  setupDevConfigCommands(dev);
+  setupDevInitCommand(dev);
+  setupDevUserCommands(dev);
+}
+
 module.exports = { setupDevCommands };

package/lib/cli/setup-environment.js

@@ -30,7 +30,8 @@ function setupEnvironmentCommands(program) {
   environment
     .command('deploy <env>')
     .description('Deploy/setup environment in Miso Controller')
-    .option('--config <file>', 'Environment configuration file')
+    .option('--config <file>', 'Environment configuration file (optional if --preset is used)')
+    .option('--preset <size>', 'Environment size preset: s, m, l, xl (default: s)', 's')
     .option('--skip-validation', 'Skip environment validation')
     .option('--poll', 'Poll for deployment status', true)
     .option('--no-poll', 'Do not poll for status')
@@ -43,7 +44,8 @@ function setupEnvironmentCommands(program) {
   env
     .command('deploy <env>')
     .description('Deploy/setup environment in Miso Controller')
-    .option('--config <file>', 'Environment configuration file')
+    .option('--config <file>', 'Environment configuration file (optional if --preset is used)')
+    .option('--preset <size>', 'Environment size preset: s, m, l, xl (default: s)', 's')
     .option('--skip-validation', 'Skip environment validation')
     .option('--poll', 'Poll for deployment status', true)
     .option('--no-poll', 'Do not poll for status')

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

@@ -56,35 +56,85 @@ function setupDeleteCommand(program) {
     });
 }
 
+/**
+ * Try to run builder-style test integration when app is not in builder or has no externalIntegration.
+ * @param {string} appName - App or system key
+ * @param {Object} options - CLI options
+ * @returns {Promise<boolean>} True if builder test was run, false otherwise
+ */
+async function tryBuilderTestIntegration(appName, options) {
+  const fsSync = require('fs');
+  const pathsUtil = require('../utils/paths');
+  const { getIntegrationPath, getBuilderPath } = pathsUtil;
+  const { resolveApplicationConfigPath } = require('../utils/app-config-resolver');
+  const { loadConfigFile } = require('../utils/config-format');
+  const integrationPath = getIntegrationPath(appName);
+  let hasExternalIntegration = false;
+  try {
+    const integrationConfig = loadConfigFile(resolveApplicationConfigPath(integrationPath));
+    hasExternalIntegration = !!(integrationConfig && integrationConfig.externalIntegration);
+  } catch {
+    // integration path or config missing
+  }
+  if (!hasExternalIntegration) {
+    const builderPath = getBuilderPath(appName);
+    const builderConfigPath = resolveApplicationConfigPath(builderPath);
+    if (fsSync.existsSync(builderPath) && fsSync.existsSync(builderConfigPath)) {
+      const { runAppTestIntegration } = require('../commands/app-test');
+      const opts = { env: options.env || options.environment || 'dev' };
+      await runAppTestIntegration(appName, opts);
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Run external system integration test via dataplane and exit on failure.
+ * @param {string} appName - App or system key
+ * @param {Object} options - CLI options
+ * @returns {Promise<void>}
+ */
+async function runExternalSystemTestIntegration(appName, options) {
+  const test = require('../external-system/test');
+  const opts = { ...options, environment: options.env || options.environment };
+  const results = await test.testExternalSystemIntegration(appName, opts);
+  test.displayIntegrationTestResults(results, options.verbose);
+  if (!results.success) process.exit(1);
+}
+
+/**
+ * Run test-integration command: builder app in container or external system via dataplane.
+ * @param {string} appName - App or system key
+ * @param {Object} options - CLI options (datasource, payload, env, verbose, timeout)
+ * @returns {Promise<void>}
+ */
+async function runTestIntegrationCommand(appName, options) {
+  const pathsUtil = require('../utils/paths');
+  const appType = await pathsUtil.detectAppType(appName).catch(() => null);
+  if (appType && appType.baseDir === 'builder') {
+    const { runAppTestIntegration } = require('../commands/app-test');
+    const opts = { env: options.env || options.environment || 'dev' };
+    await runAppTestIntegration(appName, opts);
+    return;
+  }
+  const ranBuilder = await tryBuilderTestIntegration(appName, options);
+  if (ranBuilder) return;
+  await runExternalSystemTestIntegration(appName, options);
+}
+
 function setupExternalSystemTestCommands(program) {
-  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);
-      }
-    });
+  // 'test <app>' is registered in setup-app.js and dispatches by app type (builder vs external)
   program.command('test-integration <app>')
-    .description('Run integration tests via dataplane pipeline API')
+    .description('Run integration tests (builder/docker app: in container; external system: 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('-e, --env <env>', 'Environment: dev, tst, or pro (default: from aifabrix auth config)')
     .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);
+        await runTestIntegrationCommand(appName, options);
       } catch (error) {
         handleCommandError(error, 'test-integration');
         process.exit(1);

package/lib/cli/setup-infra.js

@@ -12,7 +12,9 @@ const appLib = require('../app');
 const validator = require('../validation/validator');
 const config = require('../core/config');
 const logger = require('../utils/logger');
-const { handleCommandError } = require('../utils/cli-utils');
+const { handleCommandError, isAuthenticationError } = require('../utils/cli-utils');
+const { resolveControllerUrl } = require('../utils/controller-url');
+const { handleLogin } = require('../commands/login');
 const { handleUpMiso } = require('../commands/up-miso');
 const { handleUpDataplane } = require('../commands/up-dataplane');
 
@@ -45,13 +47,14 @@ async function runUpInfraCommand(options) {
     logger.log(chalk.green('✓ Traefik disabled and saved to config'));
   }
   const useTraefik = options.traefik === true ? true : (options.traefik === false ? false : !!(cfg.traefik));
-  await infra.startInfra(developerId, { traefik: useTraefik });
+  await infra.startInfra(developerId, { traefik: useTraefik, adminPwd: options.adminPwd });
 }
 
 function setupUpInfraCommand(program) {
   program.command('up-infra')
     .description('Start local infrastructure: Postgres, Redis, optional Traefik')
     .option('-d, --developer <id>', 'Set developer ID and start infrastructure')
+    .option('--adminPwd <password>', 'Override default admin password for new install (Postgres, pgAdmin, Redis Commander)')
     .option('--traefik', 'Include Traefik reverse proxy and save to config')
     .option('--no-traefik', 'Exclude Traefik and save to config')
     .action(async(options) => {
@@ -75,6 +78,18 @@ function setupUpPlatformCommand(program) {
         await handleUpMiso(options);
         await handleUpDataplane(options);
       } catch (error) {
+        if (isAuthenticationError(error)) {
+          const controllerUrl = error.controllerUrl || await resolveControllerUrl();
+          logger.log(chalk.blue('\nAuthentication required. Running aifabrix login...\n'));
+          try {
+            await handleLogin({ method: 'device', controller: controllerUrl });
+            await handleUpDataplane(options);
+            return;
+          } catch (loginOrRetryError) {
+            handleCommandError(loginOrRetryError, 'up-platform');
+            process.exit(1);
+          }
+        }
         handleCommandError(error, 'up-platform');
         process.exit(1);
       }
@@ -107,6 +122,18 @@ function setupUpDataplaneCommand(program) {
       try {
         await handleUpDataplane(options);
       } catch (error) {
+        if (isAuthenticationError(error)) {
+          const controllerUrl = error.controllerUrl || await resolveControllerUrl();
+          logger.log(chalk.blue('\nAuthentication required. Running aifabrix login...\n'));
+          try {
+            await handleLogin({ method: 'device', controller: controllerUrl });
+            await handleUpDataplane(options);
+            return;
+          } catch (loginOrRetryError) {
+            handleCommandError(loginOrRetryError, 'up-dataplane');
+            process.exit(1);
+          }
+        }
         handleCommandError(error, 'up-dataplane');
         process.exit(1);
       }