@tradejs/cli 3.1.29-beta.262 → 3.1.29-beta.264

package/dist/lib/runtimeEvidenceCompositionSnapshots.js

@@ -17,6 +17,7 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
   // If the importer is in node compatibility mode or this is not an ESM
   // file that has been converted to a CommonJS file using a Babel-
@@ -37,187 +38,17 @@ __export(runtimeEvidenceCompositionSnapshots_exports, {
   verifyRuntimeEvidenceCompositionSnapshot: () => verifyRuntimeEvidenceCompositionSnapshot
 });
 module.exports = __toCommonJS(runtimeEvidenceCompositionSnapshots_exports);
-var import_node_crypto2 = require("crypto");
-var import_promises2 = __toESM(require("fs/promises"));
-var import_node_path2 = __toESM(require("path"));
+var import_node_crypto = require("crypto");
+var import_promises = __toESM(require("fs/promises"));
+var import_node_path = __toESM(require("path"));
 
 // src/lib/runtimeEvidenceDeployment.ts
-var import_runtimeStrategies = require("@tradejs/node/runtimeStrategies");
-var isRecord = (value) => value != null && typeof value === "object" && !Array.isArray(value);
-var isNonEmptyString = (value) => typeof value === "string" && value.trim().length > 0;
-var isPackageVersionMap = (value) => isRecord(value) && Object.keys(value).length > 0 && Object.entries(value).every(
-  ([name, version]) => name.startsWith("@tradejs/") && isNonEmptyString(version)
-);
-var INTERVALS = /* @__PURE__ */ new Set([
-  "1",
-  "3",
-  "5",
-  "15",
-  "30",
-  "60",
-  "120",
-  "240",
-  "360",
-  "720",
-  "D",
-  "W",
-  "M"
-]);
-var UNIVERSES = /* @__PURE__ */ new Set(["crypto", "tradfi"]);
-var isRuntimeStrategySelection = (value) => value === void 0 || isRecord(value) && Object.keys(value).length === 1 && Object.keys(value).every((key) => key === "tickers") && Array.isArray(value.tickers) && value.tickers.length > 0 && value.tickers.every((ticker) => isNonEmptyString(ticker));
-var parseRuntimeEvidenceDeploymentSnapshot = (value) => {
-  if (!isRecord(value) || value.schemaVersion !== 2 || !isNonEmptyString(value.id) || !isNonEmptyString(value.deploymentCompositionId) || !/^dc1:[a-f0-9]{16}$/.test(value.deploymentCompositionId) || !isNonEmptyString(value.label) || !isNonEmptyString(value.connectorName) || !isNonEmptyString(value.provider) || !isNonEmptyString(value.accountId) || typeof value.enabled !== "boolean" || !Array.isArray(value.strategies)) {
-    throw new Error(
-      "Runtime evidence deployment snapshot is missing or invalid"
-    );
-  }
-  const strategies = value.strategies.map((candidate) => {
-    if (!isRecord(candidate) || !isNonEmptyString(candidate.strategyName) || !isNonEmptyString(candidate.strategyRevision) || !/^sr1:[a-f0-9]{16}$/.test(candidate.strategyRevision) || typeof candidate.enabled !== "boolean" || !["active", "entries_paused"].includes(String(candidate.controlState)) || !INTERVALS.has(String(candidate.interval)) || !UNIVERSES.has(String(candidate.universe)) || !isNonEmptyString(candidate.strategyPackage) || !isNonEmptyString(candidate.strategyPackageVersion) || !isPackageVersionMap(candidate.strategyDependencyVersions) || !isNonEmptyString(candidate.runtimePackageVersion) || !isRecord(candidate.strategyConfig) || !isRuntimeStrategySelection(candidate.selection)) {
-      throw new Error(
-        "Runtime evidence deployment strategy snapshot is invalid"
-      );
-    }
-    if (String(candidate.strategyConfig.INTERVAL) !== String(candidate.interval) || String(candidate.strategyConfig.UNIVERSE) !== String(candidate.universe)) {
-      throw new Error(
-        `Runtime evidence strategy config does not match its scope: ${candidate.strategyName}`
-      );
-    }
-    if (candidate.accountId != null && (!isNonEmptyString(candidate.accountId) || candidate.accountId !== value.accountId)) {
-      throw new Error(
-        `Runtime evidence strategy account does not match deployment: ${candidate.strategyName}`
-      );
-    }
-    return candidate;
-  });
-  const identities = /* @__PURE__ */ new Set();
-  for (const strategy of strategies) {
-    if (identities.has(strategy.strategyName)) {
-      throw new Error(
-        `Duplicate runtime evidence strategy: ${strategy.strategyName}`
-      );
-    }
-    identities.add(strategy.strategyName);
-  }
-  return {
-    ...value,
-    strategies
-  };
-};
-var resolveRuntimeEvidenceDeploymentSnapshot = async ({
-  userName,
-  projectRoot,
-  deploymentId
-}) => {
-  const [deployment, strategies] = await Promise.all([
-    (0, import_runtimeStrategies.getRuntimeDeployment)({ userName, projectRoot, deploymentId }),
-    (0, import_runtimeStrategies.loadResolvedRuntimeStrategies)({ userName, projectRoot, deploymentId })
-  ]);
-  if (!deployment) {
-    throw new Error(`Runtime deployment not found: ${deploymentId}`);
-  }
-  return {
-    schemaVersion: 2,
-    id: deployment.id,
-    deploymentCompositionId: deployment.deploymentCompositionId,
-    label: deployment.label,
-    connectorName: deployment.connectorName,
-    provider: deployment.provider,
-    accountId: deployment.accountId,
-    enabled: deployment.enabled,
-    strategies: strategies.map(
-      ({
-        strategyName,
-        strategyRevision,
-        enabled,
-        controlState,
-        interval,
-        universe,
-        accountId,
-        strategyPackage,
-        strategyPackageVersion,
-        strategyDependencyVersions,
-        runtimePackageVersion,
-        strategyConfig,
-        selection
-      }) => ({
-        strategyName,
-        strategyRevision,
-        enabled,
-        controlState,
-        interval,
-        universe,
-        ...accountId ? { accountId } : {},
-        strategyPackage,
-        strategyPackageVersion,
-        strategyDependencyVersions,
-        runtimePackageVersion,
-        strategyConfig,
-        ...selection ? { selection } : {}
-      })
-    ),
-    ...deployment.assetClasses ? { assetClasses: [...deployment.assetClasses] } : {},
-    ...deployment.tickers ? { tickers: [...deployment.tickers] } : {}
-  };
-};
+var runtimeEvidenceDeployment_exports = {};
+__reExport(runtimeEvidenceDeployment_exports, require("@tradejs/node/diagnostics"));
 
 // src/lib/runtimeEvidenceProducer.ts
