@tradejs/cli 3.1.16 → 3.1.17-beta.231

package/dist/scripts/runtimeEvidenceSync.js

@@ -48,6 +48,166 @@ var import_node_util = require("util");
 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 samePackageVersions = (left, right) => {
+  if (!left || !right) return false;
+  const leftEntries = Object.entries(left).sort(
+    ([a], [b]) => a.localeCompare(b)
+  );
+  const rightEntries = Object.entries(right).sort(
+    ([a], [b]) => a.localeCompare(b)
+  );
+  return JSON.stringify(leftEntries) === JSON.stringify(rightEntries);
+};
+var runtimeLineageMatchesStrategySnapshot = ({
+  lineage,
+  deployment,
+  strategy
+}) => lineage?.schemaVersion === 3 && lineage.strategyRevision === strategy.strategyRevision && lineage.deploymentCompositionId === deployment.deploymentCompositionId && lineage.strategyPackageVersion === strategy.strategyPackageVersion && lineage.runtimePackageVersion === strategy.runtimePackageVersion && samePackageVersions(
+  lineage.strategyDependencyVersions,
+  strategy.strategyDependencyVersions
+);
+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 activeRuntimeEvidenceStrategies = (deployment) => deployment.enabled ? deployment.strategies.filter((strategy) => strategy.enabled) : [];
+var unwrapRuntimeEvidenceRows = (value, field) => (Array.isArray(value) ? value : []).map((candidate) => {
+  const record = isRecord(candidate) ? candidate : null;
+  const nested = record && isRecord(record[field]) ? record[field] : null;
+  return nested ?? record;
+}).filter((record) => record != null);
+var assertCurrentRuntimeEvidenceArtifact = (artifact) => {
+  if (!isRecord(artifact) || artifact.reportType !== "runtime-evidence") {
+    throw new Error("Invalid runtime evidence artifact");
+  }
+  const deployment = parseRuntimeEvidenceDeploymentSnapshot(
+    artifact.deployment
+  );
+  const activeStrategies = activeRuntimeEvidenceStrategies(deployment);
+  if (activeStrategies.length === 0) {
+    throw new Error("Runtime evidence deployment has no enabled strategies");
+  }
+  const runtime = isRecord(artifact.runtime) ? artifact.runtime : null;
+  if (!runtime) {
+    throw new Error("Runtime evidence payload is missing");
+  }
+  if ("strategyConfigs" in runtime) {
+    throw new Error(
+      "Runtime evidence payload contains removed strategyConfigs data"
+    );
+  }
+  const rowFields = [
+    "trades",
+    "signals",
+    "evaluations",
+    "lineageScopes"
+  ];
+  for (const field of rowFields) {
+    if (!Array.isArray(runtime[field])) {
+      throw new Error(`Runtime evidence payload ${field} must be an array`);
+    }
+  }
+  const snapshots = new Map(
+    activeStrategies.map((strategy) => [strategy.strategyName, strategy])
+  );
+  const assertRows = (label, rows, lineageField) => {
+    for (const row of rows) {
+      const strategyName = String(row.strategy ?? "").trim();
+      const strategy = snapshots.get(strategyName);
+      if (!strategy || row.deploymentId !== deployment.id || row.accountId !== deployment.accountId || !runtimeLineageMatchesStrategySnapshot({
+        lineage: isRecord(row[lineageField]) ? row[lineageField] : void 0,
+        deployment,
+        strategy
+      })) {
+        throw new Error(
+          `Runtime evidence ${label} row is outside the current embedded deployment lineage`
+        );
+      }
+    }
+  };
+  assertRows(
+    "trade",
+    unwrapRuntimeEvidenceRows(runtime.trades, "trade"),
+    "runtimeLineage"
+  );
+  assertRows(
+    "signal",
+    unwrapRuntimeEvidenceRows(runtime.signals, "signal"),
+    "runtimeLineage"
+  );
+  assertRows(
+    "evaluation",
+    unwrapRuntimeEvidenceRows(runtime.evaluations, "evaluation"),
+    "runtimeLineage"
+  );
+  assertRows(
+    "lineage scope",
+    unwrapRuntimeEvidenceRows(runtime.lineageScopes, "lineageScope"),
+    "lineage"
+  );
+  return deployment;
+};
+
+// src/lib/runtimeEvidenceArtifacts.ts
 var RUNTIME_EVIDENCE_MANIFEST_FILE = "manifest.json";
 var RUNTIME_EVIDENCE_PAYLOAD_FILE = "runtime-evidence.json";
 var RUNTIME_EVIDENCE_COMPLETE_FILE = ".complete";
