@integrity-labs/agt-cli 0.15.8 → 0.15.9

package/mcp/telegram-channel.js

@@ -13863,7 +13863,21 @@ var StdioServerTransport = class {
 
 // src/telegram-channel.ts
 import https from "https";
-import { createHash } from "crypto";
+import { createHash, randomUUID } from "crypto";
+import {
+  createWriteStream,
+  existsSync,
+  mkdirSync as mkdirSync2,
+  readFileSync,
+  readdirSync,
+  renameSync as renameSync2,
+  statSync,
+  unlinkSync as unlinkSync2,
+  watch,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
 
 // src/channel-attachments.ts
 import { homedir } from "os";
@@ -14110,6 +14124,28 @@ if (!BOT_TOKEN) {
   );
   process.exit(1);
 }
+var stderrLogStream = null;
+if (AGENT_CODE_NAME && AGENT_CODE_NAME !== "unknown") {
+  try {
+    const logDir = join2(homedir2(), ".augmented", AGENT_CODE_NAME);
+    mkdirSync2(logDir, { recursive: true });
+    stderrLogStream = createWriteStream(join2(logDir, "telegram-channel-stderr.log"), {
+      flags: "a",
+      mode: 384
+    });
+    const origWrite = process.stderr.write.bind(process.stderr);
+    process.stderr.write = (chunk, ...rest) => {
+      try {
+        const buf = typeof chunk === "string" ? chunk : String(chunk);
+        const ts = (/* @__PURE__ */ new Date()).toISOString();
+        stderrLogStream?.write(`[${ts}] ${buf}${buf.endsWith("\n") ? "" : "\n"}`);
+      } catch {
+      }
+      return origWrite(chunk, ...rest);
+    };
+  } catch {
+  }
+}
 function telegramApiCall(method, body, timeoutMs) {
   return new Promise((resolve2, reject) => {
     const postData = JSON.stringify(body);
@@ -14175,13 +14211,320 @@ async function setMessageReaction(chatId, messageId, emoji2) {
     );
   }
 }
+var RESTART_FLAGS_DIR = join2(homedir2(), ".augmented", "restart-flags");
+async function handleRestartCommand(opts) {
+  try {
+    if (!existsSync(RESTART_FLAGS_DIR)) {
+      mkdirSync2(RESTART_FLAGS_DIR, { recursive: true });
+    }
+    const flagPath = join2(RESTART_FLAGS_DIR, `${AGENT_CODE_NAME}.flag`);
+    const flag = {
+      codeName: AGENT_CODE_NAME,
+      source: "telegram",
+      ts: Date.now(),
+      reply: { chat_id: opts.chatId, message_id: opts.messageId }
+    };
+    const tmpPath = `${flagPath}.${process.pid}.${randomUUID()}.tmp`;
+    writeFileSync2(tmpPath, JSON.stringify(flag) + "\n", "utf8");
+    renameSync2(tmpPath, flagPath);
+    process.stderr.write(
+      `telegram-channel(${AGENT_CODE_NAME}): /restart queued from chat ${redactId(opts.chatId)}
+`
+    );
+    try {
+      const ack = await telegramApiCall(
+        "sendMessage",
+        {
+          chat_id: opts.chatId,
+          text: `\u23F3 Restart queued for \`${AGENT_CODE_NAME}\`. The session will reconnect in a few seconds.`,
+          reply_to_message_id: Number(opts.messageId),
+          parse_mode: "Markdown"
+        },
+        1e4
+      );
+      if (!ack.ok) {
+        process.stderr.write(
+          `telegram-channel(${AGENT_CODE_NAME}): /restart ack rejected by Telegram (chat ${redactId(opts.chatId)}): ${ack.description ?? "unknown"}
+`
+        );
+      }
+    } catch (err) {
+      process.stderr.write(
+        `telegram-channel(${AGENT_CODE_NAME}): /restart ack send failed: ${redactAugmentedPaths(err.message)}
+`
+      );
+    }
+  } catch (err) {
+    process.stderr.write(
+      `telegram-channel(${AGENT_CODE_NAME}): /restart flag write failed: ${redactAugmentedPaths(err.message)}
+`
+    );
+    try {
+      const errAck = await telegramApiCall(
+        "sendMessage",
+        {
+          chat_id: opts.chatId,
+          text: `\u274C Failed to queue restart for ${AGENT_CODE_NAME}. Please try again in a few seconds.`,
+          reply_to_message_id: Number(opts.messageId)
+        },
+        1e4
+      );
+      if (!errAck.ok) {
+        process.stderr.write(
+          `telegram-channel(${AGENT_CODE_NAME}): /restart error-ack rejected by Telegram (chat ${redactId(opts.chatId)}): ${errAck.description ?? "unknown"}
+`
+        );
+      }
+    } catch {
+    }
+  }
+}
+var cachedBotUsername = null;
+async function resolveBotUsername() {
+  if (cachedBotUsername !== null) return cachedBotUsername;
+  try {
+    const resp = await telegramApiCall("getMe", {}, 5e3);
+    if (resp.ok && resp.result && typeof resp.result.username === "string") {
+      cachedBotUsername = resp.result.username.toLowerCase();
+      return cachedBotUsername;
+    }
+    process.stderr.write(
+      `telegram-channel(${AGENT_CODE_NAME}): getMe rejected: ${resp.description ?? "unknown"} \u2014 will retry on next /restart@<bot>
+`
+    );
+  } catch (err) {
+    process.stderr.write(
+      `telegram-channel(${AGENT_CODE_NAME}): getMe failed: ${redactAugmentedPaths(err.message)} \u2014 will retry on next /restart@<bot>
+`
+    );
+  }
+  return null;
+}
+var RESTART_SYNTAX_RE = /^\/restart(?:@([A-Za-z0-9_]{1,64}))?(?:\s|$)/;
+function isRestartSyntax(text) {
+  return RESTART_SYNTAX_RE.test(text);
+}
+async function classifyRestartCommand(text) {
+  const m = RESTART_SYNTAX_RE.exec(text);
+  if (!m) return "ignore";
+  const target = m[1]?.toLowerCase();
+  if (!target) return "act";
+  const ours = await resolveBotUsername();
+  if (!ours) return "verification_failed";
+  return target === ours ? "act" : "ignore";
+}
 var pendingMessages = /* @__PURE__ */ new Map();
+var AGENT_DIR = AGENT_CODE_NAME && AGENT_CODE_NAME !== "unknown" ? join2(homedir2(), ".augmented", AGENT_CODE_NAME) : null;
+var PENDING_INBOUND_DIR = AGENT_DIR ? join2(AGENT_DIR, "telegram-pending-inbound") : null;
+var RECOVERY_OUTBOX_DIR = AGENT_DIR ? join2(AGENT_DIR, "telegram-recovery-outbox") : null;
+function safeMarkerName(chatId, messageId) {
+  const safe = (s) => s.replace(/[^A-Za-z0-9_-]/g, "_");
+  return `${safe(chatId)}__${safe(messageId)}.json`;
+}
+function pendingInboundPath(chatId, messageId) {
+  if (!PENDING_INBOUND_DIR) return null;
+  return join2(PENDING_INBOUND_DIR, safeMarkerName(chatId, messageId));
+}
+function writePendingInboundMarker(chatId, messageId, chatType) {
+  const path = pendingInboundPath(chatId, messageId);
+  if (!path || !PENDING_INBOUND_DIR) return;
+  const marker = {
+    chat_id: chatId,
+    message_id: messageId,
+    chat_type: chatType,
+    received_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  try {
+    mkdirSync2(PENDING_INBOUND_DIR, { recursive: true, mode: 448 });
+    writeFileSync2(path, JSON.stringify(marker), { mode: 384 });
+  } catch (err) {
+    process.stderr.write(
+      `telegram-channel(${AGENT_CODE_NAME}): pending-inbound marker write failed: ${err.message}
+`
+    );
+  }
+}
+function clearPendingInboundMarker(chatId, messageId) {
+  const path = pendingInboundPath(chatId, messageId);
+  if (!path) return;
+  try {
+    if (existsSync(path)) unlinkSync2(path);
+  } catch {
+  }
+}
+var MAX_RECOVERY_ATTEMPTS = 3;
+function nextRetryName(filename) {
+  const match = filename.match(/^(.*?)(?:\.retry-(\d+))?\.json$/);
+  if (!match) return null;
+  const base = match[1];
+  const prev = match[2] ? parseInt(match[2], 10) : 0;
+  const attempt = prev + 1;
+  if (attempt >= MAX_RECOVERY_ATTEMPTS) {
+    return { next: `${base}.retry-${attempt}.poison.json`, attempt };
+  }
+  return { next: `${base}.retry-${attempt}.json`, attempt };
+}
+async function processRecoveryOutboxFile(filename) {
+  if (!RECOVERY_OUTBOX_DIR) return;
+  if (filename.endsWith(".poison.json") || filename.endsWith(".tmp")) return;
+  const fullPath = join2(RECOVERY_OUTBOX_DIR, filename);
+  let payload;
+  try {
+    const raw = readFileSync(fullPath, "utf-8");
+    payload = JSON.parse(raw);
+  } catch (err) {
+    process.stderr.write(
+      `telegram-channel(${AGENT_CODE_NAME}): recovery outbox parse failed (${filename}): ${err.message}
+`
+    );
+    try {
+      renameSync2(fullPath, `${fullPath}.parse-error.poison`);
+    } catch {
+    }
+    return;
+  }
+  if (!payload.chat_id || !payload.text) {
+    process.stderr.write(
+      `telegram-channel(${AGENT_CODE_NAME}): recovery outbox malformed (${filename}): missing chat_id or text
+`
+    );
+    try {
+      renameSync2(fullPath, `${fullPath}.malformed.poison`);
+    } catch {
+    }
+    return;
+  }
+  const text = `[recovered reply] ${payload.text}`;
+  const body = {
+    chat_id: payload.chat_id,
+    text,
+    allow_sending_without_reply: true
+  };
+  if (payload.message_id) body.reply_to_message_id = Number(payload.message_id);
+  let sendSucceeded = false;
+  try {
+    const resp = await telegramApiCall("sendMessage", body, 15e3);
+    if (resp.ok) {
+      sendSucceeded = true;
+      process.stderr.write(
+        `telegram-channel(${AGENT_CODE_NAME}): ghost-reply recovery sent (chat=${redactId(payload.chat_id)} msg=${redactId(payload.message_id ?? "")})
+`
+      );
+      if (payload.message_id) clearPendingInboundMarker(payload.chat_id, payload.message_id);
+    } else {
+      process.stderr.write(
+        `telegram-channel(${AGENT_CODE_NAME}): ghost-reply recovery failed (chat=${redactId(payload.chat_id)}): ${resp.description ?? "unknown"}
+`
+      );
+    }
+  } catch (err) {
+    process.stderr.write(
+      `telegram-channel(${AGENT_CODE_NAME}): ghost-reply recovery error (chat=${redactId(payload.chat_id)}): ${err.message}
+`
+    );
+  }
+  if (sendSucceeded) {
+    try {
+      unlinkSync2(fullPath);
+    } catch {
+    }
+    return;
+  }
+  const next = nextRetryName(filename);
+  if (next) {
+    try {
+      renameSync2(fullPath, join2(RECOVERY_OUTBOX_DIR, next.next));
+      if (next.attempt >= MAX_RECOVERY_ATTEMPTS) {
+        process.stderr.write(
+          `telegram-channel(${AGENT_CODE_NAME}): ghost-reply recovery exhausted retries \u2014 moved to ${next.next}
+`
+        );
+      }
+    } catch {
+    }
+  }
+}
+function isFirstAttemptOutboxFile(filename) {
+  if (!filename.endsWith(".json")) return false;
+  if (filename.includes(".retry-")) return false;
+  if (filename.endsWith(".poison.json") || filename.endsWith(".tmp")) return false;
+  if (filename.startsWith(".")) return false;
+  return true;
+}
+var RETRY_SCAN_INTERVAL_MS = 6e4;
+var RETRY_BACKOFF_BASE_MS = 6e4;
+function shouldRetryNow(filename, mtimeMs) {
+  const match = filename.match(/\.retry-(\d+)\.json$/);
+  if (!match) return false;
+  const attempt = parseInt(match[1], 10);
+  const required2 = attempt * RETRY_BACKOFF_BASE_MS;
+  return Date.now() - mtimeMs >= required2;
+}
+function scanRecoveryRetries() {
+  if (!RECOVERY_OUTBOX_DIR) return;
+  let entries;
+  try {
+    entries = readdirSync(RECOVERY_OUTBOX_DIR);
+  } catch {
+    return;
+  }
+  for (const f of entries) {
+    if (!f.endsWith(".json")) continue;
+    if (!f.includes(".retry-") || f.endsWith(".poison.json")) continue;
+    let mtimeMs;
+    try {
+      mtimeMs = statSync(join2(RECOVERY_OUTBOX_DIR, f)).mtimeMs;
+    } catch {
+      continue;
+    }
+    if (shouldRetryNow(f, mtimeMs)) {
+      void processRecoveryOutboxFile(f);
+    }
+  }
+}
+function startRecoveryOutboxWatcher() {
+  if (!RECOVERY_OUTBOX_DIR) return;
+  try {
+    mkdirSync2(RECOVERY_OUTBOX_DIR, { recursive: true, mode: 448 });
+  } catch (err) {
+    process.stderr.write(
+      `telegram-channel(${AGENT_CODE_NAME}): recovery outbox mkdir failed: ${err.message}
+`
+    );
+    return;
+  }
+  try {
+    for (const f of readdirSync(RECOVERY_OUTBOX_DIR)) {
+      if (isFirstAttemptOutboxFile(f)) void processRecoveryOutboxFile(f);
+    }
+  } catch {
+  }
+  try {
+    const watcher = watch(RECOVERY_OUTBOX_DIR, (event, filename) => {
+      if (event !== "rename" || !filename) return;
+      if (!isFirstAttemptOutboxFile(filename)) return;
+      if (existsSync(join2(RECOVERY_OUTBOX_DIR, filename))) {
+        void processRecoveryOutboxFile(filename);
+      }
+    });
+    watcher.unref?.();
+  } catch (err) {
+    process.stderr.write(
+      `telegram-channel(${AGENT_CODE_NAME}): recovery outbox watch failed: ${err.message}
+`
+    );
+  }
+  const retryTimer = setInterval(scanRecoveryRetries, RETRY_SCAN_INTERVAL_MS);
+  retryTimer.unref?.();
+}
+startRecoveryOutboxWatcher();
 function trackPendingMessage(chatId, messageId, chatType) {
   const key = `${chatId}:${messageId}`;
   const existing = pendingMessages.get(key);
   if (existing) clearTimeout(existing.timer);
   const timer = setTimeout(() => {
     pendingMessages.delete(key);
+    clearPendingInboundMarker(chatId, messageId);
     void setMessageReaction(chatId, messageId, null);
     void telegramApiCall(
       "sendMessage",
@@ -14212,6 +14555,7 @@ function trackPendingMessage(chatId, messageId, chatType) {
   }, RESPONSE_TIMEOUT_MS);
   timer.unref?.();
   pendingMessages.set(key, { timer, chatType });
+  writePendingInboundMarker(chatId, messageId, chatType);
 }
 function clearPendingMessage(chatId, messageId) {
   if (messageId) {
@@ -14220,6 +14564,7 @@ function clearPendingMessage(chatId, messageId) {
     if (entry) {
       clearTimeout(entry.timer);
       pendingMessages.delete(key);
+      clearPendingInboundMarker(chatId, messageId);
     }
     return;
   }
@@ -14230,6 +14575,8 @@ function clearPendingMessage(chatId, messageId) {
     if (entry.chatType !== "private") continue;
     clearTimeout(entry.timer);
     pendingMessages.delete(key);
+    const msgId = key.slice(prefix.length);
+    clearPendingInboundMarker(chatId, msgId);
     clearedPrivate = true;
   }
   if (clearedPrivate) return;
@@ -14238,6 +14585,8 @@ function clearPendingMessage(chatId, messageId) {
     if (entry.chatType === "private") continue;
     clearTimeout(entry.timer);
     pendingMessages.delete(key);
+    const msgId = key.slice(prefix.length);
+    clearPendingInboundMarker(chatId, msgId);
     return;
   }
 }
@@ -14252,13 +14601,14 @@ var mcp = new Server(
     // Attachments rules live near the top because they get chopped otherwise
     // and the agent silently loses attachment-handling guidance.
     instructions: [
-      'Messages from Telegram arrive as <channel source="telegram" chat_id="..." user="..." user_name="..." message_id="...">.',
-      "Inbound attachments: the <channel> tag's `files` attribute is a JSON-serialised array \u2014 JSON.parse it before iterating. If a file entry has a `path`, the image is ALREADY DOWNLOADED locally \u2014 Read that path directly, do NOT call telegram.download_attachment. That tool is only for entries with `file_id` but NO `path` (PDF, docx, voice, audio, video, animations): pass file_id + chat_id verbatim (never paraphrase), then Read the returned path. Single-image messages also get a top-level `image_path` convenience attribute; multi-image messages omit it. Caption (no text) arrives as the channel content. Never tell the user about internal file-handling failures that don't affect the answer.",
-      "The user reads Telegram, not this session. Every response goes through telegram.reply with the chat_id from the tag \u2014 clarifying questions, errors, partial answers, status updates, all of it.",
-      'For work >30s follow CLAUDE.md kanban flow: kanban.add, reply with "On it \u2014 tracking here: <kanban URL>", move to in_progress, do the work, reply with the result. Simple lookups skip kanban but still reply.',
-      "Address users by user_name; user is the numeric Telegram ID. Reply-to a specific message with reply_to_message_id, otherwise omit.",
-      "Resolve ambiguous times against your own Timezone from CLAUDE.md \u2014 do not ask the user.",
-      "Reaction taxonomy (use telegram.react sparingly \u2014 prefer a text reply via telegram.reply): \u{1F440} = ack/working on it (already auto-added on inbound, do not duplicate); \u{1F44D} or \u{1F389} = action completed successfully. NEVER react to signal failure \u2014 users misread emoji reactions and don't know why something failed. If an action failed, send a telegram.reply with one sentence explaining what went wrong (no stack traces, no secrets) so the user understands. Free-tier emoji set: \u{1F44D} \u{1F44E} \u2764 \u{1F525} \u{1F389} \u{1F914} \u{1F92F} \u{1F64F} \u{1F44C} \u{1F440} \u{1F4AF} \u270D \u{1FAE1} \u{1F192} \u{1F973} \u{1F494} (premium-only fail silently)."
+      // Highest-priority lines first — Claude Code truncates this string at
+      // 2048 chars, so anything appended late silently disappears.
+      "CRITICAL: every response to a Telegram <channel> tag MUST go through telegram.reply with the chat_id from the tag. Text in your session WITHOUT a telegram.reply call never reaches the user.",
+      'Messages from Telegram arrive as <channel source="telegram" chat_id="..." user="..." user_name="..." message_id="...">. Pass reply_to_message_id from the tag so the response lands as a quote-reply in busy chats.',
+      "Inbound attachments: <channel> `files` is a JSON-serialised array \u2014 JSON.parse it. If an entry has `path`, the image is already downloaded \u2014 Read it directly, do NOT call telegram.download_attachment. Use that tool only for entries with `file_id` but NO `path` (PDF, docx, voice, audio, video, animations): pass file_id + chat_id verbatim, then Read the returned path. Single-image messages also get a top-level `image_path`. Caption arrives as channel content. Don't surface internal file-handling errors that don't affect the answer.",
+      'For work >30s follow CLAUDE.md kanban flow: kanban.add \u2192 reply "On it \u2014 tracking here: <kanban URL>" \u2192 move to in_progress \u2192 do the work \u2192 reply with the result. Simple lookups skip kanban but still reply.',
+      "Address users by user_name; user is the numeric Telegram ID. Resolve ambiguous times against your own Timezone from CLAUDE.md \u2014 do not ask.",
+      "Reaction taxonomy (use telegram.react sparingly \u2014 prefer telegram.reply): \u{1F440} = ack (already auto-added on inbound, do not duplicate); \u{1F44D} or \u{1F389} = success. NEVER react to signal failure. On failure, telegram.reply with one sentence explaining what went wrong. Free-tier emoji: \u{1F44D} \u{1F44E} \u2764 \u{1F525} \u{1F389} \u{1F914} \u{1F92F} \u{1F64F} \u{1F44C} \u{1F440} \u{1F4AF} \u270D \u{1FAE1} \u{1F192} \u{1F973} \u{1F494}."
     ].join(" ")
   }
 );
@@ -14570,6 +14920,34 @@ async function pollLoop() {
         if (content.length === 0 && classifiedAttachments.length === 0) continue;
         const chatId = String(msg.chat.id);
         if (ALLOWED_CHATS.size > 0 && !ALLOWED_CHATS.has(chatId)) continue;
+        const trimmedContent = content.trim();
+        if (isRestartSyntax(trimmedContent)) {
+          const disposition = await classifyRestartCommand(trimmedContent);
+          if (disposition === "act") {
+            await handleRestartCommand({
+              chatId,
+              messageId: String(msg.message_id)
+            });
+          } else if (disposition === "verification_failed") {
+            try {
+              await telegramApiCall(
+                "sendMessage",
+                {
+                  chat_id: chatId,
+                  text: `\u274C Couldn't verify the restart target. Please retry /restart in a few seconds.`,
+                  reply_to_message_id: Number(msg.message_id)
+                },
+                1e4
+              );
+            } catch (err) {
+              process.stderr.write(
+                `telegram-channel(${AGENT_CODE_NAME}): /restart verification-failed ack send failed: ${redactAugmentedPaths(err.message)}
+`
+              );
+            }
+          }
+          continue;
+        }
         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 messageId = String(msg.message_id);

package/package.json

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