@aifabrix/builder 2.52.0 → 2.52.1

package/lib/role-assistant/test-cases-bid.js

@@ -0,0 +1,155 @@
+/**
+ * Evaluate expected.bid assertions for suite 002 hard GP.
+ * @fileoverview BID emission / apply expectation checks
+ */
+
+'use strict';
+
+function asArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+
+function softWrap(assertion, soft) {
+  if (!assertion || assertion.passed || !soft) {
+    return assertion;
+  }
+  return {
+    ...assertion,
+    passed: true,
+    soft: true,
+    warn: true,
+    message: `${assertion.message} (soft — warning only)`
+  };
+}
+
+function findInteraction(interactions, type) {
+  return asArray(interactions).find((row) => row && row.type === type) || null;
+}
+
+function pushBidAssertion(assertions, soft, id, passed, okMsg, failMsg) {
+  assertions.push(
+    softWrap(
+      {
+        id,
+        passed,
+        message: passed ? okMsg : failMsg
+      },
+      soft
+    )
+  );
+}
+
+function hasEmitOrApply(observed) {
+  return Boolean(observed.emitRow || observed.applyRow || observed.emitted);
+}
+
+function collectBidSchemaAssertions(expectedBid, observed, assertions, soft) {
+  const { emitRow, applyRow, emitted } = observed;
+  if (expectedBid.schemaName) {
+    const actualSchema = (emitted && emitted.schemaName) || expectedBid.schemaName;
+    pushBidAssertion(
+      assertions,
+      soft,
+      'expected.bid.schemaName',
+      hasEmitOrApply(observed) && actualSchema === expectedBid.schemaName,
+      `BID schemaName observed (${expectedBid.schemaName}).`,
+      `BID schemaName "${expectedBid.schemaName}" not observed in suite emit/apply.`
+    );
+  }
+  if (expectedBid.schemaVersion) {
+    const version = emitted && emitted.schemaVersion;
+    const versionOk =
+      version === null || version === undefined || version === expectedBid.schemaVersion;
+    pushBidAssertion(
+      assertions,
+      soft,
+      'expected.bid.schemaVersion',
+      hasEmitOrApply({ emitRow, applyRow, emitted }) && versionOk,
+      `BID schemaVersion "${expectedBid.schemaVersion}" accepted.`,
+      `BID schemaVersion "${expectedBid.schemaVersion}" not observed.`
+    );
+  }
+}
+
+function assertDefinitionHash(expectedBid, observed, assertions, soft) {
+  if (expectedBid.requireDefinitionHash !== true) {
+    return;
+  }
+  const { emitRow, applyRow, emitted } = observed;
+  const hash =
+    (emitted && emitted.definitionHash) ||
+    (emitRow && emitRow.definitionHash) ||
+    (applyRow && applyRow.definitionHash) ||
+    '';
+  pushBidAssertion(
+    assertions,
+    soft,
+    'expected.bid.requireDefinitionHash',
+    typeof hash === 'string' && hash.startsWith('sha256:'),
+    `BID definitionHash present (${String(hash).slice(0, 18)}…).`,
+    'BID definitionHash (sha256:…) not observed on emit/apply.'
+  );
+}
+
+function assertSuiteRunId(expectedBid, observed, assertions, soft) {
+  if (expectedBid.requireSuiteRunId !== true) {
+    return;
+  }
+  const { emitRow, applyRow, emitted } = observed;
+  const suiteRunId =
+    (emitted && emitted.meta && emitted.meta.suiteRunId) ||
+    (emitRow && emitRow.suiteRunId) ||
+    (applyRow && applyRow.suiteRunId) ||
+    '';
+  pushBidAssertion(
+    assertions,
+    soft,
+    'expected.bid.requireSuiteRunId',
+    Boolean(String(suiteRunId).trim()),
+    `BID suiteRunId present (${suiteRunId}).`,
+    'BID meta.suiteRunId not observed on emit/apply.'
+  );
+}
+
+function collectBidProvenanceAssertions(expectedBid, observed, assertions, soft) {
+  assertDefinitionHash(expectedBid, observed, assertions, soft);
+  assertSuiteRunId(expectedBid, observed, assertions, soft);
+}
+
+function collectBidPathAssertions(expectedBid, observed, assertions, soft) {
+  if (expectedBid.forbidGoldPaths === true) {
+    const { emitRow, applyRow, emitted } = observed;
+    const blob = JSON.stringify(emitted || emitRow || applyRow || {});
+    const banned = /test-e2e-hubspot|knownPlatform|gold-package/i.test(blob);
+    pushBidAssertion(
+      assertions,
+      soft,
+      'expected.bid.forbidGoldPaths',
+      !banned,
+      'BID trail has no gold/knownPlatform generation paths.',
+      'BID trail references forbidden gold/knownPlatform generation paths.'
+    );
+  }
+}
+
+function collectBidAssertions(expectedBid, observation, options = {}) {
+  if (!expectedBid || typeof expectedBid !== 'object') {
+    return [];
+  }
+  const interactions = asArray(observation.interactions || observation.workInteractions);
+  const observed = {
+    emitRow: findInteraction(interactions, 'bid-emit'),
+    applyRow: findInteraction(interactions, 'bid-apply'),
+    emitted: observation.emittedBid || null
+  };
+  const assertions = [];
+  const soft = options.soft === true;
+  collectBidSchemaAssertions(expectedBid, observed, assertions, soft);
+  collectBidProvenanceAssertions(expectedBid, observed, assertions, soft);
+  collectBidPathAssertions(expectedBid, observed, assertions, soft);
+  return assertions;
+}
+
+module.exports = {
+  collectBidAssertions
+};