-var import_node_crypto = require("crypto");
-var import_promises = __toESM(require("fs/promises"));
-var import_node_path = __toESM(require("path"));
-var isRecord2 = (value) => value != null && typeof value === "object" && !Array.isArray(value);
-var sha256 = (value) => (0, import_node_crypto.createHash)("sha256").update(value).digest("hex");
-var parseRuntimeEvidenceProducer = (value) => {
-  const producer = isRecord2(value) ? value : null;
-  const runtimePackageManifest = isRecord2(producer?.runtimePackageManifest) ? producer.runtimePackageManifest : null;
-  if (producer?.schemaVersion !== 1 || typeof producer.projectSha !== "string" || !/^[a-f0-9]{40}$/.test(producer.projectSha) || typeof producer.imageDigest !== "string" || !/^sha256:[a-f0-9]{64}$/.test(producer.imageDigest) || runtimePackageManifest?.file !== "runtime-package-manifest.json" || typeof runtimePackageManifest.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(runtimePackageManifest.sha256)) {
-    throw new Error("Runtime evidence producer image identity is invalid");
-  }
-  return producer;
-};
-var resolveRuntimeEvidenceProducer = async ({
-  projectRoot,
-  required
-}) => {
-  const projectSha = String(process.env.TRADEJS_PROJECT_SHA ?? "").trim();
-  const imageDigest = String(
-    process.env.TRADEJS_PROJECT_IMAGE_DIGEST ?? ""
-  ).trim();
-  if (!projectSha && !imageDigest && !required) {
-    return null;
-  }
-  if (!/^[a-f0-9]{40}$/.test(projectSha)) {
-    throw new Error(
-      "TRADEJS_PROJECT_SHA must be a full lowercase Git SHA before publishing runtime evidence"
-    );
-  }
-  if (!/^sha256:[a-f0-9]{64}$/.test(imageDigest)) {
-    throw new Error(
-      "TRADEJS_PROJECT_IMAGE_DIGEST must be an immutable sha256 digest before publishing runtime evidence"
-    );
-  }
-  const manifestPath = import_node_path.default.join(projectRoot, "runtime-package-manifest.json");
-  let manifest;
-  try {
-    manifest = await import_promises.default.readFile(manifestPath);
-  } catch (error) {
-    if (!required && error.code === "ENOENT") {
-      return null;
-    }
-    throw new Error(
-      `Runtime package manifest is required for runtime evidence: ${manifestPath}`,
-      { cause: error }
-    );
-  }
-  return {
-    schemaVersion: 1,
-    projectSha,
-    imageDigest,
-    runtimePackageManifest: {
-      file: "runtime-package-manifest.json",
-      sha256: sha256(manifest)
-    }
-  };
-};
+var runtimeEvidenceProducer_exports = {};
+__reExport(runtimeEvidenceProducer_exports, require("@tradejs/node/diagnostics"));
 
 // src/lib/runtimeEvidenceCompositionSnapshots.ts
 var SNAPSHOT_FILE = "snapshot.json";
