@0xmaxma/claude-gateway 1.7.8 → 1.7.10

package/mcp/tools/slack/module.ts

@@ -11,6 +11,7 @@
  * bot token at any time, so this module always sends directly from the
  * subprocess.
  */
+import * as fs from 'fs';
 import type { ToolModule, McpToolDefinition, McpToolResult, ToolVisibility } from '../../types';
 // mcp/ ships as source (package.json `files` lists "mcp/", not "src/") and
 // runs directly under bun — it may only import a compiled dist/ artifact,
@@ -20,11 +21,17 @@ import type { ToolModule, McpToolDefinition, McpToolResult, ToolVisibility } fro
 // "Cannot find module" from an installed package). `npm run build` must have
 // run at least once for this import to resolve locally.
 import { SlackClient } from '../../../dist/api/slack-client.js';
+import { MAX_ATTACHMENT_BYTES } from '../shared/limits';
 
 export class SlackModule implements ToolModule {
   id = 'slack';
   toolVisibility: ToolVisibility = 'current-channel';
 
+  // Files already delivered this session. Small models sometimes retry
+  // slack_reply after a transient send hiccup even though the upload
+  // succeeded, which spams duplicate images. We never re-send the same file.
+  private readonly sentFiles = new Set<string>();
+
   isEnabled(): boolean {
     return process.env.GATEWAY_ORIGIN_CHANNEL === 'slack';
   }
@@ -36,6 +43,7 @@ export class SlackModule implements ToolModule {
         description:
           'Send a reply to the current Slack conversation. ' +
           'Pass chat_id (the Slack channel/DM id shown in the <channel> tag) and text. ' +
+          'Optionally pass files (absolute paths) to attach images or documents. ' +
           'Also pass message_id from the <channel> tag when present — it clears the ' +
           '⏳ "seen" reaction the gateway left on the inbound message. ' +
           'Pass thread_id to reply inside the same thread instead of top-level.',
@@ -50,6 +58,14 @@ export class SlackModule implements ToolModule {
               type: 'string',
               description: 'Message text.',
             },
+            files: {
+              type: 'array',
+              items: { type: 'string' },
+              description:
+                'Absolute file paths to attach (e.g. a generate_image result path). ' +
+                'Optional — text can be sent alone, files can be sent alone, or both ' +
+                'together as one message with the text as caption.',
+            },
             message_id: {
               type: 'string',
               description:
@@ -63,7 +79,9 @@ export class SlackModule implements ToolModule {
                 'to a threaded message stays in-thread.',
             },
           },
-          required: ['chat_id', 'text'],
+          // `text` is NOT required: a files-only reply (an image with no caption)
+          // is a legitimate send.
+          required: ['chat_id'],
         },
       },
     ];
