Refactor Vite configuration to remove backend port definition, simplifying API root URL handling in development. Update Telegram bot service to support chunked message sending for long payloads, enhancing message delivery reliability. Replace custom message splitting logic in Telegram notifier with utility function for improved maintainability.

Author: Cohen, Yohay

client/dev-dist/sw.js

@@ -82,7 +82,7 @@ define(['./workbox-46f6dd99'], (function (workbox) { 'use strict';
     "revision": "3ca0b8505b4bec776b69afdba2768812"
   }, {
     "url": "index.html",
-    "revision": "0.hupt0fcl2eo"
+    "revision": "0.30t30nqs6k"
   }], {});
   workbox.cleanupOutdatedCaches();
   workbox.registerRoute(new workbox.NavigationRoute(workbox.createHandlerBoundToURL("index.html"), {

client/src/lib/api.ts

@@ -1,14 +1,12 @@
 import axios from 'axios';
 
-declare const __BACKEND_PORT__: string;
-
 /**
  * Root URL for the REST API (no trailing slash). In production, respects Vite `BASE_URL` (GitHub Pages project sites).
+ * In dev, use same-origin `/api` so requests go through the Vite proxy (matches `vite.config.ts` backend port).
  */
 export function getApiRoot(): string {
     if (import.meta.env.DEV) {
-        const port = typeof __BACKEND_PORT__ !== 'undefined' ? __BACKEND_PORT__ : '3000';
-        return `http://${window.location.hostname}:${port}/api`;
+        return '/api';
     }
     const base = import.meta.env.BASE_URL;
     return base.endsWith('/') ? `${base}api` : `${base}/api`;

client/vite.config.ts

@@ -82,9 +82,6 @@ export default defineConfig(() => {
         optimizeDeps: {
             include: ['@app/shared'],
         },
-        define: {
-            '__BACKEND_PORT__': JSON.stringify(targetPort)
-        },
         server: {
             port: 5173,
             host: '127.0.0.1',

server/src/routes/telegramRoutes.ts

@@ -174,8 +174,15 @@ router.get('/status', async (req: Request, res: Response) => {
  */
 router.post('/send-test-message', async (req: Request, res: Response) => {
   try {
-    const { chatId } = req.body || {};
-    const result = await telegramBotService.sendTestMessage(chatId);
+    const { chatId, testCharCount, testMode } = req.body || {};
+    const parsedCount =
+      testCharCount != null && testCharCount !== ''
+        ? Math.floor(Number(testCharCount))
+        : undefined;
+    const result = await telegramBotService.sendTestMessage(chatId, {
+      testCharCount: parsedCount,
+      mode: testMode === 'html' ? 'html' : 'plain',
+    });
     if (result.errors.length > 0 && result.sent === 0) {
       return res.status(500).json({ success: false, error: result.errors[0] });
     }

server/src/services/notifications/telegramNotifier.ts

@@ -7,6 +7,7 @@ import { BaseNotifier } from './baseNotifier.js';
 import { NotificationPayload, NotifierConfig } from './types.js';
 import axios from 'axios';
 import { serverLogger } from '../../utils/logger.js';
+import { splitTelegramPlainText } from '../../utils/telegramTextSplit.js';
 
 export interface TelegramNotifierConfig extends Omit<NotifierConfig, 'enabled'> {
   enabled?: boolean;
@@ -103,7 +104,7 @@ export class TelegramNotifier extends BaseNotifier {
     }
 
     const message = this.formatMessage(payload);
-    const chunks = this.splitMessageForTelegram(message, 3800);
+    const chunks = splitTelegramPlainText(message, 3800);
 
     for (const chatId of this.chatIds) {
       let sent = 0;
@@ -169,87 +170,6 @@ export class TelegramNotifier extends BaseNotifier {
     return this.L('sourceManual');
   }
 
-  /**
-   * Split long messages into chunks within Telegram-safe size.
-   * Prefer split points at newline, sentence boundary, then whitespace.
-   * Avoids splitting in the middle of MarkdownV2 escapes (\) or UTF-16 surrogate pairs.
-   */
-  private splitMessageForTelegram(message: string, maxLen: number): string[] {
-    const text = String(message || '');
-    if (text.length <= maxLen) return [text];
-
-    const chunks: string[] = [];
-    let remaining = text;
-
-    while (remaining.length > maxLen) {
-      let splitAt = this.findBestSplitPoint(remaining, maxLen);
-      if (splitAt <= 0 || splitAt > remaining.length) {
-        splitAt = Math.min(maxLen, remaining.length);
-      }
-      splitAt = this.adjustSplitForSafeBoundary(remaining, splitAt);
-
-      const chunk = remaining.slice(0, splitAt).trim();
-      if (chunk.length > 0) {
-        chunks.push(chunk);
-      }
-      remaining = remaining.slice(splitAt).trim();
-    }
-
-    if (remaining.length > 0) {
-      chunks.push(remaining);
-    }
-
-    return chunks;
-  }
-
-  /**
-   * Ensure we don't split in the middle of a MarkdownV2 escape (backslash + char)
-   * or in the middle of a UTF-16 surrogate pair (emoji).
-   */
-  private adjustSplitForSafeBoundary(text: string, splitAt: number): number {
-    if (splitAt <= 0 || splitAt >= text.length) return splitAt;
-    let pos = splitAt;
-    // Don't end chunk with a single backslash (would break MarkdownV2 escape in Telegram).
-    while (pos > 0 && text[pos - 1] === '\\') {
-      pos--;
-    }
-    // Don't split in the middle of a surrogate pair (low surrogate is 0xD800-0xDBFF, high is 0xDC00-0xDFFF).
-    const atPos = text.charCodeAt(pos);
-    if (pos < text.length && atPos >= 0xDC00 && atPos <= 0xDFFF && pos > 0) {
-      pos--;
-    }
-    return Math.max(1, pos);
-  }
-
-  private findBestSplitPoint(text: string, maxLen: number): number {
-    const safeMax = Math.min(maxLen, text.length);
-    const candidate = text.slice(0, safeMax + 1);
-
-    // Prefer newline boundaries.
-    const newline = candidate.lastIndexOf('\n');
-    if (newline >= Math.floor(safeMax * 0.6)) {
-      return newline + 1;
-    }
-
-    // Prefer sentence boundaries.
-    for (let i = safeMax; i >= Math.floor(safeMax * 0.6); i--) {
-      const c = candidate[i];
-      if (!c) continue;
-      if (c === '.' || c === '!' || c === '?' || c === '…' || c === ';') {
-        return i + 1;
-      }
-    }
-
-    // Fallback to whitespace boundary.
-    const ws = Math.max(candidate.lastIndexOf(' '), candidate.lastIndexOf('\t'));
-    if (ws >= Math.floor(safeMax * 0.6)) {
-      return ws + 1;
-    }
-
-    // Last resort: hard split (adjustSplitForSafeBoundary will fix escape/surrogate).
-    return safeMax;
-  }
-
   /**
    * Format payload as Telegram MarkdownV2 message
    */

server/src/services/telegramBotService.ts

@@ -18,6 +18,7 @@ import { Profile, ScrapeRequest, ScrapeResult, type Transaction, type Transactio
 import { transactionsToCsv, transactionsToJson } from '@app/shared';
 import { postScrapeService } from './postScrapeService.js';
 import { buildUnifiedChatQueryWithMemory, mergeAndPersistAiMemory } from './unifiedAiChatMemory.js';
+import { getTelegramMaxMessageChars, splitTelegramHtmlChunks, splitTelegramPlainText } from '../utils/telegramTextSplit.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -1091,8 +1092,12 @@ export class TelegramBotService {
 
     if (statusMsg && chatIdNum) {
       const body = summaryLines.length > 0 ? summaryLines.join('\n') : this.t('errorScraper');
-      const finalText = `${this.t('scraperSuccess')}\n\n${body}`.slice(0, 4096);
-      await this.editTelegramStatusMessage(ctx, chatIdNum, statusMsg.message_id, finalText);
+      const finalText = `${this.t('scraperSuccess')}\n\n${body}`;
+      const summaryChunks = splitTelegramPlainText(finalText, getTelegramMaxMessageChars());
+      await this.editTelegramStatusMessage(ctx, chatIdNum, statusMsg.message_id, summaryChunks[0]);
+      for (let i = 1; i < summaryChunks.length; i++) {
+        await ctx.reply(summaryChunks[i]);
+      }
     }
 
     if (results.length > 0) {
@@ -1306,30 +1311,26 @@ export class TelegramBotService {
         this.chatStates.set(chatIdNum.toString(), updatedState);
       }
 
-      // If response already contains HTML tags, use as-is; otherwise convert Markdown to HTML
+      // If response already contains HTML tags, use as-is; otherwise convert Markdown to HTML per chunk
       const looksLikeHtml = /<\/?\w+[^>]*>/.test(response);
-      const htmlResponse = looksLikeHtml ? response : this.convertMarkdownToHtml(response);
+      const htmlChunks: string[] = looksLikeHtml
+        ? splitTelegramHtmlChunks(response, 4080)
+        : splitTelegramPlainText(response, 3400).flatMap((ch) => {
+            const h = this.convertMarkdownToHtml(ch);
+            return h.length > 4080 ? splitTelegramHtmlChunks(h, 4080) : [h];
+          });
 
-      if (htmlResponse.length > 4096) {
-        const chunks = htmlResponse.match(/[\s\S]{1,4096}/g) || [];
-        // Edit first chunk into the thinking message
-        try {
-          // @ts-ignore
-          await ctx.telegram.editMessageText(chatIdNum, thinkingMsg.message_id, undefined, chunks[0], { parse_mode: 'HTML' });
-        } catch (e) {
-          // If edit fails, send as a new message
-          await ctx.reply(String(chunks[0]), { parse_mode: 'HTML' });
-        }
-        for (let i = 1; i < chunks.length; i++) {
-          await ctx.reply(String(chunks[i]), { parse_mode: 'HTML' });
-        }
-      } else {
-        try {
-          // @ts-ignore
-          await ctx.telegram.editMessageText(chatIdNum, thinkingMsg.message_id, undefined, htmlResponse, { parse_mode: 'HTML' });
-        } catch (e) {
-          await ctx.reply(String(htmlResponse), { parse_mode: 'HTML' });
-        }
+      const chunks = htmlChunks.length > 0 ? htmlChunks : [this.convertMarkdownToHtml(response || this.t('noAiResponse'))];
+      const firstChunk = chunks[0];
+      const restChunks = chunks.slice(1);
+
+      try {
+        await ctx.telegram.editMessageText(chatIdNum, thinkingMsg.message_id, undefined, firstChunk, { parse_mode: 'HTML' });
+      } catch (e) {
+        await ctx.reply(String(firstChunk), { parse_mode: 'HTML' });
+      }
+      for (const part of restChunks) {
+        await ctx.reply(String(part), { parse_mode: 'HTML' });
       }
     } catch (error) {
       serverLogger.error('Error in AI chat', { error });
@@ -2095,24 +2096,81 @@ export class TelegramBotService {
     return this.isRunning;
   }
 
+  /**
+   * Deterministic long payload for exercising Telegram chunking (plain or HTML).
+   */
+  private buildLargeTestTelegramPayload(targetLen: number, mode: 'plain' | 'html'): string {
+    const cap = Math.min(50000, Math.max(1, Math.floor(targetLen)));
+    if (cap < 64) {
+      return 'x'.repeat(cap);
+    }
+    let s = mode === 'html' ? '<b>LARGE-TEST</b>\n' : 'LARGE-TEST\n';
+    let n = 0;
+    while (s.length < cap) {
+      const line = mode === 'html' ? `<i>${n}</i> ${'x'.repeat(32)}\n` : `LINE ${n} ${'x'.repeat(48)}\n`;
+      const room = cap - s.length;
+      if (line.length > room) {
+        s += mode === 'html' ? 'x'.repeat(room) : line.slice(0, room);
+        break;
+      }
+      s += line;
+      n++;
+    }
+    return s.slice(0, cap);
+  }
+
   /**
    * Send a test message to the given chat(s). If chatId is provided, send only to that chat;
    * otherwise send to all notification chat IDs.
+   * Optional `testCharCount` (1–50000) sends a large payload split the same way as production long messages.
    */
-  async sendTestMessage(chatId?: string): Promise<{ sent: number; errors: string[] }> {
+  async sendTestMessage(
+    chatId?: string,
+    options?: { testCharCount?: number; mode?: 'plain' | 'html' }
+  ): Promise<{ sent: number; errors: string[] }> {
     if (!this.bot || !this.isRunning) {
       throw new Error('Telegram bot is not running. Start the bot first.');
     }
     const targetIds = chatId ? [chatId] : this.config.notificationChatIds;
     if (targetIds.length === 0) {
       throw new Error('No notification chats configured. Add at least one user to the Notification column.');
     }
-    const text = '✅ Test message from Israeli Bank Scraper. If you see this, notifications are working.';
+    const rawCount = options?.testCharCount;
+    const count =
+      rawCount != null && Number.isFinite(Number(rawCount)) ? Math.floor(Number(rawCount)) : 0;
+    const mode = options?.mode === 'html' ? 'html' : 'plain';
+
     const errors: string[] = [];
     let sent = 0;
+
+    if (count <= 0) {
+      const text = '✅ Test message from Israeli Bank Scraper. If you see this, notifications are working.';
+      for (const id of targetIds) {
+        try {
+          await this.bot.telegram.sendMessage(id, text);
+          sent++;
+        } catch (err: any) {
+          errors.push(`${id}: ${err?.message || err}`);
+        }
+      }
+      return { sent, errors };
+    }
+
+    const payload = this.buildLargeTestTelegramPayload(count, mode);
+    const chunks =
+      mode === 'html'
+        ? splitTelegramHtmlChunks(payload, 4080)
+        : splitTelegramPlainText(payload, getTelegramMaxMessageChars());
+
     for (const id of targetIds) {
       try {
-        await this.bot.telegram.sendMessage(id, text);
+        for (const chunk of chunks) {
+          await this.bot.telegram.sendMessage(
+            id,
+            chunk,
+            mode === 'html' ? { parse_mode: 'HTML' } : {}
+          );
+        }
         sent++;
       } catch (err: any) {
         errors.push(`${id}: ${err?.message || err}`);