@integrity-labs/agt-cli 0.19.18 → 0.19.19

package/mcp/telegram-channel.js

@@ -14235,13 +14235,21 @@ function classifyPeerMessage(msg, cfg, self) {
   if (self.bot_id === null || self.bot_username === null) {
     return { kind: "drop", reason: "self_resolution_pending" };
   }
-  if (isAddressedToUs(msg, self.bot_id, self.bot_username)) {
-    return { kind: "peer-ingress", peer };
+  const addressing = classifyAddressing(msg, self.bot_id, self.bot_username);
+  if (!addressing.addressed) {
+    return { kind: "drop", reason: "not_addressed" };
   }
-  return { kind: "drop", reason: "not_addressed" };
+  if (addressing.viaReplyOnly) {
+    const inAllowedGroup = cfg.peer_group_ids.length > 0 && cfg.peer_group_ids.includes(chatId);
+    const respondMode = cfg.peer_agent_mode === "respond";
+    if (!(inAllowedGroup && respondMode)) {
+      return { kind: "drop", reason: "not_addressed" };
+    }
+  }
+  return { kind: "peer-ingress", peer };
 }
-function isAddressedToUs(msg, ourBotId, ourBotUsername) {
-  if (msg.reply_to_message?.from?.id === ourBotId) return true;
+function classifyAddressing(msg, ourBotId, ourBotUsername) {
+  let viaMentionOrCommand = false;
   const text = msg.text ?? msg.caption ?? "";
   const entities = msg.entities ?? msg.caption_entities ?? [];
   const usAt = "@" + ourBotUsername;
@@ -14249,15 +14257,19 @@ function isAddressedToUs(msg, ourBotId, ourBotUsername) {
     const slice = text.slice(entity.offset, entity.offset + entity.length).toLowerCase();
     if (entity.type === "bot_command") {
       const at = slice.indexOf("@");
-      if (at < 0) {
-        return true;
+      if (at < 0 || slice.slice(at + 1) === ourBotUsername) {
+        viaMentionOrCommand = true;
+        break;
       }
-      if (slice.slice(at + 1) === ourBotUsername) return true;
     } else if (entity.type === "mention" && slice === usAt) {
-      return true;
+      viaMentionOrCommand = true;
+      break;
     }
   }
-  return false;
+  const viaReply = msg.reply_to_message?.from?.id === ourBotId;
+  if (viaMentionOrCommand) return { addressed: true, viaReplyOnly: false };
+  if (viaReply) return { addressed: true, viaReplyOnly: true };
+  return { addressed: false, viaReplyOnly: false };
 }
 var CODE_NAME_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 function parsePeersEnv(raw) {
@@ -14287,6 +14299,322 @@ function parsePeerAgentModeEnv(raw) {
   return "off";
 }
 
+// src/telegram-peer-rate-limiter.ts
+var SECOND_MS = 1e3;
+var MINUTE_MS = 60 * SECOND_MS;
+var HOUR_MS = 60 * MINUTE_MS;
+var DAY_MS = 24 * HOUR_MS;
+var DEFAULT_RATE_LIMITER_CONFIG = Object.freeze({
+  pairBurstLimit: 1,
+  pairBurstWindowMs: 10 * SECOND_MS,
+  pairWindowLimit: 5,
+  pairWindowMs: 5 * MINUTE_MS,
+  chatLimit: 10,
+  chatWindowMs: 5 * MINUTE_MS,
+  agentDailyLimit: 200,
+  agentDailyWindowMs: DAY_MS,
+  dailyBudgetLimit: 500,
+  dailyBudgetWindowMs: DAY_MS
+});
+function readSliding(window, windowMs, now) {
+  if (!window) return 0;
+  const cutoff = now - windowMs;
+  let i = 0;
+  while (i < window.timestamps.length && window.timestamps[i] <= cutoff) i++;
+  if (i > 0) window.timestamps.splice(0, i);
+  return window.timestamps.length;
+}
+function bumpSliding(window, now) {
+  window.timestamps.push(now);
+}
+function createPeerRateLimiter(config2 = DEFAULT_RATE_LIMITER_CONFIG) {
+  const counters = {
+    pairBurst: /* @__PURE__ */ new Map(),
+    pairWindow: /* @__PURE__ */ new Map(),
+    chat: /* @__PURE__ */ new Map(),
+    agentDaily: { timestamps: [] },
+    dailyBudget: { timestamps: [] }
+  };
+  let humanInbound = 0;
+  function pairKey(chatId, peerBotId) {
+    return `${chatId}:${peerBotId}`;
+  }
+  function readMap(map, key2, windowMs, now) {
+    return readSliding(map.get(key2), windowMs, now);
+  }
+  function bumpMap(map, key2, now) {
+    let entry = map.get(key2);
+    if (!entry) {
+      entry = { timestamps: [] };
+      map.set(key2, entry);
+    }
+    bumpSliding(entry, now);
+  }
+  return {
+    recordInboundPeer(chatId, peerBotId, now) {
+      const pk = pairKey(chatId, peerBotId);
+      if (readMap(counters.pairBurst, pk, config2.pairBurstWindowMs, now) >= config2.pairBurstLimit) {
+        return { decision: "rate_limit_pair", dailyBudgetWarn: false };
+      }
+      if (readMap(counters.pairWindow, pk, config2.pairWindowMs, now) >= config2.pairWindowLimit) {
+        return { decision: "rate_limit_pair", dailyBudgetWarn: false };
+      }
+      if (readMap(counters.chat, chatId, config2.chatWindowMs, now) >= config2.chatLimit) {
+        return { decision: "rate_limit_chat", dailyBudgetWarn: false };
+      }
+      if (readSliding(counters.agentDaily, config2.agentDailyWindowMs, now) >= config2.agentDailyLimit) {
+        return { decision: "rate_limit_agent_daily", dailyBudgetWarn: false };
+      }
+      const budgetSoFar = readSliding(counters.dailyBudget, config2.dailyBudgetWindowMs, now);
+      if (budgetSoFar >= config2.dailyBudgetLimit) {
+        return { decision: "daily_budget_exhausted", dailyBudgetWarn: false };
+      }
+      bumpMap(counters.pairBurst, pk, now);
+      bumpMap(counters.pairWindow, pk, now);
+      bumpMap(counters.chat, chatId, now);
+      bumpSliding(counters.agentDaily, now);
+      bumpSliding(counters.dailyBudget, now);
+      const newBudget = budgetSoFar + 1;
+      const warn80 = newBudget >= Math.ceil(config2.dailyBudgetLimit * 0.8) && newBudget < config2.dailyBudgetLimit;
+      return { decision: "ok", dailyBudgetWarn: warn80 };
+    },
+    recordInboundHuman(_chatId, _now) {
+      humanInbound += 1;
+    },
+    snapshot(now) {
+      const perChat = /* @__PURE__ */ new Map();
+      for (const [k, v] of counters.chat) {
+        perChat.set(k, readSliding(v, config2.chatWindowMs, now));
+      }
+      const perPair = /* @__PURE__ */ new Map();
+      for (const [k, v] of counters.pairWindow) {
+        perPair.set(k, readSliding(v, config2.pairWindowMs, now));
+      }
+      return {
+        perAgentDaily: readSliding(counters.agentDaily, config2.agentDailyWindowMs, now),
+        dailyBudget: readSliding(counters.dailyBudget, config2.dailyBudgetWindowMs, now),
+        perChat,
+        perPair,
+        humanInbound
+      };
+    }
+  };
+}
+function createPresenceTracker() {
+  const lastHumanByChat = /* @__PURE__ */ new Map();
+  return {
+    noteInbound(chatId, kind, now) {
+      if (kind === "human") lastHumanByChat.set(chatId, now);
+    },
+    shouldDropOutgress(chatId, now, maxAgeMs = 30 * MINUTE_MS) {
+      const last = lastHumanByChat.get(chatId);
+      if (last === void 0) return "no_human_recent";
+      if (now - last >= maxAgeMs) return "no_human_recent";
+      return null;
+    }
+  };
+}
+
+// src/telegram-peer-rate-limiter-db.ts
+function createDbBackedPeerRateLimiter(deps) {
+  const config2 = deps.config ?? DEFAULT_RATE_LIMITER_CONFIG;
+  const readCacheMs = deps.readCacheMs ?? 2e3;
+  const log = deps.log ?? (() => {
+  });
+  const caches = /* @__PURE__ */ new Map();
+  let humanInbound = 0;
+  const pendingWrites = /* @__PURE__ */ new Set();
+  function trackPending(write) {
+    pendingWrites.add(write);
+    void write.finally(() => pendingWrites.delete(write));
+  }
+  function cacheKey2(layer, chatId, peerBotId) {
+    return `${layer}|${chatId}|${peerBotId ?? ""}`;
+  }
+  const localBumpTimes = /* @__PURE__ */ new Map();
+  function bumpLocal(layer, chatId, peerBotId, now) {
+    const key2 = cacheKey2(layer, chatId, peerBotId);
+    const list = localBumpTimes.get(key2);
+    if (list) list.push(now);
+    else localBumpTimes.set(key2, [now]);
+  }
+  function localBumpsSince(key2, fetchedAt) {
+    const list = localBumpTimes.get(key2);
+    if (!list) return 0;
+    let n = 0;
+    for (let i = list.length - 1; i >= 0; i--) {
+      if (list[i] >= fetchedAt) n++;
+      else break;
+    }
+    return n;
+  }
+  function pruneLocalBumps(retentionMs, now) {
+    const cutoff = now - retentionMs;
+    for (const [key2, list] of localBumpTimes) {
+      let i = 0;
+      while (i < list.length && list[i] < cutoff) i++;
+      if (i > 0) list.splice(0, i);
+      if (list.length === 0) localBumpTimes.delete(key2);
+    }
+  }
+  async function readCount(layer, chatId, peerBotId, windowMs, now) {
+    const key2 = cacheKey2(layer, chatId, peerBotId);
+    const cached2 = caches.get(key2);
+    if (cached2 && now - cached2.fetchedAt < readCacheMs) {
+      return cached2.count + localBumpsSince(key2, cached2.fetchedAt);
+    }
+    const since = new Date(now - windowMs).toISOString();
+    let count;
+    try {
+      const args = {
+        since,
+        traffic_class: layer
+      };
+      if (layer === "pair_burst" || layer === "pair_window") {
+        args.chat_id = chatId;
+        args.peer_bot_id = peerBotId ?? void 0;
+      } else if (layer === "chat") {
+        args.chat_id = chatId;
+      }
+      count = await deps.api.countEvents(args);
+    } catch (err) {
+      log(`peer_rate_event read failed (layer=${layer}): ${err.message} \u2014 fail-open`);
+      count = 0;
+    }
+    const fetchedAt = now;
+    caches.set(key2, { fetchedAt, count });
+    return count + localBumpsSince(key2, fetchedAt);
+  }
+  async function decide(chatId, peerBotId, now) {
+    const layers = [
+      { layer: "pair_burst", chatId, peerBotId, limit: config2.pairBurstLimit, windowMs: config2.pairBurstWindowMs, reason: "rate_limit_pair" },
+      { layer: "pair_window", chatId, peerBotId, limit: config2.pairWindowLimit, windowMs: config2.pairWindowMs, reason: "rate_limit_pair" },
+      { layer: "chat", chatId, peerBotId: null, limit: config2.chatLimit, windowMs: config2.chatWindowMs, reason: "rate_limit_chat" },
+      { layer: "agent_daily", chatId: "", peerBotId: null, limit: config2.agentDailyLimit, windowMs: config2.agentDailyWindowMs, reason: "rate_limit_agent_daily" },
+      { layer: "daily_budget", chatId: "", peerBotId: null, limit: config2.dailyBudgetLimit, windowMs: config2.dailyBudgetWindowMs, reason: "daily_budget_exhausted" }
+    ];
+    for (const l of layers) {
+      const count = await readCount(l.layer, l.chatId, l.peerBotId, l.windowMs, now);
+      if (count >= l.limit) {
+        return { decision: l.reason, dailyBudgetWarn: false };
+      }
+    }
+    for (const l of layers) bumpLocal(l.layer, l.chatId, l.peerBotId, now);
+    pruneLocalBumps(Math.max(config2.pairBurstWindowMs, 6e4), now);
+    trackPending(deps.api.recordEvent({ chat_id: chatId, peer_bot_id: peerBotId, traffic_class: "pair_burst" }).catch((err) => log(`peer_rate_event write failed: ${err.message}`)));
+    trackPending(deps.api.recordEvent({ chat_id: chatId, peer_bot_id: peerBotId, traffic_class: "pair_window" }).catch((err) => log(`peer_rate_event write failed: ${err.message}`)));
+    trackPending(deps.api.recordEvent({ chat_id: chatId, peer_bot_id: null, traffic_class: "chat" }).catch((err) => log(`peer_rate_event write failed: ${err.message}`)));
+    trackPending(deps.api.recordEvent({ chat_id: chatId, peer_bot_id: null, traffic_class: "agent_daily" }).catch((err) => log(`peer_rate_event write failed: ${err.message}`)));
+    trackPending(deps.api.recordEvent({ chat_id: chatId, peer_bot_id: null, traffic_class: "daily_budget" }).catch((err) => log(`peer_rate_event write failed: ${err.message}`)));
+    const dbKey = cacheKey2("daily_budget", "", null);
+    const dbCached = caches.get(dbKey);
+    const dbBudget = (dbCached?.count ?? 0) + localBumpsSince(dbKey, dbCached?.fetchedAt ?? 0);
+    const warn80 = dbBudget >= Math.ceil(config2.dailyBudgetLimit * 0.8) && dbBudget < config2.dailyBudgetLimit;
+    return { decision: "ok", dailyBudgetWarn: warn80 };
+  }
+  return {
+    recordInboundPeer(chatId, peerBotId, now) {
+      return decide(chatId, peerBotId, now);
+    },
+    recordInboundHuman(_chatId, _now) {
+      humanInbound += 1;
+    },
+    snapshot(now) {
+      const perChat = /* @__PURE__ */ new Map();
+      const perPair = /* @__PURE__ */ new Map();
+      let perAgentDaily = 0;
+      let dailyBudget = 0;
+      for (const [k, v] of caches) {
+        const local = localBumpsSince(k, v.fetchedAt);
+        const layer = k.split("|")[0];
+        if (layer === "pair_window") {
+          const chatId = k.split("|")[1];
+          const peerBotId = k.split("|")[2];
+          perPair.set(`${chatId}:${peerBotId}`, v.count + local);
+        } else if (layer === "chat") {
+          const chatId = k.split("|")[1];
+          perChat.set(chatId, v.count + local);
+        } else if (layer === "agent_daily") {
+          perAgentDaily = v.count + local;
+        } else if (layer === "daily_budget") {
+          dailyBudget = v.count + local;
+        }
+      }
+      void now;
+      return { perAgentDaily, dailyBudget, perChat, perPair, humanInbound };
+    },
+    async flushPending() {
+      await Promise.all([...pendingWrites]);
+    }
+  };
+}
+function createDefaultPeerRateApiClient(args) {
+  if (!args.agtHost || !args.agtApiKey || !args.agentId) return null;
+  const fetchImpl = args.fetchImpl ?? fetch;
+  const base = args.agtHost.replace(/\/+$/, "");
+  let cachedToken = null;
+  let cachedTokenExpiresAt = 0;
+  async function getToken() {
+    if (cachedToken && Date.now() < cachedTokenExpiresAt) return cachedToken;
+    const resp = await fetchImpl(`${base}/host/exchange`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ host_key: args.agtApiKey })
+    });
+    if (!resp.ok) {
+      const body = await resp.text().catch(() => "");
+      throw new Error(`/host/exchange failed (${resp.status}): ${body.slice(0, 200)}`);
+    }
+    const data = await resp.json();
+    cachedToken = data.token;
+    cachedTokenExpiresAt = data.expires_at ? new Date(data.expires_at).getTime() - 12e4 : Date.now() + 55 * 6e4;
+    return cachedToken;
+  }
+  async function authedFetch(path, init) {
+    const headers = {
+      Authorization: `Bearer ${await getToken()}`
+    };
+    if (init.body !== void 0) headers["Content-Type"] = "application/json";
+    let resp = await fetchImpl(`${base}${path}`, { method: init.method, headers, body: init.body });
+    if (resp.status === 401) {
+      cachedToken = null;
+      cachedTokenExpiresAt = 0;
+      const retryHeaders = {
+        Authorization: `Bearer ${await getToken()}`
+      };
+      if (init.body !== void 0) retryHeaders["Content-Type"] = "application/json";
+      resp = await fetchImpl(`${base}${path}`, { method: init.method, headers: retryHeaders, body: init.body });
+    }
+    return resp;
+  }
+  return {
+    async recordEvent({ chat_id, peer_bot_id, traffic_class }) {
+      const resp = await authedFetch("/host/peer-rate-events", {
+        method: "POST",
+        body: JSON.stringify({ agent_id: args.agentId, chat_id, peer_bot_id, traffic_class })
+      });
+      if (!resp.ok) {
+        throw new Error(`POST /host/peer-rate-events failed: ${resp.status} ${await resp.text()}`);
+      }
+    },
+    async countEvents({ since, chat_id, peer_bot_id, traffic_class }) {
+      const params = new URLSearchParams({
+        agent_id: args.agentId,
+        since
+      });
+      if (chat_id !== void 0) params.set("chat_id", chat_id);
+      if (peer_bot_id !== void 0) params.set("peer_bot_id", String(peer_bot_id));
+      if (traffic_class !== void 0) params.set("traffic_class", traffic_class);
+      const resp = await authedFetch(`/host/peer-rate-events?${params}`, { method: "GET" });
+      if (!resp.ok) {
+        throw new Error(`GET /host/peer-rate-events failed: ${resp.status} ${await resp.text()}`);
+      }
+      const json = await resp.json();
+      return typeof json.count === "number" ? json.count : 0;
+    }
+  };
+}
+
 // src/telegram-channel.ts
 function redactId(id) {
   return createHash("sha256").update(String(id)).digest("hex").slice(0, 8);
@@ -14303,6 +14631,28 @@ var PEER_CLASSIFIER_CONFIG = {
   peer_group_ids: parsePeerGroupIdsEnv(process.env.TELEGRAM_PEER_GROUP_IDS),
   peers: parsePeersEnv(process.env.TELEGRAM_PEERS)
 };
+var PEER_DISABLED_GLOBAL = (() => {
+  const v = (process.env.TELEGRAM_PEER_DISABLED ?? "").toLowerCase();
+  return v === "1" || v === "true" || v === "yes";
+})();
+if (PEER_DISABLED_GLOBAL) {
+  process.stderr.write(
+    `telegram-channel(${AGENT_CODE_NAME}): TELEGRAM_PEER_DISABLED=true \u2014 peer ingress + outgress short-circuited
+`
+  );
+}
+var peerRateApiClient = createDefaultPeerRateApiClient({
+  agtHost: AGT_HOST,
+  agtApiKey: AGT_API_KEY,
+  agentId: process.env.AGT_AGENT_ID ?? null
+});
+var peerRateLimiter = peerRateApiClient && parsePeerAgentModeEnv(process.env.TELEGRAM_PEER_AGENT_MODE) !== "off" ? createDbBackedPeerRateLimiter({
+  api: peerRateApiClient,
+  log: (line) => process.stderr.write(`telegram-channel(${AGENT_CODE_NAME}): ${line}
+`)
+}) : createPeerRateLimiter();
+var peerPresence = createPresenceTracker();
+var dailyBudgetWarned = false;
 if (!BOT_TOKEN) {
   process.stderr.write(
     "telegram-channel: Missing TELEGRAM_BOT_TOKEN. Cannot start.\n"
@@ -14939,6 +15289,40 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
         isError: true
       };
     }
+    const peerActiveOnChat = PEER_CLASSIFIER_CONFIG.peer_agent_mode !== "off" && PEER_CLASSIFIER_CONFIG.peer_group_ids.length > 0 && PEER_CLASSIFIER_CONFIG.peer_group_ids.includes(chat_id);
+    if (peerActiveOnChat) {
+      if (PEER_DISABLED_GLOBAL) {
+        process.stderr.write(
+          `telegram-channel(${AGENT_CODE_NAME}): outgress_blocked reason=peer_disabled_global chat=${redactId(chat_id)}
+`
+        );
+        return {
+          content: [
+            {
+              type: "text",
+              text: "Multi-agent collaboration is disabled (TELEGRAM_PEER_DISABLED). Stop attempting to reply on this chat."
+            }
+          ],
+          isError: true
+        };
+      }
+      const stale = peerPresence.shouldDropOutgress(chat_id, Date.now());
+      if (stale === "no_human_recent") {
+        process.stderr.write(
+          `telegram-channel(${AGENT_CODE_NAME}): outgress_blocked reason=no_human_recent chat=${redactId(chat_id)}
+`
+        );
+        return {
+          content: [
+            {
+              type: "text",
+              text: "No human message in this chat in the last 30 minutes. Peer-agent collaboration is paused for this chat until a human posts."
+            }
+          ],
+          isError: true
+        };
+      }
+    }
     const killed = await isThreadKilled({
       channelType: "telegram",
       channelId: chat_id,
@@ -15245,11 +15629,23 @@ async function pollLoop() {
         const userId = msg.from?.id != null ? String(msg.from.id) : "unknown";
         const userName = msg.from?.username || [msg.from?.first_name, msg.from?.last_name].filter(Boolean).join(" ").trim() || userId;
         const isFromBot = !!msg.from?.is_bot;
+        const nowMs = Date.now();
         if (chatId && !isFromBot) {
           resetThread(chatId, "");
         }
+        peerPresence.noteInbound(chatId, isFromBot ? "bot" : "human", nowMs);
+        if (!isFromBot) {
+          peerRateLimiter.recordInboundHuman(chatId, nowMs);
+        }
         let peerAgentMeta = null;
         if (isFromBot) {
+          if (PEER_DISABLED_GLOBAL) {
+            process.stderr.write(
+              `telegram-channel(${AGENT_CODE_NAME}): peer_drop reason=peer_disabled_global chat=${redactId(chatId)} from=${redactId(String(msg.from?.id ?? "unknown"))}
+`
+            );
+            continue;
+          }
           const classifierMsg = {
             message_id: msg.message_id,
             text: msg.text,
@@ -15276,7 +15672,29 @@ async function pollLoop() {
             continue;
           }
           if (classification.kind === "peer-ingress") {
-            peerAgentMeta = { code_name: classification.peer.code_name, agent_id: classification.peer.agent_id };
+            const limit = await peerRateLimiter.recordInboundPeer(
+              chatId,
+              classification.peer.bot_id,
+              nowMs
+            );
+            if (limit.decision !== "ok") {
+              process.stderr.write(
+                `telegram-channel(${AGENT_CODE_NAME}): peer_drop reason=${limit.decision} chat=${redactId(chatId)} from=${redactId(String(msg.from?.id ?? "unknown"))}
+`
+              );
+              continue;
+            }
+            if (limit.dailyBudgetWarn && !dailyBudgetWarned) {
+              dailyBudgetWarned = true;
+              process.stderr.write(
+                `telegram-channel(${AGENT_CODE_NAME}): peer_warn reason=daily_budget_80pct
+`
+              );
+            }
+            peerAgentMeta = {
+              code_name: classification.peer.code_name,
+              agent_id: classification.peer.agent_id
+            };
           }
         }
         const messageId = String(msg.message_id);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@integrity-labs/agt-cli",
-  "version": "0.19.18",
+  "version": "0.19.19",
   "description": "Augmented Team CLI — agent provisioning and management",
   "type": "module",
   "engines": {