@aifabrix/builder 2.53.0 → 2.54.1

package/bin/aifabrix.js

@@ -17,6 +17,7 @@ const { Command } = require('commander');
 const cli = require('../lib/cli');
 const logger = require('../lib/utils/logger');
 const { buildCategorizedHelp } = require('../lib/utils/help-builder');
+const { rewriteClusteredNameFlag } = require('../lib/utils/rewrite-name-flag');
 const packageJson = require('../package.json');
 
 /**
@@ -47,8 +48,7 @@ More:
     return buildCategorizedHelp(program) + ROOT_HELP_FOOTER;
   };
 
-  // Parse command line arguments
-  program.parse();
+  program.parse(rewriteClusteredNameFlag(process.argv));
 }
 
 // TODO: Add error handling for CLI initialization

package/lib/api/assistants.api.js

@@ -8,20 +8,23 @@
 
 const { createDataplaneApiClient } = require('./index');
 
+function encodeAssistantPathKey(assistantKey) {
+  return encodeURIComponent(String(assistantKey || '').trim());
+}
+
 /**
  * GET /api/v1/admin/assistants/{assistantKey}
  * @async
  * @function getAssistantDetails
  * @param {string} dataplaneUrl - Dataplane base URL
- * @param {string} assistantKey - Role Assistant / digital worker key
+ * @param {string} assistantKey - Digital worker system key (exact; never rewritten)
  * @param {Object} authConfig - Auth config for dataplane client
  * @returns {Promise<Object>} API response
  * @requiresPermission {Dataplane} worker:read
  */
 async function getAssistantDetails(dataplaneUrl, assistantKey, authConfig) {
   const client = createDataplaneApiClient(dataplaneUrl, authConfig);
-  const key = encodeURIComponent(String(assistantKey || '').trim());
-  return await client.get(`/api/v1/admin/assistants/${key}`);
+  return await client.get(`/api/v1/admin/assistants/${encodeAssistantPathKey(assistantKey)}`);
 }
 
 /**
@@ -29,7 +32,7 @@ async function getAssistantDetails(dataplaneUrl, assistantKey, authConfig) {
  * @async
  * @function updateAssistantSettings
  * @param {string} dataplaneUrl
- * @param {string} assistantKey
+ * @param {string} assistantKey - Digital worker system key (exact; never rewritten)
  * @param {Object} authConfig
  * @param {Object} body - AssistantSettingsUpdate fields
  * @returns {Promise<Object>}
@@ -37,7 +40,7 @@ async function getAssistantDetails(dataplaneUrl, assistantKey, authConfig) {
  */
 async function updateAssistantSettings(dataplaneUrl, assistantKey, authConfig, body) {
   const client = createDataplaneApiClient(dataplaneUrl, authConfig);
-  const key = encodeURIComponent(String(assistantKey || '').trim());
+  const key = encodeAssistantPathKey(assistantKey);
   return await client.patch(`/api/v1/admin/assistants/${key}/settings`, { body });
 }
 

package/lib/api/channel-identity.api.js

@@ -0,0 +1,41 @@
+/**
+ * Dataplane channel identity mapping API.
+ *
+ * @fileoverview Admin batch upsert for Slack/Teams → platform user ids
+ */
+
+'use strict';
+
+const { createDataplaneApiClient } = require('./index');
+
+const MAPPINGS_ENDPOINT = '/api/v1/assistant/channel-identity/mappings';
+
+/**
+ * Upsert channel_user_identity rows (matched pairs only).
+ * @requiresPermission {Dataplane} worker:update
+ * @async
+ * @param {string} dataplaneUrl
+ * @param {Object} authConfig
+ * @param {{ sourceChannel: string, items: Array<{ externalUserId: string, platformUserId: string }> }} body
+ * @returns {Promise<{ sourceChannel?: string, linked?: number }>}
+ */
+async function upsertChannelIdentityMappings(dataplaneUrl, authConfig, body) {
+  if (!dataplaneUrl || typeof dataplaneUrl !== 'string') {
+    throw new Error('dataplaneUrl is required and must be a string');
+  }
+  const items = body && Array.isArray(body.items) ? body.items : [];
+  if (items.length === 0) {
+    return { sourceChannel: body && body.sourceChannel, linked: 0 };
+  }
+  const client = createDataplaneApiClient(dataplaneUrl, authConfig);
+  return await client.post(MAPPINGS_ENDPOINT, {
+    body: {
+      sourceChannel: body.sourceChannel,
+      items
+    }
+  });
+}
+
+module.exports = {
+  upsertChannelIdentityMappings
+};

