polygram 0.12.0-rc.7 → 0.12.0-rc.8

package/config.example.json

@@ -71,7 +71,9 @@
       "model": "opus",
       "effort": "medium",
       "cwd": "/Users/you/admin-agent",
-      "timeout": 600
+      "timeout": 600,
+      "_comment_maxFileBytes": "Optional per-chat file-size cap in BYTES for send/receive, also settable per-topic (topic wins). Default follows the backend: cloud Telegram 50MB send / 20MB receive; with bot.apiRoot (local Bot API server) 2GB both ways. An override can only LOWER the cap below the backend ceiling — Telegram rejects anything larger regardless. Example: 104857600 = 100MB (only effective when apiRoot is set).",
+      "maxFileBytes": 104857600
     },
 
     "-1000000000001": {

package/lib/attachments.js

@@ -26,9 +26,44 @@
 // bot file DOWNLOADS (getFile) at 20 MB, so 20 MB is the real ceiling on
 // cloud — raised from 10 MB so users can send larger tracks/docs. With a
 // self-hosted Bot API server (config.bot.apiRoot) the Telegram limit rises
-// to 2 GB; override per-bot via config.bot.maxInboundFileBytes if so.
+// to 2 GB; resolveFileCaps() raises the default accordingly.
 const MAX_FILE_BYTES = 20 * 1024 * 1024;
 const MAX_TOTAL_BYTES = 50 * 1024 * 1024;
+
+// ─── Backend-derived file-size caps (cloud vs local Bot API server) ──
+//
+// These are the HARD ceilings Telegram itself enforces — a per-chat
+// override can lower them but never exceed them (Telegram rejects beyond
+// regardless). NOT "adaptive": there is no intermediate tier. Cloud is a
+// flat 20 in / 50 out; a local `telegram-bot-api --local` server is a flat
+// 2 GB both ways.
+const CLOUD_MAX_IN_BYTES  = 20 * 1024 * 1024;          // getFile download limit
+const CLOUD_MAX_OUT_BYTES = 50 * 1024 * 1024;          // sendDocument upload limit
+const LOCAL_MAX_BYTES     = 2000 * 1024 * 1024;        // --local server, both ways
+
+/**
+ * Resolve the effective per-file caps for a chat/topic.
+ *
+ * @param {object} opts
+ * @param {boolean} opts.localApi   — true when config.bot.apiRoot is set
+ *   (a local Bot API server is in use → 2 GB ceiling).
+ * @param {...number} opts.override  — per-chat/topic maxFileBytes (bytes).
+ *   Resolved by the caller from topic → chat → undefined; clamped to the
+ *   backend ceiling.
+ * @returns {{ inBytes:number, outBytes:number, ceiling:number, localApi:boolean }}
+ */
+function resolveFileCaps({ localApi = false, override = null } = {}) {
+  const ceiling = localApi ? LOCAL_MAX_BYTES : null;
+  const defIn  = localApi ? LOCAL_MAX_BYTES : CLOUD_MAX_IN_BYTES;
+  const defOut = localApi ? LOCAL_MAX_BYTES : CLOUD_MAX_OUT_BYTES;
+  // A numeric override sets BOTH directions to the same value, clamped to
+  // the backend hard ceiling (cloud uses the per-direction default as the
+  // clamp so an override can't push past Telegram's own limit).
+  const ovr = (typeof override === 'number' && override > 0) ? override : null;
+  const inBytes  = ovr ? (localApi ? Math.min(ovr, ceiling) : Math.min(ovr, CLOUD_MAX_IN_BYTES))  : defIn;
+  const outBytes = ovr ? (localApi ? Math.min(ovr, ceiling) : Math.min(ovr, CLOUD_MAX_OUT_BYTES)) : defOut;
+  return { inBytes, outBytes, ceiling: ceiling ?? CLOUD_MAX_OUT_BYTES, localApi };
+}
 const MIME_ALLOW = [
   /^image\//, /^audio\//, /^video\//,
   /^application\/pdf$/, /^text\/plain$/,
@@ -114,8 +149,12 @@ function filterAttachments(attachments, opts = {}) {
 
 module.exports = {
   filterAttachments,
+  resolveFileCaps,
   MAX_FILE_BYTES,
   MAX_TOTAL_BYTES,
+  CLOUD_MAX_IN_BYTES,
+  CLOUD_MAX_OUT_BYTES,
+  LOCAL_MAX_BYTES,
   MIME_ALLOW,
   EXTENSION_ALLOW,
   FALLBACK_MIMES,

package/lib/process/channels-tool-dispatcher.js

@@ -125,7 +125,7 @@ function createChannelsToolDispatcher({
     || require('../telegram/process-agent-reply').processAndDeliverAgentText;
 
   return async function channelsToolDispatcher(call) {
-    const { sessionKey, chatId, threadId, toolName, text, files, sourceMsgId } = call;
+    const { sessionKey, chatId, threadId, toolName, text, files, sourceMsgId, maxOutboundFileBytes } = call;
 
     if (toolName !== 'reply') {
       // 0.11.0 Phase 1 ships `reply` only — react and edit_message are
@@ -196,6 +196,21 @@ function createChannelsToolDispatcher({
             failedAttachments.push({ path: filePath, error: check.error });
             continue;
           }
+          // Backend/chat-derived upload cap. Reject oversize BEFORE upload with
+          // a clear error (vs Telegram's cryptic 413/"file is too big") so
+          // claude can convert/compress and retry. maxOutboundFileBytes is
+          // undefined for non-channels callers → no cap (Telegram still gates).
+          if (typeof maxOutboundFileBytes === 'number' && maxOutboundFileBytes > 0) {
+            let size = 0;
+            try { size = fs.statSync(check.resolved).size; } catch {}
+            if (size > maxOutboundFileBytes) {
+              const mb = (n) => (n / (1024 * 1024)).toFixed(1);
+              const err = `file too large to send: ${mb(size)}MB > ${mb(maxOutboundFileBytes)}MB limit`;
+              logger.warn?.(`[channels-tool-dispatcher] ${err} (${check.resolved})`);
+              failedAttachments.push({ path: filePath, error: err });
+              continue;
+            }
+          }
           try {
             const ext = path.extname(check.resolved).toLowerCase();
             const isImage = ['.jpg', '.jpeg', '.png', '.gif', '.webp'].includes(ext);

package/lib/process/cli-process.js

@@ -52,6 +52,7 @@ const { createHookTail } = require('./hook-event-tail');
 // create exactly matches the realpath the validator accepts (no /tmp vs
 // /private/tmp drift — one of the original Music-topic failures).
 const { DEFAULT_ATTACHMENT_BASE } = require('./channels-tool-dispatcher');
+const { resolveFileCaps } = require('../attachments');
 const { runStartupGate } = require('../tmux/startup-gate');
 const { POLYGRAM_DISPLAY_HINT } = require('../telegram/display-hint');
 
@@ -255,6 +256,10 @@ class CliProcess extends Process {
     // pending turn(s): turn_id → { resolve, reject, replies: [], quietTimer, hardTimer, startedAt }
     this.pendingTurns = new Map();
 
+    // File-send outbound cap (bot → user). Safe cloud default; overwritten in
+    // _spawnTmuxClaude with the backend/chat-resolved value before any turn.
+    this.maxOutboundFileBytes = resolveFileCaps({ localApi: false }).outBytes;
+
     // P1 security (review #8): track resolved permission request_ids so a
     // double-fire of respond() can't write a second perm_verdict for the same
     // request. TmuxProcess gates on _pendingApprovalId; this is the channels
@@ -493,6 +498,18 @@ class CliProcess extends Process {
     const effort = topicConfig?.effort || opts.chatConfig?.effort || opts.effort;
     const resolvedCwd = topicConfig?.cwd || opts.chatConfig?.cwd || opts.cwd;
 
+    // File-send outbound cap (bot → user). Backend-derived (cloud 50MB vs
+    // local Bot API server 2GB via opts.localApi) with per-topic/chat
+    // maxFileBytes override, clamped to the backend ceiling. Stored for the
+    // dispatcher (live size-check) and the system prompt (so claude states
+    // the right limit). Resolved here so it follows the same topic→chat
+    // precedence as cwd/agent above.
+    const _capOverride = topicConfig?.maxFileBytes ?? opts.chatConfig?.maxFileBytes ?? null;
+    this.maxOutboundFileBytes = resolveFileCaps({
+      localApi: !!opts.localApi,
+      override: _capOverride,
+    }).outBytes;
+
     // Parity audit P8 + rc.8 fs-guard (2026-05-26 shumorobot Music topic):
     // `--session-id <id>` creates a NEW claude session with that id;
     // `--resume <id>` resumes the EXISTING conversation. Lazy-respawn after
@@ -637,9 +654,10 @@ class CliProcess extends Process {
         'path in `files`. Paths outside the workspace are rejected for safety.',
       ]),
       '',
-      'Telegram caps bot file uploads at 50 MB (cloud). For larger lossless',
-      'audio, convert to FLAC/MP3 under 50 MB first, or tell the user it exceeds',
-      'the limit. Images go as photos; everything else as documents.',
+      `Max file size for sending: ${Math.round(this.maxOutboundFileBytes / (1024 * 1024))} MB. ` +
+        'For larger lossless audio, convert to FLAC/MP3 under the limit first, ' +
+        'or tell the user it exceeds the limit. Images go as photos; everything ' +
+        'else as documents.',
     ].join('\n'));
 
     // Parity audit P6: honor isolateUserConfig — mirrors tmux pattern at
@@ -984,6 +1002,7 @@ class CliProcess extends Process {
         text: args.text,
         files: args.files,
         sessionCwd: this.sessionCwd,        // P0 #2: dispatcher uses this to allowlist file roots
+        maxOutboundFileBytes: this.maxOutboundFileBytes, // backend/chat-derived upload cap
       });
     } catch (err) {
       this._writeToBridge({ kind: 'tool_ack', tool_call_id: msg.tool_call_id, ok: false, error: err.message });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polygram",
-  "version": "0.12.0-rc.7",
+  "version": "0.12.0-rc.8",
   "description": "Telegram daemon for Claude Code that preserves the OpenClaw per-chat session model. Migration path for OpenClaw users moving to Claude Code.",
   "main": "lib/ipc/client.js",
   "bin": {

package/polygram.js

@@ -28,7 +28,7 @@ const {
   migrateJsonToDb, getClaudeSessionId, resolveSessionForSpawn,
 } = require('./lib/db/sessions');
 const { buildPrompt } = require('./lib/prompt');
-const { filterAttachments } = require('./lib/attachments');
+const { filterAttachments, resolveFileCaps, MAX_TOTAL_BYTES } = require('./lib/attachments');
 // 0.9.0: SDK ProcessManager is the only pm. CLI pm
 // (lib/process-manager.js) deleted in commit 6.
 // Both implementations expose the same public API (constructor +
@@ -461,6 +461,10 @@ function buildSpawnContext(sessionKey) {
     threadId: threadId || null,
     label: getSessionLabel(chatConfig, threadId),
     existingSessionId,
+    // File-send outbound cap inputs: localApi (bot-level) so CliProcess can
+    // resolve the per-chat/topic outbound cap (resolveFileCaps) the same way
+    // it resolves cwd/agent. Override itself lives in chatConfig/topic.
+    localApi: !!config.bot?.apiRoot,
   };
 }
 
@@ -754,7 +758,19 @@ async function handleMessage(sessionKey, chatId, msg, bot) {
   const sessionCtx = !pm.has(sessionKey) ? await readSessionContext(sessionKey, chatConfig.cwd) : '';
 
   const rawAtts = extractAttachments(msg);
-  const { accepted, rejected } = filterAttachments(rawAtts);
+  // Backend-derived inbound cap with per-topic/chat override. Cloud → 20MB;
+  // a local Bot API server (config.bot.apiRoot) → 2GB; override via
+  // chats[id].maxFileBytes or topics[t].maxFileBytes, clamped to the
+  // backend ceiling. Bytes-valued config; resolveFileCaps does the clamp.
+  const _inTopicCfg = getTopicConfig(chatConfig, threadIdStr || null);
+  const _fileCaps = resolveFileCaps({
+    localApi: !!config.bot?.apiRoot,
+    override: _inTopicCfg.maxFileBytes ?? chatConfig.maxFileBytes ?? null,
+  });
+  const { accepted, rejected } = filterAttachments(rawAtts, {
+    maxFileBytes: _fileCaps.inBytes,
+    maxTotalBytes: Math.max(_fileCaps.inBytes, MAX_TOTAL_BYTES),
+  });
   for (const { att, reason } of rejected) {
     console.log(`[${label}] attachment skipped: ${att.name} (${reason})`);
     logEvent('attachment-skipped', { chat_id: chatId, msg_id: msg.message_id, name: att.name, reason });