@aifabrix/builder 2.54.1 → 2.55.0

package/lib/search/search-run.js

@@ -0,0 +1,241 @@
+/**
+ * Orchestrate aifabrix search and aifabrix search skills.
+ *
+ * @fileoverview Search command run path (retrieve only)
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const fs = require('../internal/fs-real-sync');
+const logger = require('../utils/logger');
+const { getWorkRoles, getWorkSkills, searchWork } = require('../api/work-search.api');
+const { resolveSearchDataplaneContext } = require('./dataplane-context');
+const { SearchCliError, authRequiredError } = require('./search-errors');
+const { buildSearchBody, roleRefFromOptions, resourceTypeFromOptions } = require('./search-args');
+const {
+  skillsEnvelope,
+  resourceTypesMap,
+  typeSpec,
+  isOperationRequired,
+  assertTypePublished,
+  assertOperationPublished
+} = require('./search-skills');
+const {
+  isInteractive,
+  missingFlagsError,
+  promptRoleAssistant,
+  promptResourceType,
+  promptOperation
+} = require('./search-prompts');
+const { emitSearchSuccess, emitSkillsSuccess } = require('./search-display');
+
+/**
+ * @param {Object} [overrides]
+ * @returns {Object}
+ */
+function defaultDeps(overrides = {}) {
+  return {
+    resolveContext: resolveSearchDataplaneContext,
+    getWorkRoles,
+    getWorkSkills,
+    searchWork,
+    prompt: (qs) => require('inquirer').prompt(qs),
+    logger,
+    isTty: () => Boolean(process.stdin && process.stdin.isTTY),
+    fsApi: fs,
+    ...overrides
+  };
+}
+
+/**
+ * @param {Object} options
+ * @param {Function} resolveContext
+ * @returns {Promise<Object>}
+ */
+async function resolveContextOrThrow(options, resolveContext) {
+  try {
+    return await resolveContext(options);
+  } catch (err) {
+    const message = err.message || String(err);
+    if (/login|auth|token|controller url/i.test(message)) {
+      throw authRequiredError(message);
+    }
+    throw new SearchCliError(message);
+  }
+}
+
+/**
+ * @param {Object} options
+ */
+function assertScriptSearchFlags(options) {
+  const missing = [];
+  if (!roleRefFromOptions(options)) missing.push('--role');
+  if (!resourceTypeFromOptions(options)) missing.push('--resource-type');
+  if (missing.length) {
+    throw missingFlagsError(missing);
+  }
+}
+
+/**
+ * @param {Object} res
+ * @param {string} fallback
+ * @returns {Object}
+ */
+function payloadOrThrow(res, fallback) {
+  if (res && Number(res.status) === 200) {
+    const payload = skillsEnvelope(res.payload);
+    return payload && typeof payload === 'object' ? payload : {};
+  }
+  const text = String((res && res.errorText) || '').trim() || fallback;
+  throw new SearchCliError(text);
+}
+
+/**
+ * @param {Object} options
+ * @param {Object} ctx
+ * @param {Object} deps
+ * @returns {Promise<string>}
+ */
+async function resolveRoleRef(options, ctx, deps) {
+  const existing = roleRefFromOptions(options);
+  if (existing) {
+    return existing;
+  }
+  return promptRoleAssistant(ctx, deps);
+}
+
+/**
+ * @param {string} explicitType
+ * @param {string[]} typeKeys
+ * @param {Object} typeMap
+ * @param {boolean} interactive
+ * @param {Object} deps
+ * @returns {Promise<string>}
+ */
+async function resolveResourceType(explicitType, typeKeys, typeMap, interactive, deps) {
+  if (!typeKeys.length) {
+    throw new SearchCliError('No searchable resource types for this Role Assistant.');
+  }
+  if (explicitType) {
+    assertTypePublished(explicitType, typeMap);
+    return explicitType;
+  }
+  if (!interactive) {
+    throw missingFlagsError(['--resource-type']);
+  }
+  return promptResourceType(typeKeys, deps);
+}
+
+/**
+ * @param {string} explicitOp
+ * @param {Object} spec
+ * @param {boolean} interactive
+ * @param {Object} deps
+ * @returns {Promise<string>}
+ */
+async function resolveOperation(explicitOp, spec, interactive, deps) {
+  if (explicitOp) {
+    assertOperationPublished(explicitOp, spec);
+    return explicitOp;
+  }
+  if (isOperationRequired(spec) && !interactive) {
+    throw new SearchCliError(
+      'Operation is required for this resource type. Pass --operation.'
+    );
+  }
+  if (!interactive) {
+    return '';
+  }
+  return promptOperation(spec, deps);
+}
+
+/**
+ * @param {Object} body
+ * @param {Object} skillsPayload
+ * @param {Object} options
+ * @param {Object} deps
+ * @returns {Promise<Object>}
+ */
+async function fillTypeAndOperation(body, skillsPayload, options, deps) {
+  const typeMap = resourceTypesMap(skillsPayload);
+  const typeKeys = Object.keys(typeMap);
+  const interactive = isInteractive(options, deps.isTty);
+  const resourceType = await resolveResourceType(
+    body.resourceType || '',
+    typeKeys,
+    typeMap,
+    interactive,
+    deps
+  );
+  body.resourceType = resourceType;
+  const spec = typeSpec(typeMap, resourceType);
+  const operation = await resolveOperation(body.operation || '', spec, interactive, deps);
+  if (operation) {
+    body.operation = operation;
+  } else {
+    delete body.operation;
+  }
+  if (isOperationRequired(spec) && !body.operation) {
+    throw new SearchCliError(
+      'Operation is required for this resource type. Pass --operation.'
+    );
+  }
+  return body;
+}
+
+/**
+ * @param {Object} options
+ * @param {Object} [depOverrides]
+ * @returns {Promise<number>}
+ */
+async function runSearch(options, depOverrides) {
+  const deps = defaultDeps(depOverrides);
+  const body = buildSearchBody(options, deps.fsApi);
+  const interactive = isInteractive(options, deps.isTty);
+  if (!interactive) {
+    assertScriptSearchFlags(options);
+  }
+  const ctx = await resolveContextOrThrow(options, deps.resolveContext);
+  if (!body.roleRef) {
+    body.roleRef = await resolveRoleRef(options, ctx, deps);
+  }
+  const skillsRes = await deps.getWorkSkills(ctx.dataplaneUrl, ctx.authConfig, body.roleRef);
+  const skillsPayload = payloadOrThrow(skillsRes, 'Unable to load search skills.');
+  await fillTypeAndOperation(body, skillsPayload, options, deps);
+  const searchRes = await deps.searchWork(ctx.dataplaneUrl, ctx.authConfig, body);
+  const payload = payloadOrThrow(searchRes, 'Search request failed.');
+  emitSearchSuccess(options, body, payload, deps.logger, deps.fsApi);
+  return 0;
+}
+
+/**
+ * @param {Object} options
+ * @param {Object} [depOverrides]
+ * @returns {Promise<number>}
+ */
+async function runSearchSkills(options, depOverrides) {
+  const deps = defaultDeps(depOverrides);
+  const interactive = isInteractive(options, deps.isTty);
+  if (!interactive && !roleRefFromOptions(options)) {
+    throw missingFlagsError(['--role']);
+  }
+  const ctx = await resolveContextOrThrow(options, deps.resolveContext);
+  const roleRef = await resolveRoleRef(options, ctx, deps);
+  const skillsRes = await deps.getWorkSkills(ctx.dataplaneUrl, ctx.authConfig, roleRef);
+  const payload = payloadOrThrow(skillsRes, 'Unable to load search skills.');
+  if (!payload.roleRef) {
+    payload.roleRef = roleRef;
+  }
+  emitSkillsSuccess(options, payload, deps.logger, deps.fsApi);
+  return 0;
+}
+
+module.exports = {
+  defaultDeps,
+  runSearch,
+  runSearchSkills,
+  fillTypeAndOperation,
+  resolveRoleRef
+};

