@easyoref/agent 1.21.1

package/src/runtime/auth.ts

@@ -0,0 +1,63 @@
+#!/usr/bin/env tsx
+/**
+ * GramJS QR Auth — run once to generate session_string.
+ *
+ * Usage:
+ *   npx tsx packages/bot/src/agent/auth.ts
+ *
+ * Scan QR with burner phone → session_string printed → done.
+ */
+
+import qrcode from "qrcode-terminal";
+import { TelegramClient } from "telegram";
+import { StringSession } from "telegram/sessions/index.js";
+
+// Telegram Desktop public api_id/api_hash (from open-source TDesktop)
+const apiId = 2040;
+const apiHash = "b18441a1ff607e10a989891a5462e627";
+
+const session = new StringSession("");
+const client = new TelegramClient(session, apiId, apiHash, {
+  connectionRetries: 3,
+  deviceModel: "EasyOref Auth",
+  appVersion: "1.0.0",
+});
+
+console.log("\n🔑 EasyOref — Telegram QR Auth\n");
+console.log("Connecting to Telegram...\n");
+
+// GramJS requires phoneNumber callback to enter QR flow.
+// Throwing RESTART_AUTH_WITH_QR makes it switch to QR login.
+await client.start({
+  phoneNumber: async () => {
+    throw { errorMessage: "RESTART_AUTH_WITH_QR" };
+  },
+  password: async () => "",
+  phoneCode: async () => "",
+  qrCode: async ({ token }) => {
+    const url = `tg://login?token=${token.toString("base64url")}`;
+    console.clear();
+    console.log(
+      "📱 Scan this QR in Telegram → Settings → Devices → Link Desktop\n",
+    );
+    qrcode.generate(url, { small: true });
+    console.log("");
+  },
+  onError: (err) => {
+    if (String(err).includes("RESTART_AUTH")) return Promise.resolve(true);
+    console.error("Auth error:", err);
+    return Promise.resolve(true);
+  },
+});
+
+console.log("\n✅ Authenticated!\n");
+
+const sessionString = client.session.save() as unknown as string;
+
+console.log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+console.log("SESSION STRING (copy this to config.yaml):\n");
+console.log(sessionString);
+console.log("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+
+await client.disconnect();
+process.exit(0);

package/src/runtime/dry-run.ts

@@ -0,0 +1,303 @@
+/**
+ * Dry-run: test vote + buildEnrichedMessage without Redis / Telegram / LLM.
+ *
+ * Usage:
+ *   npx tsx packages/bot/src/agent/dry-run.ts
+ *
+ * Prints the enriched message HTML to stdout.
+ * Strip HTML tags to preview plain text:
+ *   npx tsx packages/bot/src/agent/dry-run.ts | sed 's/<[^>]*>//g'
+ */
+
+// ── Mock base message (as formatMessage() would produce) ──────────────────────
+
+const BASE_MESSAGE = [
+  "<b>🚀 Ракетная атака</b>",
+  "Ожидаются прилёты. Пройдите в укрытие.",
+  "",
+  "<b>Район:</b> Тель-Авив — Яффо",
+  "<b>Подлётное время:</b> ~5–12 мин",
+  "<b>Время оповещения:</b> 03:47",
+].join("\n");
+
+// ── Mock validated extractions (normally come from LLM) ───────────────────────
+
+const NOW = Date.now();
+const ALERT_TS = NOW - 90_000; // alert was 90s ago
+
+const MOCK_EXTRACTIONS = [
+  {
+    channel: "@newsflashhhj",
+    messageUrl: "https://t.me/newsflashhhj/12340",
+    regionRelevance: 0.9,
+    sourceTrust: 0.85,
+    tone: "calm" as const,
+    countryOrigin: "Iran",
+    rocketCount: 6,
+    isCassette: false,
+    hitsConfirmed: undefined,
+    hit_detail: undefined,
+    etaRefinedMinutes: 8,
+    confidence: 0.88,
+    valid: true,
+  },
+  {
+    channel: "@israelsecurity",
+    messageUrl: "https://t.me/israelsecurity/5521",
+    regionRelevance: 0.85,
+    sourceTrust: 0.78,
+    tone: "neutral" as const,
+    countryOrigin: "Lebanon",
+    rocketCount: 7,
+    isCassette: true,
+    hitsConfirmed: undefined,
+    hit_detail: undefined,
+    etaRefinedMinutes: 9,
+    confidence: 0.75,
+    valid: true,
+  },
+  {
+    channel: "@N12LIVE",
+    messageUrl: "https://t.me/N12LIVE/8802",
+    regionRelevance: 0.7,
+    sourceTrust: 0.9,
+    tone: "calm" as const,
+    countryOrigin: "Iran",
+    rocketCount: 5,
+    isCassette: undefined,
+    hitsConfirmed: 2,
+    hit_detail: "на открытой местности",
+    etaRefinedMinutes: undefined,
+    confidence: 0.82,
+    valid: true,
+  },
+];
+
+// ── Inline copy of vote() + buildEnrichedMessage() ────────────────────────────
+// (avoids importing config / redis which require a real config.yaml)
+
+const SUPERSCRIPTS = ["⁰", "¹", "²", "³", "⁴", "⁵", "⁶", "⁷", "⁸", "⁹"];
+function sup(indices: number[]): string {
+  return indices
+    .map((n) =>
+      String(n)
+        .split("")
+        .map((d) => SUPERSCRIPTS[Number(d)])
+        .join(""),
+    )
+    .join("");
+}
+
+const COUNTRY_RU: Record<string, string> = {
+  Iran: "Иран",
+  Yemen: "Йемен",
+  Lebanon: "Ливан",
+  Gaza: "Газа",
+  Iraq: "Ирак",
+  Syria: "Сирия",
+  Hezbollah: "Хезболла",
+};
+
+function vote(extractions: typeof MOCK_EXTRACTIONS) {
+  const indexed = extractions.map((e, i) => ({ ...e, idx: i + 1 }));
+
+  const citedSources = indexed.map((e) => ({
+    index: e.idx,
+    channel: e.channel,
+    messageUrl: e.messageUrl ?? undefined,
+  }));
+
+  // ETA: highest-confidence source
+  const withEta = indexed
+    .filter((e) => e.etaRefinedMinutes !== undefined)
+    .sort((a, b) => b.confidence - a.confidence);
+  const bestEta = withEta[0] ?? undefined;
+
+  // Countries: group, collect citations
+  const countryMap = new Map<string, number[]>();
+  for (const e of indexed) {
+    if (e.countryOrigin) {
+      const list = countryMap.get(e.countryOrigin) ?? [];
+      list.push(e.idx);
+      countryMap.set(e.countryOrigin, list);
+    }
+  }
+  const countryOrigins =
+    countryMap.size > 0
+      ? Array.from(countryMap.entries()).map(([name, citations]) => ({
+          name,
+          citations,
+        }))
+      : undefined;
+
+  // Rocket range
+  const rocketSrcs = indexed.filter((e) => e.rocketCount !== undefined);
+  const rocketVals = rocketSrcs.map((e) => e.rocketCount as number);
+  const rocketCountMin =
+    rocketVals.length > 0 ? Math.min(...rocketVals) : undefined;
+  const rocketCountMax =
+    rocketVals.length > 0 ? Math.max(...rocketVals) : undefined;
+  const rocket_citations = rocketSrcs.map((e) => e.idx);
+
+  // Cassette: majority
+  const cassVals = indexed
+    .filter((e) => e.isCassette !== undefined)
+    .map((e) => e.isCassette as boolean);
+  const isCassette =
+    cassVals.length > 0
+      ? cassVals.filter(Boolean).length > cassVals.length / 2
+      : undefined;
+
+  // Hits: median
+  const hitsVals = indexed
+    .filter((e) => e.hitsConfirmed !== undefined)
+    .map((e) => e.hitsConfirmed as number)
+    .sort((a, b) => a - b);
+  const hitsConfirmed =
+    hitsVals.length > 0 ? hitsVals[Math.floor(hitsVals.length / 2)] : undefined;
+
+  // Hits citations
+  const hitsSrcs = indexed.filter(
+    (e) => e.hitsConfirmed !== undefined && e.hitsConfirmed > 0,
+  );
+  const hits_citations = hitsSrcs.map((e) => e.idx);
+
+  // Weighted confidence
+  const totalWeight = indexed.reduce(
+    (s, e) => s + e.sourceTrust * e.confidence,
+    0,
+  );
+
+  return {
+    etaRefinedMinutes: bestEta?.etaRefinedMinutes ?? undefined,
+    eta_citations: bestEta ? [bestEta.idx] : [],
+    countryOrigins,
+    rocketCountMin,
+    rocketCountMax,
+    isCassette,
+    rocket_citations,
+    hitsConfirmed,
+    hits_citations,
+    confidence: Math.round((totalWeight / indexed.length) * 100) / 100,
+    sourcesCount: indexed.length,
+    citedSources,
+  };
+}
+
+function insertBeforeBlockEnd(text: string, line: string): string {
+  const bqIdx = text.lastIndexOf("</blockquote>");
+  if (bqIdx !== -1) {
+    return text.slice(0, bqIdx) + line + "\n" + text.slice(bqIdx);
+  }
+  const timeLinePattern = /(<b>Время оповещения:<\/b>)/;
+  const match = text.match(timeLinePattern);
+  if (match?.index) {
+    return text.slice(0, match.index) + line + "\n" + text.slice(match.index);
+  }
+  const lines = text.split("\n");
+  lines.splice(Math.max(lines.length - 1, 0), 0, line);
+  return lines.join("\n");
+}
+
+function refineEtaInPlace(
+  text: string,
+  minutes: number,
+  alertTs: number,
+  citations: number[],
+): string {
+  const absTime = new Date(alertTs + minutes * 60_000).toLocaleTimeString(
+    "he-IL",
+    { hour: "2-digit", minute: "2-digit", timeZone: "Asia/Jerusalem" },
+  );
+  const refined = `~${absTime}${sup(citations)}`;
+
+  const etaPatterns = [
+    /~\d+[–-]\d+\s*мин/,
+    /~\d+[–-]\d+\s*min/,
+    /~\d+[–-]\d+\s*דקות/,
+    /1\.5\s*мин/,
+    /1\.5\s*min/,
+  ];
+  for (const pattern of etaPatterns) {
+    if (pattern.test(text)) return text.replace(pattern, refined);
+  }
+  return text;
+}
+
+function buildEnrichedMessage(
+  currentText: string,
+  alertTs: number,
+  r: ReturnType<typeof vote>,
+): string {
+  let text = currentText;
+
+  if (r.etaRefinedMinutes !== undefined && r.eta_citations.length > 0) {
+    text = refineEtaInPlace(
+      text,
+      r.etaRefinedMinutes,
+      alertTs,
+      r.eta_citations,
+    );
+  }
+
+  if (r.countryOrigins && r.countryOrigins.length > 0) {
+    const parts = r.countryOrigins.map((c) => {
+      const ru = COUNTRY_RU[c.name] ?? c.name;
+      return `${ru}${sup(c.citations)}`;
+    });
+    // Leading \n creates blank line between ETA and intel block
+    text = insertBeforeBlockEnd(text, `\n<b>Откуда:</b> ${parts.join(" + ")}`);
+  }
+
+  if (r.rocketCountMin !== undefined && r.rocketCountMax !== undefined) {
+    const countStr =
+      r.rocketCountMin === r.rocketCountMax
+        ? `${r.rocketCountMin}`
+        : `~${r.rocketCountMin}-${r.rocketCountMax}`;
+    const cassette = r.isCassette ? " (кассет.)" : "";
+    text = insertBeforeBlockEnd(text, `<b>Ракет:</b> ${countStr}${cassette}`);
+  }
+
+  if (r.hitsConfirmed !== undefined && r.hitsConfirmed > 0) {
+    const hitsCite = r.hits_citations.length > 0 ? sup(r.hits_citations) : "";
+    text = insertBeforeBlockEnd(
+      text,
+      `<b>Попадания (Дан центр):</b> ${r.hitsConfirmed}${hitsCite}`,
+    );
+  }
+
+  const sourcesWithUrl = r.citedSources.filter((s) => s.messageUrl);
+  if (sourcesWithUrl.length > 0) {
+    const links = sourcesWithUrl
+      .map((s) => `<a href="${s.messageUrl}">[${s.index}]</a>`)
+      .join("  ");
+    text += `\n—\n<i>Источники: ${links}</i>`;
+  }
+
+  return text;
+}
+
+// ── Run ───────────────────────────────────────────────────────────────────────
+
+const voted = vote(MOCK_EXTRACTIONS);
+
+console.log("\n=== VOTE RESULT ===");
+console.log(JSON.stringify(voted, undefined, 2));
+
+const enriched = buildEnrichedMessage(BASE_MESSAGE, ALERT_TS, voted);
+
+console.log("\n=== ENRICHED MESSAGE (HTML) ===");
+console.log(enriched);
+
+console.log("\n=== PLAIN TEXT PREVIEW ===");
+console.log(
+  enriched
+    .replace(/<[^>]*>/g, "")
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">"),
+);
+
+console.log(`\n=== STATS ===`);
+console.log(`Confidence: ${voted.confidence}`);
+console.log(`Sources:    ${voted.sourcesCount}`);
+console.log(`Chars:      ${enriched.length} (TG caption limit: 1024)`);

