@tradejs/node 1.0.0

package/dist/cli.mjs

@@ -0,0 +1,548 @@
+import {
+  AI_CONCURRENCY_LIMIT,
+  KLINE_CONCURRENCY_LIMIT,
+  SCREENSHOT_CONCURRENCY_LIMIT,
+  TG_CONCURRENCY_LIMIT
+} from "./chunk-4ZPGZWO7.mjs";
+import {
+  require_lodash
+} from "./chunk-GKDBAF3A.mjs";
+import {
+  askAI
+} from "./chunk-ZIMX3JX2.mjs";
+import "./chunk-MHCXPD2B.mjs";
+import "./chunk-DE7ADBIR.mjs";
+import {
+  __toESM
+} from "./chunk-6DZX6EAA.mjs";
+
+// src/cli.ts
+var import_lodash = __toESM(require_lodash());
+import fs2 from "fs/promises";
+import ProgressBar from "progress";
+import chalk from "chalk";
+import { runWithConcurrency } from "@tradejs/core/async";
+import { getFormatted } from "@tradejs/core/backtest";
+import { PRELOAD_DAYS } from "@tradejs/core/constants";
+import { getTopTickers } from "@tradejs/core/tickers";
+import { getTimestamp } from "@tradejs/core/time";
+import { getFiles } from "@tradejs/infra/files";
+import {
+  RedisWriteBlockedError,
+  delKeyWithOptions,
+  getKeys,
+  getData as getData2,
+  redisKeys as redisKeys2
+} from "@tradejs/infra/redis";
+import { logger as logger2 } from "@tradejs/infra/logger";
+
+// src/screenshot.ts
+import fs from "fs/promises";
+import path from "path";
+import puppeteer from "puppeteer";
+import { delay } from "@tradejs/core/async";
+import { getData, redisKeys } from "@tradejs/infra/redis";
+var { APP_URL } = process.env;
+var getProjectRoot = () => {
+  const fromEnv = String(process.env.PROJECT_CWD || "").trim();
+  return fromEnv ? path.resolve(fromEnv) : process.cwd();
+};
+var getScreenshotsDir = () => path.join(getProjectRoot(), "data", "screenshots");
+var getImageUrl = ({ symbol, signalId, interval }) => `${APP_URL}/api/files/screenshot/${symbol}_${signalId}_${interval}`;
+var getScreenshotPath = ({ symbol, signalId, interval }) => {
+  return path.join(
+    getScreenshotsDir(),
+    `${symbol}_${signalId}_${interval}.png`
+  );
+};
+var screenDashboard = async (signal) => {
+  const { symbol, signalId, interval } = signal;
+  const rootUser = await getData(redisKeys.user("root"), null);
+  const token2 = rootUser && typeof rootUser === "object" ? rootUser.token : null;
+  const tokenParam = typeof token2 === "string" && token2.length > 0 ? `&token=${encodeURIComponent(token2)}` : "";
+  const browser = await puppeteer.launch({
+    headless: true,
+    executablePath: process.env.PUPPETEER_EXECUTABLE_PATH,
+    args: [
+      "--no-sandbox",
+      "--disable-setuid-sandbox",
+      "--disable-dev-shm-usage",
+      "--disable-gpu",
+      "--font-render-hinting=medium"
+    ]
+  });
+  try {
+    const page = await browser.newPage();
+    try {
+      await page.setViewport({
+        width: 1400,
+        height: 960,
+        deviceScaleFactor: 2
+      });
+      await page.goto(
+        `${APP_URL}/routes/dashboard/bybit/${symbol}/${interval}/?signalId=${signalId}&autoZoom=true${tokenParam}`
+      );
+      await delay(1e4);
+      await fs.mkdir(getScreenshotsDir(), { recursive: true });
+      await page.screenshot({
+        path: getScreenshotPath(signal)
+      });
+    } finally {
+      await page.close();
+    }
+  } finally {
+    await browser.close();
+  }
+};
+
+// src/signals.ts
+import { formatNumber } from "@tradejs/core/math";
+import { logger } from "@tradejs/infra/logger";
+var escapeHtml = (s) => {
+  if (!s) return "";
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+};
+var { APP_URL: APP_URL2, TG_BOT_TOKEN: token, TG_CHAT_ID: chatId } = process.env;
+var normalizeQuality = (value) => typeof value === "number" ? Math.max(1, Math.min(5, Math.round(value))) : null;
+var getLastNumber = (value) => {
+  if (Array.isArray(value)) {
+    const last = value[value.length - 1];
+    return typeof last === "number" ? last : void 0;
+  }
+  return typeof value === "number" ? value : void 0;
+};
+var getAiQualityLine = (analysis) => {
+  const quality = normalizeQuality(analysis?.quality);
+  if (!quality) return null;
+  const approvedCurrentDirection = analysis?.direction != null && analysis.direction !== null;
+  if (quality >= 4 && approvedCurrentDirection) {
+    return `\u{1F7E2} AI Quality: ${quality}/5`;
+  }
+  if (quality === 3 && approvedCurrentDirection) {
+    return `\u{1F7E1} AI Quality: ${quality}/5`;
+  }
+  return `\u{1F534} AI Quality: ${quality}/5`;
+};
+var formatMessage = (signal, analysis) => {
+  const {
+    symbol,
+    direction,
+    strategy,
+    orderStatus,
+    orderSkipReason,
+    isConfigFromBacktest,
+    ml,
+    prices: { currentPrice, takeProfitPrice, stopLossPrice, riskRatio },
+    indicators,
+    additionalIndicators
+  } = signal;
+  try {
+    const lines = [];
+    const distance = additionalIndicators?.distance;
+    const touches = additionalIndicators?.touches;
+    const correlation = getLastNumber(indicators.correlation);
+    const atrPct = getLastNumber(indicators.atrPct);
+    const spread = getLastNumber(indicators.spread);
+    const formatPrices = () => {
+      const tpPercent = Math.abs(
+        (takeProfitPrice - currentPrice) / currentPrice * 100
+      ).toFixed(2) + "%";
+      const slPercent = Math.abs((stopLossPrice - currentPrice) / currentPrice * 100).toFixed(
+        2
+      ) + "%";
+      const prices = [
+        `Price: <b>${formatNumber(currentPrice)}</b>`,
+        `TP: <b>${formatNumber(takeProfitPrice)}</b> (${tpPercent})`,
+        `SL: <b>${formatNumber(stopLossPrice)}</b> (${slPercent})`,
+        `R:R = <b>${riskRatio.toFixed(2)}</b>`
+      ].filter(Boolean).join("\n");
+      return prices;
+    };
+    const checkAnalys = () => {
+      const emojiDir = direction === "LONG" ? "\u{1F7E9} LONG" : direction === "SHORT" ? "\u{1F7E5} SHORT" : "\u2B1C\uFE0F NO TRADE";
+      lines.push(`<b>${emojiDir} ${symbol}</b>`);
+      lines.push(`Strategy: ${strategy}`);
+      lines.push("");
+      if (orderStatus) {
+        let orderStatusText = "\u26AA\uFE0F Order skipped";
+        if (orderStatus === "completed") {
+          orderStatusText = "\u{1F7E2} Order completed";
+        } else if (orderStatus === "failed") {
+          orderStatusText = "\u{1F534} Order failed";
+        } else if (orderStatus === "canceled") {
+          orderStatusText = "\u26AA\uFE0F Order skipped";
+        }
+        lines.push(orderStatusText);
+        if ((orderStatus === "skipped" || orderStatus === "canceled") && orderSkipReason) {
+          lines.push(`Skip reason: <b>${escapeHtml(orderSkipReason)}</b>`);
+        }
+      }
+      if (isConfigFromBacktest) {
+        lines.push("\u{1F7E2} Using config from backtest");
+      } else {
+        lines.push("\u{1F7E1} Using base config");
+      }
+      if (ml) {
+        lines.push(
+          `${ml.passed ? "\u{1F7E2} ML: PASS" : "\u{1F534} ML: FAIL"} (${ml.probability.toFixed(3)} / ${ml.threshold.toFixed(2)})`
+        );
+      }
+      const aiQualityLine = getAiQualityLine(analysis);
+      if (aiQualityLine) {
+        lines.push(aiQualityLine);
+      }
+      lines.push("");
+      if (touches) {
+        lines.push(`Points: ${touches}`);
+      }
+      if (atrPct != null && Number.isFinite(atrPct)) {
+        lines.push(`ATR: ${atrPct.toFixed(2)}`);
+      }
+      if (distance) {
+        lines.push(`Distance: ${distance}`);
+      }
+      if (correlation) {
+        lines.push(`BTC correlation: ${correlation}`);
+      }
+      if (spread != null && Number.isFinite(spread)) {
+        lines.push(`BTC spread (CB-BN)/BN: ${spread.toFixed(6)}`);
+      }
+      const prices = formatPrices();
+      if (prices) {
+        lines.push("");
+        lines.push(prices);
+      }
+    };
+    checkAnalys();
+    return lines.join("\n").trim();
+  } catch (err) {
+    return `<b>\u26A0\uFE0F \u041E\u0448\u0438\u0431\u043A\u0430 \u0444\u043E\u0440\u043C\u0430\u0442\u0438\u0440\u043E\u0432\u0430\u043D\u0438\u044F \u0441\u043E\u043E\u0431\u0449\u0435\u043D\u0438\u044F \u0434\u043B\u044F ${symbol}</b>
+\u0414\u0435\u0442\u0430\u043B\u0438: ${err.message || String(err)}`;
+  }
+};
+var sendSignal = async (signal, imgInterval, analysis) => {
+  const { symbol, signalId, interval } = signal;
+  const message = formatMessage(signal, analysis);
+  const markup = {
+    inline_keyboard: [
+      [
+        {
+          text: "Dashboard",
+          url: `${APP_URL2}/routes/dashboard/bybit/${symbol}/${interval}/?signalId=${signalId}`
+        }
+      ]
+    ]
+  };
+  if (!APP_URL2?.startsWith("https")) {
+    await fetch(`https://api.telegram.org/bot${token}/sendMessage`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        chat_id: chatId,
+        text: message,
+        parse_mode: "HTML"
+      })
+    });
+    return;
+  }
+  const imageUrl = getImageUrl({ ...signal, interval: imgInterval });
+  const res = await fetch(`https://api.telegram.org/bot${token}/sendPhoto`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      chat_id: chatId,
+      photo: imageUrl,
+      caption: message,
+      reply_markup: markup,
+      parse_mode: "HTML"
+    })
+  });
+  const data = await res.json();
+  if (!data?.ok) {
+    await fetch(`https://api.telegram.org/bot${token}/sendMessage`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        chat_id: chatId,
+        text: JSON.stringify(data),
+        parse_mode: "HTML"
+      })
+    });
+  }
+  logger.info("tg sendPhoto: %s", data?.ok ? "sent" : JSON.stringify(data));
+};
+var formatAnalysisMessage = (signal, analysis) => {
+  const lines = [];
+  const blocks = [];
+  const quality = normalizeQuality(analysis.quality);
+  lines.push(`<b>AI analysis ${signal.symbol}</b>`);
+  lines.push(`Signal direction: <b>${signal.direction}</b>`);
+  lines.push(`AI direction: <b>${analysis.direction ?? "NO TRADE"}</b>`);
+  if (quality) {
+    lines.push(`Quality: <b>${quality}/5</b>`);
+  }
+  if (typeof analysis.needRetest === "boolean") {
+    lines.push(`Need retest: <b>${analysis.needRetest ? "YES" : "NO"}</b>`);
+  }
+  if (typeof analysis.retestPrice === "number") {
+    lines.push(`Retest price: <b>${formatNumber(analysis.retestPrice)}</b>`);
+  }
+  if (typeof analysis.takeProfitPrice === "number") {
+    lines.push(`AI TP: <b>${formatNumber(analysis.takeProfitPrice)}</b>`);
+  }
+  if (typeof analysis.stopLossPrice === "number") {
+    lines.push(`AI SL: <b>${formatNumber(analysis.stopLossPrice)}</b>`);
+  }
+  const pushBlock = (title, value) => {
+    if (!value) return;
+    const clean = value.trim();
+    if (!clean) return;
+    blocks.push(`<b>${title}:</b>
+${escapeHtml(clean)}`);
+  };
+  pushBlock("Setup", analysis.setup);
+  pushBlock("Confirmations", analysis.confirmations);
+  pushBlock("BTC", analysis.btcContext);
+  pushBlock("Retest", analysis.retestPlan);
+  pushBlock("Risk/Levels", analysis.riskLevels);
+  pushBlock("Why Quality", analysis.qualityReason);
+  pushBlock("Trigger/Invalidation", analysis.triggerInvalidation);
+  if (blocks.length > 0) {
+    lines.push("");
+    lines.push(blocks.join("\n\n"));
+  }
+  return lines.join("\n");
+};
+var sendSignalAnalysis = async (signal, analysis) => {
+  const message = formatAnalysisMessage(signal, analysis);
+  const res = await fetch(`https://api.telegram.org/bot${token}/sendMessage`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      chat_id: chatId,
+      text: message,
+      parse_mode: "HTML"
+    })
+  });
+  const data = await res.json();
+  logger.info(
+    "tg sendMessage (analysis): %s",
+    data?.ok ? "sent" : JSON.stringify(data)
+  );
+};
+
+// src/cli.ts
+var cleanFiles = async (dir) => {
+  let completed = 0;
+  const files = await getFiles(dir);
+  const bar = new ProgressBar(":current/:total [:bar][:percent] :eta(s)", {
+    total: files.length,
+    width: 30
+  });
+  logger2.info(chalk.yellow("clean:", dir));
+  for await (const file of files) {
+    completed++;
+    const fullPath = `${dir}/${file}`;
+    const stat = await fs2.lstat(fullPath);
+    if (stat.isDirectory()) {
+      await fs2.rm(fullPath, { recursive: true, force: true });
+    } else {
+      await fs2.unlink(fullPath);
+    }
+    if (completed % 100 === 0 || completed === files.length) {
+      bar.tick(completed === files.length ? completed % 100 : 100);
+    }
+  }
+  logger2.info("");
+};
+var cleanRedis = async (area) => {
+  let completed = 0;
+  const keys = await getKeys(area);
+  const bar = new ProgressBar(":current/:total [:bar][:percent] :eta(s)", {
+    total: keys.length,
+    width: 30
+  });
+  logger2.info(chalk.yellow("clean:", area));
+  try {
+    for await (const key of keys) {
+      completed++;
+      await delKeyWithOptions(key, { raiseOnMisconf: true });
+      if (completed % 100 === 0 || completed === keys.length) {
+        bar.tick(completed === keys.length ? completed % 100 : 100);
+      }
+    }
+  } catch (e) {
+    if (e instanceof RedisWriteBlockedError || String(e).includes("MISCONF")) {
+      logger2.error(
+        "Redis write is blocked by MISCONF (RDB save failure). Cleanup stopped early."
+      );
+      logger2.error(
+        "Check Redis logs and fix persistence/memory pressure before retry."
+      );
+      logger2.info("");
+      return;
+    }
+    throw e;
+  }
+  logger2.info("");
+};
+var update = async (connector, interval, tickers) => {
+  const PRELOAD_START = getTimestamp(PRELOAD_DAYS);
+  const PRELOAD_END = getTimestamp();
+  const bar = new ProgressBar(
+    ":current/:total [:bar][:percent] :eta(s) :symbol",
+    {
+      total: tickers.length,
+      width: 30
+    }
+  );
+  logger2.info(chalk.yellow("update:", tickers.length));
+  const queue = tickers.slice();
+  if (!queue.includes("BTCUSDT")) {
+    queue.unshift("BTCUSDT");
+  }
+  await runWithConcurrency(queue, KLINE_CONCURRENCY_LIMIT, async (symbol) => {
+    try {
+      await connector.kline({
+        symbol,
+        start: PRELOAD_START,
+        end: PRELOAD_END,
+        interval,
+        silent: true
+      });
+    } catch {
+      logger2.error("Failed loading: %s", symbol);
+    } finally {
+      bar.tick(1, { symbol: chalk.gray(symbol) });
+    }
+  });
+  logger2.info("");
+};
+var parseSymbolsFromCLI = (symbol = "") => symbol.split(",").map((s) => {
+  const ticker = s.toUpperCase();
+  return ticker.endsWith("USDT") ? ticker : `${ticker}USDT`;
+});
+var getCLILevelColor = (level) => {
+  switch (level) {
+    case "success":
+      return chalk.green;
+    case "warning":
+      return chalk.yellow;
+    case "error":
+      return chalk.red;
+  }
+};
+var drawStatInCLI = (stat, keys) => {
+  return keys.map((key) => {
+    const { formatted, level } = getFormatted(stat, key);
+    const color = getCLILevelColor(level);
+    return color(formatted);
+  });
+};
+var scanner = async (connector, limit) => {
+  const data = await connector.getTickers();
+  const tickers = getTopTickers(data, limit);
+  return tickers.map(({ value }) => value);
+};
+var getTickers = async (connector, include = "", exclude = "", limit, chunk) => {
+  let tickers;
+  const excludeTickers = parseSymbolsFromCLI(exclude);
+  if (include) {
+    tickers = parseSymbolsFromCLI(include);
+  } else {
+    tickers = await scanner(connector, limit);
+  }
+  if (chunk) {
+    const [currentChunk, chunksCount] = chunk.split("/").map((c) => parseInt(c));
+    logger2.info("chunk: %d / %d", currentChunk, chunksCount);
+    const chunkSize = Math.ceil(tickers.length / chunksCount);
+    const chunks = import_lodash.default.chunk(tickers, chunkSize);
+    tickers = chunks[currentChunk - 1];
+  }
+  return tickers.filter((t) => !excludeTickers.includes(t));
+};
+var makeScreenshots = async (signals, interval) => {
+  const bar = new ProgressBar(
+    ":current/:total [:bar][:percent] :eta(s) :symbol",
+    {
+      total: signals.length,
+      width: 30
+    }
+  );
+  logger2.info(chalk.yellow("screenshots:", `${interval}m`, signals.length));
+  await runWithConcurrency(
+    signals,
+    SCREENSHOT_CONCURRENCY_LIMIT,
+    async (signal) => {
+      try {
+        await screenDashboard({ ...signal, interval });
+      } catch (error) {
+        logger2.error(
+          "Failed screenshot: %s (%s)",
+          signal.symbol,
+          error?.message || String(error)
+        );
+      } finally {
+        bar.tick(1, { symbol: chalk.gray(signal.symbol) });
+      }
+    }
+  );
+  logger2.info("");
+};
+var sendToAI = async (signals) => {
+  const bar = new ProgressBar(
+    ":current/:total [:bar][:percent] :eta(s) :symbol",
+    {
+      total: signals.length,
+      width: 30
+    }
+  );
+  logger2.info(chalk.yellow("AI:", signals.length));
+  await runWithConcurrency(signals, AI_CONCURRENCY_LIMIT, async (signal) => {
+    try {
+      await askAI(signal);
+    } catch {
+      logger2.error("Failed ask: %s", signal.symbol);
+    } finally {
+      bar.tick(1, { symbol: chalk.gray(signal.symbol) });
+    }
+  });
+  logger2.info("");
+};
+var sendToTG = async (signals, imgInterval) => {
+  const bar = new ProgressBar(
+    ":current/:total [:bar][:percent] :eta(s) :symbol",
+    {
+      total: signals.length,
+      width: 30
+    }
+  );
+  logger2.info(chalk.yellow("messages:", signals.length));
+  await runWithConcurrency(signals, TG_CONCURRENCY_LIMIT, async (signal) => {
+    try {
+      const analysis = await getData2(
+        redisKeys2.analysis(signal.symbol, signal.signalId),
+        null
+      );
+      await sendSignal(signal, imgInterval, analysis);
+      if (analysis && typeof analysis === "object" && Object.keys(analysis).length > 0) {
+        await sendSignalAnalysis(signal, analysis);
+      }
+    } catch {
+      logger2.error("Failed sent: %s", signal.symbol);
+    } finally {
+      bar.tick(1, { symbol: chalk.gray(signal.symbol) });
+    }
+  });
+  logger2.info("");
+};
+export {
+  cleanFiles,
+  cleanRedis,
+  drawStatInCLI,
+  getTickers,
+  makeScreenshots,
+  sendToAI,
+  sendToTG,
+  update
+};