package/lib/search/search-skills.js

@@ -0,0 +1,198 @@
+/**
+ * YAML-free copies of work.skills helpers (do not import the test runner).
+ *
+ * @fileoverview Resource type / operation keys from a skills payload
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const { SearchCliError } = require('./search-errors');
+
+/** Table retrieve keys stamped by the search grammar (list/search page, get one). */
+const RETRIEVE_TABLE_KEYS = new Set(['list', 'get', 'search']);
+
+/**
+ * @param {*} item
+ * @returns {string}
+ */
+function operationKeyFromItem(item) {
+  if (typeof item === 'string' && item.trim()) {
+    return item.trim();
+  }
+  if (item && typeof item === 'object') {
+    return String(item.key || '').trim();
+  }
+  return '';
+}
+
+/**
+ * @param {*} item
+ * @returns {boolean}
+ */
+function hasResultMode(item) {
+  return Boolean(item && typeof item === 'object' && String(item.resultMode || '').trim());
+}
+
+/**
+ * Retrieve/analyze only. Write-shaped keys stay off search.
+ * Keep table retrieve keys (list/get/search) and named views (source viewpoint).
+ *
+ * @param {*} item
+ * @param {boolean} grammarPresent
+ * @param {boolean} tableRetrievePresent
+ * @returns {boolean}
+ */
+function isRetrieveOperation(item, grammarPresent, tableRetrievePresent) {
+  const key = operationKeyFromItem(item);
+  if (!key) {
+    return false;
+  }
+  if (RETRIEVE_TABLE_KEYS.has(key)) {
+    return true;
+  }
+  if (typeof item === 'string') {
+    return !tableRetrievePresent;
+  }
+  const source = String((item && item.source) || '')
+    .trim()
+    .toLowerCase();
+  if (source === 'viewpoint') {
+    return true;
+  }
+  if (!source && !grammarPresent && !tableRetrievePresent) {
+    return true;
+  }
+  return false;
+}
+
+/**
+ * @param {Object|null|undefined} spec
+ * @returns {*[]}
+ */
+function operationItems(spec) {
+  return Array.isArray(spec && spec.operations) ? spec.operations : [];
+}
+
+/**
+ * @param {Object|null|undefined} spec
+ * @returns {string[]}
+ */
+function operationKeys(spec) {
+  const raw = operationItems(spec);
+  const grammarPresent = raw.some(hasResultMode);
+  const tableRetrievePresent = raw.some((item) =>
+    RETRIEVE_TABLE_KEYS.has(operationKeyFromItem(item))
+  );
+  const keys = [];
+  for (const item of raw) {
+    if (!isRetrieveOperation(item, grammarPresent, tableRetrievePresent)) {
+      continue;
+    }
+    const key = operationKeyFromItem(item);
+    if (key) {
+      keys.push(key);
+    }
+  }
+  return keys;
+}
+
+/**
+ * @param {Object|null|undefined} spec
+ * @returns {string[]}
+ */
+function allOperationKeys(spec) {
+  return operationItems(spec).map(operationKeyFromItem).filter(Boolean);
+}
+
+/**
+ * work.skills is an object. MCP execute may wrap it as a one-element array.
+ * @param {*} skillsPayload
+ * @returns {Object|null}
+ */
+function skillsEnvelope(skillsPayload) {
+  let cur = skillsPayload;
+  if (Array.isArray(cur) && cur.length === 1 && cur[0] && typeof cur[0] === 'object') {
+    cur = cur[0];
+  }
+  if (!cur || typeof cur !== 'object' || Array.isArray(cur)) {
+    return null;
+  }
+  if (cur.search && typeof cur.search === 'object') {
+    return cur;
+  }
+  if (cur.data && typeof cur.data === 'object' && !Array.isArray(cur.data) && cur.data.search) {
+    return cur.data;
+  }
+  return cur;
+}
+
+/**
+ * @param {Object|null|undefined} skillsPayload
+ * @returns {Object}
+ */
+function resourceTypesMap(skillsPayload) {
+  const root = skillsEnvelope(skillsPayload);
+  const rts = root && root.search && root.search.resourceTypes;
+  return rts && typeof rts === 'object' && !Array.isArray(rts) ? rts : {};
+}
+
+/**
+ * @param {Object} typeMap
+ * @param {string} resourceType
+ * @returns {Object}
+ */
+function typeSpec(typeMap, resourceType) {
+  const spec = typeMap && typeMap[resourceType];
+  return spec && typeof spec === 'object' ? spec : {};
+}
+
+/**
+ * @param {Object} spec
+ * @returns {boolean}
+ */
+function isOperationRequired(spec) {
+  return spec && spec.operationRequired === true;
+}
+
+/**
+ * @param {string} resourceType
+ * @param {Object} typeMap
+ */
+function assertTypePublished(resourceType, typeMap) {
+  if (!Object.prototype.hasOwnProperty.call(typeMap, resourceType)) {
+    throw new SearchCliError(
+      `Resource type "${resourceType}" is not published for this Role Assistant.`
+    );
+  }
+}
+
+/**
+ * @param {string} operation
+ * @param {Object} spec
+ */
+function assertOperationPublished(operation, spec) {
+  const keys = operationKeys(spec);
+  if (keys.includes(operation)) {
+    return;
+  }
+  if (allOperationKeys(spec).includes(operation)) {
+    throw new SearchCliError(
+      `Operation "${operation}" is not a retrieve operation for this resource type.`
+    );
+  }
+  throw new SearchCliError(
+    `Operation "${operation}" is not published for this resource type.`
+  );
+}
+
+module.exports = {
+  operationKeys,
+  skillsEnvelope,
+  resourceTypesMap,
+  typeSpec,
+  isOperationRequired,
+  assertTypePublished,
+  assertOperationPublished
+};