package/src/runtime/queue.ts

@@ -0,0 +1,53 @@
+/**
+ * BullMQ queue — enrich alert jobs.
+ *
+ * Job payload: { alertId, alertTs }
+ * Job is added with a delay (config.agent.enrichDelayMs) after alert fires,
+ * then the worker runs the LangGraph pipeline and edits the Telegram message.
+ */
+
+import * as logger from "@easyoref/monitoring";
+import { config } from "@easyoref/shared";
+import { Queue } from "bullmq";
+
+export interface EnrichJobData {
+  alertId: string;
+  alertTs: number;
+}
+
+let _queue: Queue<EnrichJobData> | undefined = undefined;
+
+export function getEnrichQueue(): Queue<EnrichJobData> {
+  if (!_queue) {
+    _queue = new Queue<EnrichJobData>("enrich-alert", {
+      connection: {
+        host: new URL(config.agent.redisUrl).hostname,
+        port: Number(new URL(config.agent.redisUrl).port || 6379),
+        password: new URL(config.agent.redisUrl).password || undefined,
+      },
+      defaultJobOptions: {
+        removeOnComplete: 100,
+        removeOnFail: 50,
+        attempts: 2,
+        backoff: { type: "exponential", delay: 10_000 },
+      },
+    });
+  }
+  return _queue;
+}
+
+export async function enqueueEnrich(
+  alertId: string,
+  alertTs: number,
+  delayMs?: number,
+): Promise<void> {
+  if (!config.agent.enabled) return;
+
+  const delay = delayMs ?? config.agent.enrichDelayMs;
+  const queue = getEnrichQueue();
+  await queue.add("enrich", { alertId, alertTs }, { delay });
+  logger.info("Enrich job enqueued", {
+    alertId,
+    delay_ms: delay,
+  });
+}

