@aifabrix/builder 2.51.1 → 2.52.1

package/lib/role-assistant/test-runner-workhub.js

@@ -23,6 +23,10 @@ const {
   alreadyResponded,
   buildRespondPayload
 } = require('./test-runner-workhub-answers');
+const {
+  shouldApplyBidAfterWait,
+  applyCaseBidViaBuilderApi
+} = require('./test-runner-bid-apply');
 
 const TERMINAL_TASK = new Set(['completed', 'failed', 'cancelled', 'canceled']);
 const PLAN_LOST_RE =
@@ -180,23 +184,34 @@ async function createActivateAcceptPlan(dataplaneUrl, authConfig, planBody, assi
   throw lastError || new Error('Work Hub plan create/activate/accept failed.');
 }
 
-async function maybeApproveTask(dataplaneUrl, authConfig, taskId, ctx) {
+function _approveGateDecision(ctx) {
   if (ctx.approveStopped) {
-    return;
+    return 'skip';
   }
   const status = String(ctx.status || '').trim().toLowerCase();
   if (status !== 'pendingapproval' && status !== 'pending_approval') {
-    return;
+    return 'skip';
   }
   const approvalState = String(ctx.taskRow?.approvalState || '').trim().toLowerCase();
-  if (approvalState && approvalState !== 'pending') {
-    ctx.approveStopped = true;
-    return;
+  // Treat empty / pending* as still actionable. Stop only after a terminal decision.
+  const terminalDecision = new Set([
+    'approved',
+    'rejected',
+    'cancelled',
+    'canceled',
+    'notrequired',
+    'not_required'
+  ]);
+  if (approvalState && terminalDecision.has(approvalState)) {
+    return 'stop';
   }
   if ((Number(ctx.approveAttempts) || 0) >= 8) {
-    ctx.approveStopped = true;
-    return;
+    return 'stop';
   }
+  return 'run';
+}
+
+async function _attemptApproveTask(dataplaneUrl, authConfig, taskId, ctx) {
   try {
     await approveWorkTask(dataplaneUrl, authConfig, taskId, {});
     ctx.interactions.push({ type: 'approve', taskId, attempt: ctx.approveAttempts });
@@ -211,46 +226,126 @@ async function maybeApproveTask(dataplaneUrl, authConfig, taskId, ctx) {
   }
 }
 
+async function maybeApproveTask(dataplaneUrl, authConfig, taskId, ctx) {
+  const gate = _approveGateDecision(ctx);
+  if (gate === 'skip') {
+    return;
+  }
+  if (gate === 'stop') {
+    ctx.approveStopped = true;
+    return;
+  }
+  await _attemptApproveTask(dataplaneUrl, authConfig, taskId, ctx);
+}
+
+function recordSkippedResponse(interactions, peId, fingerprint, wait) {
+  interactions.push({
+    type: 'respond-skipped',
+    processExecutionId: peId,
+    fingerprint,
+    questionKey: wait.questionKey || wait.requestKey || null,
+    objectRefKind: wait.objectRef?.kind || null,
+    reason: 'no-matching-answer-or-synthesis'
+  });
+}
+
+async function applyBidAfterWait(authConfig, testCase, interactions, peId) {
+  try {
+    const { loadCaseBidDocument } = require('./test-runner-workhub-answers');
+    const emittedBid = loadCaseBidDocument(testCase);
+    if (emittedBid && emittedBid.meta && emittedBid.meta.suiteRunId) {
+      interactions.push({
+        type: 'bid-emit',
+        processExecutionId: peId,
+        suiteRunId: emittedBid.meta.suiteRunId,
+        definitionId: emittedBid.definitionId,
+        definitionHash: emittedBid.definitionHash
+      });
+    }
+    const applied = await applyCaseBidViaBuilderApi(authConfig, testCase);
+    interactions.push({
+      type: 'bid-apply',
+      processExecutionId: peId,
+      systemKey: applied && applied.systemKey,
+      definitionHash: applied && applied.definitionHash,
+      suiteRunId: applied && applied.suiteRunId,
+      status: applied && applied.status
+    });
+  } catch (applyErr) {
+    interactions.push({
+      type: 'bid-apply-error',
+      processExecutionId: peId,
+      error: applyErr.message || String(applyErr)
+    });
+  }
+}
+
+async function respondToWaitingExecution(
+  dataplaneUrl,
+  authConfig,
+  peId,
+  testCase,
+  interactions,
+  statusRow
+) {
+  const wait = statusRow.wait && typeof statusRow.wait === 'object' ? statusRow.wait : {};
+  const fingerprint = waitRespondFingerprint(wait);
+  if (alreadyResponded(interactions, fingerprint)) {
+    return;
+  }
+  const payload = buildRespondPayload(
+    peId,
+    wait,
+    testCase,
+    statusRow,
+    interactions,
+    resolveObjective(testCase)
+  );
+  if (!payload) {
+    recordSkippedResponse(interactions, peId, fingerprint, wait);
+    return;
+  }
+  await respondWorkExecution(dataplaneUrl, authConfig, peId, payload);
+  await continueWorkExecution(dataplaneUrl, authConfig, peId, {});
+  interactions.push({ type: 'respond', processExecutionId: peId, fingerprint });
+  if (shouldApplyBidAfterWait(testCase, wait)) {
+    await applyBidAfterWait(authConfig, testCase, interactions, peId);
+  }
+}
+
 async function maybeRespondWaiting(dataplaneUrl, authConfig, taskRow, testCase, interactions) {
   const peId = extractPeFromTask(taskRow);
   if (!peId) {
     return;
   }
   try {
+    testCase._activeProcessExecutionId = peId;
     const statusRow = await getWorkExecutionStatus(dataplaneUrl, authConfig, peId);
     if (String(statusRow?.status || '').toLowerCase() !== 'waiting') {
       return;
     }
-    const wait = statusRow.wait && typeof statusRow.wait === 'object' ? statusRow.wait : {};
-    const fingerprint = waitRespondFingerprint(wait);
-    if (alreadyResponded(interactions, fingerprint)) {
-      return;
-    }
-    const payload = buildRespondPayload(
+    await respondToWaitingExecution(
+      dataplaneUrl,
+      authConfig,
       peId,
-      wait,
       testCase,
-      statusRow,
       interactions,
-      resolveObjective(testCase)
+      statusRow
     );
-    if (!payload) {
-      return;
-    }
-    await respondWorkExecution(dataplaneUrl, authConfig, peId, payload);
-    await continueWorkExecution(dataplaneUrl, authConfig, peId, {});
-    interactions.push({ type: 'respond', processExecutionId: peId, fingerprint });
   } catch (_err) {
     // Soft: continue polling task.
   }
 }
 
-function assertTerminalWorkHubTask(last, taskId, timeoutMs) {
+function assertTerminalWorkHubTask(last, taskId, timeoutMs, options = {}) {
   if (!last) {
     throw new Error(`Work Hub task ${taskId} produced no status rows.`);
   }
   const finalStatusToken = String(last?.status || last?.taskStatus || '').trim().toLowerCase();
   if (!TERMINAL_TASK.has(finalStatusToken)) {
+    if (options.soft === true) {
+      return last;
+    }
     throw new Error(
       `Work Hub task ${taskId} did not reach a terminal status within ${timeoutMs}ms (last=${finalStatusToken || 'unknown'}).`
     );
@@ -261,6 +356,7 @@ function assertTerminalWorkHubTask(last, taskId, timeoutMs) {
 async function pollWorkHubTask(dataplaneUrl, authConfig, taskId, testCase, options) {
   const timeoutMs = Number(options.pollTimeoutMs) || 180000;
   const intervalMs = Number(options.pollIntervalMs) || 3000;
+  const soft = testCase?.expected?.soft === true;
   const started = Date.now();
   let last = null;
   const timeline = [];
@@ -287,7 +383,7 @@ async function pollWorkHubTask(dataplaneUrl, authConfig, taskId, testCase, optio
   }
 
   return {
-    finalTask: assertTerminalWorkHubTask(last, taskId, timeoutMs),
+    finalTask: assertTerminalWorkHubTask(last, taskId, timeoutMs, { soft }),
     timeline,
     interactions: ctx.interactions
   };

package/lib/role-assistant/test-suite.js

@@ -0,0 +1,119 @@
+/**
+ * Role Assistant suite discovery for multi-case CLI runs.
+ * @fileoverview Discover YAML cases under tests/role-assistant/ra-* suite folders
+ */
+
+'use strict';
+
+const path = require('path');
+const fs = require('../internal/fs-real-sync');
+const { bareRoleKey } = require('../utils/role-assistant-paths');
+
+function loadNodeFs() {
+  if (global.__AIFABRIX_NODE_FS_UNMOCKED__) {
+    return global.__AIFABRIX_NODE_FS_UNMOCKED__;
+  }
+  return typeof jest !== 'undefined' && typeof jest.requireActual === 'function'
+    ? jest.requireActual('node:fs')
+    : require('node:fs');
+}
+
+const nodeFs = loadNodeFs();
+
+function exists(p) {
+  return nodeFs.existsSync(p) || fs.existsSync(p);
+}
+
+function readdir(p) {
+  if (nodeFs.existsSync(p)) {
+    return nodeFs.readdirSync(p, { withFileTypes: true });
+  }
+  return fs.readdirSync(p).map((name) => ({
+    name,
+    isDirectory: () => fs.statSync(path.join(p, name)).isDirectory()
+  }));
+}
+
+/**
+ * Resolve cases root for a role: prefer tests/role-assistant/ra-{bare}, else package tests/.
+ * @param {string} roleKey
+ * @param {{ casesRoot?: string, cwd?: string }} [options]
+ * @returns {string}
+ */
+function resolveCasesRoot(roleKey, options = {}) {
+  if (options.casesRoot) {
+    return path.resolve(String(options.casesRoot));
+  }
+  const cwd = options.cwd || process.cwd();
+  const bare = bareRoleKey(roleKey);
+  const preferred = path.join(cwd, 'tests', 'role-assistant', `ra-${bare}`);
+  if (exists(preferred)) {
+    return preferred;
+  }
+  const packageTests = path.join(cwd, 'role-assistant', `ra-${bare}`, 'tests');
+  if (exists(packageTests)) {
+    return packageTests;
+  }
+  return preferred;
+}
+
+/**
+ * @param {string} casesRoot
+ * @param {{ suite?: string }} [options]
+ * @returns {Array<{ suite: string, file: string, absPath: string, caseIdHint: string }>}
+ */
+function discoverSuiteCaseFiles(casesRoot, options = {}) {
+  if (!exists(casesRoot)) {
+    return [];
+  }
+  const suiteFilter = options.suite ? String(options.suite).trim() : '';
+  const rows = [];
+  for (const ent of readdir(casesRoot)) {
+    if (!ent.isDirectory() || String(ent.name).startsWith('.')) {
+      continue;
+    }
+    if (suiteFilter && ent.name !== suiteFilter) {
+      continue;
+    }
+    const suitePath = path.join(casesRoot, ent.name);
+    for (const fileEnt of readdir(suitePath)) {
+      const name = fileEnt.name || fileEnt;
+      if (typeof name !== 'string' || !/\.(ya?ml)$/i.test(name)) {
+        continue;
+      }
+      const absPath = path.join(suitePath, name);
+      rows.push({
+        suite: ent.name,
+        file: name,
+        absPath,
+        caseIdHint: path.basename(name, path.extname(name))
+      });
+    }
+  }
+  return rows.sort((a, b) => a.absPath.localeCompare(b.absPath));
+}
+
+/**
+ * Filter discovered rows by --case id or basename.
+ * @param {Array<{ absPath: string, caseIdHint: string, file: string }>} rows
+ * @param {string} caseSel
+ * @returns {Array}
+ */
+function filterDiscoveredCases(rows, caseSel) {
+  const sel = String(caseSel || '').trim();
+  if (!sel) {
+    return rows;
+  }
+  return rows.filter((row) => {
+    if (row.absPath === path.resolve(sel) || row.file === sel) {
+      return true;
+    }
+    return row.caseIdHint === sel || row.caseIdHint.endsWith(`-${sel}`) || sel === row.caseIdHint;
+  });
+}
+
+module.exports = {
+  resolveCasesRoot,
+  discoverSuiteCaseFiles,
+  filterDiscoveredCases
+};

package/lib/schema/application-schema.json

@@ -7,12 +7,12 @@
     "key": "application-schema",
     "name": "Application Configuration Schema",
     "description": "JSON schema for validating AI Fabrix application configuration files",
-    "version": "1.6.0",
+    "version": "1.6.2",
     "type": "schema",
     "category": "infrastructure",
     "author": "AI Fabrix Team",
     "createdAt": "2024-01-01T00:00:00Z",
-    "updatedAt": "2026-07-28T00:00:00Z",
+    "updatedAt": "2026-08-06T00:00:00Z",
     "compatibility": {
       "minVersion": "1.0.0",
       "maxVersion": "2.0.0",
@@ -30,6 +30,22 @@
       "external-datasource.schema.json"
     ],
     "changelog": [
+      {
+        "version": "1.6.2",
+        "date": "2026-08-06T00:00:00Z",
+        "changes": [
+          "portalInput.options items may be plain strings (including empty for env-default) or {label, value} objects (matches miso-ui Configuration tab and miso-controller types)."
+        ],
+        "breaking": false
+      },
+      {
+        "version": "1.6.1",
+        "date": "2026-08-03T00:00:00Z",
+        "changes": [
+          "registryMode external no longer restricts configuration item names to DOCKER_REGISTRY_SERVER_*; external is image pull source only and full env/portal configuration remains valid."
+        ],
+        "breaking": false
+      },
       {
         "version": "1.6.0",
         "date": "2026-07-28T00:00:00Z",
@@ -273,9 +289,30 @@
               },
               "options": {
                 "type": "array",
-                "description": "Options for select fields",
+                "description": "Options for select fields (plain string or {label, value}; empty string allowed for env-default)",
                 "items": {
-                  "type": "string"
+                  "oneOf": [
+                    {
+                      "type": "string"
+                    },
+                    {
+                      "type": "object",
+                      "required": [
+                        "label",
+                        "value"
+                      ],
+                      "properties": {
+                        "label": {
+                          "type": "string",
+                          "minLength": 1
+                        },
+                        "value": {
+                          "type": "string"
+                        }
+                      },
+                      "additionalProperties": false
+                    }
+                  ]
                 }
               }
             },
@@ -391,9 +428,30 @@
                     },
                     "options": {
                       "type": "array",
-                      "description": "Options for select fields",
+                      "description": "Options for select fields (plain string or {label, value}; empty string allowed for env-default)",
                       "items": {
-                        "type": "string"
+                        "oneOf": [
+                          {
+                            "type": "string"
+                          },
+                          {
+                            "type": "object",
+                            "required": [
+                              "label",
+                              "value"
+                            ],
+                            "properties": {
+                              "label": {
+                                "type": "string",
+                                "minLength": 1
+                              },
+                              "value": {
+                                "type": "string"
+                              }
+                            },
+                            "additionalProperties": false
+                          }
+                        ]
                       }
                     }
                   },
@@ -974,32 +1032,6 @@
           "databases"
         ]
       }
-    },
-    {
-      "if": {
-        "properties": {
-          "registryMode": {
-            "const": "external"
-          }
-        }
-      },
-      "then": {
-        "properties": {
-          "configuration": {
-            "items": {
-              "properties": {
-                "name": {
-                  "enum": [
-                    "DOCKER_REGISTRY_SERVER_URL",
-                    "DOCKER_REGISTRY_SERVER_USERNAME",
-                    "DOCKER_REGISTRY_SERVER_PASSWORD"
-                  ]
-                }
-              }
-            }
-          }
-        }
-      }
     }
   ]
 }

package/lib/schema/external-datasource.schema.json

@@ -7,12 +7,12 @@
          "key":"external-datasource-schema",
          "name":"External Data Source Configuration Schema",
          "description":"JSON schema for validating ExternalDataSource configuration files",
-     "version":"2.9.5",
+     "version":"2.9.6",
          "type":"schema",
          "category":"integration",
          "author":"AI Fabrix Team",
          "createdAt":"2024-01-01T00:00:00Z",
-         "updatedAt":"2026-07-31T00:00:00Z",
+         "updatedAt":"2026-08-07T00:00:00Z",
          "compatibility":{
             "minVersion":"1.0.0",
             "maxVersion":"3.0.0",
@@ -390,6 +390,12 @@
          "enum":["documentStorage","vectorStore","recordStorage","messageService","serviceContract","none"],
          "description":"Entity type identifier. Defines storage semantics and behavior: 'documentStorage' (creates document storage service with vector-storage), 'vectorStore' (external vector storage system), 'recordStorage' (creates record-based system with metadata sync and access rights), 'messageService' (message service for notifications - Slack, Teams, Email), 'serviceContract' (normalized executable service adapter without persistence — requires metadataSchema, fieldMappings, exposed), 'none' (orchestration/composition only). Required field. Canonical values are camelCase."
       },
+      "storageType":{
+         "type":"string",
+         "enum":["table","view"],
+         "default":"table",
+         "description":"recordStorage persistence mode. 'table' (default) is ordinary synced record storage. 'view' is calculated read-only CIP perspectives with fetch.source viewpoint SQL; not a permanent PostgreSQL VIEW object."
+      },
       "resourceType":{
          "type":"string",
          "pattern":"^[a-z0-9-]+$",
@@ -1307,6 +1313,33 @@
             ]
          }
       },
