@tradejs/node 1.0.8 → 1.0.10

package/dist/cli.mjs

@@ -8,12 +8,12 @@ import {
 } from "./chunk-KZDHZ56N.mjs";
 import {
   askAI
-} from "./chunk-2JKX3DM7.mjs";
-import "./chunk-WGOYR6AB.mjs";
+} from "./chunk-IUZML4RK.mjs";
+import "./chunk-QVSMINLG.mjs";
 import {
   getTradejsProjectCwd,
   loadTradejsConfig
-} from "./chunk-JU77QVJ3.mjs";
+} from "./chunk-WS5DYEVZ.mjs";
 import {
   __toESM
 } from "./chunk-6DZX6EAA.mjs";
@@ -21,6 +21,7 @@ import {
 // src/cli.ts
 var import_lodash = __toESM(require_lodash());
 import fs2 from "fs/promises";
+import path2 from "path";
 import ProgressBar from "progress";
 import chalk from "chalk";
 import { runWithConcurrency } from "@tradejs/core/async";
@@ -37,6 +38,7 @@ import {
   redisKeys
 } from "@tradejs/infra/redis";
 import { logger as logger3 } from "@tradejs/infra/logger";
+import { getDataEdgesForSymbols } from "@tradejs/infra/timescale";
 
 // src/screenshot.ts
 import fs from "fs/promises";
@@ -45,6 +47,27 @@ import puppeteer from "puppeteer";
 import { delay } from "@tradejs/core/async";
 import { logger } from "@tradejs/infra/logger";
 import { createScreenshotSessionToken } from "@tradejs/infra/redis";
+
+// src/dashboardUrl.ts
+var buildDashboardUrl = ({
+  baseUrl,
+  provider = "bybit",
+  universe = "crypto",
+  symbol,
+  interval,
+  searchParams = {}
+}) => {
+  const url = new URL(
+    `/routes/dashboard/${provider}/${universe}/${symbol}/${interval}`,
+    baseUrl
+  );
+  for (const [key, value] of Object.entries(searchParams)) {
+    url.searchParams.set(key, value);
+  }
+  return url.toString();
+};
+
+// src/screenshot.ts
 var { APP_URL } = process.env;
 var SCREENSHOT_NAVIGATION_ATTEMPTS = 3;
 var SCREENSHOT_NAVIGATION_RETRY_DELAY_MS = 2e3;
@@ -153,7 +176,18 @@ var screenDashboard = async (signal, projectRoot, userName = "root") => {
       `Failed to create screenshot session token for ${userName}`
     );
   }