package/src/runtime/redis.ts

@@ -0,0 +1,38 @@
+/**
+ * Redis singleton (ioredis).
+ * Lazily initialized so the main bot still works when agent.enabled=false.
+ */
+
+import * as logger from "@easyoref/monitoring";
+import { config } from "@easyoref/shared";
+import { Redis as IORedis } from "ioredis";
+
+let _redis: IORedis | undefined = undefined;
+
+export function getRedis(): IORedis {
+  if (!_redis) {
+    _redis = new IORedis(config.agent.redisUrl, {
+      lazyConnect: false,
+      maxRetriesPerRequest: 3,
+      enableReadyCheck: true,
+    });
+
+    _redis.on("error", (err: Error) => {
+      logger.warn("Redis error", { error: String(err) });
+    });
+
+    _redis.on("connect", () => {
+      logger.info("Redis connected", {
+        url: config.agent.redisUrl.replace(/:[^:@]+@/, ":***@"),
+      });
+    });
+  }
+  return _redis;
+}
+
+export async function closeRedis(): Promise<void> {
+  if (_redis) {
+    await _redis.quit();
+    _redis = undefined;
+  }
+}

package/src/runtime/worker.ts

@@ -0,0 +1,167 @@
+/**
+ * BullMQ worker — processes "enrich-alert" jobs.
+ *
+ * Session-aware scheduling:
+ *   early_warning → every 20s, up to 30 min
+ *   red_alert     → every 20s, up to 15 min
+ *   resolved      → every 60s, up to 10 min (tail — detailed intel)
+ *
+ * After each job, checks the session phase and re-enqueues
+ * with the appropriate delay. Stops when phase expires.
+ */
+
+import * as logger from "@easyoref/monitoring";
+import {
+  clearSession,
+  config,
+  getActiveSession,
+  getLanguagePack,
+  isPhaseExpired,
+  PHASE_ENRICH_DELAY_MS,
+  TelegramMessage,
+} from "@easyoref/shared";
+import { Worker } from "bullmq";
+import { Bot } from "grammy";
+import { runEnrichment } from "../graph.js";
+import { MONITORING_RE, stripMonitoring } from "../nodes/message.js";
+import { enqueueEnrich, type EnrichJobData } from "./queue.js";
+
+let _worker: Worker | undefined = undefined;
+
+/** Remove ⏳ monitoring indicator from all chat messages (best-effort) */
+async function removeMonitoringIndicator(session: {
+  chatId: string;
+  latestMessageId: number;
+  isCaption: boolean;
+  currentText: string;
+  telegramMessages?: TelegramMessage[];
+}): Promise<void> {
+  if (!config.botToken || !MONITORING_RE.test(session.currentText)) return;
+  const cleaned = stripMonitoring(session.currentText);
+  const tgBot = new Bot(config.botToken);
+  const targets: TelegramMessage[] = session.telegramMessages ?? [
+    {
+      chatId: session.chatId,
+      messageId: session.latestMessageId,
+      isCaption: session.isCaption,
+    },
+  ];
+  for (const cm of targets) {
+    try {
+      if (cm.isCaption) {
+        await tgBot.api.editMessageCaption(cm.chatId, cm.messageId, {
+          caption: cleaned,
+          parse_mode: "HTML",
+        });
+      } else {
+        await tgBot.api.editMessageText(cm.chatId, cm.messageId, cleaned, {
+          parse_mode: "HTML",
+        });
+      }
+    } catch (err) {
+      const errStr = String(err);
+      if (!errStr.includes("message is not modified")) {
+        logger.error("Failed to remove monitoring indicator", {
+          error: errStr,
+          chatId: cm.chatId,
+        });
+      }
+    }
+  }
+  logger.info("Removed monitoring indicator", { targets: targets.length });
+}
+
+export function startEnrichWorker(): void {
+  if (!config.agent.enabled) return;
+
+  const connection = {
+    host: new URL(config.agent.redisUrl).hostname,
+    port: Number(new URL(config.agent.redisUrl).port || 6379),
+    password: new URL(config.agent.redisUrl).password || undefined,
+  };
+
+  _worker = new Worker<EnrichJobData>(
+    "enrich-alert",
+    async (job) => {
+      const { alertId } = job.data;
+      logger.info("Enrich worker: processing job", { alertId, jobId: job.id });
+
+      const session = await getActiveSession();
+      if (!session) {
+        logger.info("Enrich worker: no active session — skipping", { alertId });
+        return;
+      }
+
+      // Phase expired → end session
+      if (isPhaseExpired(session)) {
+        logger.info("Enrich worker: phase expired — ending session", {
+          alertId: session.latestAlertId,
+          phase: session.phase,
+        });
+        await removeMonitoringIndicator(session);
+        await clearSession();
+        return;
+      }
+
+      const langPack = getLanguagePack(config.language);
+
+      // Run enrichment using latest alert's message as edit target
+      await runEnrichment({
+        alertId: session.latestAlertId,
+        alertTs: session.latestAlertTs,
+        alertType: session.phase,
+        alertAreas: session.alertAreas,
+        chatId: session.chatId,
+        messageId: session.latestMessageId,
+        isCaption: session.isCaption,
+        telegramMessages: session.telegramMessages,
+        currentText: session.baseText ?? session.currentText,
+        monitoringLabel: langPack.labels.monitoring,
+      });
+
+      // Re-check session after enrichment (may have changed phase)
+      const after = await getActiveSession();
+      if (!after) return;
+
+      if (isPhaseExpired(after)) {
+        logger.info(
+          "Enrich worker: phase expired post-enrich — ending session",
+          {
+            phase: after.phase,
+          },
+        );
+        await removeMonitoringIndicator(after);
+        await clearSession();
+        return;
+      }
+
+      // Re-enqueue with phase-appropriate delay
+      const delay = PHASE_ENRICH_DELAY_MS[after.phase];
+      await enqueueEnrich(after.latestAlertId, after.latestAlertTs, delay);
+    },
+    {
+      connection,
+      concurrency: 1,
+    },
+  );
+
+  _worker.on("completed", (job) => {
+    logger.info("Enrich worker: job completed", { jobId: job.id });
+  });
+
+  _worker.on("failed", (job, err) => {
+    logger.error("Enrich worker: job failed", {
+      jobId: job?.id,
+      error: String(err),
+    });
+  });
+
+  logger.info("Enrich worker started");
+}
+
+export async function stopEnrichWorker(): Promise<void> {
+  if (_worker) {
+    await _worker.close();
+    _worker = undefined;
+  }
+}