@tradejs/node 1.0.3 → 1.0.5

package/dist/cli.mjs

@@ -3,17 +3,17 @@ import {
   KLINE_CONCURRENCY_LIMIT,
   SCREENSHOT_CONCURRENCY_LIMIT,
   TG_CONCURRENCY_LIMIT
-} from "./chunk-4ZPGZWO7.mjs";
+} from "./chunk-SCMBUEGK.mjs";
 import {
   require_lodash
 } from "./chunk-GKDBAF3A.mjs";
 import {
   askAI
-} from "./chunk-QDYCJ2OK.mjs";
-import "./chunk-CK2PW4L5.mjs";
+} from "./chunk-LMAKIC3C.mjs";
+import "./chunk-ZY6ULOWK.mjs";
 import {
   getTradejsProjectCwd
-} from "./chunk-3C76HVLA.mjs";
+} from "./chunk-P2ZUWONT.mjs";
 import {
   __toESM
 } from "./chunk-6DZX6EAA.mjs";
@@ -36,72 +36,332 @@ import {
   getData as getData2,
   redisKeys as redisKeys2
 } from "@tradejs/infra/redis";
-import { logger as logger2 } from "@tradejs/infra/logger";
+import { logger as logger3 } 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 { logger } from "@tradejs/infra/logger";
 import { getData, redisKeys } from "@tradejs/infra/redis";
 var { APP_URL } = process.env;
+var SCREENSHOT_NAVIGATION_ATTEMPTS = 3;
+var SCREENSHOT_NAVIGATION_RETRY_DELAY_MS = 2e3;
+var SCREENSHOT_CAPTURE_ATTEMPTS = 2;
+var SCREENSHOT_CAPTURE_RETRY_DELAY_MS = 2e3;
+var SCREENSHOT_NAVIGATION_TIMEOUT_MS = 3e4;
+var SCREENSHOT_RENDER_DELAY_MS = 1e4;
+var SCREENSHOT_CONSOLE_LOG_LIMIT = 20;
+var SCREENSHOT_CONSOLE_TEXT_LIMIT = 500;
+var SCREENSHOT_BROWSER_STDERR = process.env.SCREENSHOT_BROWSER_STDERR === "1";
+var PUPPETEER_DUMPIO = process.env.PUPPETEER_DUMPIO === "1";
+var SCREENSHOT_VIEWPORT = {
+  width: 1280,
+  height: 800,
+  deviceScaleFactor: process.env.NODE_ENV === "production" ? 1 : 2
+};
 var getProjectRoot = (projectRoot) => path.resolve(getTradejsProjectCwd(projectRoot));
 var getScreenshotsDir = (projectRoot) => path.join(getProjectRoot(projectRoot), "data", "screenshots");
