@aifabrix/builder 2.40.2 → 2.42.0

package/lib/commands/datasource.js

@@ -2,7 +2,7 @@
  * AI Fabrix Builder - Datasource Commands
  *
  * Handles datasource validation, listing, comparison, and deployment
- * Commands: datasource validate, datasource list, datasource diff, datasource deploy
+ * Commands: datasource validate, datasource list, datasource diff, datasource upload
  *
  * @fileoverview Datasource management commands for AI Fabrix Builder
  * @author AI Fabrix Team
@@ -15,6 +15,9 @@ const { validateDatasourceFile } = require('../datasource/validate');
 const { listDatasources } = require('../datasource/list');
 const { compareDatasources } = require('../datasource/diff');
 const { deployDatasource } = require('../datasource/deploy');
+const { runDatasourceTestIntegration } = require('../datasource/test-integration');
+const { runDatasourceTestE2E } = require('../datasource/test-e2e');
+const { displayIntegrationTestResults, displayE2EResults } = require('../utils/external-system-display');
 
 function setupDatasourceValidateCommand(datasource) {
   datasource.command('validate <file>')
@@ -62,14 +65,80 @@ function setupDatasourceDiffCommand(datasource) {
     });
 }
 
-function setupDatasourceDeployCommand(datasource) {
-  datasource.command('deploy <myapp> <file>')
-    .description('Deploy datasource to dataplane')
+function setupDatasourceUploadCommand(datasource) {
+  datasource.command('upload <myapp> <file>')
+    .description('Upload datasource to dataplane')
     .action(async(myapp, file, options) => {
       try {
         await deployDatasource(myapp, file, options);
       } catch (error) {
-        logger.error(chalk.red('❌ Deployment failed:'), error.message);
+        logger.error(chalk.red('❌ Upload failed:'), error.message);
+        process.exit(1);
+      }
+    });
+}
+
+function setupDatasourceTestIntegrationCommand(datasource) {
+  datasource.command('test-integration <datasourceKey>')
+    .description('Run integration (config) test for one datasource via dataplane pipeline')
+    .option('-a, --app <appKey>', 'App key (default: resolve from cwd if inside integration/<appKey>/)')
+    .option('-p, --payload <file>', 'Path to custom test payload file')
+    .option('-e, --env <env>', 'Environment: dev, tst, or pro')
+    .option('--debug', 'Include debug output and write log to integration/<appKey>/logs/')
+    .option('--timeout <ms>', 'Request timeout in milliseconds', '30000')
+    .action(async(datasourceKey, options) => {
+      try {
+        const result = await runDatasourceTestIntegration(datasourceKey, {
+          app: options.app,
+          payload: options.payload,
+          environment: options.env,
+          debug: options.debug,
+          timeout: options.timeout
+        });
+        displayIntegrationTestResults({
+          systemKey: result.systemKey || 'unknown',
+          datasourceResults: [result],
+          success: result.success
+        }, options.verbose);
+        if (!result.success) process.exit(1);
+      } catch (error) {
+        logger.error(chalk.red('❌ Integration test failed:'), error.message);
+        process.exit(1);
+      }
+    });
+}
+
+function setupDatasourceTestE2ECommand(datasource) {
+  datasource.command('test-e2e <datasourceKey>')
+    .description('Run E2E test for one datasource (config, credential, sync, data, CIP) via dataplane')
+    .option('-a, --app <appKey>', 'App key (default: resolve from cwd if inside integration/<appKey>/)')
+    .option('-e, --env <env>', 'Environment: dev, tst, or pro')
+    .option('-v, --verbose', 'Show detailed step output and poll progress')
+    .option('--debug', 'Include debug output and write log to integration/<appKey>/logs/')
+    .option('--test-crud', 'Enable CRUD lifecycle test (body testCrud: true)')
+    .option('--record-id <id>', 'Record ID for test (body recordId)')
+    .option('--no-cleanup', 'Disable cleanup after test (body cleanup: false)')
+    .option('--primary-key-value <value|@path>', 'Primary key value or path to JSON file (e.g. @pk.json) for body primaryKeyValue')
+    .option('--no-async', 'Use sync mode (no polling); single POST, no asyncRun')
+    .action(async(datasourceKey, options) => {
+      try {
+        const data = await runDatasourceTestE2E(datasourceKey, {
+          app: options.app,
+          environment: options.env,
+          debug: options.debug,
+          verbose: options.verbose,
+          async: options.async !== false,
+          testCrud: options.testCrud,
+          recordId: options.recordId,
+          cleanup: options.cleanup,
+          primaryKeyValue: options.primaryKeyValue
+        });
+        displayE2EResults(data, options.verbose);
+        const steps = data.steps || data.completedActions || [];
+        const failed = data.success === false || steps.some(s => s.success === false || s.error);
+        if (failed) process.exit(1);
+      } catch (error) {
+        logger.error(chalk.red('❌ E2E test failed:'), error.message);
         process.exit(1);
       }
     });
@@ -84,7 +153,9 @@ function setupDatasourceCommands(program) {
   setupDatasourceValidateCommand(datasource);
   setupDatasourceListCommand(datasource);
   setupDatasourceDiffCommand(datasource);
-  setupDatasourceDeployCommand(datasource);
+  setupDatasourceUploadCommand(datasource);
+  setupDatasourceTestIntegrationCommand(datasource);
+  setupDatasourceTestE2ECommand(datasource);
 }
 
 module.exports = { setupDatasourceCommands };

package/lib/commands/dev-cli-handlers.js

@@ -0,0 +1,141 @@
+/**
+ * @fileoverview CLI action handlers for dev list/add/update/pin/delete (remote Builder Server)
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const chalk = require('chalk');
+const config = require('../core/config');
+const logger = require('../utils/logger');
+const devApi = require('../api/dev.api');
+const { getRemoteDevAuth } = require('../utils/remote-dev-auth');
+
+const REMOTE_NOT_CONFIGURED_MSG = 'Remote server is not configured. Set remote-server and run "aifabrix dev init" first.';
+
+const ID_WIDTH = 8;
+const NAME_WIDTH = 25;
+const EMAIL_WIDTH = 30;
+const CERT_WIDTH = 10;
+const UNTIL_WIDTH = 22; // 2026-03-20T17:31:14
+const TABLE_SEPARATOR_LENGTH = 130;
+
+/**
+ * Format certificate validity end for display (e.g. 2026-03-20T17:31:14.000Z -> 2026-03-20T17:31:14).
+ * @param {string} iso - ISO 8601 date string
+ * @returns {string} Truncated datetime without milliseconds and Z
+ */
+function formatCertUntil(iso) {
+  if (!iso || typeof iso !== 'string') return '?';
+  return iso.replace(/\.\d{3}Z?$/i, '').trim();
+}
+
+/**
+ * Handle dev list – list developer users (remote only). Table format, sorted by name.
+ * @returns {Promise<void>}
+ */
+async function handleDevList() {
+  const auth = await getRemoteDevAuth();
+  if (!auth) {
+    logger.log(chalk.yellow(REMOTE_NOT_CONFIGURED_MSG));
+    return;
+  }
+  const users = await devApi.listUsers(auth.serverUrl, auth.clientCertPem);
+  if (users.length === 0) {
+    logger.log(chalk.gray('No developers registered.'));
+    return;
+  }
+  logger.log(chalk.bold('\n📋 Developers:\n'));
+  logger.log(chalk.gray('ID'.padEnd(ID_WIDTH) + 'Name'.padEnd(NAME_WIDTH) + 'Email'.padEnd(EMAIL_WIDTH) + 'Cert'.padEnd(CERT_WIDTH) + 'Until'.padEnd(UNTIL_WIDTH) + 'Groups'));
+  logger.log(chalk.gray('-'.repeat(TABLE_SEPARATOR_LENGTH)));
+  const sorted = [...users].sort((a, b) => (a.name || '').localeCompare(b.name || '', undefined, { sensitivity: 'base' }));
+  sorted.forEach(u => {
+    const certLabel = u.certificateIssued ? 'yes' : 'no cert';
+    const untilRaw = u.certificateIssued && u.certificateValidNotAfter ? u.certificateValidNotAfter : null;
+    const untilStr = untilRaw ? formatCertUntil(untilRaw) : '-';
+    const id = String(u.id ?? '').padEnd(ID_WIDTH);
+    const name = (u.name || 'N/A').padEnd(NAME_WIDTH);
+    const email = (u.email || 'N/A').padEnd(EMAIL_WIDTH);
+    const cert = certLabel.padEnd(CERT_WIDTH);
+    const until = untilStr.padEnd(UNTIL_WIDTH);
+    const groups = (u.groups || []).join(', ');
+    logger.log(`${id}${name}${email}${cert}${until}${groups}`);
+  });
+  logger.log('');
+}
+
+/**
+ * Handle dev add – create developer (remote only).
+ * @param {Object} options - Commander options (developerId, name, email, groups)
+ * @returns {Promise<void>}
+ */
+async function handleDevAdd(options) {
+  const auth = await getRemoteDevAuth();
+  if (!auth) throw new Error(REMOTE_NOT_CONFIGURED_MSG);
+  const groups = (options.groups || 'developer').split(',').map(s => s.trim()).filter(Boolean);
+  const user = await devApi.createUser(auth.serverUrl, auth.clientCertPem, {
+    developerId: options.developerId,
+    name: options.name,
+    email: options.email,
+    groups: groups.length ? groups : ['developer']
+  });
+  logger.log(chalk.green(`✓ Developer ${user.id} created. Use "aifabrix dev pin ${user.id}" to create a PIN for onboarding.`));
+}
+
+/**
+ * Handle dev update – update developer (remote only).
+ * @param {string} developerId - Developer ID
+ * @param {Object} options - Commander options (name, email, groups)
+ * @returns {Promise<void>}
+ */
+async function handleDevUpdate(developerId, options) {
+  const auth = await getRemoteDevAuth();
+  if (!auth) throw new Error(REMOTE_NOT_CONFIGURED_MSG);
+  const id = options.developerId || options['developer-id'] || developerId;
+  if (!id) throw new Error('Developer ID is required (--developer-id or positional argument).');
+  const body = {};
+  if (options.name) body.name = options.name;
+  if (options.email) body.email = options.email;
+  if (options.groups) body.groups = options.groups.split(',').map(s => s.trim()).filter(Boolean);
+  if (Object.keys(body).length === 0) {
+    throw new Error('Provide at least one of --name, --email, --groups');
+  }
+  await devApi.updateUser(auth.serverUrl, auth.clientCertPem, id, body);
+  logger.log(chalk.green(`✓ Developer ${id} updated.`));
+}
+
+/**
+ * Handle dev pin – create/regenerate PIN (remote only).
+ * @param {string} [developerId] - Developer ID (optional; uses config if omitted)
+ * @returns {Promise<void>}
+ */
+async function handleDevPin(developerId) {
+  const auth = await getRemoteDevAuth();
+  if (!auth) throw new Error(REMOTE_NOT_CONFIGURED_MSG);
+  const id = developerId || await config.getDeveloperId();
+  if (!id) throw new Error('developerId is required (argument or set developer-id in config)');
+  const res = await devApi.createPin(auth.serverUrl, auth.clientCertPem, id);
+  logger.log(chalk.green(`✓ PIN created for ${id}, expires ${res.expiresAt}.`));
+  logger.log(chalk.yellow(`  Give this PIN once to the developer for: aifabrix dev init --developer-id ${id} --server ${auth.serverUrl} --pin ${res.pin}`));
+}
+
+/**
+ * Handle dev delete – remove developer (remote only).
+ * @param {string} developerId - Developer ID
+ * @returns {Promise<void>}
+ */
+async function handleDevDelete(developerId) {
+  const auth = await getRemoteDevAuth();
+  if (!auth) throw new Error(REMOTE_NOT_CONFIGURED_MSG);
+  const id = developerId;
+  if (!id) throw new Error('Developer ID is required (positional argument or --developer-id).');
+  await devApi.deleteUser(auth.serverUrl, auth.clientCertPem, id);
+  logger.log(chalk.green(`✓ Developer ${id} removed.`));
+}
+
+module.exports = {
+  handleDevList,
+  handleDevAdd,
+  handleDevUpdate,
+  handleDevPin,
+  handleDevDelete
+};

package/lib/commands/dev-down.js

@@ -0,0 +1,114 @@
+/**
+ * dev down – stop Mutagen sync sessions and optionally app containers for this developer.
+ *
+ * @fileoverview Dev down command (plan 65: stop sync sessions; optional stop apps)
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const { exec } = require('child_process');
+const { promisify } = require('util');
+const chalk = require('chalk');
+const logger = require('../utils/logger');
+const config = require('../core/config');
+const appLib = require('../app');
+
+const execAsync = promisify(exec);
+
+/**
+ * Stop Mutagen sync sessions for this developer (session names aifabrix-<dev-id>-*).
+ * When Mutagen is not available or no sessions exist, no-op.
+ * @param {string} developerId - Developer ID
+ * @returns {Promise<void>}
+ */
+async function stopMutagenSessions(developerId) {
+  const { getMutagenPath } = require('../utils/mutagen');
+  const mutagenPath = await getMutagenPath();
+  if (!mutagenPath) {
+    logger.log(chalk.gray('Mutagen not installed; no sync sessions to stop.'));
+    return;
+  }
+  try {
+    const { stdout } = await execAsync(`"${mutagenPath}" sync list --template '{{.Name}}'`, {
+      encoding: 'utf8',
+      timeout: 5000
+    });
+    const sessions = (stdout || '').trim().split('\n').filter(Boolean);
+    const prefix = `aifabrix-${developerId}-`;
+    const toTerminate = sessions.filter(name => name.startsWith(prefix));
+    for (const name of toTerminate) {
+      await execAsync(`"${mutagenPath}" sync terminate "${name}"`, { timeout: 5000 });
+      logger.log(chalk.green(`  ✓ Stopped sync session: ${name}`));
+    }
+    if (toTerminate.length === 0 && sessions.length > 0) {
+      logger.log(chalk.gray('No sync sessions for this developer.'));
+    } else if (toTerminate.length === 0) {
+      logger.log(chalk.gray('No Mutagen sync sessions to stop.'));
+    }
+  } catch (err) {
+    logger.log(chalk.gray('No Mutagen sync sessions to stop.'));
+  }
+}
+
+const INFRA_SUFFIXES = ['-postgres', '-redis', '-pgadmin', '-redis-commander', '-traefik', '-db-init'];
+
+/**
+ * List running app container names for this developer (excludes infra containers).
+ * @param {string} developerId - Developer ID
+ * @returns {Promise<string[]>} Container names (e.g. aifabrix-dev1-myapp)
+ */
+async function listAppContainersForDeveloper(developerId) {
+  const idNum = parseInt(developerId, 10);
+  const filter = idNum === 0 ? 'aifabrix-' : `aifabrix-dev${developerId}-`;
+  const { stdout } = await execAsync(
+    `docker ps --filter "name=${filter}" --format "{{.Names}}"`,
+    { encoding: 'utf8' }
+  );
+  const names = (stdout || '').trim().split('\n').filter(Boolean);
+  return names.filter(n => !INFRA_SUFFIXES.some(s => n.endsWith(s)));
+}
+
+/**
+ * Extract app name from container name (aifabrix-dev1-myapp -> myapp, aifabrix-myapp -> myapp).
+ * @param {string} containerName - Container name
+ * @param {string} developerId - Developer ID
+ * @returns {string} App name
+ */
+function appNameFromContainer(containerName, developerId) {
+  const idNum = parseInt(developerId, 10);
+  const prefix = idNum === 0 ? 'aifabrix-' : `aifabrix-dev${developerId}-`;
+  return containerName.startsWith(prefix) ? containerName.slice(prefix.length) : containerName;
+}
+
+/**
+ * Handle dev down: stop Mutagen sessions; optionally stop app containers.
+ * @param {Object} options - { apps: boolean }
+ * @returns {Promise<void>}
+ */
+async function handleDevDown(options = {}) {
+  const developerId = await config.getDeveloperId();
+  logger.log(chalk.blue('\nStopping dev resources for developer ' + developerId + '...\n'));
+
+  await stopMutagenSessions(developerId);
+
+  if (options.apps) {
+    const containers = await listAppContainersForDeveloper(developerId);
+    for (const containerName of containers) {
+      const appName = appNameFromContainer(containerName, developerId);
+      if (!appName) continue;
+      try {
+        await appLib.downApp(appName, {});
+        logger.log(chalk.green(`  ✓ Stopped app: ${appName}`));
+      } catch (err) {
+        logger.log(chalk.yellow(`  ⚠ Could not stop ${appName}: ${err.message}`));
+      }
+    }
+    if (containers.length === 0) {
+      logger.log(chalk.gray('No running app containers for this developer.'));
+    }
+  }
+
+  logger.log(chalk.green('\n✓ dev down complete.\n'));
+}
+
+module.exports = { handleDevDown };