-  const dashboardUrl = `${screenshotBaseUrl}/routes/dashboard/bybit/${symbol}/${interval}/?signalId=${signalId}&autoZoom=true&screenshot=1&screenshotToken=${encodeURIComponent(screenshotToken)}`;
+  const dashboardUrl = buildDashboardUrl({
+    baseUrl: screenshotBaseUrl,
+    universe: signal.universe ?? "crypto",
+    symbol,
+    interval,
+    searchParams: {
+      signalId,
+      autoZoom: "true",
+      screenshot: "1",
+      screenshotToken
+    }
+  });
   const maskedDashboardUrl = maskTokenInUrl(dashboardUrl);
   logger.info(
     "screenshot start: %s %sm url=%s path=%s",
@@ -461,6 +495,25 @@ var describeErrorValue2 = (value) => {
   return String(value);
 };
 var normalizeQuality = (value) => typeof value === "number" ? Math.max(1, Math.min(5, Math.round(value))) : null;
+var formatOrderValue = (value) => {
+  const rounded = Number(value.toFixed(2));
+  return Number.isInteger(rounded) ? String(rounded) : rounded.toFixed(2);
+};
+var getDisplayDecision = (signalDirection, analysis, fallback) => {
+  if (!analysis && !fallback) {
+    return void 0;
+  }
+  if (analysis?.direction != null && analysis.direction !== signalDirection) {
+    return "rejected";
+  }
+  if (analysis?.needRetest === true) {
+    return "pending";
+  }
+  if (analysis?.direction != null && analysis.direction === signalDirection) {
+    return "approved";
+  }
+  return fallback;
+};
 var formatAnalysisLevel = (value) => {
   if (value == null || !Number.isFinite(value)) return null;
   if (Math.abs(value) >= 1e3) {
@@ -508,24 +561,17 @@ var formatOrderSkipReason = (reason) => {
   }
   return reason;
 };
-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) => {
+var getAiQualityLine = (analysis, label = "AI Quality") => {
   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`;
+    return `\u{1F7E2} ${label}: ${quality}/5`;
   }
   if (quality === 3 && approvedCurrentDirection) {
-    return `\u{1F7E1} AI Quality: ${quality}/5`;
+    return `\u{1F7E1} ${label}: ${quality}/5`;
   }
-  return `\u{1F534} AI Quality: ${quality}/5`;
+  return `\u{1F534} ${label}: ${quality}/5`;
 };
 var getTelegramErrorReason = (data) => {
   if (data && typeof data === "object") {
@@ -651,26 +697,59 @@ var sendTextToTG = async (message, options = {}) => {
     chatId
   });
 };
-var formatMessage = (signal, analysis) => {
+var sendDocumentToTG = async (document, options = {}) => {
+  const { token, chatId } = await getTelegramSettings(options.userName);
+  const body = new FormData();
+  const fileContent = typeof document.content === "string" ? document.content : (() => {
+    const bytes = new Uint8Array(document.content.byteLength);
+    bytes.set(document.content);
+    return bytes;
+  })();
+  body.set("chat_id", String(chatId || ""));
+  body.set(
+    "document",
+    new File([fileContent], document.filename, {
+      type: "application/json"
+    })
+  );
+  if (document.caption?.trim()) {
+    body.set("caption", document.caption.trim());
+    body.set("parse_mode", "HTML");
+  }
+  const data = await requestTelegram({
+    method: "sendDocument",
+    token,
+    init: {
+      method: "POST",
+      body
+    }
+  });
+  logger2.info(
+    "tg sendDocument: %s",
+    data?.ok ? "sent" : getTelegramErrorReason(data)
+  );
+  return data;
+};
+var formatMessage = (signal, analysis, options = {}) => {
   const {
     symbol,
     direction,
     strategy,
     orderStatus,
     orderSkipReason,
+    orderFailureReason,
+    orderQty,
+    orderValue,
     isConfigFromBacktest,
     ml,
     prices: { currentPrice, takeProfitPrice, stopLossPrice, riskRatio },
-    indicators,
     additionalIndicators
   } = signal;
+  const userName = options.userName || "root";
   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
@@ -678,8 +757,10 @@ var formatMessage = (signal, analysis) => {
       const slPercent = Math.abs((stopLossPrice - currentPrice) / currentPrice * 100).toFixed(
         2
       ) + "%";
+      const resolvedOrderValue = typeof orderValue === "number" && Number.isFinite(orderValue) ? orderValue : typeof orderQty === "number" && Number.isFinite(orderQty) ? orderQty * currentPrice : null;
       const prices = [
         `Price: <b>${formatNumber(currentPrice)}</b>`,
+        resolvedOrderValue != null ? `Value: <b>${formatOrderValue(resolvedOrderValue)}$</b>` : null,
         `TP: <b>${formatNumber(takeProfitPrice)}</b> (${tpPercent})`,
         `SL: <b>${formatNumber(stopLossPrice)}</b> (${slPercent})`,
         `R:R = <b>${riskRatio.toFixed(2)}</b>`
@@ -705,6 +786,8 @@ var formatMessage = (signal, analysis) => {
           lines.push(
             `Skip reason: <b>${escapeHtml(formatOrderSkipReason(orderSkipReason))}</b>`
           );
+        } else if (orderStatus === "failed" && orderFailureReason) {
+          lines.push(`Reason: <code>${escapeHtml(orderFailureReason)}</code>`);
         }
       }
       if (isConfigFromBacktest) {
@@ -717,17 +800,25 @@ var formatMessage = (signal, analysis) => {
           `${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);
+      const gateAnalysis = analysis?.gateAnalysis && typeof analysis.gateAnalysis === "object" && !Array.isArray(analysis.gateAnalysis) ? analysis.gateAnalysis : null;
+      if (gateAnalysis) {
+        const gateQualityLine = getAiQualityLine(gateAnalysis, "Gate Quality");
+        if (gateQualityLine) {
+          lines.push(gateQualityLine);
+        }
+        const llmQualityLine = getAiQualityLine(analysis, "LLM Quality");
+        if (llmQualityLine) {
+          lines.push(llmQualityLine);
+        }
+      } else {
+        const aiQualityLine = getAiQualityLine(analysis);
+        if (aiQualityLine) {
+          lines.push(aiQualityLine);
+        }
       }
       lines.push("");
-      if (correlation) {
-        lines.push(`BTC correlation: ${correlation}`);
-      }
       const prices = formatPrices();
       if (prices) {
-        lines.push("");
         lines.push(prices);
       }
     };
@@ -741,9 +832,17 @@ var formatMessage = (signal, analysis) => {
 var sendSignal = async (signal, imgInterval, analysis, options = {}) => {
   const { symbol, signalId, interval } = signal;
   const { token, chatId } = await getTelegramSettings(options.userName);
-  const message = formatMessage(signal, analysis);
+  const message = formatMessage(signal, analysis, {
+    userName: options.userName
+  });
   const publicAppUrl = APP_URL2?.startsWith("https") ? APP_URL2 : null;
-  const dashboardUrl = publicAppUrl ? `${APP_URL2}/routes/dashboard/bybit/${symbol}/${interval}/?signalId=${signalId}` : null;
+  const dashboardUrl = publicAppUrl ? buildDashboardUrl({
+    baseUrl: publicAppUrl,
+    universe: signal.universe ?? "crypto",
+    symbol,
+    interval,
+    searchParams: { signalId }
+  }) : null;
   const actionButtons = [
     dashboardUrl ? { text: "Dashboard", url: dashboardUrl } : null
   ].filter(Boolean);
@@ -836,9 +935,19 @@ var formatAnalysisMessage = (signal, analysis) => {
   if (quality) {
     lines.push(`Quality: <b>${quality}/5</b>`);
   }
-  if (analysis.gateDecision && analysis.llmDecision) {
+  const gateDecision = getDisplayDecision(
+    signal.direction,
+    analysis.gateAnalysis,
+    analysis.gateDecision
+  );
+  const llmDecision = getDisplayDecision(
+    signal.direction,
+    analysis,
+    analysis.llmDecision
+  );
+  if (gateDecision && llmDecision) {
     lines.push(
-      `Gate vs LLM: <b>${analysis.gateContradictsLlm ? "conflict" : "aligned"}</b> (gate ${analysis.gateDecision}, LLM ${analysis.llmDecision})`
+      `Gate vs LLM: <b>${gateDecision === llmDecision ? "aligned" : "conflict"}</b> (gate ${gateDecision}, LLM ${llmDecision})`
     );
   }
   const happeningText = takeUniqueAnalysisText(
@@ -883,19 +992,6 @@ var formatAnalysisMessage = (signal, analysis) => {
   if (btcText) {
     lines.push(`BTC context: ${escapeHtml(btcText)}`);
   }
-  const levels = [];
-  if (typeof analysis.takeProfitPrice === "number") {
-    levels.push(`TP <b>${formatAnalysisLevel(analysis.takeProfitPrice)}</b>`);
-  }
-  if (typeof analysis.stopLossPrice === "number") {
-    levels.push(`SL <b>${formatAnalysisLevel(analysis.stopLossPrice)}</b>`);
-  }
-  if (typeof analysis.retestPrice === "number") {
-    levels.push(`Retest <b>${formatAnalysisLevel(analysis.retestPrice)}</b>`);
-  }
-  if (levels.length > 0) {
-    lines.push(`Levels: ${levels.join(" | ")}`);
-  }
   return lines.join("\n");
 };
 var sendSignalAnalysis = async (signal, analysis, options = {}) => {
@@ -922,10 +1018,35 @@ var sendSignalAnalysis = async (signal, analysis, options = {}) => {
 
 // src/cli.ts
 var getProjectRoot2 = () => getTradejsProjectCwd();
+var escapeHtml2 = (value) => value == null ? "" : String(value).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+var formatOptionalNumber = (value) => {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return "n/a";
+  }
+  const normalized = Number(value.toFixed(8));
+  return Number.isInteger(normalized) ? String(normalized) : String(normalized);
+};
+var formatOptionalTimestamp = (value) => {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return "n/a";
+  }
+  return new Date(value).toISOString();
+};
+var isEnoentError = (error) => error?.code === "ENOENT";
 var cleanFiles = async (dir) => {
   let completed = 0;
   const projectRoot = getProjectRoot2();
-  const files = await getFiles(dir, projectRoot);
+  let files = [];
+  try {
+    files = await getFiles(dir, projectRoot);
+  } catch (error) {
+    if (isEnoentError(error)) {
+      logger3.info(chalk.yellow("clean:", dir));
+      logger3.info("");
+      return;
+    }
+    throw error;
+  }
   const bar = new ProgressBar(":current/:total [:bar][:percent] :eta(s)", {
     total: files.length,
     width: 30
@@ -933,12 +1054,18 @@ var cleanFiles = async (dir) => {
   logger3.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);
+    const fullPath = path2.join(projectRoot, dir, file);
+    try {
+      const stat = await fs2.lstat(fullPath);
+      if (stat.isDirectory()) {
+        await fs2.rm(fullPath, { recursive: true, force: true });
+      } else {
+        await fs2.unlink(fullPath);
+      }
+    } catch (error) {
+      if (!isEnoentError(error)) {
+        throw error;
+      }
     }
     if (completed % 100 === 0 || completed === files.length) {
       bar.tick(completed === files.length ? completed % 100 : 100);
@@ -983,28 +1110,58 @@ var update = async (connector, interval, tickers, preloadDays = PRELOAD_DAYS, op
   );
   const preloadEnd = Math.trunc(options.preloadEnd ?? getTimestamp());
   const connectorLabel = String(options.connectorLabel || "").trim();
-  const preloadLabel = options.preloadStart != null || options.preloadEnd != null ? `preloadStart=${preloadStart}, preloadEnd=${preloadEnd}` : `preloadDays=${preloadDays}`;
+  const preloadLabel = options.preloadStart != null || options.preloadEnd != null ? `preloadStart=${formatOptionalTimestamp(preloadStart)}, preloadEnd=${formatOptionalTimestamp(preloadEnd)}` : `preloadDays=${preloadDays}`;
   if (preloadStart >= preloadEnd) {
     throw new Error(
       `Invalid update preload window: start (${preloadStart}) must be less than end (${preloadEnd})`
     );
   }
+  let queue = [...new Set(tickers.slice())];
+  if (!queue.includes("BTCUSDT")) {
+    queue.unshift("BTCUSDT");
+  }
+  const intervalMinutes = Number(interval);
+  if (options.skipCovered && connectorLabel && Number.isFinite(intervalMinutes) && intervalMinutes > 0) {
+    const edges = await getDataEdgesForSymbols(
+      connectorLabel,
+      queue,
+      Math.floor(intervalMinutes)
+    );
+    const initialCount = queue.length;
+    queue = queue.filter((symbol) => {
+      const edge = edges.get(String(symbol).toUpperCase());
+      return !edge || edge.min === void 0 || edge.max === void 0 || edge.min > preloadStart || edge.max < preloadEnd;
+    });
+    const skippedCount = initialCount - queue.length;
+    if (skippedCount > 0) {
+      logger3.info(
+        chalk.gray(
+          `update ${connectorLabel}: skip ${skippedCount}/${initialCount} cached symbols for interval=${interval}`
+        )
+      );
+    }
+  }
+  if (queue.length === 0) {
+    logger3.info(
+      chalk.yellow(
+        `update: 0 (connector=${connectorLabel || "unknown"}, interval=${interval}, klineConcurrency=${KLINE_CONCURRENCY_LIMIT}, ${preloadLabel})`
+      )
+    );
+    logger3.info("");
+    return;
+  }
   const bar = new ProgressBar(
     ":current/:total [:bar][:percent] :eta(s) :symbol",
     {
-      total: tickers.length,
+      total: queue.length,
       width: 30
     }
   );
   logger3.info(
     chalk.yellow(
-      `update: ${tickers.length} (connector=${connectorLabel || "unknown"}, klineConcurrency=${KLINE_CONCURRENCY_LIMIT}, ${preloadLabel})`
+      `update: ${queue.length} (connector=${connectorLabel || "unknown"}, interval=${interval}, klineConcurrency=${KLINE_CONCURRENCY_LIMIT}, ${preloadLabel})`
     )
   );
-  const queue = tickers.slice();
-  if (!queue.includes("BTCUSDT")) {
-    queue.unshift("BTCUSDT");
-  }
   await runWithConcurrency(queue, KLINE_CONCURRENCY_LIMIT, async (symbol) => {
     try {
       await connector.kline({
@@ -1033,6 +1190,8 @@ var getCLILevelColor = (level) => {
       return chalk.green;
     case "warning":
       return chalk.yellow;
+    case "neutral":
+      return chalk.gray;
     case "error":
       return chalk.red;
   }
@@ -1044,18 +1203,18 @@ var drawStatInCLI = (stat, keys) => {
     return color(formatted);
   });
 };
-var scanner = async (connector, limit) => {
-  const data = await connector.getTickers();
+var scanner = async (connector, limit, query) => {
+  const data = await connector.getTickers(query);
   const tickers = getTopTickers(data, limit);
   return tickers.map(({ value }) => value);
 };
-var getTickers = async (connector, include = "", exclude = "", limit, chunk) => {
+var getTickers = async (connector, include = "", exclude = "", limit, chunk, query) => {
   let tickers;
   const excludeTickers = parseSymbolsFromCLI(exclude);
   if (include) {
     tickers = parseSymbolsFromCLI(include);
   } else {
-    tickers = await scanner(connector, limit);
+    tickers = await scanner(connector, limit, query);
   }
   if (chunk) {
     const [currentChunk, chunksCount] = chunk.split("/").map((c) => parseInt(c));
@@ -1115,7 +1274,79 @@ var sendToAI = async (signals, userName = "root") => {
   });
   logger3.info("");
 };
+var formatRuntimeCloseNotification = (event, _userName = event.userName ?? "root") => {
+  const ownership = event.openedByStrategy === event.strategy ? "matched" : `mismatch: opened by ${event.openedByStrategy}`;
+  return [
+    "<b>Strategy self-close</b>",
+    `Symbol: <b>${escapeHtml2(event.symbol)}</b>`,
+    `Strategy: <b>${escapeHtml2(event.strategy)}</b>`,
+    `Direction: <b>${escapeHtml2(event.direction)}</b>`,
+    `Reason: <code>${escapeHtml2(event.code)}</code>`,
+    "",
+    `Opened by journal: <b>${escapeHtml2(event.openedByStrategy)}</b>`,
+    `Ownership: <b>${escapeHtml2(ownership)}</b>`,
+    "",
+    `Entry: <b>${escapeHtml2(formatOptionalNumber(event.entryPrice))}</b> at <code>${escapeHtml2(formatOptionalTimestamp(event.entryTimestamp))}</code>`,
+    `Exit: <b>${escapeHtml2(formatOptionalNumber(event.exitPrice))}</b> at <code>${escapeHtml2(formatOptionalTimestamp(event.exitTimestamp))}</code>`,
+    `Qty: <b>${escapeHtml2(formatOptionalNumber(event.qty))}</b>`,
+    `Closed PnL: <b>${escapeHtml2(formatOptionalNumber(event.closedPnl))}</b>`
+  ].join("\n");
+};
+var sendRuntimeCloseNotificationsToTG = async (events, userName = "root") => {
+  logger3.info(chalk.yellow("close messages:", events.length));
+  if (!events.length) {
+    logger3.info("");
+    return;
+  }
+  const bar = new ProgressBar(
+    ":current/:total [:bar][:percent] :eta(s) :symbol",
+    {
+      total: events.length,
+      width: 30
+    }
+  );
+  await runWithConcurrency(events, 1, async (event) => {
+    try {
+      await sendTextToTG(formatRuntimeCloseNotification(event, userName), {
+        userName
+      });
+    } catch (err) {
+      logger3.error(
+        "Failed close notification: %s %s",
+        event.symbol,
+        err?.message || String(err)
+      );
+    } finally {
+      bar.tick(1, { symbol: chalk.gray(event.symbol) });
+    }
+  });
+  logger3.info("");
+};
 var sendToTG = async (signals, imgInterval, userName = "root") => {
+  const strategyConfigCache = /* @__PURE__ */ new Map();
+  const resolveStrategyConfig = async (strategyName) => {
+    if (strategyConfigCache.has(strategyName)) {
+      return strategyConfigCache.get(strategyName);
+    }
+    const config = await getData(
+      `users:${userName}:strategies:${strategyName}:config`,
+      null
+    );
+    strategyConfigCache.set(strategyName, config);
+    return config;
+  };
+  const resolveDecision = (analysis, direction, minQuality = 4) => {
+    if (analysis?.needRetest === true) {
+      return "rejected";
+    }
+    const quality = Number(analysis?.quality);
+    if (!Number.isFinite(quality)) {
+      return "rejected";
+    }
+    const normalized = Math.round(quality);
+    const resolvedQuality = analysis?.direction === direction ? normalized : 0;
+    return resolvedQuality >= minQuality ? "approved" : "rejected";
+  };
   const deliverableSignals = signals.filter(
     (signal) => signal.orderStatus !== "skipped" && signal.orderStatus !== "canceled"
   );
@@ -1133,17 +1364,56 @@ var sendToTG = async (signals, imgInterval, userName = "root") => {
   );
   await runWithConcurrency(deliverableSignals, 1, async (signal) => {
     try {
-      const analysis = await getData(
+      let analysis = await getData(
         redisKeys.analysis(signal.symbol, signal.signalId),
         null
       );
+      let shouldSendSignalAnalysis = analysis && typeof analysis === "object" && Object.keys(analysis).length > 0;
+      const strategyConfig = await resolveStrategyConfig(signal.strategy);
+      const aiMode = strategyConfig?.AI_MODE;
+      const gateAnalysis = signal.aiAnalysis;
+      if (aiMode === "gate" && gateAnalysis) {
+        const minQuality = Number(strategyConfig?.MIN_AI_QUALITY) || 4;
+        const gateDecision = resolveDecision(
+          gateAnalysis,
+          signal.direction,
+          minQuality
+        );
+        try {
+          const llmAnalysis = await askAI(signal, { userName });
+          const llmDecision = resolveDecision(
+            llmAnalysis,
+            signal.direction,
+            minQuality
+          );
+          analysis = {
+            ...llmAnalysis ?? {},
+            gateAnalysis,
+            gateDecision,
+            llmDecision,
+            gateContradictsLlm: gateDecision !== llmDecision
+          };
+          shouldSendSignalAnalysis = true;
+        } catch (error) {
+          logger3.error(
+            "LLM commentary failed: %s (%s)",
+            signal.symbol,
+            error?.message || String(error)
+          );
+          analysis = {
+            gateAnalysis,
+            gateDecision
+          };
+          shouldSendSignalAnalysis = false;
+        }
+      }
       await sendSignal(signal, imgInterval, analysis, { userName });
-      if (analysis && typeof analysis === "object" && Object.keys(analysis).length > 0) {
+      if (shouldSendSignalAnalysis && analysis && typeof analysis === "object" && Object.keys(analysis).length > 0) {
         await sendSignalAnalysis(signal, analysis, { userName });
       }
     } catch (err) {
       logger3.error(
-        "Failed sent: %s %s",
+        "Signal notification failed: %s (%s)",
         signal.symbol,
         err?.message || String(err)
       );
@@ -1157,9 +1427,12 @@ export {
   cleanFiles,
   cleanRedis,
   drawStatInCLI,
+  formatRuntimeCloseNotification,
   getTickers,
   loadTradejsConfig,
   makeScreenshots,
+  sendDocumentToTG,
+  sendRuntimeCloseNotificationsToTG,
   sendTextToTG,
   sendToAI,
   sendToTG,