@tradejs/cli 3.1.28-beta.256 → 3.1.28-beta.258

package/dist/scripts/runtimeFeedbackNotify.js

@@ -0,0 +1,438 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+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-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/scripts/runtimeFeedbackNotify.ts
+var runtimeFeedbackNotify_exports = {};
+__export(runtimeFeedbackNotify_exports, {
+  main: () => main,
+  runtimeFeedbackNotify: () => runtimeFeedbackNotify
+});
+module.exports = __toCommonJS(runtimeFeedbackNotify_exports);
+var import_node_path4 = __toESM(require("path"));
+var import_args = __toESM(require("args"));
+var import_chalk = __toESM(require("chalk"));
+
+// src/lib/runtimeFeedbackArtifacts.ts
+var import_node_crypto3 = require("crypto");
+var import_promises3 = __toESM(require("fs/promises"));
+var import_node_path3 = __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 activeRuntimeEvidenceStrategies = (deployment) => deployment.enabled ? deployment.strategies.filter((strategy) => strategy.enabled) : [];
+
+// src/lib/runtimeEvidenceArtifacts.ts
+var import_node_crypto = require("crypto");
+var import_promises = __toESM(require("fs/promises"));
+var import_node_path = __toESM(require("path"));
+
+// src/lib/runtimeEvidenceProducer.ts
+var import_node_crypto2 = require("crypto");
+var import_promises2 = __toESM(require("fs/promises"));
+var import_node_path2 = __toESM(require("path"));
+var isRecord2 = (value) => value != null && typeof value === "object" && !Array.isArray(value);
+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;
+};
+
+// src/lib/runtimeFeedbackArtifacts.ts
+var RUNTIME_FEEDBACK_MANIFEST_FILE = "manifest.json";
+var RUNTIME_FEEDBACK_REPLAY_FILE = "replay-runtime-evidence.json";
+var RUNTIME_FEEDBACK_LOG_FILE = "replay.log";
+var RUNTIME_FEEDBACK_COMPLETE_FILE = ".complete";
+var isRecord3 = (value) => value != null && typeof value === "object" && !Array.isArray(value);
+var sha256 = (value) => (0, import_node_crypto3.createHash)("sha256").update(value).digest("hex");
+var parsePayload = (value, expectedFile) => {
+  const payload = isRecord3(value) ? value : null;
+  if (payload?.file !== expectedFile || typeof payload.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(payload.sha256) || typeof payload.bytes !== "number" || !Number.isFinite(payload.bytes) || payload.bytes < 0) {
+    throw new Error(`Invalid runtime feedback payload: ${expectedFile}`);
+  }
+  return payload;
+};
+var parseManifest = (value) => {
+  const manifest = isRecord3(value) ? value : null;
+  const window = isRecord3(manifest?.window) ? manifest.window : null;
+  const runtimeEvidence = isRecord3(manifest?.runtimeEvidence) ? manifest.runtimeEvidence : null;
+  const safety = isRecord3(manifest?.safety) ? manifest.safety : null;
+  const payloads = isRecord3(manifest?.payloads) ? manifest.payloads : null;
+  if (manifest?.schemaVersion !== 1 || manifest.reportType !== "runtime-feedback-replay" || typeof manifest.artifactId !== "string" || !manifest.artifactId.trim() || typeof manifest.runId !== "string" || !manifest.runId.trim() || typeof manifest.deploymentId !== "string" || !manifest.deploymentId.trim() || typeof manifest.deploymentCompositionId !== "string" || !/^dc1:[a-f0-9]{16}$/.test(manifest.deploymentCompositionId) || typeof manifest.userName !== "string" || !manifest.userName.trim() || typeof manifest.createdAt !== "number" || typeof window?.startTime !== "number" || typeof window.endTime !== "number" || typeof runtimeEvidence?.artifactId !== "string" || typeof runtimeEvidence.payloadSha256 !== "string" || !/^[a-f0-9]{64}$/.test(runtimeEvidence.payloadSha256) || !Array.isArray(manifest.activeStrategies) || manifest.activeStrategies.length === 0 || !manifest.activeStrategies.every(
+    (strategy) => typeof strategy === "string" && strategy.trim()
+  ) || typeof manifest.cycleCount !== "number" || !Number.isFinite(manifest.cycleCount) || manifest.cycleCount <= 0 || safety?.cacheOnly !== true || safety.externalOrderPlacement !== false || safety.redis !== "isolated" || safety.timescale !== "read_only") {
+    throw new Error("Invalid runtime feedback replay manifest");
+  }
+  const replayEvidence = parsePayload(
+    payloads?.replayEvidence,
+    RUNTIME_FEEDBACK_REPLAY_FILE
+  );
+  const log = parsePayload(payloads?.log, RUNTIME_FEEDBACK_LOG_FILE);
+  return {
+    ...manifest,
+    producer: parseRuntimeEvidenceProducer(manifest.producer),
+    payloads: {
+      replayEvidence: {
+        ...replayEvidence,
+        file: RUNTIME_FEEDBACK_REPLAY_FILE
+      },
+      log: { ...log, file: RUNTIME_FEEDBACK_LOG_FILE }
+    }
+  };
+};
+var verifyRuntimeFeedbackReplayBundle = async (bundleDir) => {
+  const manifestPath = import_node_path3.default.join(bundleDir, RUNTIME_FEEDBACK_MANIFEST_FILE);
+  const replayEvidencePath = import_node_path3.default.join(bundleDir, RUNTIME_FEEDBACK_REPLAY_FILE);
+  const logPath = import_node_path3.default.join(bundleDir, RUNTIME_FEEDBACK_LOG_FILE);
+  const completePath = import_node_path3.default.join(bundleDir, RUNTIME_FEEDBACK_COMPLETE_FILE);
+  const [manifestText, replayPayload, logPayload, completeText] = await Promise.all([
+    import_promises3.default.readFile(manifestPath, "utf8"),
+    import_promises3.default.readFile(replayEvidencePath),
+    import_promises3.default.readFile(logPath),
+    import_promises3.default.readFile(completePath, "utf8")
+  ]);
+  const manifest = parseManifest(JSON.parse(manifestText));
+  if (completeText.trim() !== manifest.artifactId) {
+    throw new Error(`Invalid runtime feedback completion marker: ${bundleDir}`);
+  }
+  for (const [payload, descriptor] of [
+    [replayPayload, manifest.payloads.replayEvidence],
+    [logPayload, manifest.payloads.log]
+  ]) {
+    if (payload.byteLength !== descriptor.bytes) {
+      throw new Error(
+        `Runtime feedback payload size mismatch: ${descriptor.file}`
+      );
+    }
+    if (sha256(payload) !== descriptor.sha256) {
+      throw new Error(
+        `Runtime feedback payload checksum mismatch: ${descriptor.file}`
+      );
+    }
+  }
+  const replayEvidence = JSON.parse(replayPayload.toString("utf8"));
+  if (replayEvidence.reportType !== "replay-runtime-evidence") {
+    throw new Error("Invalid runtime feedback replay evidence payload");
+  }
+  const replayWindow = isRecord3(replayEvidence.window) ? replayEvidence.window : null;
+  const replay = isRecord3(replayEvidence.replay) ? replayEvidence.replay : null;
+  const replayDeployment = parseRuntimeEvidenceDeploymentSnapshot(
+    replayEvidence.deployment
+  );
+  const replayStrategies = activeRuntimeEvidenceStrategies(replayDeployment).map(({ strategyName }) => strategyName).sort();
+  if (replayEvidence.userName !== manifest.userName || replayWindow?.startTime !== manifest.window.startTime || replayWindow.endTime !== manifest.window.endTime || replayDeployment.id !== manifest.deploymentId || replayDeployment.deploymentCompositionId !== manifest.deploymentCompositionId || Number(replay?.cycleCount) !== manifest.cycleCount || JSON.stringify(replayStrategies) !== JSON.stringify([...manifest.activeStrategies].sort())) {
+    throw new Error("Runtime feedback replay payload does not match manifest");
+  }
+  return {
+    bundleDir,
+    manifestPath,
+    replayEvidencePath,
+    logPath,
+    manifest,
+    replayEvidence
+  };
+};
+
+// src/lib/telegramReports.ts
+var import_cli = require("@tradejs/node/cli");
+var TELEGRAM_REPORT_CHUNK_LIMIT = 3900;
+var buildPartHeader = (index, total) => `\u{1F4E9} <b>Part ${index}/${total}</b>`;
+var splitLongLine = (line, limit) => {
+  const chunks = [];
+  for (let index = 0; index < line.length; index += limit) {
+    chunks.push(line.slice(index, index + limit));
+  }
+  return chunks;
+};
+var splitTelegramReport = (message, limit = TELEGRAM_REPORT_CHUNK_LIMIT) => {
+  const normalizedLimit = Math.max(100, Math.floor(limit));
+  if (message.length <= normalizedLimit) {
+    return [message];
+  }
+  const chunks = [];
+  let current = "";
+  const flush = () => {
+    if (!current) {
+      return;
+    }
+    chunks.push(current);
+    current = "";
+  };
+  for (const line of message.split("\n")) {
+    const next = current ? `${current}
+${line}` : line;
+    if (next.length <= normalizedLimit) {
+      current = next;
+      continue;
+    }
+    flush();
+    if (line.length <= normalizedLimit) {
+      current = line;
+      continue;
+    }
+    chunks.push(...splitLongLine(line, normalizedLimit));
+  }
+  flush();
+  return chunks;
+};
+var sendTelegramReport = async (message, options = {}) => {
+  const chunks = splitTelegramReport(message);
+  const sendAttachments = async () => {
+    for (const attachment of options.attachments || []) {
+      await (0, import_cli.sendDocumentToTG)(attachment, {
+        userName: options.userName
+      });
+    }
+  };
+  if (chunks.length === 1) {
+    await (0, import_cli.sendTextToTG)(chunks[0], options);
+    await sendAttachments();
+    return chunks.length;
+  }
+  for (const [index, chunk] of chunks.entries()) {
+    const header = buildPartHeader(index + 1, chunks.length);
+    await (0, import_cli.sendTextToTG)(`${header}
+
+${chunk}`, {
+      userName: options.userName,
+      markup: index === chunks.length - 1 ? options.markup : void 0
+    });
+  }
+  await sendAttachments();
+  return chunks.length;
+};
+
+// src/lib/runtimeFeedbackNotification.ts
+var isRecord4 = (value) => value != null && typeof value === "object" && !Array.isArray(value);
+var asRecord = (value) => isRecord4(value) ? value : {};
+var asArray = (value) => Array.isArray(value) ? value.map(asRecord) : [];
+var finiteNumber = (value, fallback = 0) => {
+  const number = Number(value);
+  return Number.isFinite(number) ? number : fallback;
+};
+var requiredTimestamp = (value, field) => {
+  const timestamp = Number(value);
+  if (!Number.isFinite(timestamp)) {
+    throw new Error(`Runtime feedback replay is missing ${field}`);
+  }
+  return timestamp;
+};
+var escapeHtml = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+var formatMskDateTime = (timestamp) => new Intl.DateTimeFormat("ru-RU", {
+  timeZone: "Europe/Moscow",
+  year: "numeric",
+  month: "2-digit",
+  day: "2-digit",
+  hour: "2-digit",
+  minute: "2-digit",
+  hour12: false
+}).format(new Date(timestamp));
+var formatConnectorName = (value) => {
+  const connectorName = String(value ?? "unknown").trim() || "unknown";
+  return connectorName.toLowerCase() === "bybit" ? "ByBit" : connectorName;
+};
+var sumRows = (rows, field) => rows.reduce((total, row) => total + finiteNumber(row[field]), 0);
+var buildRuntimeFeedbackTelegramMessage = (replayEvidence) => {
+  if (replayEvidence.reportType !== "replay-runtime-evidence") {
+    throw new Error("Invalid runtime feedback replay evidence payload");
+  }
+  const window = asRecord(replayEvidence.window);
+  const startTime = requiredTimestamp(window.startTime, "window.startTime");
+  const endTime = requiredTimestamp(window.endTime, "window.endTime");
+  const deployment = asRecord(replayEvidence.deployment);
+  const replay = asRecord(replayEvidence.replay);
+  if (!isRecord4(replay.runtimeComparison) || !isRecord4(replay.runtimeComparison.counts) || !Array.isArray(replay.runtimeComparison.rows) || !isRecord4(replay.runtimeComparison.lineage)) {
+    throw new Error("Runtime feedback replay comparison is missing");
+  }
+  const comparison = asRecord(replay.runtimeComparison);
+  const comparisonCounts = asRecord(comparison.counts);
+  const runtimeCounts = asRecord(asRecord(replayEvidence.runtime).counts);
+  const lineage = asRecord(comparison.lineage);
+  const rows = asArray(comparison.rows);
+  const matched = finiteNumber(comparisonCounts.matched);
+  const runtimeOnly = finiteNumber(comparisonCounts.runtimeOnly);
+  const backtestOnly = finiteNumber(comparisonCounts.backtestOnly);
+  const orderFailed = sumRows(rows, "orderFailed");
+  const runtimeEntries = sumRows(rows, "runtimeTrades");
+  const backtestEntries = sumRows(rows, "backtestEntries");
+  const replayScopes = finiteNumber(lineage.replayScopes);
+  const comparableScopes = finiteNumber(lineage.comparableScopes);
+  const excludedRuntimeTrades = finiteNumber(lineage.excludedRuntimeTrades);
+  const issueRows = rows.filter(
+    (row) => finiteNumber(row.runtimeOnly) > 0 || finiteNumber(row.backtestOnly) > 0 || finiteNumber(row.orderFailed) > 0
+  );
+  const lines = [
+    "\u{1F9EA} <b>TradeJS runtime parity</b>",
+    "",
+    "\u{1F552} <b>Window</b>",
+    `<b>${escapeHtml(formatMskDateTime(startTime))} - ${escapeHtml(formatMskDateTime(endTime))} MSK</b>`,
+    "",
+    `\u{1F50C} Connector: <b>${escapeHtml(formatConnectorName(deployment.connectorName ?? deployment.provider))}</b>`,
+    "\u{1F9EC} Source: <b>verified runtime feedback</b>",
+    `\u{1F4E6} Deployment: <b>${escapeHtml(String(deployment.id ?? "unknown"))}</b>`,
+    `\u{1F510} Composition: <code>${escapeHtml(String(deployment.deploymentCompositionId ?? "unknown"))}</code>`,
+    "",
+    "\u{1F4CC} <b>Overview</b>",
+    `\u2022 Runtime evidence: trades=<b>${finiteNumber(runtimeCounts.trades)}</b>, signals=<b>${finiteNumber(runtimeCounts.signals)}</b>, evaluations=<b>${finiteNumber(runtimeCounts.evaluations)}</b>`,
+    `\u2022 Comparable entries: runtime=<b>${runtimeEntries}</b> / backtest=<b>${backtestEntries}</b>`,
+    `\u2022 Matched: <b>${matched}</b> / order failed: <b>${orderFailed}</b>`,
+    `\u2022 Runtime only: <b>${runtimeOnly}</b> / Backtest only: <b>${backtestOnly}</b>`,
+    `\u2022 Lineage scopes: <b>${comparableScopes} / ${replayScopes}</b>`
+  ];
+  if (excludedRuntimeTrades > 0) {
+    lines.push(
+      `\u2022 Excluded runtime trades outside comparable lineage: <b>${excludedRuntimeTrades}</b>`
+    );
+  }
+  if (issueRows.length) {
+    lines.push("", "\u{1F4CA} <b>Strategy issues</b>");
+    for (const row of issueRows.slice(0, 10)) {
+      const issues = [
+        finiteNumber(row.orderFailed) > 0 ? `orderFailed=${finiteNumber(row.orderFailed)}` : null,
+        finiteNumber(row.runtimeOnly) > 0 ? `runtimeOnly=${finiteNumber(row.runtimeOnly)}` : null,
+        finiteNumber(row.backtestOnly) > 0 ? `backtestOnly=${finiteNumber(row.backtestOnly)}` : null
+      ].filter((value) => value != null);
+      lines.push(
+        `\u2022 ${escapeHtml(String(row.strategyName ?? "[unknown]"))}: ${issues.join(", ")}`
+      );
+    }
+    if (issueRows.length > 10) {
+      lines.push(`... <b>${issueRows.length - 10}</b> more`);
+    }
+  } else if (rows.length) {
+    lines.push(
+      "",
+      `\u{1F4CA} <b>Strategies</b>: clean <b>${rows.length}</b> / total <b>${rows.length}</b>`
+    );
+  }
+  return lines.join("\n");
+};
+var notifyRuntimeFeedbackBundle = async ({
+  bundleDir,
+  send = sendTelegramReport
+}) => {
+  const verified = await verifyRuntimeFeedbackReplayBundle(bundleDir);
+  const message = buildRuntimeFeedbackTelegramMessage(verified.replayEvidence);
+  await send(message, { userName: verified.manifest.userName });
+  return {
+    artifactId: verified.manifest.artifactId,
+    userName: verified.manifest.userName,
+    message
+  };
+};
+
+// src/scripts/runtimeFeedbackNotify.ts
+import_args.default.option("bundle", "Verified runtime feedback replay bundle directory");
+import_args.default.option("dryRun", "Verify and print the message without sending it", false);
+var flags = import_args.default.parse(process.argv);
+var projectRoot = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
+var runtimeFeedbackNotify = async () => {
+  const bundle = String(flags.bundle ?? "").trim();
+  if (!bundle) {
+    throw new Error("Provide --bundle for runtime feedback notification.");
+  }
+  const bundleDir = import_node_path4.default.resolve(projectRoot, bundle);
+  if (flags.dryRun) {
+    const verified = await verifyRuntimeFeedbackReplayBundle(bundleDir);
+    console.log(buildRuntimeFeedbackTelegramMessage(verified.replayEvidence));
+    return;
+  }
+  const result = await notifyRuntimeFeedbackBundle({ bundleDir });
+  console.log(
+    import_chalk.default.green(`Runtime feedback notification sent: ${result.artifactId}`)
+  );
+};
+var main = runtimeFeedbackNotify;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  main,
+  runtimeFeedbackNotify
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tradejs/cli",
-  "version": "3.1.28-beta.256",
+  "version": "3.1.28-beta.258",
   "description": "Official CLI for the TradeJS TypeScript framework: infra setup, backtests, signals, bots, and ML workflows.",
   "keywords": [
     "tradejs",
@@ -36,13 +36,13 @@
     "tradejs": "dist/cli.js"
   },
   "dependencies": {
-    "@tradejs/connectors": "^3.1.28-beta.256",
-    "@tradejs/core": "^3.1.28-beta.256",
-    "@tradejs/indicators": "^3.1.28-beta.256",
-    "@tradejs/infra": "^3.1.28-beta.256",
-    "@tradejs/node": "^3.1.28-beta.256",
-    "@tradejs/strategy-kit": "3.0.5",
-    "@tradejs/types": "^3.1.28-beta.256",
+    "@tradejs/connectors": "^3.1.28-beta.258",
+    "@tradejs/core": "^3.1.28-beta.258",
+    "@tradejs/indicators": "^3.1.28-beta.258",
+    "@tradejs/infra": "^3.1.28-beta.258",
+    "@tradejs/node": "^3.1.28-beta.258",
+    "@tradejs/strategy-kit": "3.0.6",
+    "@tradejs/types": "^3.1.28-beta.258",
     "args": "^5.0.3",
     "bcryptjs": "^2.4.3",
     "chalk": "4.1.2",