@integrity-labs/agt-cli 0.28.739 → 0.28.741

package/dist/lib/manager-worker.js

@@ -57,7 +57,7 @@ import {
   safeWriteJsonAtomic,
   setConfigHash,
   tripClass
-} from "../chunk-ZKWY6MNV.js";
+} from "../chunk-2HGXCU4Y.js";
 import {
   getProjectDir as getProjectDir2,
   getReadyTasks,
@@ -13154,7 +13154,7 @@ var agentRestartTimezoneInputs = /* @__PURE__ */ new Map();
 var lastVersionCheckAt = 0;
 var VERSION_CHECK_INTERVAL_MS = 5 * 60 * 1e3;
 var lastResponsivenessProbeAt = 0;
-var agtCliVersion = true ? "0.28.739" : "dev";
+var agtCliVersion = true ? "0.28.741" : "dev";
 function resolveBrewPath(execFileSync3) {
   try {
     const out = execFileSync3("which", ["brew"], { timeout: 5e3 }).toString().trim();

package/dist/mcp/telegram-channel.js

@@ -39055,9 +39055,55 @@ var TELEGRAM_EGRESS_TOOLS = /* @__PURE__ */ new Set([
   "telegram.react",
   "telegram.upload_file",
   "telegram.consume",
+  // ENG-9677: leaving a chat is delivery-state mutation of the bluntest kind -
+  // after it, nothing from that chat can ever arrive. An impersonating operator
+  // must not be able to cut an agent off from a customer's group.
+  "telegram.leave_chat",
   "channel_request_input"
 ]);
 
+// src/telegram-leave-chat-policy.ts
+function validateLeaveChatArgs(args) {
+  const { chat_id, reason } = args ?? {};
+  if (typeof chat_id !== "string" || !chat_id.trim()) {
+    return {
+      ok: false,
+      message: "telegram.leave_chat requires chat_id (from the <channel> tag)."
+    };
+  }
+  if (typeof reason !== "string" || !reason.trim()) {
+    return {
+      ok: false,
+      message: "telegram.leave_chat requires a reason (a non-empty string). It is logged, not sent to the chat."
+    };
+  }
+  return { ok: true, chatId: chat_id.trim(), reason: reason.trim() };
+}
+function isGroupShapedChatId(chatId) {
+  return /^-\d+$/.test(chatId.trim());
+}
+function decideLeaveChat(input) {
+  const chatId = input.chatId.trim();
+  if (input.allowedChats.size > 0 && !input.allowedChats.has(chatId)) {
+    return { allowed: true, because: "not-on-the-allowlist" };
+  }
+  if (input.allowedChats.has(chatId)) {
+    return {
+      allowed: false,
+      because: "operator-only",
+      detail: "this chat is on the agent's allowed_chats list, so leaving it is an operator decision"
+    };
+  }
+  if (input.privateChatsOnly && isGroupShapedChatId(chatId)) {
+    return { allowed: true, because: "group-chat-under-private-chats-only" };
+  }
+  return {
+    allowed: false,
+    because: "operator-only",
+    detail: input.allowedChats.size > 0 ? "this chat is on the agent's allowed_chats list, so leaving it is an operator decision" : input.privateChatsOnly ? "this chat is not a group, so private-chats-only does not bar the agent from it" : "no chat policy is configured for this agent, so nothing marks this chat as one it should not be in"
+  };
+}
+
 // src/telegram-upload.ts
 var TELEGRAM_PHOTO_MAX_BYTES = 10 * 1024 * 1024;
 var TELEGRAM_DOCUMENT_MAX_BYTES = 50 * 1024 * 1024;
@@ -41428,6 +41474,14 @@ async function computeTelegramOwnChannelLiveStatus() {
   try {
     const resp = await telegramApiCall("getMe", {}, 5e3);
     if (resp.ok) {
+      const canJoinGroups = resp.result?.can_join_groups;
+      if (PRIVATE_CHATS_ONLY && canJoinGroups === true) {
+        return {
+          level: "ok",
+          checked_at,
+          reason: "getMe ok \u2014 but this bot can still be ADDED to groups. private_chats_only makes the agent ignore group traffic; it does not close the door. Only the bot owner can: @BotFather \u2192 /mybots \u2192 this bot \u2192 Bot Settings \u2192 Allow Groups? \u2192 Turn off."
+        };
+      }
       return { level: "ok", checked_at, reason: "getMe ok" };
     }
     return { level: "error", checked_at, reason: `getMe rejected: ${resp.description ?? "unknown"}` };
@@ -41937,6 +41991,14 @@ async function refreshBotIdentity() {
       if (typeof result.id === "number") {
         cachedBotId = result.id;
       }
+      if (typeof result.can_join_groups === "boolean") {
+        if (result.can_join_groups && PRIVATE_CHATS_ONLY) {
+          process.stderr.write(
+            `telegram-channel(${AGENT_CODE_NAME}): WARNING private_chats_only is set but this bot's can_join_groups is TRUE, so it can still be added to groups. Only the bot owner can change that: message @BotFather -> /mybots -> select this bot -> Bot Settings -> Group Privacy / Allow Groups? -> Turn off.
+`
+          );
+        }
+      }
       if (cachedBotUsername !== null && cachedBotId !== null) return;
     }
     process.stderr.write(
@@ -43109,6 +43171,24 @@ mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
         required: ["chat_id"]
       }
     },
+    {
+      name: "telegram.leave_chat",
+      description: "Remove this agent's bot from a Telegram group, supergroup or channel it should not be in. Pass the chat_id from the <channel> tag and a short reason. ONLY works for a chat the agent is already barred from engaging with - one outside its allowed_chats, or a group while private_chats_only is set. Leaving a chat the agent is permitted to be in is an operator decision and this tool will refuse it, deliberately: an agent that can be talked into leaving any chat is a denial-of-service primitive. Leaving does NOT stop anyone re-adding the bot - that is a BotFather setting the owner has to change.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          chat_id: {
+            type: "string",
+            description: "Telegram chat ID to leave (from the chat_id attribute in the <channel> tag)"
+          },
+          reason: {
+            type: "string",
+            description: "Why the bot is leaving. Required, logged, and not sent to the chat. Leaving a chat with no recorded reason is indistinguishable from a mistake when someone reads it back."
+          }
+        },
+        required: ["chat_id", "reason"]
+      }
+    },
     {
       name: "telegram.send_message",
       description: "Send a new Telegram message to an arbitrary chat (agent-initiated, not a reply)",
@@ -43321,6 +43401,75 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
       return { content: [{ type: "text", text: `Telegram ${method} error: ${err.message}` }], isError: true };
     }
   }