package/lib/utils/authentication-slot-show.js

@@ -0,0 +1,153 @@
+/**
+ * Connected System credential line for `aifabrix show` (usage slots + online/offline).
+ *
+ * @fileoverview TTY formatter for authentications[] / legacy authentication
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const chalk = require('chalk');
+const { getAuthMethodFromAuthentication } = require('./authentication-shape');
+
+/** Same labels as the dataplane Connected System authentication tab. */
+const AUTHENTICATION_USAGE_LABELS = Object.freeze({
+  api: 'API calls',
+  webhookInbound: 'Webhook inbound',
+  syncExecution: 'Sync execution',
+  messageInbound: 'Message inbound',
+  messageOutbound: 'Message outbound',
+  callback: 'Callback',
+  provisioning: 'Provisioning'
+});
+
+/**
+ * @param {string} method
+ * @param {string} glyph
+ * @returns {string}
+ */
+function chalkGlyph(method, glyph) {
+  const fn = chalk[method];
+  return typeof fn === 'function' ? fn(glyph) : glyph;
+}
+
+/**
+ * @param {string|null|undefined} status
+ * @returns {string}
+ */
+function formatOnlineOfflineIcon(status) {
+  const raw = String(status || 'offline').trim().toLowerCase();
+  if (raw === 'online') return chalkGlyph('green', '✔');
+  if (raw === 'partially') return chalkGlyph('yellow', '⚠');
+  return chalkGlyph('red', '✖');
+}
+
+/**
+ * @param {unknown} value
+ * @returns {Object|null}
+ */
+function asObject(value) {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : null;
+}
+
+/**
+ * @param {Object} slot
+ * @returns {string}
+ */
+function formatSlotType(slot) {
+  const authType = String(slot.authType || '').trim().toLowerCase();
+  if (authType === 'system' || authType === 'none') return authType;
+  if (authType === 'apiprovider') return 'apiProvider';
+  const method = getAuthMethodFromAuthentication(slot);
+  if (method) return method;
+  const nested = asObject(slot.credential);
+  const nestedMethod = nested && typeof nested.method === 'string' ? nested.method.trim() : '';
+  return nestedMethod || authType || '—';
+}
+
+/**
+ * @param {Object} slot
+ * @param {string|null|undefined} systemStatus
+ * @returns {string}
+ */
+function slotStatus(slot, systemStatus) {
+  const authType = String(slot.authType || '').trim().toLowerCase();
+  if (authType === 'system' || authType === 'none') return 'online';
+  return systemStatus || 'offline';
+}
+
+/**
+ * @param {Object} slot
+ * @param {string|null|undefined} systemStatus
+ * @param {boolean} includeUsage
+ * @returns {string}
+ */
+function formatOneSlot(slot, systemStatus, includeUsage) {
+  const type = formatSlotType(slot);
+  const icon = formatOnlineOfflineIcon(slotStatus(slot, systemStatus));
+  if (!includeUsage) return `${type}  ${icon}`;
+  const usage = String(slot.usage || 'api').trim() || 'api';
+  const label = AUTHENTICATION_USAGE_LABELS[usage] || usage;
+  return `${label}: ${type} ${icon}`;
+}
+
+/**
+ * @param {unknown} entry
+ * @returns {Object|null}
+ */
+function normalizeSlot(entry) {
+  const obj = asObject(entry);
+  if (!obj) return null;
+  const key = typeof obj.key === 'string' && obj.key.trim() ? obj.key.trim() : 'default';
+  const usage = typeof obj.usage === 'string' && obj.usage.trim() ? obj.usage.trim() : 'api';
+  return { ...obj, key, usage };
+}
+
+/**
+ * @param {Object|null|undefined} config
+ * @param {Object|null|undefined} system
+ * @returns {Object[]}
+ */
+function resolveAuthenticationSlots(config, system) {
+  const cfg = asObject(config) || {};
+  const sys = asObject(system) || {};
+  const fromCfg = Array.isArray(cfg.authentications) && cfg.authentications.length > 0
+    ? cfg.authentications
+    : null;
+  const fromSys = Array.isArray(sys.authentications) && sys.authentications.length > 0
+    ? sys.authentications
+    : null;
+  const rawSlots = fromCfg || fromSys;
+  if (rawSlots) return rawSlots.map(normalizeSlot).filter(Boolean);
+  const legacy = asObject(cfg.authentication) || asObject(sys.authentication);
+  if (!legacy) return [];
+  return [normalizeSlot({ ...legacy, key: 'default', usage: 'api' })];
+}
+
+/**
+ * One slot: `oauth2  ✔`. Several: `API calls: oauth2 ✔, Webhook inbound: hmac ✔`.
+ * @param {Object} ext
+ * @returns {string}
+ */
+function formatCredentialShowLine(ext) {
+  if (!ext || typeof ext !== 'object') return '—';
+  const slots = Array.isArray(ext.authenticationSlots) ? ext.authenticationSlots : [];
+  const status = ext.authenticationStatus;
+  if (slots.length === 1) return formatOneSlot(slots[0], status, false);
+  if (slots.length > 1) {
+    return slots.map((slot) => formatOneSlot(slot, status, true)).join(', ');
+  }
+  const method = typeof ext.credentialMethod === 'string' ? ext.credentialMethod.trim() : '';
+  if (method && method.toLowerCase() !== 'unknown') {
+    return `${method}  ${formatOnlineOfflineIcon(status)}`;
+  }
+  return '—';
+}
+
+module.exports = {
+  AUTHENTICATION_USAGE_LABELS,
+  resolveAuthenticationSlots,
+  formatCredentialShowLine,
+  formatOnlineOfflineIcon
+};