package/dist/connectors.d.mts

@@ -0,0 +1,20 @@
+import { ConnectorCreator, ConnectorRegistryEntry } from '@tradejs/types';
+
+declare const BUILTIN_CONNECTOR_NAMES: {
+    readonly ByBit: "ByBit";
+    readonly Binance: "Binance";
+    readonly Coinbase: "Coinbase";
+    readonly Test: "Test";
+};
+declare const ensureConnectorPluginsLoaded: () => Promise<void>;
+declare const getConnectorCreatorByName: (connectorName: unknown) => Promise<ConnectorCreator | undefined>;
+declare const getConnectorNameByProvider: (provider: unknown) => Promise<string | undefined>;
+declare const getConnectorCreatorByProvider: (provider: unknown) => Promise<ConnectorCreator | undefined>;
+declare const resolveConnectorName: (providerOrName: unknown) => Promise<string | undefined>;
+declare const getAvailableConnectorNames: () => Promise<string[]>;
+declare const getAvailableConnectorProviders: () => Promise<string[]>;
+declare const registerConnectorEntries: (entries: readonly ConnectorRegistryEntry[]) => void;
+declare const resetConnectorRegistryCache: () => void;
+declare const DEFAULT_CONNECTOR_NAME: "ByBit";
+
+export { BUILTIN_CONNECTOR_NAMES, DEFAULT_CONNECTOR_NAME, ensureConnectorPluginsLoaded, getAvailableConnectorNames, getAvailableConnectorProviders, getConnectorCreatorByName, getConnectorCreatorByProvider, getConnectorNameByProvider, registerConnectorEntries, resetConnectorRegistryCache, resolveConnectorName };

