ai-delivery-workflow 0.2.2 → 0.4.0

package/lib/workflow-manager-mock.mjs

@@ -0,0 +1,183 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { createRequire } from "node:module";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import {
+  abortWorkflowManagerExternalEffect,
+  beginWorkflowManagerExternalEffect,
+  completeWorkflowManagerExternalEffect,
+  publishWorkflowManagerExternalEffect,
+} from "./workflow-manager-transaction.mjs";
+
+const runtimeRoot = path.dirname(fileURLToPath(import.meta.url));
+const installedYaml = path.join(runtimeRoot, "..", "state", "vendor", "yaml", "dist", "index.js");
+const require = createRequire(import.meta.url);
+const YAML = require(fs.existsSync(installedYaml) ? installedYaml : "yaml");
+const installedMockRuntime = path.join(runtimeRoot, "..", "mock", "mock-system.mjs");
+const packageMockRuntime = path.join(runtimeRoot, "mock-system.mjs");
+const { mockProtocolExpectation, runMockSystemAction } = await import(pathToFileURL(
+  fs.existsSync(installedMockRuntime) ? installedMockRuntime : packageMockRuntime,
+).href);
+
+export const WORKFLOW_MANAGER_MOCK_SCHEMA_VERSION = "workflow-manager.mock.v1";
+const catalogs = Object.freeze([
+  { kind: "external-dependency", collection: "external_dependencies", ref: ".workflow/mock-system/external-dependencies.yaml", prefix: ".workflow/mock-system/definitions/external/" },
+  { kind: "product-backend", collection: "product_backends", ref: ".workflow/mock-system/product-backends.yaml", prefix: ".workflow/mock-system/definitions/product-backend/" },
+]);
+const RECEIPTS_RELATIVE = ".workflow/control/receipts";
+const EVENTS_RELATIVE = ".workflow/control/events/workflow-manager-events.jsonl";
+
+function sha256(value) { return crypto.createHash("sha256").update(value).digest("hex"); }
+function inside(root, candidate) { const relative = path.relative(root, candidate); return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative)); }
+function contained(root, relative, prefix, label) {
+  if (typeof relative !== "string" || !relative.startsWith(prefix) || relative.includes("\\") || relative.includes("\0")
+    || path.posix.isAbsolute(relative) || path.posix.normalize(relative) !== relative) throw new Error(`${label} is outside the registered Mock definition path`);
+  const absolute = path.resolve(root, ...relative.split("/"));
+  if (!inside(root, absolute)) throw new Error(`${label} escapes the project`);
+  return absolute;
+}
+function readYaml(file, label) { try { return YAML.parse(fs.readFileSync(file, "utf8")); } catch (error) { throw new Error(`${label} is invalid YAML: ${error.message}`); } }
+
+function empty(outcome = "not-registered") {
+  return { schema_version: WORKFLOW_MANAGER_MOCK_SCHEMA_VERSION, registration_status: outcome, provider: null, management_url: null, protocols: [], scenarios: [], mutability: "derived-read-only" };
+}
+
+function scenarioType(id) {
+  const value = String(id).toLowerCase();
+  if (/system|timeout|unavailable|internal|network|crash/.test(value)) return "system-exception";
+  if (/declin|reject|invalid|denied|conflict|business|insufficient/.test(value)) return "business-exception";
+  return "normal";
+}
+
+export async function inspectWorkflowManagerMock(projectRoot, options = {}) {
+  const root = path.resolve(projectRoot);
+  if (!catalogs.every((catalog) => fs.existsSync(path.join(root, ...catalog.ref.split("/"))))) return empty();
+  const validated = await runMockSystemAction(root, "sync", { dryRun: true, ...options.mockOptions });
+  const protocolMap = new Map(); const scenarios = [];
+  for (const catalog of catalogs) {
+    const file = path.join(root, ...catalog.ref.split("/")); const document = readYaml(file, `${catalog.kind} Mock catalog`);
+    for (const entry of document[catalog.collection] || []) {
+      const contractFile = contained(root, entry.contract_ref, catalog.prefix, "Mock contract_ref");
+      const definition = readYaml(contractFile, `Mock contract ${entry.contract_ref}`);
+      const expectation = mockProtocolExpectation(definition, entry);
+      const protocolId = `${entry.mock_kind}:${entry.mock_id}:${entry.operation_or_channel}`;
+      if (!protocolMap.has(protocolId)) protocolMap.set(protocolId, {
+        protocol_id: protocolId, mock_id: entry.mock_id, mock_kind: entry.mock_kind, owner: entry.owner,
+        protocol: expectation.protocol, operation_or_channel: entry.operation_or_channel,
+        source_ref: entry.contract_ref, source_checksum: sha256(fs.readFileSync(contractFile)),
+        contract_approval_ref: entry.contract_approval_ref, mutability: "derived-read-only",
+      });
+      scenarios.push({
+        scenario_key: `${entry.mock_kind}:${entry.mock_id}:${entry.scenario_id}`, mock_id: entry.mock_id,
+        mock_kind: entry.mock_kind, scenario_id: entry.scenario_id, protocol: expectation.protocol,
+        scenario_type: scenarioType(entry.scenario_id),
+        operation_or_channel: entry.operation_or_channel, trigger: expectation.request || expectation.message || null,
+        result: expectation.response || null, source_ref: entry.contract_ref,
+        source_checksum: sha256(fs.readFileSync(contractFile)), mutability: "derived-read-only",
+      });
+    }
+  }
+  return {
+    schema_version: WORKFLOW_MANAGER_MOCK_SCHEMA_VERSION, registration_status: "registered",
+    provider: validated.provider, management_url: validated.base_url,
+    protocols: [...protocolMap.values()].sort((a, b) => a.protocol_id.localeCompare(b.protocol_id)),
+    scenarios: scenarios.sort((a, b) => a.scenario_key.localeCompare(b.scenario_key)),
+    sync: { planned_contracts: validated.planned_contracts, action: "plan-sync", available: true },
+    mutability: "derived-read-only",
+  };
+}
+
+export async function planWorkflowManagerMockSync(projectRoot, input = {}, options = {}) {
+  const root = path.resolve(projectRoot);
+  if (!catalogs.every((catalog) => fs.existsSync(path.join(root, ...catalog.ref.split("/"))))) return {
+    schema_version: WORKFLOW_MANAGER_MOCK_SCHEMA_VERSION, action: "plan-sync", outcome: "not-registered",
+    registration_status: "not-registered", idempotency_key: input.idempotency_key || null, affected_identities: [],
+  };
+  const delegated = await runMockSystemAction(root, "sync", { dryRun: true, ...options.mockOptions });
+  const affected = [
+    ...(delegated.external_dependencies || []), ...(delegated.product_backends || []),
+  ].map((entry) => ({ mock_id: entry.mock_id, mock_kind: entry.mock_kind, scenario_id: entry.scenario_id }));
+  const result = {
+    schema_version: WORKFLOW_MANAGER_MOCK_SCHEMA_VERSION, action: "plan-sync", outcome: "planned",
+    registration_status: "registered", provider: delegated.provider, management_url: delegated.base_url,
+    idempotency_key: input.idempotency_key || null, planned_contracts: delegated.planned_contracts,
+    affected_identities: affected, delegated_plan: delegated,
+  };
+  result.plan_checksum = sha256(JSON.stringify({ provider: result.provider,
+    management_url: result.management_url, planned_contracts: result.planned_contracts,
+    affected_identities: result.affected_identities }));
+  return result;
+}
+
+export async function applyWorkflowManagerMockSync(projectRoot, input = {}, options = {}) {
+  const root = path.resolve(projectRoot);
+  const receiptRoot = path.join(root, RECEIPTS_RELATIVE);
+  if (input.idempotency_key && fs.existsSync(receiptRoot)) {
+    for (const name of fs.readdirSync(receiptRoot)) {
+      if (!name.endsWith(".json")) continue;
+      try {
+        const receipt = JSON.parse(fs.readFileSync(path.join(receiptRoot, name), "utf8"));
+        if (receipt.action === "mock-sync" && receipt.idempotency_key === input.idempotency_key) {
+          if (receipt.plan_checksum !== input.expected_plan_checksum) {
+            throw new Error("Mock sync idempotency key was already used for a different plan");
+          }
+          return { schema_version: WORKFLOW_MANAGER_MOCK_SCHEMA_VERSION,
+            action: "apply-sync", outcome: "idempotent-replay", receipt };
+        }
+      } catch (error) {
+        if (/idempotency key/.test(error.message)) throw error;
+      }
+    }
+  }
+  const plan = await planWorkflowManagerMockSync(root, input, options);
+  if (plan.outcome === "not-registered") return { ...plan, action: "apply-sync" };
+  if (!input.expected_plan_checksum || input.expected_plan_checksum !== plan.plan_checksum) {
+    throw new Error("Mock sync plan checksum mismatch");
+  }
+  const action = "mock-sync-apply";
+  const pending = beginWorkflowManagerExternalEffect(root, {
+    action, subject: "mock-system", input, planChecksum: plan.plan_checksum,
+  });
+  if (pending.record.status === "succeeded" || pending.record.status === "delivered") {
+    const recovered = publishWorkflowManagerExternalEffect(root, {
+      action, subject: "mock-system", input, planChecksum: plan.plan_checksum,
+      transactionHooks: options.transactionHooks, recovered: pending.record.status === "succeeded",
+    });
+    return {
+      schema_version: WORKFLOW_MANAGER_MOCK_SCHEMA_VERSION,
+      action: "apply-sync",
+      outcome: recovered.outcome,
+      idempotency_key: input.idempotency_key,
+      affected_identities: plan.affected_identities,
+      receipt: recovered.receipt,
+      event: recovered.event || null,
+      result: recovered.result,
+    };
+  }
+  let applied;
+  try {
+    applied = await runMockSystemAction(root, "sync", options.mockOptions || {});
+  } catch (error) {
+    abortWorkflowManagerExternalEffect(pending);
+    throw error;
+  }
+  completeWorkflowManagerExternalEffect(pending, {
+    result: applied,
+    detail: {
+      affected_identities: plan.affected_identities,
+      uploaded_contracts: applied.uploaded_contracts,
+    },
+    receiptPrefix: "WMM",
+    eventType: "workflow-manager.mock-synced",
+  });
+  const recorded = publishWorkflowManagerExternalEffect(root, {
+    action, subject: "mock-system", input, planChecksum: plan.plan_checksum,
+    transactionHooks: options.transactionHooks,
+  });
+  return {
+    schema_version: WORKFLOW_MANAGER_MOCK_SCHEMA_VERSION, action: "apply-sync", outcome: "applied",
+    idempotency_key: input.idempotency_key || null, affected_identities: plan.affected_identities,
+    receipt: recorded.receipt, event: recorded.event, result: applied,
+  };
+}