@aifabrix/builder 2.44.5 → 2.44.6

package/lib/commands/setup-prompts.js

@@ -0,0 +1,388 @@
+/**
+ * Inquirer prompts for `aifabrix setup`.
+ *
+ * Three small prompt helpers:
+ *   1. {@link promptModeSelection} - Mode menu shown when infra is already up.
+ *   2. {@link promptAdminCredentials} - Admin email + password (fresh install only).
+ *   3. {@link promptAiTool} - AI tool provider + keys, only when the merged
+ *      secret cascade (user-local + shared) does not already provide the keys.
+ *
+ * Reads merged secrets via `loadSecrets()` from `lib/core/secrets.js` so the
+ * resolution honors both user-local secrets and the shared `aifabrix-secrets`
+ * store (file or remote API) when configured.
+ *
+ * Writes use `setSecretInStore(...)` (primary user `secrets.local.yaml` only; shared is human via
+ * `aifabrix secret set --shared`) so the
+ * installer can write either to user-local secrets or to the shared store,
+ * depending on config.
+ *
+ * @fileoverview Setup prompts (mode menu, admin creds, AI tool)
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+'use strict';
+
+const inquirer = require('inquirer');
+const chalk = require('chalk');
+const logger = require('../utils/logger');
+const secretsCore = require('../core/secrets');
+const secretsEnsure = require('../core/secrets-ensure');
+const { formatSuccessLine, infoLine } = require('../utils/cli-test-layout-chalk');
+
+/** Mode identifiers. Public so callers can switch on them without string typos. */
+const MODE = Object.freeze({
+  REINSTALL: 'reinstall',
+  WIPE_DATA: 'wipe-data',
+  CLEAN_FILES: 'clean-files',
+  UPDATE_IMAGES: 'update-images'
+});
+
+/** AI tool key names in `secrets.local.yaml` / shared secrets. */
+const AI_KEYS = Object.freeze({
+  OPENAI_API_KEY: 'secrets-openaiApiKeyVault',
+  AZURE_OPENAI_URL: 'azure-openaiapi-urlKeyVault',
+  AZURE_OPENAI_API_KEY: 'secrets-azureOpenaiApiKeyVault'
+});
+
+/** Builder folder conflict actions (setup preflight). */
+const BUILDER_DIR_ACTION = Object.freeze({
+  KEEP: 'keep',
+  KEEP_FILES: 'keep-files',
+  BACKUP: 'backup',
+  ABORT: 'abort'
+});
+
+/**
+ * Prompt the user to choose what to do when infra is already running.
+ * @async
+ * @returns {Promise<string>} One of MODE.* values
+ */
+async function promptModeSelection() {
+  const { mode } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'mode',
+      message: 'Infrastructure is already running. What do you want to do?',
+      choices: [
+        {
+          name: 'Re-install platform + infra (DESTROYS all local data)',
+          value: MODE.REINSTALL
+        },
+        {
+          name: 'Reset databases (keeps volumes, removes DBs/users)',
+          value: MODE.WIPE_DATA
+        },
+        {
+          name: 'Refresh platform config (keeps data, re-copy platform files)',
+          value: MODE.CLEAN_FILES
+        },
+        {
+          name: 'Update images + restart services (keeps data)',
+          value: MODE.UPDATE_IMAGES
+        }
+      ]
+    }
+  ]);
+  return mode;
+}
+
+/**
+ * Confirm a destructive mode unless `assumeYes` is true.
+ * @async
+ * @param {string} mode - One of MODE.* values
+ * @param {boolean} assumeYes - When true, skip the confirmation
+ * @returns {Promise<boolean>} True when the user confirms (or `assumeYes`)
+ */
+async function confirmDestructiveMode(mode, assumeYes) {
+  if (assumeYes) return true;
+  if (mode !== MODE.REINSTALL && mode !== MODE.WIPE_DATA) return true;
+  const message =
+    mode === MODE.REINSTALL
+      ? 'This will stop all services and DELETE every infra volume. Continue?'
+      : 'This will DROP every database and DB user. Continue?';
+  const { ok } = await inquirer.prompt([
+    { type: 'confirm', name: 'ok', message, default: false }
+  ]);
+  return ok === true;
+}
+
+/**
+ * Validate an email address (RFC 5322-lite for CLI use).
+ * @param {string} input
+ * @returns {true|string}
+ */
+function validateEmail(input) {
+  const value = (input || '').trim();
+  if (!value) return 'Admin email is required';
+  if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value)) return 'Enter a valid email address';
+  return true;
+}
+
+/**
+ * Validate a password (non-empty, at least 8 chars).
+ * @param {string} input
+ * @returns {true|string}
+ */
+function validatePassword(input) {
+  const value = String(input ?? '');
+  if (value.length === 0) return 'Admin password is required';
+  if (value.length < 8) return 'Admin password must be at least 8 characters';
+  return true;
+}
+
+/**
+ * Prompt for admin email + password (fresh install only).
+ * Asks once for the password and once for confirmation; returns trimmed email
+ * and the verbatim password (never logged).
+ *
+ * @async
+ * @returns {Promise<{ adminEmail: string, adminPassword: string }>}
+ */
+async function promptAdminCredentials() {
+  const answers = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'adminEmail',
+      message: 'Admin email (Keycloak / pgAdmin login):',
+      validate: validateEmail
+    },
+    {
+      type: 'password',
+      name: 'adminPassword',
+      message: 'Admin password (Postgres / Keycloak / pgAdmin):',
+      mask: '*',
+      validate: validatePassword
+    },
+    {
+      type: 'password',
+      name: 'adminPasswordConfirm',
+      message: 'Confirm admin password:',
+      mask: '*',
+      validate(input, all) {
+        if (input !== all.adminPassword) return 'Passwords do not match';
+        return true;
+      }
+    }
+  ]);
+  return {
+    adminEmail: String(answers.adminEmail).trim(),
+    adminPassword: answers.adminPassword
+  };
+}
+
+/**
+ * @typedef {Object} AiToolStatus
+ * @property {boolean} openAiConfigured - True when OpenAI key resolves non-empty
+ * @property {boolean} azureOpenAiConfigured - True when Azure URL + key resolve non-empty
+ */
+
+/**
+ * Detect whether AI tool keys are already present in the merged secret view.
+ * Treats values surrounded by Handlebars-style placeholders (e.g. `{{...}}`)
+ * as not configured.
+ *
+ * @async
+ * @returns {Promise<AiToolStatus>}
+ */
+async function detectAiToolStatus() {
+  let merged = {};
+  try {
+    merged = await secretsCore.loadSecrets(undefined);
+  } catch {
+    merged = {};
+  }
+  const isSet = (key) => {
+    const raw = merged ? merged[key] : undefined;
+    if (raw === undefined || raw === null) return false;
+    const value = String(raw).trim();
+    if (!value) return false;
+    if (value.startsWith('{{') && value.endsWith('}}')) return false;
+    return true;
+  };
+  return {
+    openAiConfigured: isSet(AI_KEYS.OPENAI_API_KEY),
+    azureOpenAiConfigured:
+      isSet(AI_KEYS.AZURE_OPENAI_URL) && isSet(AI_KEYS.AZURE_OPENAI_API_KEY)
+  };
+}
+
+/**
+ * Ask which AI tool the user wants to configure when none is configured yet.
+ * @async
+ * @returns {Promise<'openai'|'azure'|'skip'>}
+ */
+async function askAiToolChoice() {
+  const { choice } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'choice',
+      message: 'Which AI tool do you want to configure for the dataplane?',
+      choices: [
+        { name: 'OpenAI (api.openai.com)', value: 'openai' },
+        { name: 'Azure OpenAI (your Azure resource)', value: 'azure' },
+        { name: 'Skip for now (set later via aifabrix secret set)', value: 'skip' }
+      ]
+    }
+  ]);
+  return choice;
+}
+
+/**
+ * Collect and persist OpenAI key.
+ * @async
+ * @returns {Promise<void>}
+ */
+async function collectAndSaveOpenAiKey() {
+  const { apiKey } = await inquirer.prompt([
+    {
+      type: 'password',
+      name: 'apiKey',
+      message: 'OpenAI API key:',
+      mask: '*',
+      validate(input) {
+        return String(input || '').trim() ? true : 'API key is required';
+      }
+    }
+  ]);
+  await secretsEnsure.setSecretInStore(AI_KEYS.OPENAI_API_KEY, String(apiKey).trim());
+  logger.log(formatSuccessLine('OpenAI API key saved'));
+}
+
+/**
+ * Collect and persist Azure OpenAI URL + key.
+ * @async
+ * @returns {Promise<void>}
+ */
+async function collectAndSaveAzureOpenAi() {
+  const answers = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'url',
+      message: 'Azure OpenAI endpoint URL (e.g. https://my-aoai.openai.azure.com):',
+      validate(input) {
+        const value = String(input || '').trim();
+        if (!value) return 'Endpoint URL is required';
+        if (!/^https?:\/\//.test(value)) return 'URL must start with http(s)://';
+        return true;
+      }
+    },
+    {
+      type: 'password',
+      name: 'apiKey',
+      message: 'Azure OpenAI API key:',
+      mask: '*',
+      validate(input) {
+        return String(input || '').trim() ? true : 'API key is required';
+      }
+    }
+  ]);
+  await secretsEnsure.setSecretInStore(AI_KEYS.AZURE_OPENAI_URL, String(answers.url).trim());
+  await secretsEnsure.setSecretInStore(AI_KEYS.AZURE_OPENAI_API_KEY, String(answers.apiKey).trim());
+  logger.log(formatSuccessLine('Azure OpenAI endpoint and API key saved'));
+}
+
+/**
+ * Run the AI tool prompt sequence.
+ * Skips silently when either provider is already configured (in any source).
+ *
+ * @async
+ * @param {{ silentIfConfigured?: boolean }} [options]
+ * @returns {Promise<void>}
+ */
+async function promptAiTool(options = {}) {
+  const silentIfConfigured = options && options.silentIfConfigured === true;
+  const status = await detectAiToolStatus();
+  if (status.openAiConfigured) {
+    if (!silentIfConfigured) {
+      logger.log(infoLine('OpenAI key already configured - skipping AI tool prompt.'));
+    }
+    return;
+  }
+  if (status.azureOpenAiConfigured) {
+    if (!silentIfConfigured) {
+      logger.log(infoLine('Azure OpenAI endpoint and key already configured - skipping AI tool prompt.'));
+    }
+    return;
+  }
+  const choice = await askAiToolChoice();
+  if (choice === 'openai') {
+    await collectAndSaveOpenAiKey();
+    return;
+  }
+  if (choice === 'azure') {
+    await collectAndSaveAzureOpenAi();
+    return;
+  }
+  logger.log(
+    chalk.gray(
+      'Skipped. Set later: aifabrix secret set ' +
+        AI_KEYS.OPENAI_API_KEY +
+        ' <key>  (or the two azure-openaiapi-urlKeyVault / secrets-azureOpenaiApiKeyVault keys)'
+    )
+  );
+}
+
+/**
+ * When `aifabrix setup` is about to run `up-platform --force`, it will wipe
+ * platform app directories under `builder/`. If the builder root already
+ * contains files, prompt for how to proceed.
+ *
+ * @async
+ * @param {{
+ *   builderRoot: string,
+ *   totalEntries: number,
+ *   platformApps: string[],
+ *   systemBuilderRoot?: string,
+ *   systemPlatformApps?: string[]
+ * }} info
+ * @returns {Promise<'keep'|'keep-files'|'backup'|'abort'>}
+ */
+async function promptBuilderDirConflict(info) {
+  const builderRoot = info && typeof info.builderRoot === 'string' ? info.builderRoot : 'builder/';
+  const totalEntries = info && Number.isFinite(info.totalEntries) ? info.totalEntries : 0;
+  const platformApps = info && Array.isArray(info.platformApps) ? info.platformApps : [];
+  const sysRoot = info && typeof info.systemBuilderRoot === 'string' ? info.systemBuilderRoot : '';
+  const sysApps = info && Array.isArray(info.systemPlatformApps) ? info.systemPlatformApps : [];
+  const systemNote =
+    sysRoot && sysApps.length > 0
+      ? `\n\nNon-empty platform app folder(s) also exist under:\n  ${sysRoot}/\n  (${sysApps.join(', ')})`
+      : '';
+
+  const warning =
+    'Existing builder folder detected:\n' +
+    `  ${builderRoot}\n\n` +
+    `It contains ${totalEntries} item(s).` +
+    systemNote +
+    '\n\n' +
+    'This setup path will REPLACE the platform app folders under:\n' +
+    `  ${platformApps.map(a => `builder/${a}/`).join('\n  ')}`;
+
+  const { action } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'action',
+      message: `${warning}\n\nHow do you want to proceed?`,
+      choices: [
+        { name: 'Continue (platform app folders will be replaced)', value: BUILDER_DIR_ACTION.KEEP },
+        { name: 'Keep platform app folders and continue (no replacement)', value: BUILDER_DIR_ACTION.KEEP_FILES },
+        { name: 'Backup platform app folders under builder/ and continue (recommended)', value: BUILDER_DIR_ACTION.BACKUP },
+        { name: 'Abort setup (no changes)', value: BUILDER_DIR_ACTION.ABORT }
+      ],
+      default: BUILDER_DIR_ACTION.BACKUP
+    }
+  ]);
+  return action;
+}
+
+module.exports = {
+  MODE,
+  AI_KEYS,
+  BUILDER_DIR_ACTION,
+  promptModeSelection,
+  confirmDestructiveMode,
+  promptAdminCredentials,
+  promptAiTool,
+  detectAiToolStatus,
+  promptBuilderDirConflict
+};

