@andrey4emk/npm-app-back-b24 4.0.2 → 5.1.0

package/bitrix24/b24/retry.ts

@@ -1,6 +1,7 @@
 import { AjaxError, RefreshTokenError, SdkError } from "@bitrix24/b24jssdk";
 import { logs } from "../../logs/logs.ts";
 import { isNetworkError, isPreConnectionError } from "../../utils/fetchRetry.ts";
+import { isNonJsonResponseError } from "./nonJsonResponse.ts";
 
 // ==================== Типы ====================
 
@@ -20,6 +21,15 @@ export type AsyncFn = (...args: never[]) => Promise<unknown>;
 export const RETRY_COUNT = 5;
 /** Задержка между попытками (мс) */
 export const RETRY_DELAY_MS = 500;
+/**
+ * Первая пауза при ответе портала без JSON (HTML-страница прокси, пустое тело), мс.
+ * Дальше пауза удваивается: 1, 2, 4, 8 с — пять попыток растягиваются на 15 секунд.
+ *
+ * Ровная пауза в 500 мс укладывала все пять попыток в 2 секунды, а сбой 29.09.2026
+ * длился около трёх (T-65): повторы закончились раньше, чем портал пришёл в себя.
+ * Транспортные сбои по-прежнему идут с ровной паузой — растягивать их причины нет.
+ */
+export const NON_JSON_RETRY_BASE_DELAY_MS = 1000;
 
 /**
  * Коды транспортного сбоя. Один набор и для SdkError (AjaxError, RefreshTokenError),
@@ -113,6 +123,16 @@ function normalizeMethodName(raw: string): string {
     return head.replace(/\.json$/, "");
 }
 
+/**
+ * Пауза перед следующей попыткой: нарастающая для ответа без JSON, ровная для остального.
+ *
+ * @param error — ошибка упавшей попытки
+ * @param attempt — номер упавшей попытки, с единицы
+ */
+export function retryDelayFor(error: unknown, attempt: number): number {
+    return isNonJsonResponseError(error) ? NON_JSON_RETRY_BASE_DELAY_MS * 2 ** (attempt - 1) : RETRY_DELAY_MS;
+}
+
 /** Фраза для лога: повтор отменён, потому что вызов создаёт сущности */
 const creatingReason = (what: string): string => `вызов создаёт сущности (${what})`;
 
