@tradejs/cli 1.0.9 → 1.0.10

package/dist/lib/runtimeTradeSync.js

@@ -0,0 +1,263 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/runtimeTradeSync.ts
+var runtimeTradeSync_exports = {};
+__export(runtimeTradeSync_exports, {
+  EXCHANGE_HISTORY_MAX_RANGE_MS: () => EXCHANGE_HISTORY_MAX_RANGE_MS,
+  consumeClosedPnlMatch: () => consumeClosedPnlMatch,
+  formatRuntimeTradeSyncError: () => formatRuntimeTradeSyncError,
+  loadClosedPnlRows: () => loadClosedPnlRows,
+  splitExchangeHistoryTimeRange: () => splitExchangeHistoryTimeRange,
+  syncRuntimeTrades: () => syncRuntimeTrades
+});
+module.exports = __toCommonJS(runtimeTradeSync_exports);
+var import_constants = require("@tradejs/core/constants");
+var import_time = require("@tradejs/core/time");
+var import_redis = require("@tradejs/infra/redis");
+var CLOSED_PNL_LIMIT = 100;
+var EXCHANGE_HISTORY_MAX_RANGE_MS = 7 * 24 * 60 * 60 * 1e3;
+var splitExchangeHistoryTimeRange = ({
+  startTime,
+  endTime,
+  maxRangeMs = EXCHANGE_HISTORY_MAX_RANGE_MS
+}) => {
+  if (!Number.isFinite(startTime) || !Number.isFinite(endTime) || !Number.isFinite(maxRangeMs) || maxRangeMs <= 0 || endTime <= startTime) {
+    return [{ startTime, endTime }];
+  }
+  const chunks = [];
+  let chunkStart = Math.trunc(startTime);
+  const finalEnd = Math.trunc(endTime);
+  const maxRange = Math.trunc(maxRangeMs);
+  while (chunkStart < finalEnd) {
+    const chunkEnd = Math.min(finalEnd, chunkStart + maxRange);
+    chunks.push({ startTime: chunkStart, endTime: chunkEnd });
+    if (chunkEnd >= finalEnd) {
+      break;
+    }
+    chunkStart = chunkEnd + 1;
+  }
+  return chunks;
+};
+var formatRuntimeTradeSyncError = (error) => {
+  if (!error || typeof error !== "object") {
+    return String(error || "unknown error");
+  }
+  const record = error;
+  const message = typeof record.message === "string" && record.message.trim() ? record.message.trim() : String(error);
+  const code = typeof record.code === "string" && record.code.trim() ? record.code.trim() : null;
+  const isAxiosError = record.isAxiosError === true;
+  const config = record.config && typeof record.config === "object" ? record.config : null;
+  const response = record.response && typeof record.response === "object" ? record.response : null;
+  const method = typeof config?.method === "string" && config.method.trim() ? config.method.toUpperCase() : null;
+  const url = typeof config?.url === "string" && config.url.trim() ? config.url.trim() : null;
+  const timeout = typeof config?.timeout === "number" && Number.isFinite(config.timeout) ? config.timeout : null;
+  const status = typeof response?.status === "number" && Number.isFinite(response.status) ? response.status : null;
+  const details = [
+    isAxiosError ? "axios" : null,
+    code,
+    status == null ? null : `status=${status}`,
+    method && url ? `${method} ${url}` : url,
+    timeout == null ? null : `timeout=${timeout}ms`
+  ].filter(Boolean);
+  return details.length > 0 ? `${message} (${details.join(", ")})` : message;
+};
+var loadClosedPnlRows = async ({
+  connector,
+  startTime,
+  endTime,
+  callbacks
+}) => {
+  if (typeof connector.getClosedPnl !== "function") {
+    callbacks?.onUnsupported?.();
+    return [];
+  }
+  const rows = [];
+  const chunks = splitExchangeHistoryTimeRange({ startTime, endTime });
+  for (const chunk of chunks) {
+    try {
+      const chunkRows = await connector.getClosedPnl({
+        startTime: chunk.startTime,
+        endTime: chunk.endTime,
+        limit: CLOSED_PNL_LIMIT
+      });
+      if (chunkRows.length >= CLOSED_PNL_LIMIT) {
+        callbacks?.onCapped?.(chunkRows.length);
+      }
+      rows.push(...chunkRows);
+    } catch (error) {
+      callbacks?.onError?.(error);
+    }
+  }
+  return rows.sort((left, right) => left.closedAt - right.closedAt);
+};
+var consumeClosedPnlMatch = (buckets, trade) => {
+  const rows = buckets.get(trade.symbol);
+  if (!rows?.length) {
+    return null;
+  }
+  const minimumClosedAt = trade.entryTimestamp - 5 * 6e4;
+  const matchIndex = rows.findIndex(
+    (row2) => Number.isFinite(row2.closedAt) && row2.closedAt >= minimumClosedAt
+  );
+  if (matchIndex < 0) {
+    return null;
+  }
+  const [row] = rows.splice(matchIndex, 1);
+  return row ?? null;
+};
+var syncRuntimeTrades = async ({
+  userName,
+  connector,
+  trades,
+  startTime,
+  endTime,
+  closedPnlCallbacks,
+  openPositionCallbacks
+}) => {
+  let openPositions = [];
+  let openPositionsReliable = true;
+  if (typeof connector.getOpenPositionPnl === "function") {
+    try {
+      openPositions = await connector.getOpenPositionPnl();
+    } catch (error) {
+      openPositionCallbacks?.onError?.(error);
+      openPositionsReliable = false;
+      openPositions = [];
+    }
+  }
+  const openPositionsBySymbol = new Map(
+    openPositions.map((position) => [position.symbol, position])
+  );
+  const activeOrderIdBySymbol = /* @__PURE__ */ new Map();
+  const symbols = [...new Set(trades.map((trade) => trade.symbol))];
+  await Promise.all(
+    symbols.map(async (symbol) => {
+      const activeRef = await (0, import_redis.getData)(
+        import_redis.redisKeys.runtimeActiveTrade(userName, symbol),
+        null
+      );
+      activeOrderIdBySymbol.set(
+        symbol,
+        typeof activeRef?.orderId === "string" ? activeRef.orderId : null
+      );
+    })
+  );
+  const closedPnlRows = await loadClosedPnlRows({
+    connector,
+    startTime,
+    endTime,
+    callbacks: closedPnlCallbacks
+  });
+  const closedPnlBuckets = /* @__PURE__ */ new Map();
+  for (const row of closedPnlRows) {
+    const bucket = closedPnlBuckets.get(row.symbol) ?? [];
+    bucket.push(row);
+    closedPnlBuckets.set(row.symbol, bucket);
+  }
+  const syncedTrades = [];
+  for (const trade of trades) {
+    if (trade.status !== "active") {
+      syncedTrades.push(trade);
+      continue;
+    }
+    const openPosition = openPositionsBySymbol.get(trade.symbol);
+    const activeOrderId = activeOrderIdBySymbol.get(trade.symbol);
+    const isCurrentActiveTrade = activeOrderId === trade.orderId;
+    if (!openPositionsReliable) {
+      syncedTrades.push({
+        ...trade,
+        status: "active",
+        lastSyncedAt: endTime
+      });
+      continue;
+    }
+    if (isCurrentActiveTrade && openPosition && openPosition.direction === trade.direction) {
+      const nextTrade2 = {
+        ...trade,
+        status: "active",
+        currentPrice: openPosition.currentPrice,
+        currentPnl: openPosition.unrealizedPnl,
+        lastSyncedAt: endTime
+      };
+      await (0, import_redis.setData)(
+        import_redis.redisKeys.runtimeTrade(userName, trade.orderId),
+        nextTrade2,
+        {
+          expire: 0
+        }
+      );
+      await (0, import_redis.setHashJsonField)(
+        import_redis.redisKeys.runtimeTradeBucket(
+          userName,
+          (0, import_time.getRuntimeStorageDayKey)(trade.entryTimestamp)
+        ),
+        trade.orderId,
+        nextTrade2,
+        { expire: 0 }
+      );
+      syncedTrades.push(nextTrade2);
+      continue;
+    }
+    const matchedClosedPnl = consumeClosedPnlMatch(closedPnlBuckets, trade);
+    const nextTrade = {
+      ...trade,
+      status: "closed",
+      currentPrice: matchedClosedPnl?.exitPrice ?? trade.currentPrice ?? null,
+      currentPnl: matchedClosedPnl?.closedPnl ?? trade.closedPnl ?? trade.currentPnl ?? null,
+      closedPnl: matchedClosedPnl?.closedPnl ?? trade.closedPnl ?? trade.currentPnl ?? null,
+      actualEntryPrice: matchedClosedPnl?.entryPrice ?? trade.actualEntryPrice ?? null,
+      exitPrice: matchedClosedPnl?.exitPrice ?? trade.exitPrice ?? null,
+      actualExitPrice: matchedClosedPnl?.exitPrice ?? trade.actualExitPrice ?? null,
+      exitTimestamp: matchedClosedPnl?.closedAt ?? trade.exitTimestamp ?? endTime,
+      exitType: trade.exitType ?? null,
+      openFee: matchedClosedPnl?.openFee ?? trade.openFee ?? null,
+      closeFee: matchedClosedPnl?.closeFee ?? trade.closeFee ?? null,
+      fundingFee: matchedClosedPnl?.fundingFee ?? trade.fundingFee ?? null,
+      totalFee: matchedClosedPnl?.totalFee ?? trade.totalFee ?? null,
+      lastSyncedAt: endTime
+    };
+    await Promise.all([
+      (0, import_redis.setData)(import_redis.redisKeys.runtimeTrade(userName, trade.orderId), nextTrade, {
+        expire: import_constants.TTL_1M
+      }),
+      (0, import_redis.setHashJsonField)(
+        import_redis.redisKeys.runtimeTradeBucket(
+          userName,
+          (0, import_time.getRuntimeStorageDayKey)(trade.entryTimestamp)
+        ),
+        trade.orderId,
+        nextTrade,
+        { expire: import_constants.TTL_1M }
+      ),
+      ...isCurrentActiveTrade ? [(0, import_redis.delKey)(import_redis.redisKeys.runtimeActiveTrade(userName, trade.symbol))] : []
+    ]);
+    syncedTrades.push(nextTrade);
+  }
+  return syncedTrades;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EXCHANGE_HISTORY_MAX_RANGE_MS,
+  consumeClosedPnlMatch,
+  formatRuntimeTradeSyncError,
+  loadClosedPnlRows,
+  splitExchangeHistoryTimeRange,
+  syncRuntimeTrades
+});

