@0xmaxma/claude-gateway 1.7.9 → 1.7.10

package/mcp/tools/telegram/typing.ts

@@ -173,6 +173,47 @@ export const STATUS_EMOJI: Record<string, string> = {
   error:    '😱',
 }
 
+/**
+ * Telegram reports failures as `description` on a GrammyError; anything else
+ * thrown here (a network error, a plain Error in tests) carries `message`.
+ *
+ * Read structurally rather than with `err instanceof GrammyError &&
+ * err.error_code`, the convention in receiver-server.ts, for two reasons: this
+ * module deliberately has no grammy import — it takes an injected BotApi so
+ * tests can drive it — and the two cases below are both HTTP 400, so the code
+ * alone cannot tell them apart. The description is the only thing that can.
+ */
+function errorText(err: unknown): string {
+  if (typeof err === 'object' && err !== null) {
+    const e = err as { description?: unknown; message?: unknown }
+    if (typeof e.description === 'string') return e.description
+    if (typeof e.message === 'string') return e.message
+  }
+  return String(err)
+}
+
+/**
+ * Telegram rejects an edit whose new text is byte-identical to what the
+ * message already shows. That is not a failure to recover from — the message
+ * is intact and already correct — so the status loop must keep editing it
+ * rather than concluding it is gone and posting a replacement.
+ */
+export function isNotModifiedError(err: unknown): boolean {
+  return /message is not modified/i.test(errorText(err))
+}
+
+/**
+ * The message can never be edited again: deleted, or past Telegram's edit
+ * window. Only these justify dropping the id and sending a fresh message.
+ * A transient failure (network, 429) deliberately does NOT — the message is
+ * still there, and re-sending would leave a duplicate behind.
+ */
+export function isMessageGoneError(err: unknown): boolean {
+  return /message to (?:edit|be edited) not found|message can'?t be edited|message not found/i.test(
+    errorText(err),
+  )
+}
+
 export function parseStatusFile(content: string): { status: string; detail?: string } {
   try {
     const parsed = JSON.parse(content);
@@ -193,6 +234,10 @@ export interface WorkingState {
   currentReaction: string | null
   lastDetail: string | null
   recentDetails: string[]
+  /** Text the status message currently displays. An edit that would rewrite a
+   *  message with the exact text it already has is rejected by Telegram, so it
+   *  is never issued. */
+  lastStatusText: string | null
   /** Last stage an incident was raised for — dedupes the turn-trace watchdog
    *  so one contiguous stalled episode emits a single incident, not one per
    *  15s tick. Reset to null once the turn is no longer stalled. */
@@ -216,6 +261,78 @@ export interface FsApi {
   statSync(path: string): { mtimeMs: number }
 }
 
+/**
+ * A single queued auto-forward. `turnId` identifies the turn that produced it
+ * (the live typing-signal timestamp read at write time) — `null` when no
+ * signal file existed yet (e.g. an orphan forward from an autonomous wake
+ * with no inbound message). Writers: `AgentRunner.writeAutoForward()`.
+ */
+export interface ForwardEntry {
+  text: string
+  format: 'text' | 'html'
+  turnId: string | null
+}
+
+function normalizeForwardEntry(raw: unknown): ForwardEntry | null {
+  if (raw && typeof raw === 'object' && typeof (raw as { text?: unknown }).text === 'string') {
+    const o = raw as { text: string; format?: unknown; turnId?: unknown }
+    return {
+      text: o.text,
+      format: o.format === 'html' ? 'html' : 'text',
+      turnId: typeof o.turnId === 'string' ? o.turnId : null,
+    }
+  }
+  return null
+}
+
+/**
+ * Parse `.forward` file content into an ordered queue of entries. Accepts the
+ * current queue format (a JSON array), the pre-queue single-object format,
+ * and the original plain-text format — so an in-flight file survives a
+ * rolling deploy in either direction instead of losing its content.
+ */
+export function parseForwardQueue(raw: string): ForwardEntry[] {
+  const trimmed = raw.trim()
+  if (!trimmed) return []
+  try {
+    const parsed = JSON.parse(trimmed)
+    if (Array.isArray(parsed)) {
+      return parsed.map(normalizeForwardEntry).filter((e): e is ForwardEntry => e !== null)
+    }
+    const single = normalizeForwardEntry(parsed)
+    return single ? [single] : []
+  } catch {
+    return [{ text: trimmed, format: 'text', turnId: null }]
+  }
+}
+
+/**
+ * Parse `.replied` marker content. Current format is `{ text, turnId }`; a
+ * legacy marker (plain text, or JSON without a `turnId`) parses to
+ * `turnId: null`, which — per `resolveForwardDelivery` below — never
+ * satisfies dedup, so a marker from a version predating this format degrades
+ * to "deliver" rather than risking a silent drop.
+ */
+function parseRepliedTurnId(raw: string): string | null {
+  try {
+    const parsed = JSON.parse(raw.trim()) as { turnId?: unknown }
+    if (parsed && typeof parsed === 'object' && typeof parsed.turnId === 'string') {
+      return parsed.turnId
+    }
+  } catch {}
+  return null
+}
+
+/**
+ * Turn-scoped dedup: an entry is already covered by the reply tool only when
+ * both sides captured the SAME live turn id at write time. A `null` turnId on
+ * either side never matches — favors an extra/duplicate delivery over a
+ * silently dropped one.
+ */
+function isEntryAlreadyReplied(entry: ForwardEntry, repliedTurnId: string | null): boolean {
+  return repliedTurnId !== null && entry.turnId !== null && entry.turnId === repliedTurnId
+}
+
 /**
  * Deliver auto-forwarded turn text to a chat, never silently dropping content.
  * Each chunk that fails as HTML (e.g. Telegram rejects an entity the balancer
@@ -292,22 +409,18 @@ export function drainOrphanForwards(
     // Remove BEFORE sending so a slow/failing send can't double-deliver.
     fsApi.rmSync(forwardPath, { force: true })
     // Mirror stop()'s dedup: a lingering .replied with no typing state means
-    // the agent already sent this turn's text via the reply tool.
+    // the agent already sent SOME turn's text via the reply tool — but only
+    // entries whose turnId matches that marker's turn are actually covered.
     const repliedPath = `${typingDir}/${chatId}.replied`
+    let repliedTurnId: string | null = null
     if (fsApi.existsSync(repliedPath)) {
+      try { repliedTurnId = parseRepliedTurnId(fsApi.readFileSync(repliedPath, 'utf8')) } catch {}
       fsApi.rmSync(repliedPath, { force: true })
-      continue
     }
-    let text = raw
-    let parseMode: 'HTML' | undefined
-    try {
-      const parsed = JSON.parse(raw) as { text: string; format: string }
-      text = parsed.text
-      parseMode = parsed.format === 'html' ? 'HTML' : undefined
-    } catch {
-      // Old format: plain text
+    for (const entry of parseForwardQueue(raw)) {
+      if (!entry.text || isEntryAlreadyReplied(entry, repliedTurnId)) continue
+      void deliverForwardText(botApi, chatId, entry.text, entry.format === 'html' ? 'HTML' : undefined)
     }
-    if (text) void deliverForwardText(botApi, chatId, text, parseMode)
   }
 }
 
@@ -472,30 +585,29 @@ export function createWorkingStateManager(
         }
       } catch {}
     }
-    // Auto-forward result text to Telegram if the agent did not already reply with the same text.
+    // Auto-forward queued turn text to Telegram, skipping only the entries the
+    // reply tool already sent (same turnId as the .replied marker) — turn A's
+    // leftover marker must never suppress turn B's forward. See
+    // isEntryAlreadyReplied() / the module docstring for the race this guards.
     const forwardPath = forwardFilePath(chatId)
     const repliedPath = repliedFilePath(chatId)
     if (fsApi.existsSync(forwardPath)) {
+      let entries: ForwardEntry[] = []
       try {
-        const raw = fsApi.readFileSync(forwardPath, 'utf8').trim()
-        let forwardText: string
-        let parseMode: 'HTML' | undefined
-        try {
-          const parsed = JSON.parse(raw) as { text: string; format: string }
-          forwardText = parsed.text
-          parseMode = parsed.format === 'html' ? 'HTML' : undefined
-        } catch {
-          // Fallback: treat as plain text (old format compatibility)
-          forwardText = raw
-          parseMode = undefined
-        }
-        // Skip if the reply tool already sent a message (agent already replied)
-        const alreadyReplied = fsApi.existsSync(repliedPath)
-        if (!alreadyReplied && forwardText) {
-          await deliverForwardText(botApi, chatId, forwardText, parseMode)
-        }
+        entries = parseForwardQueue(fsApi.readFileSync(forwardPath, 'utf8'))
       } catch {}
+      // Remove BEFORE delivering (mirrors drainOrphanForwards' same comment):
+      // delivery can take a while (multiple chunks, retries), and a
+      // writeAutoForward() append landing mid-delivery must start a fresh
+      // file rather than have this call's cleanup silently discard it.
       fsApi.rmSync(forwardPath, { force: true })
+      const repliedTurnId = fsApi.existsSync(repliedPath)
+        ? parseRepliedTurnId(fsApi.readFileSync(repliedPath, 'utf8'))
+        : null
+      for (const entry of entries) {
+        if (!entry.text || isEntryAlreadyReplied(entry, repliedTurnId)) continue
+        await deliverForwardText(botApi, chatId, entry.text, entry.format === 'html' ? 'HTML' : undefined)
+      }
     }
     // NOTE: interactive-menu (.menu) delivery is handled by an independent poller
     // in receiver-server.ts (drainMenuFiles), NOT here. A menu can be emitted
@@ -551,6 +663,7 @@ export function createWorkingStateManager(
       currentReaction: null,
       lastDetail: null,
       recentDetails: [],
+      lastStatusText: null,
       lastIncidentStage: null,
     }
     states.set(chatId, state)
@@ -583,13 +696,44 @@ export function createWorkingStateManager(
         if (s.statusMessageId === null) {
           try {
             const sent = await botApi.sendMessage(chatId, text)
-            s.statusMessageId = sent.message_id
+            // Re-read rather than writing through the captured `s`: the turn
+            // can end while the send is in flight, and the state this records
+            // against must be the live one or none at all.
+            const current = states.get(chatId)
+            if (current) {
+              current.statusMessageId = sent.message_id
+              current.lastStatusText = text
+            }
           } catch {}
-        } else {
-          await botApi.editMessageText(chatId, s.statusMessageId, text).catch(async () => {
+        } else if (text !== s.lastStatusText) {
+          // Nothing to say, so nothing is sent. The cost is that a status
+          // message deleted by hand is not noticed until the next edit — but
+          // the elapsed line advances every minute even at `Xh Ym`, so that
+          // wait is bounded, and it buys immunity from the duplicate loop.
+          try {
+            await botApi.editMessageText(chatId, s.statusMessageId, text)
+            s.lastStatusText = text
+          } catch (err) {
             const current = states.get(chatId)
-            if (current) current.statusMessageId = null
-          })
+            if (!current) {
+              // The turn ended while the edit was in flight.
+            } else if (isNotModifiedError(err)) {
+              // The message already shows this text — nothing to recover from.
+              current.lastStatusText = text
+            } else if (isMessageGoneError(err)) {
+              current.statusMessageId = null
+              current.lastStatusText = null
+            } else {
+              // Keep the id — the message is still there, and the next tick
+              // edits it again; re-sending would leave a duplicate behind.
+              // Logged because a silently swallowed edit failure is exactly
+              // what let the duplicate loop run unnoticed: if Telegram ever
+              // returns something this does not classify, it should be
+              // visible in the receiver log rather than inferred from
+              // symptoms.
+              console.error(`[typing] status edit failed (retrying next tick): ${errorText(err)}`)
+            }
+          }
         }
       } finally {
         statusUpdatePending = false

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xmaxma/claude-gateway",
-  "version": "1.7.9",
+  "version": "1.7.10",
   "description": "Multi-agent gateway for Claude",
   "repository": {
     "type": "git",