@@ -146,11 +166,16 @@ const reservingReason = (what: string): string => `вызов резервиру
  */
 export function isB24NetworkError(error: unknown): boolean {
     if (error instanceof AjaxError) {
-        // Практически недостижимо (SDK бросает реальную ошибку раньше),
+        // Практически недостижимо в SDK 2.x и 3.0 (SDK бросает реальную ошибку раньше),
         // но если код всё же пришёл — SDK уже исчерпал свои попытки
         if (error.code === "JSSDK_CALL_ALL_ATTEMPTS_EXHAUSTED") return false;
     }
 
+    // Портал (или прокси перед ним) отдал не JSON — временный сбой на его стороне,
+    // повтор осмыслен. Сегодня такая ошибка прошла бы и веткой status 0, но держаться
+    // за случайность формы обёртки SDK не хочется: признак проверяется явно
+    if (isNonJsonResponseError(error)) return true;
+
     if (error instanceof SdkError) {
         const { code, originalError, status } = error;
         const originalCode = (originalError as { code?: string } | undefined)?.code;
@@ -254,7 +279,7 @@ export function refreshFailureCode(error: unknown): string {
  * Возвращает null, если форма команды не распознана.
  */
 export function extractBatchCommandMethod(cmd: unknown): string | null {
-    // Кортеж ["crm.deal.add", { ... }] — основная форма в SDK 2.x
+    // Кортеж ["crm.deal.add", { ... }] — основная форма в SDK 2.x и 3.0
     if (Array.isArray(cmd)) {
         return typeof cmd[0] === "string" ? cmd[0] : null;
     }
@@ -265,7 +290,7 @@ export function extractBatchCommandMethod(cmd: unknown): string | null {
         return typeof method === "string" ? method : null;
     }
 
-    // Строка "crm.deal.add?ID=1" — в SDK 2.x эта форма уже не поддерживается
+    // Строка "crm.deal.add?ID=1" — в SDK 2.x и 3.0 эта форма не поддерживается
     // (ParseRow бросает JSSDK_INTERACTION_BATCH_ROW_FAIL), разбираем на случай,
     // если потребитель остался на ней со старой версии
     if (typeof cmd === "string") {
@@ -429,12 +454,13 @@ export async function runWithRetry<T>(fn: () => Promise<T>, label: string, block
 
             // Начало строки менять нельзя: по «попытка N/5 не удалась» грепают в логах
             const lifted = blockReason ? ` — соединение не состоялось, ограничение (${blockReason}) снято` : "";
+            const pause = retryDelayFor(error, attempt);
 
-            // Промежуточные попытки — warn: в чат B24 уходит только уровень error,
+            // Промежуточные попытки — warn: в Телеграм через ретранслятор уходит только уровень error,
             // иначе один упавший вызов дал бы пять сообщений
-            logs.add(`${label}${code}: попытка ${attempt}/${RETRY_COUNT} не удалась (${msg}), повтор через ${RETRY_DELAY_MS}мс${lifted}`, "warn");
+            logs.add(`${label}${code}: попытка ${attempt}/${RETRY_COUNT} не удалась (${msg}), повтор через ${pause}мс${lifted}`, "warn");
 
-            await delay(RETRY_DELAY_MS);
+            await delay(pause);
         }
     }
 

package/bitrix24/b24/tokens.ts

@@ -190,7 +190,7 @@ function refreshAuthWithMutex(): Promise<AuthData> {
 
             // Уровень warn, а не error, намеренно: брошенную ниже ошибку поймает
             // refreshAndSaveTokens и напишет свою строку уровня error, а error уходит
-            // в чат B24 — иначе на одно залипание пришло бы два сообщения
+            // в Телеграм через ретранслятор — иначе на одно залипание пришло бы два сообщения
             logs.add(
                 `refreshAuth: обмен токена не завершился за ${REFRESH_STUCK_TIMEOUT_MS / 60000} мин — ${mutexPart}, зависший запрос продолжает работу и сохранит токены сам, если ответ придёт`,
                 "warn"

package/bitrix24/b24/types.ts

@@ -31,19 +31,20 @@ export interface AuthSaveResponse {
 /**
  * `B24OAuth` плюс пять методов, которые пакет реализует сам поверх `actions.v2.*`.
  *
- * SDK 2.x помечает `callMethod`/`callListMethod`/`fetchListMethod`/`callBatch`/`callBatchByChunk`
- * к удалению в следующем major. Пакет предоставляет их сам, поэтому сигнатуры для потребителя
- * не меняются, а зависимости от удаляемого API у нас больше нет.
+ * В SDK 3.0.0 `callMethod`/`callListMethod`/`fetchListMethod`/`callBatch`/`callBatchByChunk`
+ * из `AbstractB24` удалены. Пакет предоставляет их сам, поэтому сигнатуры для потребителя
+ * не меняются, а зависимости от удалённого API у нас нет.
  *
  * Тип расширяет `B24OAuth`, поэтому `$b24` по-прежнему передаётся туда, где ждут `B24OAuth`
  * (`new Smsgold(auth, $b24)`, `new Event($b24)`).
  *
- * Пять сигнатур ниже объявлены НАМЕРЕННО и сегодня дублируют то, что и так приходит
- * по наследству от `B24OAuth`. Удалять их нельзя: в SDK 3.x этих методов в `AbstractB24`
- * не будет, и вместе с ними из типа пропадёт вся поверхность фасада — а тайпчек на
- * SDK 2.2.0 останется зелёным, то есть пропажа обнаружится только у потребителя.
- * Страховка от «уборки дублей» — `tests/client-type.test.ts`: он читает текст этого
- * файла и падает, если хоть одно объявление отсюда исчезло.
+ * Пять сигнатур ниже — единственный источник поверхности фасада: по наследству от `B24OAuth`
+ * они больше не приходят. Пропажу любого объявления ловит тайпчек самого пакета —
+ * `FacadeMethods` ниже и эталон в `tests/client-type.test.ts` берут их через `Pick`.
+ *
+ * `Promise<Result<any>>`, а не голый `Result`: с SDK 3 дефолт `Result<T>` — `unknown`,
+ * и код потребителей `(await $b24.callListMethod(...)).getData().forEach(...)` перестал бы
+ * компилироваться. Обоснование то же, что у остальных `any` ниже.
  *
  * `any` в сигнатурах оставлен НАМЕРЕННО и снятию по T-53 не подлежит: это дефолты
  * дженериков публичной поверхности, дословно повторяющие `AbstractB24`. На них стоит
@@ -54,28 +55,28 @@ export interface AuthSaveResponse {
  */
 export interface B24Client extends B24OAuth {
     callMethod<T = any>(method: string, params?: object, start?: number): Promise<AjaxResult<T>>;
-    callListMethod(method: string, params?: object, progress?: null | ((progress: number) => void), customKeyForResult?: string | null): Promise<Result>;
+    callListMethod(method: string, params?: object, progress?: null | ((progress: number) => void), customKeyForResult?: string | null): Promise<Result<any>>;
     fetchListMethod(method: string, params?: any, idKey?: string, customKeyForResult?: string | null): AsyncGenerator<any[]>;
-    callBatch(calls: Array<any> | object, isHaltOnError?: boolean, returnAjaxResult?: boolean): Promise<Result>;
-    callBatchByChunk(calls: Array<any>, isHaltOnError: boolean): Promise<Result>;
+    callBatch(calls: Array<any> | object, isHaltOnError?: boolean, returnAjaxResult?: boolean): Promise<Result<any>>;
+    callBatchByChunk(calls: Array<any>, isHaltOnError: boolean): Promise<Result<any>>;
 }
 
 /**
  * Минимальный контракт «умеет вызывать REST-методы B24».
  *
  * Нужен внутренним классам (`Event`, `Smsgold`), которые принимают экземпляр извне.
- * Объявляет `callMethod` сам, поэтому переживёт удаление метода из `B24OAuth`.
+ * Объявляет `callMethod` сам: в `B24OAuth` этого метода нет с SDK 3.0.0.
  *
  * Объединение `B24OAuth | B24Client` эту задачу не решает: `B24Client` расширяет
  * `B24OAuth`, union схлопывается в супертип, а вызов метода на union требует его
- * наличия в обеих ветках — то есть после удаления из SDK тайпчек сломается всё равно.
+ * наличия в обеих ветках.
  *
- * Структурный тип шире `B24OAuth`, поэтому публичные сигнатуры конструкторов
- * не сужаются: и `B24OAuth`, и `$b24`, и любой свой объект с `callMethod` подходят.
+ * Голый `B24OAuth` под этот тип с SDK 3.0.0 не подходит — передавать нужно `$b24`
+ * (или любой свой объект с `callMethod`).
  */
 export interface B24MethodCaller {
-    // Дженерика здесь быть не должно: у SDK метод не generic, и `B24OAuth`
-    // потребителя перестал бы подходить под этот тип. Проверено тайпчеком
+    // Дженерика нет, чтобы не расширять публичный тип без нужды: внутренние
+    // классы читают ответ через getResultData(), параметр типа им не нужен
     callMethod(method: string, params?: object, start?: number): Promise<AjaxResult>;
 }
 

package/bitrix24/errTaskB24.ts

@@ -223,7 +223,7 @@ export async function errorB24(dataTask: ErrorTaskData): Promise<ErrorB24Result>
         //
         // Условие обязательно: сетевой отказ retry-слой уже записал сам — строкой
         // про исчерпание попыток либо про отменённый повтор. Без проверки вторая
-        // строка ушла бы дублем в чат B24, куда уходит уровень `error`
+        // строка ушла бы дублем в Телеграм через ретранслятор, куда уходит уровень `error`
         if (!isB24NetworkError(error)) {
             logs.add(`errorB24: задача «${dataTask.title}» не создана (группа ${groupId ?? "не задана"}) — ${message}`, "error");
         }

package/bitrix24/eventB24.ts

@@ -232,8 +232,8 @@ function classifyEntityEvent(raw: unknown, requestedEventName: string): EntityVe
  * Класс для работы с офлайн-событиями Bitrix24
  */
 export class Event {
-    // Структурный тип, а не B24OAuth: объявляет callMethod сам, поэтому переживёт
-    // удаление метода из SDK. Сигнатуру конструктора не сужает — она стала шире
+    // Структурный тип, а не B24OAuth: объявляет callMethod сам — метода в B24OAuth
+    // нет с SDK 3.0.0, поэтому передавать нужно $b24, а не голый B24OAuth
     private b24: B24MethodCaller;
 
     /** Расширения видео-файлов */
@@ -441,7 +441,7 @@ export class Event {
 
             // Битой оказалась вся выборка целиком — это уже не одна кривая запись,
             // а похоже на смену формы ответа портала (переименованное поле). Уровень
-            // error, потому что строка обязана дойти до чата B24: очередь при этом
+            // error, потому что строка обязана дойти до Телеграма: очередь при этом
             // продолжает вычищаться пакет за пакетом, и локальный лог никто не увидит
             if (verdicts.length > 1 && brokenVerdicts.length === verdicts.length) {
                 const firstReason = brokenVerdicts.at(0)?.reason ?? "причина не определена";
@@ -492,7 +492,7 @@ export class Event {
                     const message = error instanceof Error ? error.message : String(error);
 
                     // Уровень warn, а не error: окончательный отказ вызова уже написал
-                    // строку error retry-слой Proxy, дубль ушёл бы в чат B24 второй раз
+                    // строку error retry-слой Proxy, дубль ушёл бы в Телеграм через ретранслятор второй раз
                     logs.add(
                         `event.offline.clear: не удалось снять с резерва записи, их ${messageIdsToClear.length} — ${message}. Записи придут следующим опросом`,
                         "warn"

package/logs/logs.ts

@@ -1,6 +1,7 @@
 import path from "path";
 import Conf from "conf";
 import dotEnv from "dotenv";
+import { maskPhones } from "./maskPhones.ts";
 
 dotEnv.config();
 
@@ -19,28 +20,33 @@ interface LogLevelConfig {
 /** Полная конфигурация логирования */
 type LogConfig = Record<LogLevel, LogLevelConfig>;
 
-// ==================== Константы B24 Chat ====================
+// ==================== Константы канала в Телеграм ====================
 
-/** ID бота в B24 для отправки error-логов */
-const B24_BOT_ID = 66600;
-
-/** CLIENT_ID бота в B24 */
-const B24_CLIENT_ID = "6rf74zyu842h6op1z186b08k7aavqq7z";
-
-/** Лимит длины сообщения для B24 чата (безопасный, с запасом на BB-обёртку) */
-const B24_TEXT_LIMIT = 4000;
+/**
+ * Предел длины текста, отправляемого в ретранслятор. Совпадает с `ENTRY_TEXT_LIMIT`
+ * ретранслятора (`tg_relay/src/format.ts`): длиннее он обрезал бы запись сам, уже после
+ * нашей маскировки и без нашей пометки. Сообщение Телеграма — 4096 символов, остаток
+ * ретранслятор оставляет под заголовок записи и строку «пропущено N»
+ */
+const RELAY_TEXT_LIMIT = 3800;
 
 /**
- * Бюджет времени на отправку error-лога в чат B24, мс.
+ * Бюджет времени на отправку одного error-лога в ретранслятор, мс.
  *
  * Своя константа, а не `FETCH_TIMEOUTS` из `utils/fetchRetry.ts`: тот модуль импортирует
  * `logs` первой строкой, и обратный импорт дал бы цикл. Дублирование одного числа
  * дешевле цикла зависимостей.
  */
-const B24_CHAT_TIMEOUT_MS = 5_000;
+const RELAY_TIMEOUT_MS = 5_000;
+
+/** Сколько символов тела неуспешного ответа ретранслятора показывать в `console.error` */
+const RELAY_BODY_PREVIEW = 300;
 
-/** Сколько символов тела неуспешного ответа чата показывать в `console.error` */
-const B24_CHAT_BODY_PREVIEW = 300;
+/** Пояснения к статусам ответа ретранслятора, которые чаще всего придётся разбирать */
+const RELAY_STATUS_HINTS: Readonly<Record<number, string>> = {
+    401: "ключ LOG_RELAY_KEY не принят",
+    503: "ретранслятор останавливается и не принимает",
+};
 
 /**
  * Ошибка — обрыв по бюджету `AbortSignal.timeout`. Проверка локальная, без импорта
@@ -50,6 +56,41 @@ function isTimeout(error: unknown): boolean {
     return (error as { name?: unknown } | null)?.name === "TimeoutError";
 }
 
+/**
+ * Короткое описание ошибки отправки без текста сообщения: `name` и код или имя причины.
+ * Текст сообщения сетевой ошибки может содержать адрес запроса, а адрес и ключ канала
+ * в консоль не печатаются
+ */
+function describeSendError(error: unknown): string {
+    const name = error instanceof Error ? error.name : typeof error;
+    const cause = error instanceof Error ? (error.cause as { code?: unknown; name?: unknown } | null | undefined) : undefined;
+    const causeLabel = cause && typeof cause === "object" ? (cause.code ?? cause.name) : undefined;
+    return typeof causeLabel === "string" && causeLabel ? `${name} (${causeLabel})` : name;
+}
+
+/** Ключ ретранслятора — только видимые символы ASCII, без пробелов и управляющих */
+const RELAY_KEY_RE = /^[\x21-\x7e]+$/;
+
+/**
+ * Проверяет адрес ретранслятора: только `http`/`https` и без логина и пароля в адресе.
+ * Возвращает причину отказа или `null`. Значение адреса в причину не попадает
+ */
+function relayUrlProblem(raw: string): string | null {
+    let parsed: URL;
+    try {
+        parsed = new URL(raw);
+    } catch {
+        return "LOG_RELAY_URL не разбирается как адрес";
+    }
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        return "LOG_RELAY_URL должен начинаться с http:// или https://";
+    }
+    if (parsed.username || parsed.password) {
+        return "LOG_RELAY_URL не должен содержать логин и пароль";
+    }
+    return null;
+}
+
 // ==================== Настройки ====================
 
 const configDir: string = process.env.CONFIG_DIR || "../config";
@@ -93,20 +134,43 @@ class LogsAPI {
 
     private readonly resetColor = "\x1b[0m";
 
-    /** Webhook URL для отправки error-логов в B24 чат */
-    private readonly b24WebhookUrl: string | undefined;
+    /** Адрес `POST /send` ретранслятора (`LOG_RELAY_URL`); `undefined` — канал выключен */
+    private readonly relayUrl: string | undefined;
 
-    /** ID чата B24 для отправки error-логов (формат: chatXXXXXX) */
-    private readonly b24ChatId: string | undefined;
-
-    /** Имя приложения для заголовка сообщения */
-    private readonly appName: string;
+    /** Ключ клиента ретранслятора (`LOG_RELAY_KEY`); `undefined` — канал выключен */
+    private readonly relayKey: string | undefined;
 
     constructor() {
         this.initConfig();
-        this.b24WebhookUrl = process.env.LOG_B24_WEBHOOK_URL;
-        this.b24ChatId = process.env.LOG_B24_CHAT_ID;
-        this.appName = process.env.APP_NAME || "Unknown App";
+        const url = process.env.LOG_RELAY_URL?.trim() || undefined;
+        const key = process.env.LOG_RELAY_KEY?.trim() || undefined;
+
+        // Канал включается только парой. Половина пары — ошибка настройки: одна строка
+        // предупреждения и канал выключен, а не запрос без ключа или в никуда
+        // Непригодные значения тоже выключают канал одной строкой. Сами значения в строку
+        // не попадают: адрес с паролем или ключ ушли бы в журнал контейнера
+        let enabled = false;
+        if (Boolean(url) !== Boolean(key)) {
+            console.warn("Logs: задан только один из LOG_RELAY_URL/LOG_RELAY_KEY — отправка error-логов в Телеграм выключена");
+        } else if (url && key) {
+            const problem = relayUrlProblem(url) ?? (RELAY_KEY_RE.test(key) ? null : "LOG_RELAY_KEY содержит пробелы или управляющие символы");
+            if (problem) {
+                console.warn(`Logs: ${problem} — отправка error-логов в Телеграм выключена`);
+            } else {
+                enabled = true;
+            }
+        }
+        this.relayUrl = enabled ? url : undefined;
+        this.relayKey = enabled ? key : undefined;
+
+        // Старый канал в чат Bitrix24 снят. Строка ровно одна за процесс: конструктор
+        // singleton'а вызывается один раз. Без неё обновление пакета молча оставило бы
+        // проект без канала error-логов
+        if (process.env.LOG_B24_WEBHOOK_URL || process.env.LOG_B24_CHAT_ID) {
+            console.warn(
+                "Logs: канал Bitrix24 снят в 5.1.0 — LOG_B24_WEBHOOK_URL и LOG_B24_CHAT_ID больше не читаются, error-логи идут через LOG_RELAY_URL/LOG_RELAY_KEY",
+            );
+        }
     }
 
     /** Проверяем и заполняем конфиг дефолтными значениями если данных нет */
@@ -121,7 +185,7 @@ class LogsAPI {
     /**
      * Добавляет сообщение в лог
      *
-     * Важно: при уровне `error` сообщение отправляется в B24 чат (через webhook)
+     * Важно: при уровне `error` сообщение отправляется в Телеграм через ретранслятор
      * независимо от настройки `error.enabled` в `log.json`. Настройка `enabled`
      * управляет только выводом в консоль. Это сделано намеренно, чтобы критические
      * ошибки всегда доходили до команды даже при отключённом консольном логировании.
@@ -132,11 +196,15 @@ class LogsAPI {
      */
     add(message: string | object, level?: LogLevel, jsonData?: unknown): void {
         const levelStr: LogLevel = level || "info";
-        const messageText = typeof message === "string" ? message : JSON.stringify(message);
+        // JSON.stringify отдаёт undefined для undefined, функции и объекта с toJSON → undefined;
+        // тогда берём String(), иначе дальше по коду шёл бы не текст
+        const messageText = typeof message === "string" ? message : (JSON.stringify(message) ?? String(message));
 
-        // Отправляем error-логи в B24 чат независимо от настроек консольного вывода
+        // Отправляем error-логи в Телеграм независимо от настроек консольного вывода.
+        // В консоль ниже уходят исходные message и jsonData — маскировка телефонов
+        // касается только текста для Телеграма
         if (levelStr === "error") {
-            this.sendToB24Chat(messageText, jsonData);
+            this.sendToRelay(messageText, jsonData);
         }
 
         // Проверяем конфиг, и если логирование отключено, то выходим
@@ -161,117 +229,87 @@ class LogsAPI {
     }
 
     /**
-     * Убирает BB-теги для plain text отправки (при обрезке текста)
+     * Готовит текст error-лога и отправляет его в ретранслятор (fire-and-forget).
+     *
+     * Телефоны маскируются ДО обрезки по длине: после обрезки хвост номера на границе
+     * уже не узнать шаблоном, и он ушёл бы в Телеграм открытым.
      */
-    private stripBbCodes(text: string): string {
-        return text.replace(/\[\/?(b|code)\]/g, "");
-    }
+    private sendToRelay(message: string, jsonData?: unknown): void {
+        if (!this.relayUrl || !this.relayKey) return;
 
-    /**
-     * Отправляет error-сообщение в чат B24 через webhook (fire-and-forget)
-     * Использует нативный fetch, а не fetchRetry/fetchWithTimeout — во избежание
-     * циклической зависимости, поэтому и таймаут выставляется здесь вручную через
-     * `AbortSignal.timeout`: без него зависшее соединение никого бы не разбудило,
-     * вызов идёт без await
-     * Ошибки не пробрасываются, только console.error
-     */
-    private sendToB24Chat(message: string, jsonData?: unknown): void {
-        if (!this.b24WebhookUrl || !this.b24ChatId) return;
-
-        // Нормализуем URL — гарантируем trailing slash
-        const baseUrl = this.b24WebhookUrl.endsWith("/") ? this.b24WebhookUrl : `${this.b24WebhookUrl}/`;
-        const url = `${baseUrl}imbot.message.add.json`;
-
-        let text = `[b]ERROR[/b] | ${this.appName}\n${message}`;
-
-        // Добавляем jsonData если есть
-        if (jsonData !== undefined) {
-            // Безопасная сериализация — логгер не должен бросать исключения
-            let jsonStr: string;
-            try {
-                jsonStr = JSON.stringify(jsonData, null, 2);
-            } catch {
-                jsonStr = "[Не удалось сериализовать jsonData]";
+        // Логгер не должен бросать синхронно: его зовут из catch-блоков потребителей,
+        // и бросок отсюда подменил бы исходную ошибку. Отказ — только console.error
+        try {
+            let text = message.trim() ? message : "(пустое сообщение)";
+
+            // null и undefined не дописываем: строка «null» в Телеграме ничего не говорит
+            if (jsonData != null) {
+                // Безопасная сериализация: циклы бросают, функция и undefined дают undefined
+                try {
+                    const serialized = JSON.stringify(jsonData, null, 2) as string | undefined;
+                    text += `\n${serialized ?? String(jsonData)}`;
+                } catch {
+                    text += "\n[Не удалось сериализовать jsonData]";
+                }
             }
-            text += `\n[code]${jsonStr}[/code]`;
-        }
 
-        // Обрезаем до лимита B24
-        let isTruncated = false;
-        if (text.length > B24_TEXT_LIMIT) {
-            const truncatedSuffix = "\n...(обрезано)";
-            text = text.slice(0, B24_TEXT_LIMIT - truncatedSuffix.length) + truncatedSuffix;
-            isTruncated = true;
-        }
+            text = maskPhones(text);
 
-        // Если текст обрезан — отправляем без BB-тегов, чтобы не разорвать [code]...[/code]
-        if (isTruncated) {
-            text = this.stripBbCodes(text);
-        }
+            if (text.length > RELAY_TEXT_LIMIT) {
+                const truncatedSuffix = "\n...(обрезано)";
+                text = text.slice(0, RELAY_TEXT_LIMIT - truncatedSuffix.length) + truncatedSuffix;
+            }
 
-        void this.postToB24Chat(url, text);
+            void this.postToRelay(this.relayUrl, this.relayKey, text);
+        } catch (error: unknown) {
+            console.error(`Logs Relay: не удалось подготовить сообщение — ${describeSendError(error)}`);
+        }
     }
 
     /**
-     * Сам запрос в чат и разбор ответа. Никогда не бросает: все ошибки — в `console.error`,
-     * не через `logs`, иначе отказ канала порождал бы новый error и зацикливался.
+     * Сам запрос к ретранслятору и разбор ответа. Никогда не бросает: все ошибки — в
+     * `console.error`, не через `logs`, иначе отказ канала порождал бы новый error и зацикливался.
+     *
+     * Нативный `fetch`, а не `fetchRetry`/`fetchWithTimeout` — во избежание циклической
+     * зависимости, поэтому таймаут выставляется здесь через `AbortSignal.timeout`: вызов идёт
+     * без `await`, и без бюджета зависшее соединение никого бы не разбудило. Сигнал действует
+     * и на чтение тела ответа — зависшее тело обрывается тем же бюджетом.
      *
-     * Сигнал `AbortSignal.timeout` отдан в `fetch`, а он действует и на чтение тела
-     * ответа: зависшее тело обрывается тем же бюджетом с `TimeoutError`. До общего `catch`
-     * такая ошибка не доходит — у каждого чтения тела свой `.catch`, поэтому таймаут
-     * разбирается прямо там: при `!ok` к статусу дописывается пометка «тело не дочитано»,
-     * при 200 пишется отдельная строка «доставка не подтверждена».
+     * Ни адрес, ни ключ в строки ошибок не попадают: вместо текста сетевой ошибки
+     * (он может содержать адрес) печатается только её имя и код причины.
      */
-    private async postToB24Chat(url: string, text: string): Promise<void> {
+    private async postToRelay(url: string, key: string, text: string): Promise<void> {
         try {
             const response = await fetch(url, {
                 method: "POST",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify({
-                    BOT_ID: B24_BOT_ID,
-                    CLIENT_ID: B24_CLIENT_ID,
-                    DIALOG_ID: this.b24ChatId,
-                    MESSAGE: text,
-                }),
-                signal: AbortSignal.timeout(B24_CHAT_TIMEOUT_MS),
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${key}`,
+                },
+                body: JSON.stringify({ level: "error", text }),
+                signal: AbortSignal.timeout(RELAY_TIMEOUT_MS),
             });
 
