@tradejs/node 1.0.4 → 1.0.6

package/dist/cli.mjs

@@ -1,19 +1,18 @@
 import {
   AI_CONCURRENCY_LIMIT,
   KLINE_CONCURRENCY_LIMIT,
-  SCREENSHOT_CONCURRENCY_LIMIT,
-  TG_CONCURRENCY_LIMIT
-} from "./chunk-4ZPGZWO7.mjs";
+  SCREENSHOT_CONCURRENCY_LIMIT
+} from "./chunk-SCMBUEGK.mjs";
 import {
   require_lodash
 } from "./chunk-GKDBAF3A.mjs";
 import {
   askAI
-} from "./chunk-LMAKIC3C.mjs";
-import "./chunk-ZY6ULOWK.mjs";
+} from "./chunk-72FKXJ2I.mjs";
+import "./chunk-EOZSJKUM.mjs";
 import {
   getTradejsProjectCwd
-} from "./chunk-P2ZUWONT.mjs";
+} from "./chunk-CGJ2UU6H.mjs";
 import {
   __toESM
 } from "./chunk-6DZX6EAA.mjs";
@@ -33,76 +32,438 @@ import {
   RedisWriteBlockedError,
   delKeyWithOptions,
   getKeys,
-  getData as getData2,
-  redisKeys as redisKeys2
+  getData,
+  redisKeys
 } 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 { getData, redisKeys } from "@tradejs/infra/redis";