@@ -237,8 +68,8 @@ var createRuntimeEvidenceCompositionSnapshotRecorder = ({
     }
   };
 };
-var isRecord3 = (value) => value != null && typeof value === "object" && !Array.isArray(value);
-var sha2562 = (value) => (0, import_node_crypto2.createHash)("sha256").update(value).digest("hex");
+var isRecord = (value) => value != null && typeof value === "object" && !Array.isArray(value);
+var sha256 = (value) => (0, import_node_crypto.createHash)("sha256").update(value).digest("hex");
 var safeSegment = (value, label) => {
   const normalized = value.trim();
   if (!normalized || !/^[a-zA-Z0-9._:-]+$/.test(normalized)) {
@@ -251,8 +82,8 @@ var isExistingDestinationError = (error) => {
   return code === "EEXIST" || code === "ENOTEMPTY";
 };
 var parseManifest = (value) => {
-  const manifest = isRecord3(value) ? value : null;
-  const payload = isRecord3(manifest?.payload) ? manifest.payload : null;
+  const manifest = isRecord(value) ? value : null;
+  const payload = isRecord(manifest?.payload) ? manifest.payload : null;
   if (manifest?.schemaVersion !== 1 || manifest.reportType !== "runtime-evidence-composition-snapshot" || typeof manifest.createdAt !== "number" || typeof manifest.userName !== "string" || typeof manifest.deploymentId !== "string" || typeof manifest.deploymentCompositionId !== "string" || payload?.file !== SNAPSHOT_FILE || typeof payload.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(payload.sha256) || typeof payload.bytes !== "number") {
     throw new Error("Invalid runtime evidence composition snapshot manifest");
   }
@@ -260,28 +91,28 @@ var parseManifest = (value) => {
 };
 var verifyRuntimeEvidenceCompositionSnapshot = async (bundleDir) => {
   const [manifestText, payload, completeText] = await Promise.all([
-    import_promises2.default.readFile(import_node_path2.default.join(bundleDir, MANIFEST_FILE), "utf8"),
-    import_promises2.default.readFile(import_node_path2.default.join(bundleDir, SNAPSHOT_FILE)),
-    import_promises2.default.readFile(import_node_path2.default.join(bundleDir, COMPLETE_FILE), "utf8")
+    import_promises.default.readFile(import_node_path.default.join(bundleDir, MANIFEST_FILE), "utf8"),
+    import_promises.default.readFile(import_node_path.default.join(bundleDir, SNAPSHOT_FILE)),
+    import_promises.default.readFile(import_node_path.default.join(bundleDir, COMPLETE_FILE), "utf8")
   ]);
   const manifest = parseManifest(JSON.parse(manifestText));
   if (completeText.trim() !== manifest.deploymentCompositionId) {
     throw new Error(`Invalid completion marker in ${bundleDir}`);
   }
-  if (payload.byteLength !== manifest.payload.bytes || sha2562(payload) !== manifest.payload.sha256) {
+  if (payload.byteLength !== manifest.payload.bytes || sha256(payload) !== manifest.payload.sha256) {
     throw new Error(
       `Runtime evidence snapshot checksum mismatch in ${bundleDir}`
     );
   }
   const value = JSON.parse(payload.toString("utf8"));
-  const record = isRecord3(value) ? value : null;
+  const record = isRecord(value) ? value : null;
   if (record?.schemaVersion !== 1 || record.reportType !== "runtime-evidence-composition-snapshot" || record.userName !== manifest.userName) {
     throw new Error(
       `Invalid runtime evidence snapshot payload in ${bundleDir}`
     );
   }
-  const deployment = parseRuntimeEvidenceDeploymentSnapshot(record.deployment);
-  const producer = parseRuntimeEvidenceProducer(record.producer);
+  const deployment = (0, runtimeEvidenceDeployment_exports.parseRuntimeEvidenceDeploymentSnapshot)(record.deployment);
+  const producer = (0, runtimeEvidenceProducer_exports.parseRuntimeEvidenceProducer)(record.producer);
   if (deployment.id !== manifest.deploymentId || deployment.deploymentCompositionId !== manifest.deploymentCompositionId) {
     throw new Error(
       `Runtime evidence snapshot identity mismatch in ${bundleDir}`
@@ -321,43 +152,43 @@ var publishRuntimeEvidenceCompositionSnapshot = async ({
     deploymentCompositionId: compositionId,
     payload: {
       file: SNAPSHOT_FILE,
-      sha256: sha2562(payload),
+      sha256: sha256(payload),
       bytes: Buffer.byteLength(payload)
     }
   };
-  const snapshotsRoot = import_node_path2.default.join(evidenceRoot, "snapshots", deploymentId);
-  const bundleDir = import_node_path2.default.join(snapshotsRoot, compositionId);
-  const temporaryDir = import_node_path2.default.join(
+  const snapshotsRoot = import_node_path.default.join(evidenceRoot, "snapshots", deploymentId);
+  const bundleDir = import_node_path.default.join(snapshotsRoot, compositionId);
+  const temporaryDir = import_node_path.default.join(
     evidenceRoot,
     "incoming",
-    `snapshot-${compositionId}.tmp-${(0, import_node_crypto2.randomUUID)()}`
+    `snapshot-${compositionId}.tmp-${(0, import_node_crypto.randomUUID)()}`
   );
-  await import_promises2.default.mkdir(temporaryDir, { recursive: true });
+  await import_promises.default.mkdir(temporaryDir, { recursive: true });
   try {
     await Promise.all([
-      import_promises2.default.writeFile(import_node_path2.default.join(temporaryDir, SNAPSHOT_FILE), payload, "utf8"),
-      import_promises2.default.writeFile(
-        import_node_path2.default.join(temporaryDir, MANIFEST_FILE),
+      import_promises.default.writeFile(import_node_path.default.join(temporaryDir, SNAPSHOT_FILE), payload, "utf8"),
+      import_promises.default.writeFile(
+        import_node_path.default.join(temporaryDir, MANIFEST_FILE),
         `${JSON.stringify(manifest, null, 2)}
 `,
         "utf8"
       )
     ]);
-    await import_promises2.default.writeFile(
-      import_node_path2.default.join(temporaryDir, COMPLETE_FILE),
+    await import_promises.default.writeFile(
+      import_node_path.default.join(temporaryDir, COMPLETE_FILE),
       `${compositionId}
 `,
       "utf8"
     );
-    await import_promises2.default.mkdir(snapshotsRoot, { recursive: true });
+    await import_promises.default.mkdir(snapshotsRoot, { recursive: true });
     try {
-      await import_promises2.default.rename(temporaryDir, bundleDir);
+      await import_promises.default.rename(temporaryDir, bundleDir);
     } catch (error) {
       if (!isExistingDestinationError(error)) throw error;
-      await import_promises2.default.rm(temporaryDir, { recursive: true, force: true });
+      await import_promises.default.rm(temporaryDir, { recursive: true, force: true });
     }
   } catch (error) {
-    await import_promises2.default.rm(temporaryDir, { recursive: true, force: true });
+    await import_promises.default.rm(temporaryDir, { recursive: true, force: true });
     throw error;
   }
   const verified = await verifyRuntimeEvidenceCompositionSnapshot(bundleDir);
@@ -375,12 +206,12 @@ var captureRuntimeEvidenceCompositionSnapshot = async ({
   expectedCompositionId
 }) => {
   const [deployment, producer] = await Promise.all([
-    resolveRuntimeEvidenceDeploymentSnapshot({
+    (0, runtimeEvidenceDeployment_exports.resolveRuntimeEvidenceDeploymentSnapshot)({
       userName,
       projectRoot,
       deploymentId
     }),
-    resolveRuntimeEvidenceProducer({ projectRoot, required: true })
+    (0, runtimeEvidenceProducer_exports.resolveRuntimeEvidenceProducer)({ projectRoot, required: true })
   ]);
   if (!producer) {
     throw new Error("Runtime evidence producer identity is required");
@@ -391,31 +222,31 @@ var captureRuntimeEvidenceCompositionSnapshot = async ({
     );
   }
   await publishRuntimeEvidenceCompositionSnapshot({
-    evidenceRoot: import_node_path2.default.join(projectRoot, "data", "runtime-evidence"),
+    evidenceRoot: import_node_path.default.join(projectRoot, "data", "runtime-evidence"),
     userName,
     deployment,
     producer
   });
 };
 var discoverRuntimeEvidenceCompositionSnapshots = async (evidenceRoot) => {
-  const rootDir = import_node_path2.default.join(evidenceRoot, "snapshots");
+  const rootDir = import_node_path.default.join(evidenceRoot, "snapshots");
   const bundleDirs = [];
   let deployments;
   try {
-    deployments = await import_promises2.default.readdir(rootDir, { withFileTypes: true });
+    deployments = await import_promises.default.readdir(rootDir, { withFileTypes: true });
   } catch (error) {
     if (error.code === "ENOENT") return [];
     throw error;
   }
   for (const deployment of deployments.filter((entry) => entry.isDirectory())) {
-    const deploymentDir = import_node_path2.default.join(rootDir, deployment.name);
-    const compositions = await import_promises2.default.readdir(deploymentDir, {
+    const deploymentDir = import_node_path.default.join(rootDir, deployment.name);
+    const compositions = await import_promises.default.readdir(deploymentDir, {
       withFileTypes: true
     });
     bundleDirs.push(
       ...compositions.filter(
         (entry) => entry.isDirectory() && !entry.name.startsWith(".") && !entry.name.includes(".tmp-")
-      ).map((entry) => import_node_path2.default.join(deploymentDir, entry.name))
+      ).map((entry) => import_node_path.default.join(deploymentDir, entry.name))
     );
   }
   return Promise.all(