package/dist/lib/telegramReports.js

@@ -68,8 +68,16 @@ ${line}` : line;
 };
 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()) {
@@ -81,6 +89,7 @@ ${chunk}`, {
       markup: index === chunks.length - 1 ? options.markup : void 0
     });
   }
+  await sendAttachments();
   return chunks.length;
 };
 // Annotate the CommonJS export names for ESM import in node:

package/dist/lib/tickerUniverseCache.js

@@ -0,0 +1,116 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/tickerUniverseCache.ts
+var tickerUniverseCache_exports = {};
+__export(tickerUniverseCache_exports, {
+  loadRunTickers: () => loadRunTickers
+});
+module.exports = __toCommonJS(tickerUniverseCache_exports);
+var import_tickers = require("@tradejs/core/tickers");
+var import_redis = require("@tradejs/infra/redis");
+var import_cli = require("@tradejs/node/cli");
+var TICKER_CACHE_VERSION = 1;
+var parseSymbolsFromCLI = (symbols = "") => symbols.split(",").map((symbol) => symbol.trim().toUpperCase()).filter(Boolean);
+var isTickerLike = (value) => {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const ticker = value;
+  return typeof ticker.symbol === "string" && ticker.symbol.trim().length > 0 && typeof ticker.volume24h === "number" && Number.isFinite(ticker.volume24h);
+};
+var readCachedTickerUniverse = async (cacheKey) => {
+  const cached = await (0, import_redis.getData)(cacheKey, null);
+  if (!cached || !Array.isArray(cached.tickers)) {
+    return null;
+  }
+  const tickers = cached.tickers.filter(isTickerLike);
+  return tickers.length ? tickers : null;
+};
+var selectTickerSymbols = ({
+  tickers,
+  exclude,
+  limit
+}) => {
+  const excludedTickers = parseSymbolsFromCLI(exclude);
+  return (0, import_tickers.getTopTickers)(tickers, limit).map(({ value }) => value).filter((ticker) => !excludedTickers.includes(ticker));
+};
+var loadRunTickers = async ({
+  connector,
+  connectorName,
+  userName,
+  include,
+  exclude,
+  limit,
+  cacheOnly,
+  universe,
+  accountId,
+  assetClasses
+}) => {
+  if (include?.trim()) {
+    return (0, import_cli.getTickers)(connector, include, exclude, limit, void 0, {
+      universe,
+      assetClasses
+    });
+  }
+  const cacheKey = import_redis.redisKeys.tickerUniverse(
+    userName,
+    connectorName,
+    universe,
+    accountId
+  );
+  if (cacheOnly) {
+    const cachedTickers = await readCachedTickerUniverse(cacheKey);
+    if (!cachedTickers) {
+      throw new Error(
+        `No cached ticker universe for ${connectorName}. Run once without --cacheOnly or pass --tickers explicitly.`
+      );
+    }
+    return selectTickerSymbols({
+      tickers: cachedTickers,
+      exclude,
+      limit
+    });
+  }
+  const exchangeTickers = await connector.getTickers({
+    universe,
+    assetClasses
+  });
+  if (exchangeTickers.length) {
+    await (0, import_redis.setData)(
+      cacheKey,
+      {
+        version: TICKER_CACHE_VERSION,
+        connectorName,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        tickers: exchangeTickers
+      },
+      { expire: 0 }
+    );
+  }
+  return selectTickerSymbols({
+    tickers: exchangeTickers,
+    exclude,
+    limit
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  loadRunTickers
+});

package/dist/lib/timeWindow.js

@@ -54,9 +54,10 @@ var resolveTimeWindow = ({
 }) => {
   const explicitStart = toEpochMs(startTime);
   const explicitEnd = toEpochMs(endTime);
+  const resolvedDays = toPositiveNumber(days);
   if (explicitStart != null || explicitEnd != null) {
-    const resolvedEnd2 = explicitEnd ?? defaultEndMs ?? nowMs;
-    const resolvedStart = explicitStart ?? defaultStartMs;
+    const resolvedStart = explicitStart ?? (resolvedDays != null && explicitEnd != null ? explicitEnd - resolvedDays * ONE_DAY_MS : defaultStartMs);
+    const resolvedEnd2 = explicitEnd ?? (resolvedDays != null && explicitStart != null ? explicitStart + resolvedDays * ONE_DAY_MS : defaultEndMs ?? nowMs);
     if (resolvedStart >= resolvedEnd2) {
       throw new Error(
         `Invalid time window: startTime (${resolvedStart}) must be less than endTime (${resolvedEnd2})`
@@ -68,7 +69,6 @@ var resolveTimeWindow = ({
       source: "explicit"
     };
   }
-  const resolvedDays = toPositiveNumber(days);
   if (resolvedDays != null) {
     const resolvedEnd2 = defaultEndMs ?? nowMs;
     const resolvedStart = resolvedEnd2 - resolvedDays * ONE_DAY_MS;

package/dist/scripts/agentRun.js

@@ -39,6 +39,7 @@ var import_promises = __toESM(require("fs/promises"));
 var import_node_os = __toESM(require("os"));
 var import_node_path2 = __toESM(require("path"));
 var import_node_child_process = require("child_process");
+var import_constants = require("@tradejs/core/constants");
 var import_redis = require("@tradejs/infra/redis");
 var import_userSettings = require("@tradejs/infra/userSettings");
 
@@ -86,8 +87,16 @@ ${line}` : line;
 };
 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()) {
@@ -99,6 +108,7 @@ ${chunk}`, {
       markup: index === chunks.length - 1 ? options.markup : void 0
     });
   }
+  await sendAttachments();
   return chunks.length;
 };
 
@@ -603,9 +613,11 @@ var saveAgentRun = async (userName, runId, strategy, agentRun) => {
     ...run.artifacts,
     agentRun
   };
-  await (0, import_redis.setData)(import_redis.redisKeys.researchRun(userName, runId), run, { expire: 0 });
+  await (0, import_redis.setData)(import_redis.redisKeys.researchRun(userName, runId), run, {
+    expire: import_constants.TTL_1M
+  });
   await (0, import_redis.setData)(import_redis.redisKeys.researchLatestRun(userName, strategy), run, {
-    expire: 0
+    expire: import_constants.TTL_1M
   });
 };
 var resolveGithubRepository = async (worktreePath) => {
@@ -897,12 +909,6 @@ Return a corrected unified diff only. Keep the same allowed paths.`
     }
   }
 };
-if (require.main === module) {
-  main().catch((error) => {
-    console.error(import_chalk.default.red(error?.message || String(error)));
-    process.exit(1);
-  });
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   main