package/lib/utils/credential-display.js

@@ -8,6 +8,7 @@
  */
 
 const chalk = require('chalk');
+const { formatCredentialShowLine } = require('./authentication-slot-show');
 
 /** @type {{ verified: string, pending: string, failed: string, expired: string }} */
 const STATUS_ICONS = {
@@ -74,10 +75,51 @@ function formatCredentialWithStatus(credential) {
   return { key, name, statusFormatted, statusLabel };
 }
 
+/**
+ * @param {unknown[]} values
+ * @returns {string|null}
+ */
+function firstNonEmptyScalar(values) {
+  for (const value of values) {
+    if (typeof value === 'number') return String(value);
+    if (typeof value === 'string' && value.trim()) return value.trim();
+  }
+  return null;
+}
+
+/**
+ * Identity from a dataplane credential id or ForeignKeyReference. Never `[object Object]`.
+ * @param {unknown} value
+ * @returns {string|null}
+ */
+function formatCredentialIdentity(value) {
+  if (value === null || value === undefined || value === '') return null;
+  if (typeof value !== 'object') return String(value);
+  return firstNonEmptyScalar([
+    value.name,
+    value.displayName,
+    value.key,
+    value.id,
+    value.credentialKey,
+    value.credentialId
+  ]);
+}
+
+/**
+ * Scalar credential id/key for show output. Objects must not print as [object Object].
+ * @param {unknown} value
+ * @returns {string}
+ */
+function formatCredentialIdValue(value) {
+  return formatCredentialIdentity(value) || '—';
+}
+
 module.exports = {
   STATUS_ICONS,
   STATUS_LABELS,
   STATUS_CHALK,
   formatCredentialStatus,
-  formatCredentialWithStatus
+  formatCredentialWithStatus,
+  formatCredentialIdValue,
+  formatCredentialShowLine
 };

package/lib/utils/external-system-readiness-compact-blocks.js

@@ -75,7 +75,11 @@ function logUploadReadinessSummaryCompact(ctx) {
   const genMcp = publication?.generateMcpContract !== false;
   const tierA = summarizeDatasourceTiersA(publication?.datasources || [], genMcp);
   const systemCfg = manifest?.system || {};
-  const statusLabel = resolveConnectedSystemStatus({ publication });
+  const statusLabel = resolveConnectedSystemStatus({
+    command: 'upload',
+    publication,
+    systemFromDataplane: ctx.systemFromDataplane
+  });
 
   logCompactHeader({ command: 'upload', systemKey, environment, dataplaneUrl });
   if (forcePublish) {