@tradejs/node 1.0.3 → 1.0.5

package/dist/cli.js

@@ -3933,7 +3933,7 @@ var require_lodash = __commonJS({
         var defer = baseRest(function(func, args) {
           return baseDelay(func, 1, args);
         });
-        var delay2 = baseRest(function(func, wait, args) {
+        var delay3 = baseRest(function(func, wait, args) {
           return baseDelay(func, toNumber(wait) || 0, args);
         });
         function flip(func) {
@@ -5047,7 +5047,7 @@ var require_lodash = __commonJS({
         lodash.defaults = defaults;
         lodash.defaultsDeep = defaultsDeep;
         lodash.defer = defer;
-        lodash.delay = delay2;
+        lodash.delay = delay3;
         lodash.difference = difference;
         lodash.differenceBy = differenceBy;
         lodash.differenceWith = differenceWith;
@@ -5528,7 +5528,7 @@ var import_promises2 = __toESM(require("fs/promises"));
 var import_lodash = __toESM(require_lodash());
 var import_progress = __toESM(require("progress"));
 var import_chalk = __toESM(require("chalk"));
-var import_async2 = require("@tradejs/core/async");
+var import_async3 = require("@tradejs/core/async");
 var import_backtest = require("@tradejs/core/backtest");
 var import_constants = require("@tradejs/core/constants");
 var import_tickers = require("@tradejs/core/tickers");
@@ -5536,7 +5536,16 @@ var import_time = require("@tradejs/core/time");
 
 // src/constants.ts
 var { NODE_ENV } = process.env;
-var KLINE_CONCURRENCY_LIMIT = NODE_ENV === "production" ? 5 : 10;
+var getPositiveIntegerEnv = (name, fallback) => {
+  const rawValue = process.env[name];
+  const parsedValue = Number(rawValue);
+  return Number.isInteger(parsedValue) && parsedValue > 0 ? parsedValue : fallback;
+};
+var DEFAULT_KLINE_CONCURRENCY_LIMIT = NODE_ENV === "production" ? 1 : 10;
+var KLINE_CONCURRENCY_LIMIT = getPositiveIntegerEnv(
+  "KLINE_CONCURRENCY_LIMIT",
+  DEFAULT_KLINE_CONCURRENCY_LIMIT
+);
 var TG_CONCURRENCY_LIMIT = 3;
 var AI_CONCURRENCY_LIMIT = 3;
 var SCREENSHOT_CONCURRENCY_LIMIT = NODE_ENV === "production" ? 1 : 2;
@@ -5544,7 +5553,7 @@ var SCREENSHOT_CONCURRENCY_LIMIT = NODE_ENV === "production" ? 1 : 2;
 // src/cli.ts
 var import_files = require("@tradejs/infra/files");
 var import_redis3 = require("@tradejs/infra/redis");
-var import_logger4 = require("@tradejs/infra/logger");
+var import_logger5 = require("@tradejs/infra/logger");
 
 // src/ai.ts
 var import_redis = require("@tradejs/infra/redis");
@@ -5897,65 +5906,325 @@ var import_promises = __toESM(require("fs/promises"));
 var import_path2 = __toESM(require("path"));
 var import_puppeteer = __toESM(require("puppeteer"));
 var import_async = require("@tradejs/core/async");
+var import_logger3 = require("@tradejs/infra/logger");
 var import_redis2 = require("@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) => import_path2.default.resolve(getTradejsProjectCwd(projectRoot));
 var getScreenshotsDir = (projectRoot) => import_path2.default.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 import_promises.default.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 import_path2.default.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 (0, import_redis2.getData)(import_redis2.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 import_puppeteer.default.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);
+  import_logger3.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 import_puppeteer.default.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) {
+        import_logger3.logger.info(
+          "screenshot browser: %s %sm captureAttempt=%d pid=%s exec=%s",
+          symbol,
+          interval,
+          captureAttempt,
+          String(browserProcess.pid ?? "unknown"),
+          browserProcess.spawnfile || "unknown"
+        );
+      }
+      import_logger3.logger.info(
+        "screenshot browser version: %s %sm captureAttempt=%d version=%s",
+        symbol,
+        interval,
+        captureAttempt,
+        await browser.version()
       );
-      await (0, import_async.delay)(1e4);
-      await import_promises.default.mkdir(getScreenshotsDir(projectRoot), { recursive: true });
-      await page.screenshot({
-        path: getScreenshotPath(signal, projectRoot)
+      browser.on("disconnected", () => {
+        import_logger3.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;
+          }
+          import_logger3.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;
+          }
+          import_logger3.logger.error(
+            "screenshot request failed: %s %sm %s (%s)",
+            symbol,
+            interval,
+            maskTokenInUrl(request.url()),
+            request.failure()?.errorText || "unknown"
+          );
+        });
+        page.on("pageerror", (error) => {
+          import_logger3.logger.error(
+            "screenshot page error: %s %sm (%s)",
+            symbol,
+            interval,
+            error.message || String(error)
+          );
+        });
+        page.on("error", (error) => {
+          import_logger3.logger.error(
+            "screenshot target error: %s %sm (%s)",
+            symbol,
+            interval,
+            error.message || String(error)
+          );
+        });
+        page.on("close", () => {
+          import_logger3.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}` : "";
+          import_logger3.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;
+          }
+          import_logger3.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;
+        import_logger3.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 {
+            import_logger3.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
+            });
+            import_logger3.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())
+            );
+            import_logger3.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;
+            import_logger3.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 (0, import_async.delay)(SCREENSHOT_NAVIGATION_RETRY_DELAY_MS);
+          }
+        }
+        if (gotoError) {
+          throw new Error(
+            `Failed to open dashboard ${dashboardUrl}: ${gotoError.message || String(gotoError)}`
+          );
+        }
+        await (0, import_async.delay)(SCREENSHOT_RENDER_DELAY_MS);
+        await import_promises.default.mkdir(getScreenshotsDir(projectRoot), { recursive: true });
+        await page.screenshot({
+          path: screenshotPath,
+          type: "png"
+        });
+        import_logger3.logger.info(
+          "screenshot saved: %s %sm path=%s",
+          symbol,
+          interval,
+          screenshotPath
+        );
+        return;
+      } finally {
+        await page.close().catch(() => void 0);
+      }
+    } catch (error) {
+      captureError = error;
+      import_logger3.logger.error(
+        "screenshot capture failed: %s %sm captureAttempt=%d (%s)",
+        symbol,
+        interval,
+        captureAttempt,
+        getErrorMessage(captureError)
+      );
+      if (captureAttempt < SCREENSHOT_CAPTURE_ATTEMPTS) {
+        await (0, import_async.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
+var import_async2 = require("@tradejs/core/async");
 var import_math = require("@tradejs/core/math");
-var import_logger3 = require("@tradejs/infra/logger");
+var import_logger4 = require("@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)) {
@@ -5976,6 +6245,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;
+      import_logger4.logger.error(
+        "tg %s network failed: attempt=%d (%s)",
+        method,
+        attempt,
+        getErrorMessage2(error)
+      );
+      if (attempt < TG_REQUEST_ATTEMPTS) {
+        await (0, import_async2.delay)(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"
+    })
+  });
+  import_logger4.logger.info(
+    "tg sendMessage: %s",
+    data?.ok ? "sent" : getTelegramErrorReason(data)
+  );
+  return data;
+};
 var formatMessage = (signal, analysis) => {
   const {
     symbol,
@@ -6076,53 +6438,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) {
+    import_logger4.logger.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);
+    import_logger4.logger.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);
+    import_logger4.logger.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;
   }
-  import_logger3.logger.info("tg sendPhoto: %s", data?.ok ? "sent" : JSON.stringify(data));
+  import_logger4.logger.info("tg sendPhoto: sent");
 };
 var formatAnalysisMessage = (signal, analysis) => {
   const lines = [];
@@ -6168,7 +6553,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({
@@ -6177,10 +6562,9 @@ var sendSignalAnalysis = async (signal, analysis) => {
       parse_mode: "HTML"
     })
   });
-  const data = await res.json();
-  import_logger3.logger.info(
+  import_logger4.logger.info(
     "tg sendMessage (analysis): %s",
-    data?.ok ? "sent" : JSON.stringify(data)
+    data?.ok ? "sent" : getTelegramErrorReason(data)
   );
 };
 
@@ -6194,7 +6578,7 @@ var cleanFiles = async (dir) => {
     total: files.length,
     width: 30
   });
-  import_logger4.logger.info(import_chalk.default.yellow("clean:", dir));
+  import_logger5.logger.info(import_chalk.default.yellow("clean:", dir));
   for await (const file of files) {
     completed++;
     const fullPath = `${dir}/${file}`;
@@ -6208,7 +6592,7 @@ var cleanFiles = async (dir) => {
       bar.tick(completed === files.length ? completed % 100 : 100);
     }
   }
-  import_logger4.logger.info("");
+  import_logger5.logger.info("");
 };
 var cleanRedis = async (area) => {
   let completed = 0;
@@ -6217,7 +6601,7 @@ var cleanRedis = async (area) => {
     total: keys.length,
     width: 30
   });
-  import_logger4.logger.info(import_chalk.default.yellow("clean:", area));
+  import_logger5.logger.info(import_chalk.default.yellow("clean:", area));
   try {
     for await (const key of keys) {
       completed++;
@@ -6228,18 +6612,18 @@ var cleanRedis = async (area) => {
     }
   } catch (e) {
     if (e instanceof import_redis3.RedisWriteBlockedError || String(e).includes("MISCONF")) {
-      import_logger4.logger.error(
+      import_logger5.logger.error(
         "Redis write is blocked by MISCONF (RDB save failure). Cleanup stopped early."
       );
-      import_logger4.logger.error(
+      import_logger5.logger.error(
         "Check Redis logs and fix persistence/memory pressure before retry."
       );
-      import_logger4.logger.info("");
+      import_logger5.logger.info("");
       return;
     }
     throw e;
   }
-  import_logger4.logger.info("");
+  import_logger5.logger.info("");
 };
 var update = async (connector, interval, tickers) => {
   const PRELOAD_START = (0, import_time.getTimestamp)(import_constants.PRELOAD_DAYS);
@@ -6251,12 +6635,16 @@ var update = async (connector, interval, tickers) => {
       width: 30
     }
   );
-  import_logger4.logger.info(import_chalk.default.yellow("update:", tickers.length));
+  import_logger5.logger.info(
+    import_chalk.default.yellow(
+      `update: ${tickers.length} (klineConcurrency=${KLINE_CONCURRENCY_LIMIT})`
+    )
+  );
   const queue = tickers.slice();
   if (!queue.includes("BTCUSDT")) {
     queue.unshift("BTCUSDT");
   }
-  await (0, import_async2.runWithConcurrency)(queue, KLINE_CONCURRENCY_LIMIT, async (symbol) => {
+  await (0, import_async3.runWithConcurrency)(queue, KLINE_CONCURRENCY_LIMIT, async (symbol) => {
     try {
       await connector.kline({
         symbol,
@@ -6266,12 +6654,12 @@ var update = async (connector, interval, tickers) => {
         silent: true
       });
     } catch {
-      import_logger4.logger.error("Failed loading: %s", symbol);
+      import_logger5.logger.error("Failed loading: %s", symbol);
     } finally {
       bar.tick(1, { symbol: import_chalk.default.gray(symbol) });
     }
   });
-  import_logger4.logger.info("");
+  import_logger5.logger.info("");
 };
 var parseSymbolsFromCLI = (symbol = "") => symbol.split(",").map((s) => {
   const ticker = s.toUpperCase();
@@ -6309,7 +6697,7 @@ var getTickers = async (connector, include = "", exclude = "", limit, chunk) =>
   }
   if (chunk) {
     const [currentChunk, chunksCount] = chunk.split("/").map((c) => parseInt(c));
-    import_logger4.logger.info("chunk: %d / %d", currentChunk, chunksCount);
+    import_logger5.logger.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];
@@ -6325,15 +6713,15 @@ var makeScreenshots = async (signals, interval) => {
       width: 30
     }
   );
-  import_logger4.logger.info(import_chalk.default.yellow("screenshots:", `${interval}m`, signals.length));
-  await (0, import_async2.runWithConcurrency)(
+  import_logger5.logger.info(import_chalk.default.yellow("screenshots:", `${interval}m`, signals.length));
+  await (0, import_async3.runWithConcurrency)(
     signals,
     SCREENSHOT_CONCURRENCY_LIMIT,
     async (signal) => {
       try {
         await screenDashboard({ ...signal, interval }, projectRoot);
       } catch (error) {
-        import_logger4.logger.error(
+        import_logger5.logger.error(
           "Failed screenshot: %s (%s)",
           signal.symbol,
           error?.message || String(error)
@@ -6343,7 +6731,7 @@ var makeScreenshots = async (signals, interval) => {
       }
     }
   );
-  import_logger4.logger.info("");
+  import_logger5.logger.info("");
 };
 var sendToAI = async (signals) => {
   const bar = new import_progress.default(
@@ -6353,17 +6741,17 @@ var sendToAI = async (signals) => {
       width: 30
     }
   );
-  import_logger4.logger.info(import_chalk.default.yellow("AI:", signals.length));
-  await (0, import_async2.runWithConcurrency)(signals, AI_CONCURRENCY_LIMIT, async (signal) => {
+  import_logger5.logger.info(import_chalk.default.yellow("AI:", signals.length));
+  await (0, import_async3.runWithConcurrency)(signals, AI_CONCURRENCY_LIMIT, async (signal) => {
     try {
       await askAI(signal);
     } catch {
-      import_logger4.logger.error("Failed ask: %s", signal.symbol);
+      import_logger5.logger.error("Failed ask: %s", signal.symbol);
     } finally {
       bar.tick(1, { symbol: import_chalk.default.gray(signal.symbol) });
     }
   });
-  import_logger4.logger.info("");
+  import_logger5.logger.info("");
 };
 var sendToTG = async (signals, imgInterval) => {
   const bar = new import_progress.default(
@@ -6373,8 +6761,8 @@ var sendToTG = async (signals, imgInterval) => {
       width: 30
     }
   );
-  import_logger4.logger.info(import_chalk.default.yellow("messages:", signals.length));
-  await (0, import_async2.runWithConcurrency)(signals, TG_CONCURRENCY_LIMIT, async (signal) => {
+  import_logger5.logger.info(import_chalk.default.yellow("messages:", signals.length));
+  await (0, import_async3.runWithConcurrency)(signals, TG_CONCURRENCY_LIMIT, async (signal) => {
     try {
       const analysis = await (0, import_redis3.getData)(
         import_redis3.redisKeys.analysis(signal.symbol, signal.signalId),
@@ -6384,13 +6772,17 @@ var sendToTG = async (signals, imgInterval) => {
       if (analysis && typeof analysis === "object" && Object.keys(analysis).length > 0) {
         await sendSignalAnalysis(signal, analysis);
       }
-    } catch {
-      import_logger4.logger.error("Failed sent: %s", signal.symbol);
+    } catch (err) {
+      import_logger5.logger.error(
+        "Failed sent: %s %s",
+        signal.symbol,
+        err?.message || String(err)
+      );
     } finally {
       bar.tick(1, { symbol: import_chalk.default.gray(signal.symbol) });
     }
   });
-  import_logger4.logger.info("");
+  import_logger5.logger.info("");
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {