@tradejs/cli 3.1.29-beta.281 → 3.1.29-beta.283

package/dist/lib/mcpReplayProcess.js

@@ -59,8 +59,21 @@ const timer = setInterval(() => {
   try {
     const result = JSON.parse(fs.readFileSync(file + '.result', 'utf8'));
     console.log(result.message);
+    if (result.exitCode !== 0) {
+      let fd;
+      try {
+        fd = fs.openSync(file + '.log', fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+        const size = fs.fstatSync(fd).size;
+        const tail = Buffer.alloc(Math.min(size, 65536));
+        fs.readSync(fd, tail, 0, tail.length, Math.max(0, size - tail.length));
+        // The worker redacts each line before persisting or returning it through MCP.
+        for (const line of tail.toString('utf8').split(/[\\r\\n]+/).filter(Boolean).slice(-150)) console.error('Host replay: ' + line);
+      } catch (error) {
+        console.error('Host replay log unavailable: ' + error.code);
+      } finally { if (fd !== undefined) fs.closeSync(fd); }
+    }
     clearInterval(timer);
-    process.exit(result.exitCode === 0 ? 0 : 1);
+    process.exitCode = result.exitCode === 0 ? 0 : 1;
   } catch (error) { if (error.code !== 'ENOENT') throw error; }
 }, 1000);
 `;
@@ -83,7 +96,7 @@ var buildMcpReplayProcess = async ({
   const heartbeat = JSON.parse(
     await import_promises.default.readFile(import_node_path.default.join(root, "heartbeat.json"), "utf8")
   );
-  if (!Number.isFinite(heartbeat.observedAt) || Date.now() - heartbeat.observedAt < 0 || Date.now() - heartbeat.observedAt > 12e4)
+  if (heartbeat.protocolVersion !== 2 || !Number.isFinite(heartbeat.observedAt) || Date.now() - heartbeat.observedAt < 0 || Date.now() - heartbeat.observedAt > 12e4)
     throw new Error("Host replay runner heartbeat is stale");
   const bytes = await import_promises.default.readFile(evidencePath);
   const request = JSON.stringify({

package/dist/lib/runtimeDebugEvidence.js

@@ -42,39 +42,6 @@ var isRuntimeTradeRecord = (value) => {
   const record = value;
   return typeof record.orderId === "string" && typeof record.strategy === "string" && typeof record.symbol === "string" && typeof record.entryTimestamp === "number" && typeof record.entryPrice === "number" && typeof record.qty === "number" && (record.direction === "LONG" || record.direction === "SHORT");
 };
-var loadRuntimeTrades = async (userName, {
-  startTime,
-  endTime
-} = {}) => {
-  const hasWindow = Number.isFinite(startTime) && Number.isFinite(endTime) && startTime != null && endTime != null;
-  const filterByWindow = (trade) => !hasWindow || trade.entryTimestamp >= startTime && trade.entryTimestamp <= endTime;
-  if (hasWindow) {
-    const dayKeys = (0, import_time.getRuntimeStorageDayKeys)(startTime, endTime);
-    const bucketTrades = (await Promise.all(
-      dayKeys.map(
-        (dayKey) => (0, import_redis.getHashJsonValues)(
-          import_redis.redisKeys.runtimeTradeBucket(userName, dayKey)
-        )
-      )
-    )).flat();
-    const dedupedBucketTrades = /* @__PURE__ */ new Map();
-    for (const trade of bucketTrades) {
-      if (!isRuntimeTradeRecord(trade)) {
-        continue;
-      }
-      dedupedBucketTrades.set(trade.orderId, trade);
-    }
-    const windowedTrades = [...dedupedBucketTrades.values()].filter(filterByWindow).sort((left, right) => left.entryTimestamp - right.entryTimestamp);
-    return windowedTrades;
-  }
-  const tradePrefix = import_redis.redisKeys.runtimeTrades(userName);
-  const bucketPrefix = import_redis.redisKeys.runtimeTradeBuckets(userName);
-  const keys = (await (0, import_redis.getKeys)(tradePrefix)).filter(
-    (key) => !key.startsWith(bucketPrefix)
-  );
-  const trades = await Promise.all(keys.map((key) => (0, import_redis.getData)(key, null)));
-  return trades.filter(isRuntimeTradeRecord).filter(filterByWindow).sort((left, right) => left.entryTimestamp - right.entryTimestamp);
-};
 var loadRuntimeClosedTrades = async (userName, {
   startTime,
   endTime
@@ -98,6 +65,49 @@ var loadRuntimeClosedTrades = async (userName, {
     (left, right) => left.exitTimestamp - right.exitTimestamp
   );
 };
+var loadRuntimeEvidenceTrades = async (userName, { startTime, endTime }) => {
+  const prefix = import_redis.redisKeys.runtimeTradeBuckets(userName);
+  const lastDay = (0, import_time.getRuntimeStorageDayKey)(endTime - 1);
+  const keys = (await (0, import_redis.getKeys)(prefix)).filter((key) => {
+    const day = key.slice(prefix.length);
+    return key.startsWith(prefix) && /^\d{4}-\d{2}-\d{2}$/.test(day) && day <= lastDay;
+  });
+  const retained = /* @__PURE__ */ new Map();
+  for (let offset = 0; offset < keys.length; offset += 16) {
+    const buckets = await Promise.all(
+      keys.slice(offset, offset + 16).map((key) => (0, import_redis.getHashJsonValues)(key))
+    );
+    for (const row of buckets.flat())
+      if (isRuntimeTradeRecord(row)) retained.set(row.orderId, row);
+  }
+  for (const row of await loadRuntimeClosedTrades(userName, {
+    startTime,
+    endTime
+  }))
+    retained.set(row.orderId, row);
+  return [...retained.values()].filter(
+    (row) => row.entryTimestamp < endTime && (row.status === "active" || Number.isFinite(row.exitTimestamp) && row.exitTimestamp >= startTime)
+  ).map((row) => {
+    const closesAfterCutoff = row.status === "closed" && row.exitTimestamp >= endTime;
+    if (!closesAfterCutoff && !(row.status === "active" && row.lastSyncedAt >= endTime))
+      return row;
+    return {
+      ...row,
+      status: "active",
+      currentPrice: null,
+      currentPnl: null,
+      closedPnl: null,
+      exitPrice: null,
+      actualExitPrice: null,
+      exitTimestamp: null,
+      exitType: null,
+      closeFee: null,
+      fundingFee: null,
+      totalFee: null,
+      lastSyncedAt: void 0
+    };
+  }).sort((a, b) => a.entryTimestamp - b.entryTimestamp);
+};
 
 // src/lib/runtimeSignalsLoader.ts
 var import_redis2 = require("@tradejs/infra/redis");
@@ -318,30 +328,13 @@ var collectRuntimeDebugEvidence = async ({
 }) => {
   const dayKeys = (0, import_time2.getRuntimeStorageDayKeys)(startTime, endTime);
   const dayKeySet = new Set(dayKeys);
-  const [
-    entryTrades,
-    closedTrades,
-    signals,
-    evaluations,
-    evaluationStatsBuckets,
-    lineageScopes
-  ] = await Promise.all([
-    loadRuntimeTrades(userName, { startTime, endTime }),
-    loadRuntimeClosedTrades(userName, { startTime, endTime }),
+  const [trades, signals, evaluations, evaluationStatsBuckets, lineageScopes] = await Promise.all([
+    loadRuntimeEvidenceTrades(userName, { startTime, endTime }),
     loadRuntimeSignals(userName, { startTime, endTime }),
     loadRuntimeSignalEvaluations(userName, { startTime, endTime }),
     loadRuntimeSignalEvaluationStatsBuckets(userName),
     loadRuntimeLineageScopes(userName, { startTime, endTime })
   ]);
-  const tradesByOrderId = new Map(
-    entryTrades.map((trade) => [trade.orderId, trade])
-  );
-  for (const trade of closedTrades) {
-    tradesByOrderId.set(trade.orderId, trade);
-  }
-  const trades = [...tradesByOrderId.values()].sort(
-    (left, right) => left.entryTimestamp - right.entryTimestamp
-  );
   const filteredStats = evaluationStatsBuckets.filter(
     (entry) => dayKeySet.has(entry.dayKey) && (!deploymentId || entry.deploymentId === deploymentId) && (!strategies?.length || strategies.includes(entry.strategy))
   );