@@ -117,6 +277,10 @@ var verifyRuntimeEvidenceBundle = async (bundleDir) => {
   if (artifact?.reportType !== "runtime-evidence" || artifactWindow?.startTime !== manifest.window.startTime || artifactWindow.endTime !== manifest.window.endTime) {
     throw new Error(`Runtime evidence payload mismatch in ${bundleDir}`);
   }
+  const deployment = assertCurrentRuntimeEvidenceArtifact(artifact);
+  if (deployment.id !== manifest.deploymentId) {
+    throw new Error(`Runtime evidence deployment mismatch in ${bundleDir}`);
+  }
   return {
     bundleDir,
     manifestPath,
@@ -151,70 +315,6 @@ var discoverRuntimeEvidenceBundles = async (rootDir) => {
   return bundles.sort();
 };
 
-// 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 activeRuntimeEvidenceStrategies = (deployment) => deployment.enabled ? deployment.strategies.filter((strategy) => strategy.enabled) : [];
-
 // src/lib/runtimeEvidenceSync.ts
 var execFileAsync = (0, import_node_util.promisify)(import_node_child_process.execFile);
 var isExistingDestinationError = (error) => {
@@ -248,25 +348,7 @@ var buildRuntimeEvidenceRsyncArgs = ({
 ];
 var receiptPath = (receiptsRoot, artifactId) => import_node_path2.default.join(receiptsRoot, `${safeSegment(artifactId, "artifact")}.json`);
 var compareBundles = (left, right) => left.manifest.window.endTime - right.manifest.window.endTime || left.manifest.createdAt - right.manifest.createdAt;
-var inspectRuntimeEvidenceBundleSupport = (bundle) => {
-  try {
-    const deployment = parseRuntimeEvidenceDeploymentSnapshot(
-      bundle.artifact.deployment
-    );
-    if (activeRuntimeEvidenceStrategies(deployment).length === 0) {
-      throw new Error(
-        "Runtime evidence deployment has no enabled active strategies"
-      );
-    }
-    return { supported: true };
-  } catch (error) {
-    return {
-      supported: false,
-      reason: error instanceof Error ? error.message : String(error)
-    };
-  }
-};
-var listRuntimeEvidenceBundleStatuses = async ({
+var listPendingRuntimeEvidenceBundles = async ({
   evidenceRoot,
   deploymentId
 }) => {
@@ -275,29 +357,19 @@ var listRuntimeEvidenceBundleStatuses = async ({
   const receiptsRoot = import_node_path2.default.join(evidenceRoot, "receipts", safeDeploymentId);
   const bundles = await discoverRuntimeEvidenceBundles(artifactsRoot);
   const pending = [];
-  const unsupported = [];
   for (const bundleDir of bundles) {
     const verified = await verifyRuntimeEvidenceBundle(bundleDir);
     if (verified.manifest.deploymentId !== safeDeploymentId) continue;
+    assertCurrentRuntimeEvidenceArtifact(verified.artifact);
     try {
       await import_promises2.default.access(receiptPath(receiptsRoot, verified.manifest.artifactId));
       continue;
     } catch (error) {
       if (error.code !== "ENOENT") throw error;
     }
-    const support = inspectRuntimeEvidenceBundleSupport(verified);
-    if (support.supported) {
-      pending.push(verified);
-    } else {
-      unsupported.push({ bundle: verified, reason: support.reason });
-    }
+    pending.push(verified);
   }
-  return {
-    pending: pending.sort(compareBundles),
-    unsupported: unsupported.sort(
-      (left, right) => compareBundles(left.bundle, right.bundle)
-    )
-  };
+  return pending.sort(compareBundles);
 };
 var syncRuntimeEvidenceBundles = async ({
   source,
@@ -331,6 +403,7 @@ var syncRuntimeEvidenceBundles = async ({
         `Artifact deployment mismatch: expected ${safeDeploymentId}, received ${verified.manifest.deploymentId}`
       );
     }
+    assertCurrentRuntimeEvidenceArtifact(verified.artifact);
     const destinationDir = import_node_path2.default.join(
       artifactsRoot,
       ...dateParts(verified.manifest.window.endTime),
@@ -351,7 +424,7 @@ var syncRuntimeEvidenceBundles = async ({
     }
     received.push(await verifyRuntimeEvidenceBundle(destinationDir));
   }
-  const statuses = await listRuntimeEvidenceBundleStatuses({
+  const pending = await listPendingRuntimeEvidenceBundles({
     evidenceRoot,
     deploymentId: safeDeploymentId
   });
@@ -360,7 +433,7 @@ var syncRuntimeEvidenceBundles = async ({
     stdout: String(transfer.stdout ?? ""),
     stderr: String(transfer.stderr ?? ""),
     received,
-    ...statuses
+    pending
   };
 };
 
@@ -397,7 +470,7 @@ var runtimeEvidenceSync = async () => {
   });
   console.log(
     import_chalk.default.green(
-      `Runtime evidence sync completed: received=${result.received.length} pending=${result.pending.length} unsupported=${result.unsupported.length}`
+      `Runtime evidence sync completed: received=${result.received.length} pending=${result.pending.length}`
     )
   );
   console.log(
@@ -414,13 +487,6 @@ var runtimeEvidenceSync = async () => {
           bundleDir: bundle.bundleDir,
           payloadPath: bundle.payloadPath,
           window: bundle.manifest.window
-        })),
-        unsupported: result.unsupported.map(({ bundle, reason }) => ({
-          artifactId: bundle.manifest.artifactId,
-          bundleDir: bundle.bundleDir,
-          payloadPath: bundle.payloadPath,
-          window: bundle.manifest.window,
-          reason
         }))
       },
       null,

package/dist/scripts/runtimeParity.js

@@ -411,9 +411,7 @@ var loadRuntimeTrades = async (userName, {
       dedupedBucketTrades.set(trade.orderId, trade);
     }
     const windowedTrades = [...dedupedBucketTrades.values()].filter(filterByWindow).sort((left, right) => left.entryTimestamp - right.entryTimestamp);
-    if (windowedTrades.length > 0 || dayKeys.length === 0) {
-      return windowedTrades;
-    }
+    return windowedTrades;
   }
   const tradePrefix = import_redis.redisKeys.runtimeTrades(userName);
   const bucketPrefix = import_redis.redisKeys.runtimeTradeBuckets(userName);