+  if (name === "telegram.leave_chat") {
+    const parsed = validateLeaveChatArgs(args);
+    if (!parsed.ok) {
+      return { content: [{ type: "text", text: parsed.message }], isError: true };
+    }
+    const { chatId: chat_id, reason } = parsed;
+    const decision = decideLeaveChat({
+      chatId: chat_id,
+      allowedChats: ALLOWED_CHATS,
+      privateChatsOnly: PRIVATE_CHATS_ONLY
+    });
+    if (!decision.allowed) {
+      process.stderr.write(
+        `telegram-channel(${AGENT_CODE_NAME}): leave_chat REFUSED chat=${redactId(chat_id)} why=${decision.because} detail=${JSON.stringify(decision.detail)}
+`
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Not leaving ${chat_id}: ${decision.detail}. This tool only removes the bot from chats the agent is already barred from engaging with, so that an instruction to leave cannot be used to cut the owner off from a chat they wanted. An operator can do it from the console.`
+          }
+        ],
+        isError: true
+      };
+    }
+    let resp;
+    try {
+      resp = await telegramApiCall("leaveChat", { chat_id }, 1e4);
+    } catch (err) {
+      const detail = err.message;
+      process.stderr.write(
+        `telegram-channel(${AGENT_CODE_NAME}): leave_chat chat=${redactId(chat_id)} allowed_because=${decision.because} ok=false transport_error=${JSON.stringify(detail)} reason=${JSON.stringify(reason)}
+`
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Could not reach Telegram to leave ${chat_id}: ${detail}. The bot is still in the chat \u2014 nothing changed, so this is safe to retry.`
+          }
+        ],
+        isError: true
+      };
+    }
+    process.stderr.write(
+      `telegram-channel(${AGENT_CODE_NAME}): leave_chat chat=${redactId(chat_id)} allowed_because=${decision.because} ok=${resp.ok} reason=${JSON.stringify(reason)}${resp.ok ? "" : ` error=${resp.description ?? "unknown"}`}
+`
+    );
+    if (!resp.ok) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Telegram refused the leave for ${chat_id}: ${resp.description ?? "unknown error"}.`
+          }
+        ],
+        isError: true
+      };
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Left ${chat_id}. Note this does NOT stop anyone adding the bot back: whether it can be added to groups at all is a BotFather setting (/setjoingroups), which only the bot owner can change.`
+        }
+      ]
+    };
+  }
   if (name === "telegram.consume") {
     const { chat_id, reason } = args;
     if (!chat_id) {

package/package.json

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