package/lib/role-assistant/test-cases-evaluate.js

@@ -9,6 +9,7 @@ const {
   buildHonestyObservation,
   evaluateHonestyExpectations
 } = require('./test-cases-honesty');
+const { collectBidAssertions } = require('./test-cases-bid');
 
 function getValueAtPath(obj, dottedPath) {
   const parts = String(dottedPath || '').split('.').filter(Boolean);
@@ -109,7 +110,13 @@ function buildCaseObservation(result, lifecycleVerdict, portalUrl) {
     processExecutionId: result?.processExecutionId || null,
     workResult,
     workResultError: result?.workResultError || null,
-    honesty: buildHonestyObservation(workResult)
+    honesty: buildHonestyObservation(workResult),
+    interactions: Array.isArray(result?.interactions)
+      ? result.interactions
+      : Array.isArray(result?.workInteractions)
+        ? result.workInteractions
+        : [],
+    emittedBid: result?.emittedBid || null
   };
 }
 
@@ -146,6 +153,7 @@ function collectCaseAssertions(expected, observation) {
   assertions.push(...evaluateFactExpectations(expected.facts, observation));
   assertions.push(...evaluateProhibitedExpectations(expected.prohibited, observation));
   assertions.push(...evaluateHonestyExpectations(expected.honesty, observation, { soft }));
+  assertions.push(...collectBidAssertions(expected.bid, observation, { soft }));
   return assertions;
 }
 

package/lib/role-assistant/test-cases-honesty.js

@@ -68,7 +68,18 @@ function buildHonestyObservation(workResult) {
   };
 }
 
-function pushHonestyAssertion(assertions, id, passed, message) {
+function pushHonestyAssertion(assertions, id, passed, message, options = {}) {
+  const soft = options.soft === true;
+  if (soft && !passed) {
+    assertions.push({
+      id,
+      passed: true,
+      soft: true,
+      warn: true,
+      message: `${message} (soft — warning only)`
+    });
+    return;
+  }
   assertions.push({ id, passed, message });
 }
 
@@ -87,7 +98,7 @@ function assertWorkResultPresent(assertions, honesty, observation) {
   );
 }
 