package/dist/connectors.d.ts

@@ -0,0 +1,20 @@
+import { ConnectorCreator, ConnectorRegistryEntry } from '@tradejs/types';
+
+declare const BUILTIN_CONNECTOR_NAMES: {
+    readonly ByBit: "ByBit";
+    readonly Binance: "Binance";
+    readonly Coinbase: "Coinbase";
+    readonly Test: "Test";
+};
+declare const ensureConnectorPluginsLoaded: () => Promise<void>;
+declare const getConnectorCreatorByName: (connectorName: unknown) => Promise<ConnectorCreator | undefined>;
+declare const getConnectorNameByProvider: (provider: unknown) => Promise<string | undefined>;
+declare const getConnectorCreatorByProvider: (provider: unknown) => Promise<ConnectorCreator | undefined>;
+declare const resolveConnectorName: (providerOrName: unknown) => Promise<string | undefined>;
+declare const getAvailableConnectorNames: () => Promise<string[]>;
+declare const getAvailableConnectorProviders: () => Promise<string[]>;
+declare const registerConnectorEntries: (entries: readonly ConnectorRegistryEntry[]) => void;
+declare const resetConnectorRegistryCache: () => void;
+declare const DEFAULT_CONNECTOR_NAME: "ByBit";
+
+export { BUILTIN_CONNECTOR_NAMES, DEFAULT_CONNECTOR_NAME, ensureConnectorPluginsLoaded, getAvailableConnectorNames, getAvailableConnectorProviders, getConnectorCreatorByName, getConnectorCreatorByProvider, getConnectorNameByProvider, registerConnectorEntries, resetConnectorRegistryCache, resolveConnectorName };