+import { logger } from "@tradejs/infra/logger";
+import { getUserSettings } from "@tradejs/infra/userSettings";
 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 getErrorFields = (value) => {
+  if (!value || typeof value !== "object") {
+    return [];
+  }
+  const record = value;
+  const fields = [
+    ["name", record.name],
+    ["code", record.code],
+    ["errno", record.errno],
+    ["type", record.type],
+    ["syscall", record.syscall],
+    ["hostname", record.hostname],
+    ["host", record.host],
+    ["address", record.address],
+    ["port", record.port]
+  ];
+  return fields.filter(([, fieldValue]) => fieldValue != null && String(fieldValue).trim()).map(([key, fieldValue]) => `${key}=${String(fieldValue)}`);
+};
+var describeErrorValue = (value) => {
+  if (value == null) {
+    return "";
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  if (value instanceof Error) {
+    const message = value.message?.trim() || "";
+    const fields = getErrorFields(value);
+    return [message, ...fields].filter(Boolean).join(" ");
+  }
+  if (typeof value === "object") {
+    const fields = getErrorFields(value);
+    if (fields.length) {
+      return fields.join(" ");
+    }
+    try {
+      return JSON.stringify(value);
+    } catch {
+      return String(value);
+    }
+  }
+  return String(value);
+};
+var getErrorMessage = (error) => {
+  const maybeError = error;
+  const message = describeErrorValue(error) || String(error);
+  if (maybeError?.cause == null) {
+    return message;
+  }
+  const cause = describeErrorValue(maybeError.cause);
+  if (!cause) {
+    return message;
+  }
+  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) => {
+var screenDashboard = async (signal, projectRoot, userName = "root") => {
   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();
+  const screenshotBaseUrl = getScreenshotRenderBaseUrl();
+  const screenshotPath = getScreenshotPath(signal, projectRoot);
+  const settings = await getUserSettings(userName);
+  const token = settings.token;
+  const tokenParam = typeof token === "string" && token.length > 0 ? `&token=${encodeURIComponent(token)}` : "";
+  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();
+    let browserCloseRequested = false;
     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", () => {
+        if (browserCloseRequested) {
+          return;
+        }
+        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();
+      browserCloseRequested = true;
+      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";
+import { getUserSettings as getUserSettings2 } from "@tradejs/infra/userSettings";
 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 { APP_URL: APP_URL2 } = process.env;
+var TG_REQUEST_ATTEMPTS = 3;
+var TG_REQUEST_RETRY_DELAY_MS = 2e3;
+var getErrorFields2 = (value) => {
+  if (!value || typeof value !== "object") {
+    return [];
+  }
+  const record = value;
+  const fields = [
+    ["name", record.name],
+    ["code", record.code],
+    ["errno", record.errno],
+    ["type", record.type],
+    ["syscall", record.syscall],
+    ["hostname", record.hostname],
+    ["host", record.host],
+    ["address", record.address],
+    ["port", record.port]
+  ];
+  return fields.filter(([, fieldValue]) => fieldValue != null && String(fieldValue).trim()).map(([key, fieldValue]) => `${key}=${String(fieldValue)}`);
+};
+var describeErrorValue2 = (value) => {
+  if (value == null) {
+    return "";
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  if (value instanceof Error) {
+    const message = value.message?.trim() || "";
+    const fields = getErrorFields2(value);
+    return [message, ...fields].filter(Boolean).join(" ");
+  }
+  if (typeof value === "object") {
+    const fields = getErrorFields2(value);
+    if (fields.length) {
+      return fields.join(" ");
+    }
+    try {
+      return JSON.stringify(value);
+    } catch {
+      return String(value);
+    }
+  }
+  return String(value);
+};
 var normalizeQuality = (value) => typeof value === "number" ? Math.max(1, Math.min(5, Math.round(value))) : null;
+var formatOrderSkipReason = (reason) => {
+  if (!reason) return "";
+  if (reason.startsWith("AI_QUALITY_BELOW_MIN")) {
+    return "AI_QUALITY_BELOW_MIN";
+  }
+  return reason;
+};
 var getLastNumber = (value) => {
   if (Array.isArray(value)) {
     const last = value[value.length - 1];
@@ -122,6 +483,121 @@ 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 = describeErrorValue2(error) || String(error);
+  if (maybeError?.cause == null) {
+    return message;
+  }
+  const cause = describeErrorValue2(maybeError.cause);
+  if (!cause) {
+    return message;
+  }
+  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 getTelegramSettings = async (userName = "root") => {
+  const settings = await getUserSettings2(userName);
+  const token = settings.TG_BOT_TOKEN;
+  const chatId = settings.TG_CHAT_ID;
+  if (!token || !chatId) {
+    throw new Error(`Telegram settings are incomplete for user ${userName}`);
+  }
+  return { token, chatId };
+};
+var requestTelegram = async ({
+  method,
+  token,
+  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,
+  token,
+  chatId
+}) => {
+  const data = await requestTelegram({
+    method: "sendMessage",
+    token,
+    init: {
+      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,
@@ -173,7 +649,9 @@ var formatMessage = (signal, analysis) => {
         }
         lines.push(orderStatusText);
         if ((orderStatus === "skipped" || orderStatus === "canceled") && orderSkipReason) {
-          lines.push(`Skip reason: <b>${escapeHtml(orderSkipReason)}</b>`);
+          lines.push(
+            `Skip reason: <b>${escapeHtml(formatOrderSkipReason(orderSkipReason))}</b>`
+          );
         }
       }
       if (isConfigFromBacktest) {
@@ -191,21 +669,9 @@ var formatMessage = (signal, analysis) => {
         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("");
@@ -219,58 +685,88 @@ var formatMessage = (signal, analysis) => {
 \u0414\u0435\u0442\u0430\u043B\u0438: ${err.message || String(err)}`;
   }
 };
-var sendSignal = async (signal, imgInterval, 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 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"
-      })
+  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, token, chatId });
+    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({
+      method: "sendPhoto",
+      token,
+      init: {
+        method: "POST",
+        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,
+      token,
+      chatId
     });
     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) {
-    logger.error("tg sendPhoto failed: %s", JSON.stringify(data));
-    await fetch(`https://api.telegram.org/bot${token}/sendMessage`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        chat_id: chatId,
-        text: message,
-        reply_markup: markup,
-        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,
+      token,
+      chatId
     });
+    return;
   }
-  logger.info("tg sendPhoto: %s", data?.ok ? "sent" : JSON.stringify(data));
+  logger2.info("tg sendPhoto: sent");
 };
 var formatAnalysisMessage = (signal, analysis) => {
   const lines = [];
@@ -314,21 +810,25 @@ ${escapeHtml(clean)}`);
   }
   return lines.join("\n");
 };
-var sendSignalAnalysis = async (signal, analysis) => {
+var sendSignalAnalysis = async (signal, analysis, options = {}) => {
+  const { token, chatId } = await getTelegramSettings(options.userName);
   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 requestTelegram({
+    method: "sendMessage",
+    token,
+    init: {
+      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(
+  logger2.info(
     "tg sendMessage (analysis): %s",
-    data?.ok ? "sent" : JSON.stringify(data)
+    data?.ok ? "sent" : getTelegramErrorReason(data)
   );
 };
 
@@ -342,7 +842,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}`;
@@ -356,7 +856,7 @@ var cleanFiles = async (dir) => {
       bar.tick(completed === files.length ? completed % 100 : 100);
     }
   }
-  logger2.info("");
+  logger3.info("");
 };
 var cleanRedis = async (area) => {
   let completed = 0;
@@ -365,7 +865,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++;
@@ -376,21 +876,21 @@ 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);
+var update = async (connector, interval, tickers, preloadDays = PRELOAD_DAYS) => {
+  const PRELOAD_START = getTimestamp(preloadDays);
   const PRELOAD_END = getTimestamp();
   const bar = new ProgressBar(
     ":current/:total [:bar][:percent] :eta(s) :symbol",
@@ -399,7 +899,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}, preloadDays=${preloadDays})`
+    )
+  );
   const queue = tickers.slice();
   if (!queue.includes("BTCUSDT")) {
     queue.unshift("BTCUSDT");
@@ -411,15 +915,16 @@ var update = async (connector, interval, tickers) => {
         start: PRELOAD_START,
         end: PRELOAD_END,
         interval,
-        silent: true
+        silent: true,
+        warmOnly: 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();
@@ -457,14 +962,14 @@ 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];
   }
   return tickers.filter((t) => !excludeTickers.includes(t));
 };
-var makeScreenshots = async (signals, interval) => {
+var makeScreenshots = async (signals, interval, userName = "root") => {
   const projectRoot = getProjectRoot2();
   const bar = new ProgressBar(
     ":current/:total [:bar][:percent] :eta(s) :symbol",
@@ -473,15 +978,15 @@ 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,
     async (signal) => {
       try {
-        await screenDashboard({ ...signal, interval }, projectRoot);
+        await screenDashboard({ ...signal, interval }, projectRoot, userName);
       } catch (error) {
-        logger2.error(
+        logger3.error(
           "Failed screenshot: %s (%s)",
           signal.symbol,
           error?.message || String(error)
@@ -491,9 +996,9 @@ var makeScreenshots = async (signals, interval) => {
       }
     }
   );
-  logger2.info("");
+  logger3.info("");
 };
-var sendToAI = async (signals) => {
+var sendToAI = async (signals, userName = "root") => {
   const bar = new ProgressBar(
     ":current/:total [:bar][:percent] :eta(s) :symbol",
     {
@@ -501,19 +1006,19 @@ 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);
+      await askAI(signal, { userName });
     } 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) => {
+var sendToTG = async (signals, imgInterval, userName = "root") => {
   const bar = new ProgressBar(
     ":current/:total [:bar][:percent] :eta(s) :symbol",
     {
@@ -521,19 +1026,19 @@ var sendToTG = async (signals, imgInterval) => {
       width: 30
     }
   );
-  logger2.info(chalk.yellow("messages:", signals.length));
-  await runWithConcurrency(signals, TG_CONCURRENCY_LIMIT, async (signal) => {
+  logger3.info(chalk.yellow("messages:", signals.length));
+  await runWithConcurrency(signals, 1, async (signal) => {
     try {
-      const analysis = await getData2(
-        redisKeys2.analysis(signal.symbol, signal.signalId),
+      const analysis = await getData(
+        redisKeys.analysis(signal.symbol, signal.signalId),
         null
       );
-      await sendSignal(signal, imgInterval, analysis);
+      await sendSignal(signal, imgInterval, analysis, { userName });
       if (analysis && typeof analysis === "object" && Object.keys(analysis).length > 0) {
-        await sendSignalAnalysis(signal, analysis);
+        await sendSignalAnalysis(signal, analysis, { userName });
       }
     } catch (err) {
-      logger2.error(
+      logger3.error(
         "Failed sent: %s %s",
         signal.symbol,
         err?.message || String(err)
@@ -542,7 +1047,7 @@ var sendToTG = async (signals, imgInterval) => {
       bar.tick(1, { symbol: chalk.gray(signal.symbol) });
     }
   });
-  logger2.info("");
+  logger3.info("");
 };
 export {
   cleanFiles,