-var getImageUrl = ({ symbol, signalId, interval }) => `${APP_URL}/api/files/screenshot/${symbol}_${signalId}_${interval}`;
+var maskTokenInUrl = (url) => url.replace(/([?&]token=)[^&]+/i, "$1<hidden>");
+var getErrorMessage = (error) => {
+  const maybeError = error;
+  const message = maybeError?.message || String(error);
+  if (maybeError?.cause == null) {
+    return message;
+  }
+  const cause = maybeError.cause instanceof Error ? maybeError.cause.message : String(maybeError.cause);
+  return `${message}; cause: ${cause}`;
+};
+var truncateText = (value, maxLength = SCREENSHOT_CONSOLE_TEXT_LIMIT) => value.length > maxLength ? `${value.slice(0, maxLength)}...` : value;
+var shouldLogConsoleMessage = (type) => ["error", "warning", "assert"].includes(type);
+var getScreenshotBuffer = async (signal, projectRoot) => {
+  const screenshotPath = getScreenshotPath(signal, projectRoot);
+  return fs.readFile(screenshotPath);
+};
+var getScreenshotFilename = ({
+  symbol,
+  signalId,
+  interval
+}) => `${symbol}_${signalId}_${interval}.png`;
+var getScreenshotRenderBaseUrl = () => {
+  const fallback = String(APP_URL || "").trim();
+  if (fallback) {
+    return fallback;
+  }
+  throw new Error("APP_URL is required for screenshots");
+};
 var getScreenshotPath = ({ symbol, signalId, interval }, projectRoot) => {
   return path.join(
     getScreenshotsDir(projectRoot),
-    `${symbol}_${signalId}_${interval}.png`
+    getScreenshotFilename({ symbol, signalId, interval })
   );
 };
 var screenDashboard = async (signal, projectRoot) => {
   const { symbol, signalId, interval } = signal;
+  const screenshotBaseUrl = getScreenshotRenderBaseUrl();
+  const screenshotPath = getScreenshotPath(signal, projectRoot);
   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();
+  const dashboardUrl = `${screenshotBaseUrl}/routes/dashboard/bybit/${symbol}/${interval}/?signalId=${signalId}&autoZoom=true&screenshot=1${tokenParam}`;
+  const maskedDashboardUrl = maskTokenInUrl(dashboardUrl);
+  logger.info(
+    "screenshot start: %s %sm url=%s path=%s",
+    symbol,
+    interval,
+    maskedDashboardUrl,
+    screenshotPath
+  );
+  let captureError = null;
+  for (let captureAttempt = 1; captureAttempt <= SCREENSHOT_CAPTURE_ATTEMPTS; captureAttempt += 1) {
+    const browser = await puppeteer.launch({
+      headless: true,
+      dumpio: PUPPETEER_DUMPIO,
+      executablePath: process.env.PUPPETEER_EXECUTABLE_PATH,
+      args: [
+        "--no-sandbox",
+        "--disable-setuid-sandbox",
+        "--disable-dev-shm-usage",
+        "--disable-gpu",
+        "--font-render-hinting=medium"
+      ]
+    });
+    const browserProcess = browser.process();
     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}`
+      if (browserProcess) {
+        logger.info(
+          "screenshot browser: %s %sm captureAttempt=%d pid=%s exec=%s",
+          symbol,
+          interval,
+          captureAttempt,
+          String(browserProcess.pid ?? "unknown"),
+          browserProcess.spawnfile || "unknown"
+        );
+      }
+      logger.info(
+        "screenshot browser version: %s %sm captureAttempt=%d version=%s",
+        symbol,
+        interval,
+        captureAttempt,
+        await browser.version()
       );
-      await delay(1e4);
-      await fs.mkdir(getScreenshotsDir(projectRoot), { recursive: true });
-      await page.screenshot({
-        path: getScreenshotPath(signal, projectRoot)
+      browser.on("disconnected", () => {
+        logger.error(
+          "screenshot browser disconnected: %s %sm captureAttempt=%d",
+          symbol,
+          interval,
+          captureAttempt
+        );
       });
+      if (SCREENSHOT_BROWSER_STDERR && browserProcess?.stderr) {
+        browserProcess.stderr.on("data", (chunk) => {
+          const text = String(chunk).trim();
+          if (!text) {
+            return;
+          }
+          logger.error(
+            "screenshot browser stderr: %s %sm captureAttempt=%d (%s)",
+            symbol,
+            interval,
+            captureAttempt,
+            truncateText(text)
+          );
+        });
+      }
+      const page = await browser.newPage();
+      try {
+        let consoleMessagesLogged = 0;
+        page.on("requestfailed", (request) => {
+          if (!request.isNavigationRequest() && request.resourceType() !== "document") {
+            return;
+          }
+          logger.error(
+            "screenshot request failed: %s %sm %s (%s)",
+            symbol,
+            interval,
+            maskTokenInUrl(request.url()),
+            request.failure()?.errorText || "unknown"
+          );
+        });
+        page.on("pageerror", (error) => {
+          logger.error(
+            "screenshot page error: %s %sm (%s)",
+            symbol,
+            interval,
+            error.message || String(error)
+          );
+        });
+        page.on("error", (error) => {
+          logger.error(
+            "screenshot target error: %s %sm (%s)",
+            symbol,
+            interval,
+            error.message || String(error)
+          );
+        });
+        page.on("close", () => {
+          logger.info(
+            "screenshot page closed: %s %sm captureAttempt=%d",
+            symbol,
+            interval,
+            captureAttempt
+          );
+        });
+        page.on("console", (message) => {
+          if (!shouldLogConsoleMessage(message.type())) {
+            return;
+          }
+          if (consoleMessagesLogged >= SCREENSHOT_CONSOLE_LOG_LIMIT) {
+            return;
+          }
+          consoleMessagesLogged += 1;
+          const location = message.location();
+          const suffix = location.url ? ` ${maskTokenInUrl(location.url)}:${location.lineNumber ?? 0}:${location.columnNumber ?? 0}` : "";
+          logger.error(
+            "screenshot console %s: %s %sm captureAttempt=%d (%s%s)",
+            message.type(),
+            symbol,
+            interval,
+            captureAttempt,
+            truncateText(message.text()),
+            suffix
+          );
+        });
+        page.on("response", (response) => {
+          const status = response.status();
+          if (status < 400) {
+            return;
+          }
+          const request = response.request();
+          const resourceType = request.resourceType();
+          if (!["document", "script", "stylesheet", "fetch", "xhr"].includes(
+            resourceType
+          )) {
+            return;
+          }
+          logger.error(
+            "screenshot response failed: %s %sm captureAttempt=%d status=%d type=%s url=%s",
+            symbol,
+            interval,
+            captureAttempt,
+            status,
+            resourceType,
+            maskTokenInUrl(response.url())
+          );
+        });
+        await page.setViewport(SCREENSHOT_VIEWPORT);
+        let gotoError = null;
+        logger.info(
+          "screenshot render: %s %sm captureAttempt=%d viewport=%dx%d@%d",
+          symbol,
+          interval,
+          captureAttempt,
+          SCREENSHOT_VIEWPORT.width,
+          SCREENSHOT_VIEWPORT.height,
+          SCREENSHOT_VIEWPORT.deviceScaleFactor
+        );
+        for (let attempt = 1; attempt <= SCREENSHOT_NAVIGATION_ATTEMPTS; attempt += 1) {
+          try {
+            logger.info(
+              "screenshot goto: %s %sm captureAttempt=%d attempt=%d url=%s",
+              symbol,
+              interval,
+              captureAttempt,
+              attempt,
+              maskedDashboardUrl
+            );
+            const response = await page.goto(dashboardUrl, {
+              waitUntil: "domcontentloaded",
+              timeout: SCREENSHOT_NAVIGATION_TIMEOUT_MS
+            });
+            logger.info(
+              "screenshot goto ok: %s %sm captureAttempt=%d attempt=%d status=%s finalUrl=%s",
+              symbol,
+              interval,
+              captureAttempt,
+              attempt,
+              response ? String(response.status()) : "null",
+              maskTokenInUrl(page.url())
+            );
+            logger.info(
+              "screenshot page info: %s %sm captureAttempt=%d title=%s ua=%s",
+              symbol,
+              interval,
+              captureAttempt,
+              truncateText(await page.title(), 120),
+              truncateText(await page.evaluate(() => navigator.userAgent), 240)
+            );
+            gotoError = null;
+            break;
+          } catch (error) {
+            gotoError = error;
+            logger.error(
+              "screenshot goto failed: %s %sm captureAttempt=%d attempt=%d url=%s (%s)",
+              symbol,
+              interval,
+              captureAttempt,
+              attempt,
+              maskedDashboardUrl,
+              gotoError.message || String(gotoError)
+            );
+            if (attempt >= SCREENSHOT_NAVIGATION_ATTEMPTS) {
+              break;
+            }
+            await delay(SCREENSHOT_NAVIGATION_RETRY_DELAY_MS);
+          }
+        }
+        if (gotoError) {
+          throw new Error(
+            `Failed to open dashboard ${dashboardUrl}: ${gotoError.message || String(gotoError)}`
+          );
+        }
+        await delay(SCREENSHOT_RENDER_DELAY_MS);
+        await fs.mkdir(getScreenshotsDir(projectRoot), { recursive: true });
+        await page.screenshot({
+          path: screenshotPath,
+          type: "png"
+        });
+        logger.info(
+          "screenshot saved: %s %sm path=%s",
+          symbol,
+          interval,
+          screenshotPath
+        );
+        return;
+      } finally {
+        await page.close().catch(() => void 0);
+      }
+    } catch (error) {
+      captureError = error;
+      logger.error(
+        "screenshot capture failed: %s %sm captureAttempt=%d (%s)",
+        symbol,
+        interval,
+        captureAttempt,
+        getErrorMessage(captureError)
+      );
+      if (captureAttempt < SCREENSHOT_CAPTURE_ATTEMPTS) {
+        await delay(SCREENSHOT_CAPTURE_RETRY_DELAY_MS);
+      }
     } finally {
-      await page.close();
+      await browser.close().catch(() => void 0);
     }
-  } finally {
-    await browser.close();
   }
+  throw captureError || new Error(`Failed screenshot: ${symbol} ${interval}`);
 };
 
 // src/signals.ts
+import { delay as delay2 } from "@tradejs/core/async";
 import { formatNumber } from "@tradejs/core/math";
-import { logger } from "@tradejs/infra/logger";
+import { logger as logger2 } 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 TG_REQUEST_ATTEMPTS = 3;
+var TG_REQUEST_RETRY_DELAY_MS = 2e3;
 var normalizeQuality = (value) => typeof value === "number" ? Math.max(1, Math.min(5, Math.round(value))) : null;
 var getLastNumber = (value) => {
   if (Array.isArray(value)) {
@@ -122,6 +382,99 @@ var getAiQualityLine = (analysis) => {
   }
   return `\u{1F534} AI Quality: ${quality}/5`;
 };
+var getTelegramErrorReason = (data) => {
+  if (data && typeof data === "object") {
+    const record = data;
+    const description = typeof record.description === "string" ? record.description : "";
+    const errorCode = typeof record.error_code === "number" ? record.error_code : void 0;
+    if (description && errorCode != null) {
+      return `${errorCode}: ${description}`;
+    }
+    if (description) {
+      return description;
+    }
+  }
+  try {
+    return JSON.stringify(data);
+  } catch {
+    return String(data);
+  }
+};
+var getErrorMessage2 = (error) => {
+  const maybeError = error;
+  const message = maybeError?.message || String(error);
+  if (maybeError?.cause == null) {
+    return message;
+  }
+  const cause = maybeError.cause instanceof Error ? maybeError.cause.message : String(maybeError.cause);
+  return `${message}; cause: ${cause}`;
+};
+var parseTelegramResponse = async (response) => {
+  const fallback = {
+    ok: response.ok,
+    error_code: response.status,
+    description: response.statusText
+  };
+  try {
+    return await response.json();
+  } catch {
+    try {
+      const text = await response.text();
+      return text ? {
+        ...fallback,
+        description: text
+      } : fallback;
+    } catch {
+      return fallback;
+    }
+  }
+};
+var requestTelegram = async (method, init) => {
+  let lastError = null;
+  for (let attempt = 1; attempt <= TG_REQUEST_ATTEMPTS; attempt += 1) {
+    try {
+      const res = await fetch(
+        `https://api.telegram.org/bot${token}/${method}`,
+        {
+          ...init
+        }
+      );
+      return await parseTelegramResponse(res);
+    } catch (error) {
+      lastError = error;
+      logger2.error(
+        "tg %s network failed: attempt=%d (%s)",
+        method,
+        attempt,
+        getErrorMessage2(error)
+      );
+      if (attempt < TG_REQUEST_ATTEMPTS) {
+        await delay2(TG_REQUEST_RETRY_DELAY_MS);
+      }
+    }
+  }
+  throw lastError || new Error(`Telegram ${method} request failed`);
+};
+var sendTelegramMessage = async ({
+  message,
+  markup
+}) => {
+  const data = await requestTelegram("sendMessage", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      chat_id: chatId,
+      text: message,
+      reply_markup: markup,
+      parse_mode: "HTML"
+    })
+  });
+  logger2.info(
+    "tg sendMessage: %s",
+    data?.ok ? "sent" : getTelegramErrorReason(data)
+  );
+  return data;
+};
 var formatMessage = (signal, analysis) => {
   const {
     symbol,
@@ -222,53 +575,76 @@ var formatMessage = (signal, analysis) => {
 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`, {
+  const publicAppUrl = APP_URL2?.startsWith("https") ? APP_URL2 : null;
+  const dashboardUrl = publicAppUrl ? `${APP_URL2}/routes/dashboard/bybit/${symbol}/${interval}/?signalId=${signalId}` : null;
+  const actionButtons = [
+    dashboardUrl ? { text: "Dashboard", url: dashboardUrl } : null
+  ].filter(Boolean);
+  const markup = actionButtons.length ? {
+    inline_keyboard: [actionButtons]
+  } : void 0;
+  let screenshotBytes = null;
+  try {
+    const screenshot = await getScreenshotBuffer({
+      ...signal,
+      interval: imgInterval
+    });
+    screenshotBytes = screenshot.buffer.slice(
+      screenshot.byteOffset,
+      screenshot.byteOffset + screenshot.byteLength
+    );
+  } catch (error) {
+    logger2.error(
+      "tg screenshot unavailable: %s (%s)",
+      symbol,
+      error?.message || String(error)
+    );
+    await sendTelegramMessage({ message, markup });
+    return;
+  }
+  const photoBody = new FormData();
+  photoBody.set("chat_id", String(chatId || ""));
+  photoBody.set(
+    "photo",
+    new Blob([screenshotBytes], { type: "image/png" }),
+    getScreenshotFilename({ ...signal, interval: imgInterval })
+  );
+  photoBody.set("caption", message);
+  photoBody.set("parse_mode", "HTML");
+  if (markup) {
+    photoBody.set("reply_markup", JSON.stringify(markup));
+  }
+  let data;
+  try {
+    data = await requestTelegram("sendPhoto", {
       method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        chat_id: chatId,
-        text: message,
-        parse_mode: "HTML"
-      })
+      body: photoBody
+    });
+  } catch (error) {
+    const reason = getErrorMessage2(error);
+    logger2.error("tg sendPhoto request failed: %s", reason);
+    await sendTelegramMessage({
+      message: `${message}
+
+\u26A0\uFE0F <b>Photo delivery failed</b>
+Reason: <code>${escapeHtml(reason)}</code>`,
+      markup
     });
     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"
-      })
+    const reason = getTelegramErrorReason(data);
+    logger2.error("tg sendPhoto failed: %s", JSON.stringify(data));
+    await sendTelegramMessage({
+      message: `${message}
+
+\u26A0\uFE0F <b>Photo delivery failed</b>
+Reason: <code>${escapeHtml(reason)}</code>`,
+      markup
     });
+    return;
   }
-  logger.info("tg sendPhoto: %s", data?.ok ? "sent" : JSON.stringify(data));
+  logger2.info("tg sendPhoto: sent");
 };
 var formatAnalysisMessage = (signal, analysis) => {
   const lines = [];
@@ -314,7 +690,7 @@ ${escapeHtml(clean)}`);
 };
 var sendSignalAnalysis = async (signal, analysis) => {
   const message = formatAnalysisMessage(signal, analysis);
-  const res = await fetch(`https://api.telegram.org/bot${token}/sendMessage`, {
+  const data = await requestTelegram("sendMessage", {
     method: "POST",
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify({
@@ -323,10 +699,9 @@ var sendSignalAnalysis = async (signal, analysis) => {
       parse_mode: "HTML"
     })
   });
-  const data = await res.json();
-  logger.info(
+  logger2.info(
     "tg sendMessage (analysis): %s",
-    data?.ok ? "sent" : JSON.stringify(data)
+    data?.ok ? "sent" : getTelegramErrorReason(data)
   );
 };
 
@@ -340,7 +715,7 @@ var cleanFiles = async (dir) => {
     total: files.length,
     width: 30
   });
-  logger2.info(chalk.yellow("clean:", dir));
+  logger3.info(chalk.yellow("clean:", dir));
   for await (const file of files) {
     completed++;
     const fullPath = `${dir}/${file}`;
@@ -354,7 +729,7 @@ var cleanFiles = async (dir) => {
       bar.tick(completed === files.length ? completed % 100 : 100);
     }
   }
-  logger2.info("");
+  logger3.info("");
 };
 var cleanRedis = async (area) => {
   let completed = 0;
@@ -363,7 +738,7 @@ var cleanRedis = async (area) => {
     total: keys.length,
     width: 30
   });
-  logger2.info(chalk.yellow("clean:", area));
+  logger3.info(chalk.yellow("clean:", area));
   try {
     for await (const key of keys) {
       completed++;
@@ -374,18 +749,18 @@ var cleanRedis = async (area) => {
     }
   } catch (e) {
     if (e instanceof RedisWriteBlockedError || String(e).includes("MISCONF")) {
-      logger2.error(
+      logger3.error(
         "Redis write is blocked by MISCONF (RDB save failure). Cleanup stopped early."
       );
-      logger2.error(
+      logger3.error(
         "Check Redis logs and fix persistence/memory pressure before retry."
       );
-      logger2.info("");
+      logger3.info("");
       return;
     }
     throw e;
   }
-  logger2.info("");
+  logger3.info("");
 };
 var update = async (connector, interval, tickers) => {
   const PRELOAD_START = getTimestamp(PRELOAD_DAYS);
@@ -397,7 +772,11 @@ var update = async (connector, interval, tickers) => {
       width: 30
     }
   );
-  logger2.info(chalk.yellow("update:", tickers.length));
+  logger3.info(
+    chalk.yellow(
+      `update: ${tickers.length} (klineConcurrency=${KLINE_CONCURRENCY_LIMIT})`
+    )
+  );
   const queue = tickers.slice();
   if (!queue.includes("BTCUSDT")) {
     queue.unshift("BTCUSDT");
@@ -412,12 +791,12 @@ var update = async (connector, interval, tickers) => {
         silent: true
       });
     } catch {
-      logger2.error("Failed loading: %s", symbol);
+      logger3.error("Failed loading: %s", symbol);
     } finally {
       bar.tick(1, { symbol: chalk.gray(symbol) });
     }
   });
-  logger2.info("");
+  logger3.info("");
 };
 var parseSymbolsFromCLI = (symbol = "") => symbol.split(",").map((s) => {
   const ticker = s.toUpperCase();
@@ -455,7 +834,7 @@ var getTickers = async (connector, include = "", exclude = "", limit, chunk) =>
   }
   if (chunk) {
     const [currentChunk, chunksCount] = chunk.split("/").map((c) => parseInt(c));
-    logger2.info("chunk: %d / %d", currentChunk, chunksCount);
+    logger3.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];
@@ -471,7 +850,7 @@ var makeScreenshots = async (signals, interval) => {
       width: 30
     }
   );
-  logger2.info(chalk.yellow("screenshots:", `${interval}m`, signals.length));
+  logger3.info(chalk.yellow("screenshots:", `${interval}m`, signals.length));
   await runWithConcurrency(
     signals,
     SCREENSHOT_CONCURRENCY_LIMIT,
@@ -479,7 +858,7 @@ var makeScreenshots = async (signals, interval) => {
       try {
         await screenDashboard({ ...signal, interval }, projectRoot);
       } catch (error) {
-        logger2.error(
+        logger3.error(
           "Failed screenshot: %s (%s)",
           signal.symbol,
           error?.message || String(error)
@@ -489,7 +868,7 @@ var makeScreenshots = async (signals, interval) => {
       }
     }
   );
-  logger2.info("");
+  logger3.info("");
 };
 var sendToAI = async (signals) => {
   const bar = new ProgressBar(
@@ -499,17 +878,17 @@ var sendToAI = async (signals) => {
       width: 30
     }
   );
-  logger2.info(chalk.yellow("AI:", signals.length));
+  logger3.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);
+      logger3.error("Failed ask: %s", signal.symbol);
     } finally {
       bar.tick(1, { symbol: chalk.gray(signal.symbol) });
     }
   });
-  logger2.info("");
+  logger3.info("");
 };
 var sendToTG = async (signals, imgInterval) => {
   const bar = new ProgressBar(
@@ -519,7 +898,7 @@ var sendToTG = async (signals, imgInterval) => {
       width: 30
     }
   );
-  logger2.info(chalk.yellow("messages:", signals.length));
+  logger3.info(chalk.yellow("messages:", signals.length));
   await runWithConcurrency(signals, TG_CONCURRENCY_LIMIT, async (signal) => {
     try {
       const analysis = await getData2(
@@ -530,13 +909,17 @@ var sendToTG = async (signals, imgInterval) => {
       if (analysis && typeof analysis === "object" && Object.keys(analysis).length > 0) {
         await sendSignalAnalysis(signal, analysis);
       }
-    } catch {
-      logger2.error("Failed sent: %s", signal.symbol);
+    } catch (err) {
+      logger3.error(
+        "Failed sent: %s %s",
+        signal.symbol,
+        err?.message || String(err)
+      );
     } finally {
       bar.tick(1, { symbol: chalk.gray(signal.symbol) });
     }
   });
-  logger2.info("");
+  logger3.info("");
 };
 export {
   cleanFiles,