package/lib/api/evidence-authoring.api.js

@@ -10,6 +10,7 @@ const { createDataplaneApiClient } = require('./index');
 const { listEvidenceKinds } = require('./evidence-kinds.api');
 const { listResourceTypes } = require('./resource-types.api');
 const { getAssistantDetails } = require('./assistants.api');
+const { roleAssistantSystemKey } = require('../utils/role-assistant-paths');
 const {
   listEvidence,
   loadEvidenceBulk,
@@ -191,8 +192,11 @@ async function getEvidenceMetadata(dataplaneUrl, authConfig, roleKey, options =
     throw new Error('controllerUrl is required for evidence.metadata');
   }
 
+  // Evidence.roleKey is the business role. Assistant HTTP uses the digital-worker
+  // system key (ra-{roleKey}), which is a different resource than a connected system.
+  const assistantKey = roleAssistantSystemKey(normalizedRoleKey) || normalizedRoleKey;
   const [assistantDetails, evidenceKindsRes, resourceTypesRes, evidenceRows] = await Promise.all([
-    getAssistantDetails(dataplaneUrl, normalizedRoleKey, authConfig),
+    getAssistantDetails(dataplaneUrl, assistantKey, authConfig),
     listEvidenceKinds(options.controllerUrl, authConfig, { page: 1, pageSize: 500 }),
     listResourceTypes(options.controllerUrl, authConfig, { page: 1, pageSize: 500 }),
     listEvidence(dataplaneUrl, authConfig, { roleKey: normalizedRoleKey }, options)

package/lib/api/evidence.api.js

@@ -62,6 +62,8 @@ async function listEvidence(dataplaneUrl, authConfig, params = {}, options = {})
   if (params.roleKey) query.roleKey = params.roleKey;
   if (params.genericOnly === true) query.genericOnly = true;
   if (params.status) query.status = params.status;
+  if (params.page) query.page = params.page;
+  if (params.pageSize) query.pageSize = params.pageSize;
   const res = assertApiSuccess(
     await client.get(BASE, { params: query }),
     'List evidence'

package/lib/api/types/evidence.types.js

@@ -111,6 +111,8 @@
  * @property {string} [search]
  * @property {number} [limit]
  * @property {number} [offset]
+ * @property {number} [page]
+ * @property {number} [pageSize]
  */
 
 /**

package/lib/api/work-search.api.js

@@ -0,0 +1,136 @@
+/**
+ * Layer B work.skills / work.search client for role-assistant test cases.
+ *
+ * @fileoverview Execute governed Role Assistant search tools via Dataplane MCP
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const { createDataplaneApiClient } = require('./index');
+const { unwrapApiData } = require('../utils/external-system-readiness-core');
+
+const SEARCH_TIMEOUT_MS = 120000;
+const LAYER_B_SYSTEM_KEY = process.env.RUNTIME_ORCHESTRATION_SYSTEM_KEY || 'runtime-orchestration';
+const LAYER_B_TOOLS = Object.freeze({
+  skills: { resourceType: 'work-skills', toolName: 'work_skills.get' },
+  search: { resourceType: 'work-search', toolName: 'work_search.create' }
+});
+
+function buildLayerBExecutePath(tool) {
+  const systemKey = encodeURIComponent(LAYER_B_SYSTEM_KEY);
+  const resourceType = encodeURIComponent(tool.resourceType);
+  const toolName = encodeURIComponent(tool.toolName);
+  return `/api/v1/mcp/servers/${systemKey}/${resourceType}/tools/${toolName}/execute`;
+}
+
+function pushText(parts, value) {
+  if (typeof value === 'string' && value.trim()) {
+    parts.push(value.trim());
+  }
+}
+
+function extractErrorText(res) {
+  const parts = [];
+  pushText(parts, res && res.error);
+  pushText(parts, res && res.formattedError);
+  const data = res && res.errorData;
+  if (data && typeof data === 'object') {
+    pushText(parts, data.error);
+    pushText(parts, data.detail);
+    pushText(parts, data.title);
+    pushText(parts, data.message);
+  }
+  return parts.join(' ');
+}
+
+function unwrapExecutePayload(res) {
+  const body = unwrapApiData(res);
+  if (!body || typeof body !== 'object') {
+    return body;
+  }
+  if (body.result && typeof body.result === 'object') {
+    return body.result;
+  }
+  if (body.json && typeof body.json === 'object') {
+    return body.json;
+  }
+  if (body.root && typeof body.root === 'object') {
+    return body.root;
+  }
+  return body;
+}
+
+function normalizeLayerBResult(res) {
+  const status = Number(res && (res.status || res.statusCode)) || (res && res.success === false ? 0 : 200);
+  const payload = unwrapExecutePayload(res);
+  const errorText = res && res.success === false ? extractErrorText(res) : '';
+  return {
+    status,
+    payload,
+    errorText,
+    raw: res
+  };
+}
+
+/**
+ * Execute a Layer B MCP tool.
+ * POST /api/v1/mcp/servers/{system}/{resourceType}/tools/{tool}/execute
+ * @requiresPermission {Dataplane} Authenticated (oauth2: [])
+ * @async
+ * @param {string} dataplaneUrl
+ * @param {Object} authConfig
+ * @param {{ resourceType: string, toolName: string }} tool
+ * @param {Object} [args]
+ * @returns {Promise<{ status: number, payload: Object|null, errorText: string, raw: Object }>}
+ */
+async function executeLayerBTool(dataplaneUrl, authConfig, tool, args = {}) {
+  const client = createDataplaneApiClient(dataplaneUrl, authConfig);
+  const res = await client.post(buildLayerBExecutePath(tool), {
+    body: { arguments: args && typeof args === 'object' ? args : {} },
+    timeoutMs: SEARCH_TIMEOUT_MS
+  });
+  return normalizeLayerBResult(res);
+}
+
+/**
+ * GET-equivalent work.skills for one roleRef.
+ * Requests detail=full so search.resourceTypes (executable grammar) is present.
+ * Compact summary omits that slice and cannot evaluate named viewpoint ops.
+ * @requiresPermission {Dataplane} Authenticated (oauth2: [])
+ * @async
+ */
+async function getWorkSkills(dataplaneUrl, authConfig, roleRef) {
+  return executeLayerBTool(dataplaneUrl, authConfig, LAYER_B_TOOLS.skills, {
+    roleRef: String(roleRef || '').trim(),
+    detail: 'full'
+  });
+}
+
+/**
+ * POST-equivalent work.search for one roleRef.
+ * @requiresPermission {Dataplane} Authenticated (oauth2: [])
+ * @async
+ */
+async function searchWork(dataplaneUrl, authConfig, body) {
+  return executeLayerBTool(
+    dataplaneUrl,
+    authConfig,
+    LAYER_B_TOOLS.search,
+    body && typeof body === 'object' ? body : {}
+  );
+}
+
+module.exports = {
+  LAYER_B_SYSTEM_KEY,
+  LAYER_B_TOOLS,
+  SEARCH_TIMEOUT_MS,
+  buildLayerBExecutePath,
+  extractErrorText,
+  unwrapExecutePayload,
+  normalizeLayerBResult,
+  executeLayerBTool,
+  getWorkSkills,
+  searchWork
+};