package/lib/commands/setup.js

@@ -0,0 +1,149 @@
+/**
+ * Top-level handler for `aifabrix setup`.
+ *
+ * Decides between:
+ *   - fresh install (no infra running) — wizard for admin creds + AI tool, then up-infra + up-platform.
+ *   - mode menu (infra already running) — dispatch one of four destructive/refresh paths.
+ *
+ * The mode handlers live in `setup-modes.js`; the prompts live in
+ * `setup-prompts.js`. This module is a thin orchestrator so it stays well
+ * under the 50-line/function limit.
+ *
+ * @fileoverview aifabrix setup orchestrator
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+'use strict';
+
+const chalk = require('chalk');
+
+const config = require('../core/config');
+const infra = require('../infrastructure');
+const logger = require('../utils/logger');
+const {
+  formatSuccessParagraph,
+  formatProgress,
+  infoLine
+} = require('../utils/cli-test-layout-chalk');
+
+const setupPrompts = require('./setup-prompts');
+const setupModes = require('./setup-modes');
+
+const MODE = setupPrompts.MODE;
+
+const SEPARATOR = '────────────────────────────────────────';
+
+function title(text) {
+  return chalk.bold(text);
+}
+
+function logSetupHeader() {
+  logger.log('');
+  logger.log(title('AI Fabrix Setup'));
+  logger.log(SEPARATOR);
+  logger.log('');
+}
+
+async function maybePinDeveloperIdForFreshInstall(rawDeveloper) {
+  if (rawDeveloper === undefined || rawDeveloper === null) return;
+  const dev = String(rawDeveloper).trim();
+  if (!dev) return;
+  await config.setDeveloperId(dev);
+  logger.log(infoLine(`Developer ID pinned to ${dev}.`));
+}
+
+async function runFreshInstallFlow(options) {
+  await maybePinDeveloperIdForFreshInstall(options.developer);
+  logger.log(infoLine('No infrastructure detected; starting fresh install.'));
+  const adminCreds = await setupPrompts.promptAdminCredentials();
+  await setupModes.runFreshInstall(adminCreds);
+  logger.log(formatSuccessParagraph('aifabrix setup complete (fresh install).'));
+}
+
+async function runExistingInfraFlow(assumeYes) {
+  const mode = await setupPrompts.promptModeSelection();
+  const proceed = await setupPrompts.confirmDestructiveMode(mode, assumeYes);
+  if (!proceed) {
+    logger.log(chalk.yellow('Aborted by user.'));
+    return;
+  }
+  await dispatchMode(mode);
+  logger.log(formatSuccessParagraph(`aifabrix setup complete (mode: ${mode}).`));
+}
+
+/**
+ * Detect whether any infra service is currently running.
+ * Treats "running" or "healthy" container state as "infra is up".
+ *
+ * @async
+ * @returns {Promise<boolean>}
+ */
+async function isInfraRunning() {
+  let status;
+  try {
+    status = await infra.getInfraStatus();
+  } catch {
+    return false;
+  }
+  if (!status || typeof status !== 'object') return false;
+  return Object.values(status).some(svc => {
+    if (!svc || typeof svc !== 'object') return false;
+    const s = String(svc.status || '').toLowerCase();
+    return s === 'running' || s === 'healthy' || s === 'starting';
+  });
+}
+
+/**
+ * Dispatch a chosen mode handler.
+ * @async
+ * @param {string} mode - One of MODE.* values
+ * @returns {Promise<void>}
+ * @throws {Error} If mode is unknown
+ */
+async function dispatchMode(mode) {
+  switch (mode) {
+  case MODE.REINSTALL:
+    return setupModes.runReinstall();
+  case MODE.WIPE_DATA:
+    return setupModes.runWipeData();
+  case MODE.CLEAN_FILES:
+    return setupModes.runCleanInstallFiles();
+  case MODE.UPDATE_IMAGES:
+    return setupModes.runUpdateImages();
+  default:
+    throw new Error(`Unknown setup mode: ${mode}`);
+  }
+}
+
+/**
+ * Run the setup wizard / dispatcher.
+ *
+ * @async
+ * @function handleSetup
+ * @param {Object} [options] - Commander options
+ * @param {boolean} [options.yes] - Skip destructive confirmation prompts
+ * @param {string} [options.developer] - Pin developer ID before fresh install (fresh path only)
+ * @returns {Promise<void>}
+ * @throws {Error} If a sub-step fails (caller surfaces via handleCommandError)
+ */
+async function handleSetup(options = {}) {
+  const assumeYes = options.yes === true || options.assumeYes === true;
+
+  logSetupHeader();
+
+  logger.log(formatProgress('Detecting current installation state...'));
+  const running = await isInfraRunning();
+
+  if (!running) {
+    await runFreshInstallFlow(options);
+    return;
+  }
+  await runExistingInfraFlow(assumeYes);
+}
+
+module.exports = {
+  handleSetup,
+  isInfraRunning,
+  dispatchMode
+};