-function assertSchemaVersion(assertions, honestySpec, honesty) {
+function assertSchemaVersion(assertions, honestySpec, honesty, soft) {
   if (!honestySpec.schemaVersion) {
     return;
   }
@@ -99,11 +110,12 @@ function assertSchemaVersion(assertions, honestySpec, honesty) {
     passed,
     passed
       ? `schemaVersion matched "${expected}".`
-      : `schemaVersion expected "${expected}" but got ${JSON.stringify(honesty.schemaVersion)}.`
+      : `schemaVersion expected "${expected}" but got ${JSON.stringify(honesty.schemaVersion)}.`,
+    { soft }
   );
 }
 
-function assertCompletion(assertions, honestySpec, honesty) {
+function assertCompletion(assertions, honestySpec, honesty, soft) {
   if (honestySpec.requireCompletion === false) {
     return;
   }
@@ -115,11 +127,12 @@ function assertCompletion(assertions, honestySpec, honesty) {
     stateOk && goalOk,
     stateOk && goalOk
       ? `completion.state/goalStatus honest (${honesty.completionState}/${honesty.goalStatus}).`
-      : `completion missing or invalid: state=${JSON.stringify(honesty.completionState)} goalStatus=${JSON.stringify(honesty.goalStatus)}.`
+      : `completion missing or invalid: state=${JSON.stringify(honesty.completionState)} goalStatus=${JSON.stringify(honesty.goalStatus)}.`,
+    { soft }
   );
 }
 
-function assertContribution(assertions, honestySpec, honesty) {
+function assertContribution(assertions, honestySpec, honesty, soft) {
   if (honestySpec.requireContributionObservation === false) {
     return;
   }
@@ -130,7 +143,8 @@ function assertContribution(assertions, honestySpec, honesty) {
     ok,
     ok
       ? `contributionObservation.status honest (${honesty.contributionStatus}).`
-      : `contributionObservation.status missing or invalid: ${JSON.stringify(honesty.contributionStatus)}.`
+      : `contributionObservation.status missing or invalid: ${JSON.stringify(honesty.contributionStatus)}.`,
+    { soft }
   );
 }
 
@@ -171,9 +185,9 @@ function evaluateHonestyExpectations(honestySpec, observation, options = {}) {
     // Missing Output is always a hard failure when required — soft does not waive it.
     return assertions;
   }
-  assertSchemaVersion(assertions, honestySpec, honesty);
-  assertCompletion(assertions, honestySpec, honesty);
-  assertContribution(assertions, honestySpec, honesty);
+  assertSchemaVersion(assertions, honestySpec, honesty, soft);
+  assertCompletion(assertions, honestySpec, honesty, soft);
+  assertContribution(assertions, honestySpec, honesty, soft);
   assertMinResourceChanges(assertions, honestySpec, honesty, soft);
   return assertions;
 }

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

@@ -331,6 +331,32 @@ function collectCapabilitiesFromWorkSteps(out, steps) {
   }
 }
 
+/**
+ * Work-result artifactIndex often carries CIP fingerprints like
+ * `capabilityKey=customer.createBasic|operationId=createbasic` when steps[] is empty.
+ * @param {Set<string>} out
+ * @param {unknown} artifacts
+ */
+function collectCapabilitiesFromArtifactIndex(out, artifacts) {
+  if (!Array.isArray(artifacts)) return;
+  for (const row of artifacts) {
+    if (!row || typeof row !== 'object') continue;
+    addCapabilityToken(out, row.capabilityKey);
+    addCapabilityToken(out, row.capability);
+    const fingerprint = typeof row.fingerprint === 'string' ? row.fingerprint : '';
+    const match = fingerprint.match(/(?:^|[|,])capabilityKey=([^|,]+)/);
+    if (match) {
+      addCapabilityToken(out, match[1]);
+    }
+    const artifactRef = typeof row.artifactRef === 'string' ? row.artifactRef : '';
+    // cip-log:fallback:customer.create:create:<id>
+    const refMatch = artifactRef.match(/^cip-log:[^:]+:([^:]+):/);
+    if (refMatch) {
+      addCapabilityToken(out, refMatch[1]);
+    }
+  }
+}
+
 function collectObservedCapabilities(result) {
   const out = new Set();
   const steps = Array.isArray(result?.stepsRun) ? result.stepsRun : [];
@@ -341,6 +367,8 @@ function collectObservedCapabilities(result) {
   }
   collectCapabilitiesFromWorkSteps(out, result?.steps);
   collectCapabilitiesFromWorkSteps(out, result?.workResult?.steps);
+  collectCapabilitiesFromArtifactIndex(out, result?.workResult?.artifactIndex);
+  collectCapabilitiesFromArtifactIndex(out, result?.artifactIndex);
   addCapabilityToken(out, result?.task?.capabilityKey);
   addCapabilityToken(out, result?.task?.capability);
   if (result?.task?.approvalContext && typeof result.task.approvalContext === 'object') {

package/lib/role-assistant/test-runner-bid-apply.js

@@ -0,0 +1,122 @@
+/**
+ * Soft-loop BID apply after workspace.createsystem (suite 002 / plan 512.4).
+ * @fileoverview Apply input.bidPath into builder-api workspace when Runtime COM
+ * cannot yet invoke template.applyintegrationdefinition (RA facade not refreshed).
+ */
+
+'use strict';
+
+const fs = require('../internal/fs-real-sync');
+const path = require('path');
+const {
+  loadCaseBidDocument,
+  resolveTargetSystemKey
+} = require('./test-runner-bid-document');
+
+/**
+ * @returns {string}
+ */
+function resolveBuilderApiBaseUrl() {
+  const fromEnv = String(process.env.BUILDER_API_URL || process.env.BUILDER_URL || '').trim();
+  if (fromEnv) {
+    return fromEnv.replace(/\/$/, '');
+  }
+  let developerId = 0;
+  try {
+    const yaml = require('js-yaml');
+    const cfgPath = path.join(
+      process.env.HOME || '',
+      '.aifabrix',
+      'config.yaml'
+    );
+    if (fs.existsSync(cfgPath)) {
+      const cfg = yaml.load(fs.readFileSync(cfgPath, 'utf8')) || {};
+      developerId = Number(cfg['developer-id'] || cfg.developerId || 0) || 0;
+    }
+  } catch (_err) {
+    developerId = 0;
+  }
+  return `http://localhost:${3005 + developerId * 100}`;
+}
+
+/**
+ * @param {Object} authConfig
+ * @returns {string}
+ */
+function extractBearer(authConfig) {
+  if (!authConfig || typeof authConfig !== 'object') {
+    return '';
+  }
+  if (typeof authConfig.token === 'string' && authConfig.token.trim()) {
+    return authConfig.token.trim();
+  }
+  if (typeof authConfig.bearerToken === 'string' && authConfig.bearerToken.trim()) {
+    return authConfig.bearerToken.trim();
+  }
+  const header = authConfig.headers && authConfig.headers.Authorization;
+  const m = /^Bearer\s+(.+)$/i.exec(String(header || ''));
+  return m ? m[1].trim() : '';
+}
+
+/**
+ * @param {Object} testCase
+ * @param {Object} wait
+ * @returns {boolean}
+ */
+function shouldApplyBidAfterWait(testCase, wait) {
+  const bid = loadCaseBidDocument(testCase);
+  if (!bid) {
+    return false;
+  }
+  const capability = String(
+    wait.questionKey || wait.objectRef?.capabilityKey || wait.prompt || ''
+  ).toLowerCase();
+  return (
+    capability.includes('createsystem') ||
+    capability.includes('applyintegrationdefinition')
+  );
+}
+
+/**
+ * @param {Object} authConfig
+ * @param {Object} testCase
+ * @returns {Promise<Object|null>}
+ */
+async function applyCaseBidViaBuilderApi(authConfig, testCase) {
+  const bid = loadCaseBidDocument(testCase);
+  const systemKey = resolveTargetSystemKey(testCase);
+  const token = extractBearer(authConfig);
+  if (!bid || !systemKey || !token) {
+    return null;
+  }
+  const url = `${resolveBuilderApiBaseUrl()}/api/v1/builder/systems/${encodeURIComponent(systemKey)}/integration-definition/apply`;
+  const res = await fetch(url, {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${token}`,
+      'Content-Type': 'application/json'
+    },
+    body: JSON.stringify({ integrationDefinition: bid, force: true })
+  });
+  const text = await res.text();
+  let body = null;
+  try {
+    body = text ? JSON.parse(text) : null;
+  } catch (_err) {
+    body = { raw: text };
+  }
+  if (!res.ok) {
+    const err = new Error(
+      `BID apply failed HTTP ${res.status}: ${typeof body === 'object' ? JSON.stringify(body).slice(0, 300) : text}`
+    );
+    err.status = res.status;
+    throw err;
+  }
+  return body && body.data ? body.data : body;
+}
+
+module.exports = {
+  resolveBuilderApiBaseUrl,
+  shouldApplyBidAfterWait,
+  applyCaseBidViaBuilderApi
+};