-            if (!response.ok) {
-                // Тело — подсказка к причине отказа, его чтение отправку уронить не должно
-                const body = await response.text().catch((error: unknown) =>
-                    isTimeout(error) ? `[тело не дочитано за ${B24_CHAT_TIMEOUT_MS / 1000}с]` : "",
-                );
-                const bodyPart = body ? ` — ${body.slice(0, B24_CHAT_BODY_PREVIEW)}` : "";
-                console.error(`Logs B24 Chat: HTTP ${response.status}, сообщение не доставлено${bodyPart}`);
+            // 202 — принято в очередь ретранслятора; тело не нужно, соединение освобождаем
+            if (response.status === 202) {
+                await response.body?.cancel().catch(() => {});
                 return;
             }
 
-            // B24 умеет отвечать 200 с телом {error, error_description} — сообщения при этом нет.
-            // Нечитаемый JSON — молча null (портал ответил 200, ошибки в теле не видно),
-            // а вот зависшее тело — отказ канала: доставку подтвердить нечем, молчать нельзя
-            let bodyTimedOut = false;
-            const data: unknown = await response.json().catch((error: unknown) => {
-                bodyTimedOut = isTimeout(error);
-                return null;
-            });
-            if (bodyTimedOut) {
-                console.error(
-                    `Logs B24 Chat: HTTP ${response.status}, но ответ не дочитан за ${B24_CHAT_TIMEOUT_MS / 1000}с — доставка не подтверждена`,
-                );
-                return;
-            }
-            if (data && typeof data === "object" && "error" in data) {
-                const { error, error_description: description } = data as { error?: unknown; error_description?: unknown };
-                const reason = description ? String(description) : String(error);
-                console.error(`Logs B24 Chat: портал отклонил сообщение — ${reason}`);
-            }
+            // Тело — подсказка к причине отказа, его чтение отправку уронить не должно
+            const body = await response.text().catch((error: unknown) =>
+                isTimeout(error) ? `[тело не дочитано за ${RELAY_TIMEOUT_MS / 1000}с]` : "",
+            );
+            const bodyPart = body ? ` — ${body.slice(0, RELAY_BODY_PREVIEW)}` : "";
+            const hint = RELAY_STATUS_HINTS[response.status];
+            const hintPart = hint ? ` (${hint})` : "";
+            console.error(`Logs Relay: HTTP ${response.status}, сообщение не доставлено${hintPart}${bodyPart}`);
         } catch (error: unknown) {
             if (isTimeout(error)) {
-                console.error(`Logs B24 Chat: не ответил за ${B24_CHAT_TIMEOUT_MS / 1000}с, сообщение не доставлено`);
+                console.error(`Logs Relay: не ответил за ${RELAY_TIMEOUT_MS / 1000}с, сообщение не доставлено`);
                 return;
             }
-            const errMsg = error instanceof Error ? error.message : String(error);
-            console.error(`Logs B24 Chat: ошибка отправки — ${errMsg}`);
+            console.error(`Logs Relay: ошибка отправки — ${describeSendError(error)}`);
         }
     }
 }