@aifabrix/builder 2.49.2 → 2.50.0

package/lib/commands/dev-host-ops.js

@@ -9,50 +9,30 @@ const chalk = require('chalk');
 const logger = require('../utils/logger');
 const { formatSuccessLine } = require('../utils/cli-test-layout-chalk');
 const { getRemoteDevAuth } = require('../utils/remote-dev-auth');
+const { createHostOpsPollHandlers } = require('../utils/host-ops-poll-ui');
+const { buildHostOpsActionLabel, resolveHostOpsTargetLabel } = require('../utils/host-ops-job-labels');
+const { pollHostOpsJobUntilTerminal } = require('./dev-host-ops-poll');
+const { buildJobParams } = require('./dev-host-ops-params');
 const hostOpsApi = require('../api/host-ops.api');
+const { assertHostOpsJobSucceeded } = require('../utils/host-ops-job-result');
 
 const REMOTE_NOT_CONFIGURED_MSG =
   'Remote server is not configured. Set remote-server and run "aifabrix dev init" first.';
 
-const POLL_INTERVAL_MS = 3000;
-const POLL_TIMEOUT_MS = 3 * 60 * 60 * 1000;
-
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
 /**
- * Build job params from Commander options.
+ * @param {string} type
+ * @param {Object} params
  * @param {Object} options
- * @param {string} [developerId]
  * @returns {Object}
  */