+      {
+         "if":{
+            "properties":{
+               "storageType":{
+                  "const":"view"
+               }
+            },
+            "required":[
+               "storageType"
+            ]
+         },
+         "then":{
+            "properties":{
+               "entityType":{
+                  "const":"recordStorage"
+               },
+               "execution":{
+                  "type":"object",
+                  "properties":{
+                     "engine":{
+                        "const":"cip"
+                     }
+                  }
+               }
+            }
+         }
+      },
       {
          "if":{
             "properties":{
@@ -2498,11 +2531,12 @@
                   "source":{
                      "type":"string",
                      "enum":[
-                        "openapi",
+                       "openapi",
                        "http",
-                       "datasource"
+                       "datasource",
+                       "viewpoint"
                      ],
-                    "description":"If 'openapi', refer to openapi.operations.*. If 'http', use explicit method/path. If 'datasource', execute another datasource operation."
+                    "description":"If 'openapi', refer to openapi.operations.*. If 'http', use explicit method/path. If 'datasource', execute another datasource operation. If 'viewpoint', execute saved SQL in fetch.query against records storage (storageType view)."
                   },
                   "openapiRef":{
                      "type":"string",
@@ -2555,16 +2589,7 @@
                     "description":"When true, append fetch items to the pipeline accumulator for a following merge step."
                  },
                   "query":{
-                     "type":"object",
-                     "description":"Static query parameters. ABAC/runtime can still override or append at runtime.",
-                     "additionalProperties":{
-                        "type":[
-                           "string",
-                           "number",
-                           "boolean",
-                           "null"
-                        ]
-                     }
+                     "description":"When source is openapi/http/datasource: static query parameter object. When source is viewpoint: non-empty SQL SELECT string. ABAC/runtime may still append supported filters at execution for viewpoint."
                   },
                   "bodyTemplate":{
                      "description":"Optional static request body or template for POST/PUT/PATCH fetches.",
@@ -2606,7 +2631,20 @@
                                  "operationId"
                               ]
                            }
-                        ]
+                        ],
+                        "properties":{
+                           "query":{
+                              "type":"object",
+                              "additionalProperties":{
+                                 "type":[
+                                    "string",
+                                    "number",
+                                    "boolean",
+                                    "null"
+                                 ]
+                              }
+                           }
+                        }
                      }
                   },
                   {
@@ -2621,7 +2659,20 @@
                         "required":[
                            "method",
                            "path"
-                        ]
+                        ],
+                        "properties":{
+                           "query":{
+                              "type":"object",
+                              "additionalProperties":{
+                                 "type":[
+                                    "string",
+                                    "number",
+                                    "boolean",
+                                    "null"
+                                 ]
+                              }
+                           }
+                        }
                      }
                  },
                  {
@@ -2637,9 +2688,44 @@
                           "datasource":{
                              "type":"string",
                              "description":"Target child datasource key. Omitted when parent manifest composition.datasources has two or more entries; runtime resolves via selector input."
+                          },
+                          "query":{
+                             "type":"object",
+                             "additionalProperties":{
+                                "type":[
+                                   "string",
+                                   "number",
+                                   "boolean",
+                                   "null"
+                                ]
+                             }
                           }
                        }
                     }
+                  },
+                  {
+                     "if":{
+                        "properties":{
+                           "source":{
+                              "const":"viewpoint"
+                           }
+                        },
+                        "required":[
+                           "source"
+                        ]
+                     },
+                     "then":{
+                        "required":[
+                           "query"
+                        ],
+                        "properties":{
+                           "query":{
+                              "type":"string",
+                              "minLength":1,
+                              "description":"Saved read-only SQL SELECT for viewpoint fetch. Parameter-free in first implementation."
+                           }
+                        }
+                     }
                   }
                ],
                "additionalProperties":false