@@ -79,12 +97,26 @@ export class SlackModule implements ToolModule {
     const text = typeof args.text === 'string' ? args.text : '';
     const messageId = typeof args.message_id === 'string' ? args.message_id : '';
     const threadId = typeof args.thread_id === 'string' ? args.thread_id : '';
+    const requested = Array.isArray(args.files) ? (args.files as unknown[]) : [];
     const token = process.env.SLACK_BOT_TOKEN ?? '';
 
     if (!chatId) {
       return { content: [{ type: 'text', text: 'slack_reply: missing chat_id' }], isError: true };
     }
-    if (!text) {
+
+    // Drop files already delivered successfully this session (retry-dedup): a
+    // small model sometimes retries slack_reply after a transient hiccup even
+    // though the upload landed, which would spam duplicate images.
+    const files = requested.filter(
+      (f): f is string => typeof f === 'string' && !this.sentFiles.has(f),
+    );
+
+    // Nothing new to say or send — the whole reply is a duplicate retry. No-op
+    // success so the agent treats it as delivered and stops retrying.
+    if (!text && files.length === 0 && requested.length > 0) {
+      return { content: [{ type: 'text', text: 'already sent (duplicate suppressed)' }] };
+    }
+    if (!text && files.length === 0) {
       return { content: [{ type: 'text', text: 'slack_reply: text cannot be empty' }], isError: true };
     }
     if (!token) {
@@ -93,16 +125,46 @@ export class SlackModule implements ToolModule {
 
     const client = new SlackClient({ botToken: token, logDir: process.env.GATEWAY_WORKSPACE_DIR ?? '/tmp' });
     try {
-      const sent = await client.postMessage(chatId, text, threadId || undefined);
+      // Size-check before any upload starts, so an oversized file fails fast
+      // instead of half-way through a multi-file batch.
+      for (const f of files) {
+        const st = fs.statSync(f);
+        if (st.size > MAX_ATTACHMENT_BYTES) {
+          throw new Error(`file too large: ${f} (${(st.size / 1024 / 1024).toFixed(1)}MB, max 50MB)`);
+        }
+      }
+
+      // With files, ONE uploadFiles call carries both the attachments and the
+      // text (as Slack's initial_comment) — never also postMessage, which would
+      // split one reply into two Slack messages.
+      const sent =
+        files.length > 0
+          ? await client.uploadFiles(chatId, files, {
+              threadTs: threadId || undefined,
+              initialComment: text || undefined,
+            })
+          : await client.postMessage(chatId, text, threadId || undefined);
       if (!sent.ok) {
         return { content: [{ type: 'text', text: `slack_reply failed: ${sent.error}` }], isError: true };
       }
+      // Mark as sent only AFTER the send succeeds — a genuine failure leaves
+      // them eligible for a retry rather than silently dropped.
+      for (const f of files) this.sentFiles.add(f);
       // Best-effort: clear the ack-reaction the webhook left on the inbound
       // message. Never blocks or fails the reply itself on a reaction error.
       if (messageId) {
         void client.removeReaction(chatId, messageId).catch(() => {});
       }
-      return { content: [{ type: 'text', text: 'Sent message to Slack.' }] };
+      return {
+        content: [
+          {
+            type: 'text',
+            text: files.length > 0
+              ? `Sent message to Slack (${files.length} file(s)).`
+              : 'Sent message to Slack.',
+          },
+        ],
+      };
     } catch (err) {
       return {
         content: [{ type: 'text', text: `slack_reply failed: ${(err as Error).message}` }],

package/mcp/tools/telegram/module.ts

@@ -8,6 +8,7 @@ import * as fs from 'fs';
 import * as os from 'os';
 import { migrateAccess, defaultAccess } from './pure';
 import { chunkText, htmlToPlain } from './typing';
+import { MAX_ATTACHMENT_BYTES } from '../shared/limits';
 import type {
   ChannelModule,
   ChannelCapabilities,
@@ -20,7 +21,6 @@ import type {
 } from '../../types';
 
 const PHOTO_EXTS = new Set(['.jpg', '.jpeg', '.png', '.gif', '.webp']);
-const MAX_ATTACHMENT_BYTES = 50 * 1024 * 1024;
 const MAX_CHUNK_LIMIT = 4096;
 
 export class TelegramModule implements ChannelModule {
@@ -363,10 +363,18 @@ export class TelegramModule implements ChannelModule {
       }
     }
 
-    // Write .replied marker
+    // Write .replied marker, tagged with the live typing-signal timestamp as
+    // this turn's id — the receiver (typing.ts) only treats a queued
+    // auto-forward as "already replied" when its own turnId matches this one,
+    // so a marker left over from an earlier turn can never suppress a later
+    // turn's forward (see typing.ts's isEntryAlreadyReplied()).
     try {
       fs.mkdirSync(this.typingDir, { recursive: true });
-      fs.writeFileSync(path.join(this.typingDir, `${chat_id}.replied`), sendText);
+      let turnId: string | null = null;
+      try {
+        turnId = fs.readFileSync(path.join(this.typingDir, chat_id), 'utf8').trim() || null;
+      } catch {}
+      fs.writeFileSync(path.join(this.typingDir, `${chat_id}.replied`), JSON.stringify({ text: sendText, turnId }));
     } catch {}
 
     const result = sentIds.length === 1

package/mcp/tools/telegram/receiver-server.ts

@@ -39,6 +39,7 @@ import { createIncidentStore } from '../../../dist/agent/incident-store.js'
 import type { RecoveryOutcome } from '../../../dist/agent/incident.js'
 import { initDedupDir, isDuplicate as _isDuplicate, pruneDedup as _pruneDedup } from './dedup'
 import { normalizeTelegramLineBreaks, resolveTelegramReplyFormat, migrateAccess, telegramDisplayName } from './pure'
+import { MAX_ATTACHMENT_BYTES } from '../shared/limits'
 
 // Standalone fallback: default state dir to ~/.claude/channels/telegram
 const STATE_DIR = process.env.TELEGRAM_STATE_DIR ?? join(homedir(), '.claude', 'channels', 'telegram')
@@ -336,7 +337,6 @@ function defaultAccess(): Access {
 }
 
 const MAX_CHUNK_LIMIT = 4096
-const MAX_ATTACHMENT_BYTES = 50 * 1024 * 1024
 
 // reply's files param takes any path. Claude can already Read+paste file
 // contents, so this isn't a new exfil channel for arbitrary paths — but the
@@ -783,10 +783,17 @@ mcp.setRequestHandler(CallToolRequestSchema, async req => {
 
         // Typing persists until agent-runner sees result event + delay.
         // Removed signalReplyDone() — reply does not mean done, agent may continue working.
-        // Write .replied marker so auto-forward in typing.ts skips duplicate send.
+        // Write .replied marker so auto-forward in typing.ts skips duplicate send —
+        // tagged with the live typing-signal timestamp as this turn's id, so a
+        // marker left over from an earlier turn can never suppress a later
+        // turn's forward (see typing.ts's isEntryAlreadyReplied()).
         try {
           mkdirSync(TYPING_DIR, { recursive: true })
-          writeFileSync(join(TYPING_DIR, `${chat_id}.replied`), sendText)
+          let turnId: string | null = null
+          try {
+            turnId = readFileSync(join(TYPING_DIR, chat_id), 'utf8').trim() || null
+          } catch {}
+          writeFileSync(join(TYPING_DIR, `${chat_id}.replied`), JSON.stringify({ text: sendText, turnId }))
         } catch { /* non-fatal */ }
 
         const result =

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.8",
+  "version": "1.7.10",
   "description": "Multi-agent gateway for Claude",
   "repository": {
     "type": "git",