-function buildJobParams(options, developerId) {
-  const params = {};
-  const id = developerId || options.developerId || options['developer-id'];
-  if (id) params.developerId = String(id).trim();
-  if (options.include) params.include = options.include;
-  if (options.exclude) params.exclude = options.exclude;
-  if (options.builderVersion || options['builder-version']) {
-    params.builderVersion = options.builderVersion || options['builder-version'];
-  }
-  if (options.adminEmail || options['admin-email']) {
-    params.adminEmail = options.adminEmail || options['admin-email'];
-  }
-  if (options.adminPassword || options['admin-password']) {
-    params.adminPassword = options.adminPassword || options['admin-password'];
-  }
-  if (options.platform) params.platform = options.platform;
-  if (options.installation) params.installation = options.installation;
-  if (options.skipCert || options['skip-cert']) params.skipCert = true;
-  if (options.skipPlatform || options['skip-platform']) params.skipPlatform = true;
-  if (options.skipCli || options['skip-cli']) params.skipCli = true;
-  if (options.check) params.check = true;
-  if (options.failOnBlocked) params.failOnBlocked = true;
-  if (options.timeoutMinutes || options['timeout-minutes']) {
-    params.timeoutMinutes = parseInt(options.timeoutMinutes || options['timeout-minutes'], 10);
-  }
-  return params;
+function buildHostOpsWaitOpts(type, params, options) {
+  return {
+    wait: options.wait !== false,
+    json: Boolean(options.json),
+    jobType: type,
+    targetLabel: resolveHostOpsTargetLabel(params),
+    params
+  };
 }
 
 /**
@@ -70,26 +50,20 @@ async function waitForHostOpsJob(auth, jobId, opts = {}) {
   if (!wait) {
     return { jobId, status: 'pending' };
   }
-  const started = Date.now();
-  while (Date.now() - started < POLL_TIMEOUT_MS) {
-    const job = await hostOpsApi.getHostOpsJob(
-      auth.serverUrl,
-      auth.clientCertPem,
-      jobId,
-      auth.serverCaPem || undefined
-    );
-    if (!json) {
-      logger.log(chalk.gray(`  host-ops job ${jobId}: ${job.status}`));
-    }
-    if (job.status === 'completed' || job.status === 'failed') {
-      if (job.status === 'failed') {
-        throw new Error(job.error || `Host-ops job ${jobId} failed`);
-      }
-      return job;
-    }
-    await sleep(POLL_INTERVAL_MS);
+  const pollContext = {
+    jobType: opts.jobType,
+    targetLabel: opts.targetLabel,
+    params: opts.params,
+    startedAt: Date.now()
+  };
+  const pollUi = json
+    ? { onPollProgress: () => {}, onTransientError: () => {}, finish: () => {} }
+    : createHostOpsPollHandlers(jobId, pollContext);
+  try {
+    return await pollHostOpsJobUntilTerminal(auth, jobId, pollUi, json);
+  } finally {
+    pollUi.finish();
   }
-  throw new Error(`Timed out waiting for host-ops job ${jobId}`);
 }
 
 /**
@@ -135,13 +109,26 @@ async function runHostOpsJob(type, params, options = {}) {
     { type, params },
     auth.serverCaPem || undefined
   );
+  const waitOpts = buildHostOpsWaitOpts(type, params, options);
+  if (options.wait === false) {
+    if (options.json) {
+      logger.log(JSON.stringify({ jobId, status: 'pending', type }, null, 2));
+    } else {
+      const action = buildHostOpsActionLabel(type, waitOpts.targetLabel);
+      logger.log(formatSuccessLine(`${action} queued (job ${jobId}).`));
+    }
+    return { jobId, status: 'pending' };
+  }
   if (options.json) {
-    const job = await waitForHostOpsJob(auth, jobId, { wait: options.wait !== false, json: true });
+    const job = await waitForHostOpsJob(auth, jobId, waitOpts);
+    assertHostOpsJobSucceeded(job);
     logger.log(JSON.stringify(job, null, 2));
     return job;
   }
-  const job = await waitForHostOpsJob(auth, jobId, { wait: options.wait !== false, json: false });
-  logger.log(formatSuccessLine(`Host-ops job ${jobId} completed (${type}).`));
+  const job = await waitForHostOpsJob(auth, jobId, waitOpts);
+  assertHostOpsJobSucceeded(job);
+  const action = buildHostOpsActionLabel(type, waitOpts.targetLabel);
+  logger.log(formatSuccessLine(`${action} completed.`));
   return job;
 }
 
@@ -161,6 +148,63 @@ async function handlePlatformUpdate(developerId, options) {
   await runHostOpsJob('update-dev-platform', params, options);
 }
 
+function logPlatformInstallOutcomes(developerId, job, json) {
+  if (json) {
+    logger.log(JSON.stringify(job, null, 2));
+    return;
+  }
+  if (!Array.isArray(job.outcomes)) {
+    return;
+  }
+  job.outcomes.forEach((row) => {
+    logger.log(`  ${row.linuxUser || developerId}: ${row.overall || row.status}${row.detail ? ` — ${row.detail}` : ''}`);
+  });
+}
+
+async function runPlatformInstallPreflight(auth, params) {
+  const { jobId } = await hostOpsApi.preflightHostOps(
+    auth.serverUrl,
+    auth.clientCertPem,
+    { type: 'install-dev-platform', params },
+    auth.serverCaPem || undefined
+  );
+  return waitForHostOpsJob(auth, jobId, buildHostOpsWaitOpts('install-dev-platform', params, {}));
+}
+
+async function handlePlatformInstallCheck(developerId, params, options) {
+  const auth = await getRemoteDevAuth();
+  if (!auth) throw new Error(REMOTE_NOT_CONFIGURED_MSG);
+  params.check = true;
+  const { jobId } = await hostOpsApi.preflightHostOps(
+    auth.serverUrl,
+    auth.clientCertPem,
+    { type: 'install-dev-platform', params },
+    auth.serverCaPem || undefined
+  );
+  const job = await waitForHostOpsJob(auth, jobId, buildHostOpsWaitOpts('install-dev-platform', params, options));
+  logPlatformInstallOutcomes(developerId, job, options.json);
+  assertHostOpsJobSucceeded(job);
+  return job;
+}
+
+async function confirmPlatformReinstall(developerId, params, options) {
+  const auth = await getRemoteDevAuth();
+  if (!auth) throw new Error(REMOTE_NOT_CONFIGURED_MSG);
+  const preflight = await runPlatformInstallPreflight(auth, { ...params, developerId });
+  if (!platformAlreadyInstalled(preflight.outcomes)) {
+    return null;
+  }
+  const ok = await promptYesNo(
+    `Platform already installed for dev${String(developerId).padStart(2, '0')}. Re-install?`
+  );
+  if (!ok) {
+    logger.log(chalk.gray('Cancelled.'));
+    return preflight;
+  }
+  await runHostOpsJob('reinstall-dev-platform', params, options);
+  return undefined;
+}
+
 async function handlePlatformInstall(developerId, options) {
   if (!developerId) {
     throw new Error('Developer ID is required (positional argument).');
@@ -168,46 +212,13 @@ async function handlePlatformInstall(developerId, options) {
   const params = buildJobParams(options, developerId);
 
   if (options.check) {
-    params.check = true;
-    const auth = await getRemoteDevAuth();
-    if (!auth) throw new Error(REMOTE_NOT_CONFIGURED_MSG);
-    const { jobId } = await hostOpsApi.preflightHostOps(
-      auth.serverUrl,
-      auth.clientCertPem,
-      { type: 'install-dev-platform', params },
-      auth.serverCaPem || undefined
-    );
-    const job = await waitForHostOpsJob(auth, jobId, options);
-    if (options.json) {
-      logger.log(JSON.stringify(job, null, 2));
-    } else if (Array.isArray(job.outcomes)) {
-      job.outcomes.forEach((row) => {
-        logger.log(`  ${row.linuxUser || developerId}: ${row.overall || row.status}${row.detail ? ` — ${row.detail}` : ''}`);
-      });
-    }
-    return job;
+    return handlePlatformInstallCheck(developerId, params, options);
   }
 
   if (!options.force && !options.yes) {
-    const auth = await getRemoteDevAuth();
-    if (!auth) throw new Error(REMOTE_NOT_CONFIGURED_MSG);
-    const { jobId } = await hostOpsApi.preflightHostOps(
-      auth.serverUrl,
-      auth.clientCertPem,
-      { type: 'install-dev-platform', params: { ...params, developerId } },
-      auth.serverCaPem || undefined
-    );
-    const preflight = await waitForHostOpsJob(auth, jobId, { ...options, json: false });
-    if (platformAlreadyInstalled(preflight.outcomes)) {
-      const ok = await promptYesNo(
-        `Platform already installed for dev${String(developerId).padStart(2, '0')}. Re-install?`
-      );
-      if (!ok) {
-        logger.log(chalk.gray('Cancelled.'));
-        return preflight;
-      }
-      await runHostOpsJob('reinstall-dev-platform', params, options);
-      return;
+    const cancelled = await confirmPlatformReinstall(developerId, params, options);
+    if (cancelled) {
+      return cancelled;
     }
   }
 
@@ -230,7 +241,9 @@ async function handleRemoveDevUser(developerId, options) {
 
 module.exports = {
   buildJobParams,
+  buildHostOpsWaitOpts,
   waitForHostOpsJob,
+  runHostOpsJob,
   handlePlatformInstallCli,
   handlePlatformUpdate,
   handlePlatformInstall,

package/lib/commands/dev-init.js

@@ -33,7 +33,7 @@ const {
   isLinuxCaSudoRequiredError
 } = require('../utils/dev-ca-install');
 const { runOptionalHostsSetup } = require('../utils/dev-hosts-helper');
-const { mergeDevSshConfigAfterInit } = require('../utils/dev-init-ssh-merge');
+const { mergeDevSshConfigAfterInit, logDevSshConnectHint } = require('../utils/dev-init-ssh-merge');
 const { resolveInitOptions } = require('../utils/dev-init-resolve');
 const { displayDevConfig } = require('./dev-show-display');
 const {
@@ -426,6 +426,7 @@ async function runCertificateRefresh(auth) {
     warn: (msg) => logger.log(chalk.yellow(`  ⚠ ${msg}`))
   });
   logger.log(formatSuccessLine('Certificate refreshed and config updated from server.\n'));
+  logDevSshConnectHint(await mergeDevSshConfigAfterInit(auth.serverUrl, devId));
 }
 
 /**
@@ -481,6 +482,7 @@ async function runDevRefresh(options = {}) {
     return;
   }
   await fetchAndMergeRemoteSettings(auth, clientCertPem, clientKeyPem, devId);
+  logDevSshConnectHint(await mergeDevSshConfigAfterInit(auth.serverUrl, devId));
 }
 
 module.exports = { runDevInit, runDevRefresh };

package/lib/commands/enterprise-knowledge.js

@@ -0,0 +1,284 @@
+/**
+ * Enterprise Knowledge CLI commands (456.16).
+ *
+ * @fileoverview enterprise-knowledge generate-manifest
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const {
+  existsSync,
+  readFileSync,
+  mkdirSync,
+  writeFileSync
+} = require('../internal/fs-real-sync');
+const path = require('path');
+const chalk = require('chalk');
+const logger = require('../utils/logger');
+const { resolveControllerUrl } = require('../utils/controller-url');
+const { resolveDataplaneAndAuth } = require('./upload');
+const { postGenerateManifest } = require('../api/enterprise-knowledge.api');
+const { getEnterpriseKnowledgePath } = require('../utils/enterprise-knowledge-paths');
+const { resolveAppWorkspace } = require('../utils/app-path-resolve');
+const {
+  formatBlockingError,
+  formatSuccessLine,
+  formatWarningLine,
+  infoLine,
+  headerKeyValue
+} = require('../utils/cli-layout-chalk');
+const { formatApiError } = require('../utils/api-error-handler');
+
+const DOMAIN_PATTERN = /^[a-z][a-z0-9-]*$/;
+const GENERATED_DIR = 'generated-service-contracts';
+const DEFAULT_PREVIEW_FILE = 'generate-manifest-preview.json';
+
+const ENTERPRISE_KNOWLEDGE_HELP_AFTER = `
+
+Examples:
+  $ aifabrix enterprise-knowledge generate-manifest --domain sales
+  $ aifabrix enterprise-knowledge generate-manifest --domain sales --source-system hubspot-e2e
+  $ aifabrix enterprise-knowledge generate-manifest --domain sales --output ./preview.json
+
+Per-command help:  aifabrix enterprise-knowledge <command> --help
+`;
+
+const GENERATE_MANIFEST_HELP_AFTER = `
+
+Examples:
+  $ aifabrix enterprise-knowledge generate-manifest --domain sales
+  $ aifabrix enterprise-knowledge generate-manifest --domain sales --owner-system-key ek-sales
+  $ aifabrix enterprise-knowledge generate-manifest --domain sales --source-system vendor-crm --json
+
+Preview only — review output before upload (candidate) and deploy.
+
+`;
+
+/**
+ * @param {string} raw
+ * @returns {string}
+ */
+function requireDomain(raw) {
+  const domain = String(raw || '').trim().toLowerCase();
+  if (!domain) {
+    throw new Error('--domain is required.');
+  }
+  if (!DOMAIN_PATTERN.test(domain)) {
+    throw new Error(
+      'domain must start with a lowercase letter and contain only lowercase letters, numbers, and hyphens.'
+    );
+  }
+  return domain;
+}
+
+/**
+ * @param {string} domain
+ * @param {string|undefined|null} raw
+ * @returns {string}
+ */
+function resolveOwnerSystemKey(domain, raw) {
+  const key = String(raw || '').trim() || `ek-${domain}`;
+  if (!/^[a-z0-9-_]+$/.test(key)) {
+    throw new Error('owner-system-key must contain only lowercase letters, numbers, hyphens, and underscores.');
+  }
+  return key;
+}
+
+/**
+ * @param {string} ownerSystemKey
+ * @returns {Object[]}
+ */
+function loadAnchorSubscriptions(ownerSystemKey) {
+  try {
+    const { appPath } = resolveAppWorkspace(ownerSystemKey, {
+      workspace: 'enterprise-knowledge'
+    });
+    const systemFile = path.join(appPath, `${ownerSystemKey}-system.json`);
+    if (!existsSync(systemFile)) {
+      return [];
+    }
+    const raw = JSON.parse(readFileSync(systemFile, 'utf8'));
+    return Array.isArray(raw.subscriptions) ? raw.subscriptions : [];
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * @param {Object} options
+ * @param {string} domain
+ * @param {string} ownerSystemKey
+ * @returns {import('../api/types/enterprise-knowledge.types').GenerateManifestRequest}
+ */
+function buildGenerateManifestRequest(options, domain, ownerSystemKey) {
+  if (options.file) {
+    const filePath = path.resolve(String(options.file));
+    if (!existsSync(filePath)) {
+      throw new Error(`File not found: ${filePath}`);
+    }
+    const parsed = JSON.parse(readFileSync(filePath, 'utf8'));
+    if (!parsed || typeof parsed !== 'object') {
+      throw new Error('Request file must be a JSON object.');
+    }
+    return {
+      domain: requireDomain(parsed.domain || domain),
+      ownerSystemKey: resolveOwnerSystemKey(domain, parsed.ownerSystemKey || ownerSystemKey),
+      displayName: parsed.displayName,
+      description: parsed.description,
+      subscriptions: Array.isArray(parsed.subscriptions) ? parsed.subscriptions : [],
+      sourceSystemKeys: Array.isArray(parsed.sourceSystemKeys) ? parsed.sourceSystemKeys : [],
+      version: parsed.version
+    };
+  }
+
+  const sourceKeys = [];
+  if (Array.isArray(options.sourceSystem)) {
+    sourceKeys.push(...options.sourceSystem.map((k) => String(k).trim()).filter(Boolean));
+  } else if (typeof options.sourceSystem === 'string' && options.sourceSystem.trim()) {
+    sourceKeys.push(options.sourceSystem.trim());
+  }
+
+  const subscriptions = loadAnchorSubscriptions(ownerSystemKey);
+  const title = domain.replace(/-/g, ' ').replace(/\b\w/g, (c) => c.toUpperCase());
+
+  return {
+    domain,
+    ownerSystemKey,
+    displayName: options.displayName || `Enterprise Knowledge — ${title}`,
+    description:
+      options.description ||
+      `Domain enterprise-knowledge preview for ${domain}. Human approval required before upload.`,
+    subscriptions,
+    sourceSystemKeys: sourceKeys,
+    version: options.version || '1.0.0'
+  };
+}
+
+/**
+ * @param {string} ownerSystemKey
+ * @param {string|undefined|null} outputOption
+ * @returns {string}
+ */
+function resolveOutputPath(ownerSystemKey, outputOption) {
+  if (outputOption) {
+    return path.resolve(String(outputOption));
+  }
+  const anchorDir = getEnterpriseKnowledgePath(ownerSystemKey);
+  return path.join(anchorDir, GENERATED_DIR, DEFAULT_PREVIEW_FILE);
+}
+
+/**
+ * @param {import('../api/types/enterprise-knowledge.types').GenerateManifestResponse} preview
+ * @returns {void}
+ */
+function logPreviewSummary(preview) {
+  headerKeyValue('Enterprise Knowledge manifest preview', preview.ownerSystemKey);
+  infoLine('Status', preview.previewOnly ? 'preview only (not published)' : 'unexpected');
+  infoLine('Version', preview.version || '1.0.0');
+  infoLine('Generated datasources', String((preview.externalDataSources || []).length));
+  const compilerCount = (preview.compilerFindings || []).length;
+  const trustCount = (preview.trustFindings || []).length;
+  if (compilerCount > 0) {
+    formatWarningLine(`${compilerCount} compiler finding(s) require review`);
+  }
+  if (trustCount > 0) {
+    formatWarningLine(`${trustCount} trust finding(s) require review`);
+  }
+  if (preview.message) {
+    logger.log(chalk.gray(preview.message));
+  }
+}
+
+/**
+ * @param {Object} options
+ * @returns {Promise<void>}
+ */
+async function runGenerateManifestCommand(options) {
+  const domain = requireDomain(options.domain);
+  const ownerSystemKey = resolveOwnerSystemKey(domain, options.ownerSystemKey);
+  const body = buildGenerateManifestRequest(options, domain, ownerSystemKey);
+
+  const { dataplaneUrl, authConfig } = await resolveDataplaneAndAuth(ownerSystemKey, {
+    silent: true
+  });
+  const controllerUrl = await resolveControllerUrl();
+
+  let preview;
+  try {
+    preview = await postGenerateManifest(dataplaneUrl, authConfig, body, { controllerUrl });
+  } catch (error) {
+    throw new Error(formatApiError(error, dataplaneUrl));
+  }
+
+  if (options.json) {
+    logger.log(JSON.stringify(preview, null, 2));
+    return;
+  }
+
+  const outputPath = resolveOutputPath(ownerSystemKey, options.output);
+  mkdirSync(path.dirname(outputPath), { recursive: true });
+  writeFileSync(outputPath, `${JSON.stringify(preview, null, 2)}\n`, 'utf8');
+
+  logPreviewSummary(preview);
+  formatSuccessLine(`Preview written to ${outputPath}`);
+  logger.log(chalk.gray('Review and edit before upload (candidate) and deploy.'));
+}
+
+/**
+ * @param {import('commander').Command} ek
+ * @returns {void}
+ */
+function setupGenerateManifestCommand(ek) {
+  ek.command('generate-manifest')
+    .description('Preview full Enterprise Knowledge manifest from published Connected Systems')
+    .addHelpText('after', GENERATE_MANIFEST_HELP_AFTER)
+    .requiredOption('--domain <domain>', 'Business domain slug (e.g. sales)')
+    .option('--owner-system-key <key>', 'Enterprise Knowledge anchor key (default ek-<domain>)')
+    .option('--source-system <key>', 'Published Connected System key (repeatable)', collectValues, [])
+    .option('--display-name <name>', 'Enterprise Knowledge display name override')
+    .option('--description <text>', 'Enterprise Knowledge description override')
+    .option('--version <semver>', 'Manifest version label', '1.0.0')
+    .option('--file <path>', 'Full request JSON (overrides built-in body)')
+    .option('--output <path>', 'Write preview JSON to this path')
+    .option('--json', 'Print preview JSON to stdout instead of writing a file')
+    .action(async(options) => {
+      try {
+        await runGenerateManifestCommand(options);
+      } catch (error) {
+        formatBlockingError(error.message || String(error));
+        process.exit(1);
+      }
+    });
+}
+
+/**
+ * @param {string} value
+ * @param {string[]} previous
+ * @returns {string[]}
+ */
+function collectValues(value, previous) {
+  return previous.concat([value]);
+}
+
+/**
+ * @param {import('commander').Command} program
+ * @returns {void}
+ */
+function setupEnterpriseKnowledgeCommands(program) {
+  const ek = program
+    .command('enterprise-knowledge')
+    .description('Enterprise Knowledge authoring helpers')
+    .addHelpText('after', ENTERPRISE_KNOWLEDGE_HELP_AFTER);
+  setupGenerateManifestCommand(ek);
+}
+
+module.exports = {
+  setupEnterpriseKnowledgeCommands,
+  runGenerateManifestCommand,
+  buildGenerateManifestRequest,
+  resolveOutputPath,
+  requireDomain,
+  resolveOwnerSystemKey
+};