polygram 0.12.0-rc.6 → 0.12.0-rc.8

package/config.example.json

@@ -4,6 +4,7 @@
   "bots": {
     "admin-bot": {
       "token": "REPLACE_WITH_BOT_TOKEN_FROM_BOTFATHER",
+      "_comment_apiRoot": "Optional. Point grammy at a self-hosted Telegram Bot API server (e.g. 'http://localhost:8081' from a local `telegram-bot-api --local` process) to raise file send/receive limits from cloud's 50MB-out / 20MB-in to 2GB both ways. Omit for cloud Telegram (default, unchanged). The server is a separate localhost-only companion daemon — see docs/0.12.0-file-send.md.",
       "allowConfigCommands": true,
       "_comment_adminChatId": "Required when allowConfigCommands is true for pairing commands (/pair-code, /pairings, /unpair) to work. These grant cross-chat trust and are gated to the admin chat only.",
       "adminChatId": "123456789",
@@ -70,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

@@ -22,8 +22,48 @@
  *     extension — the fallback only kicks in when MIME is unhelpful.
  */
 
-const MAX_FILE_BYTES = 10 * 1024 * 1024;
-const MAX_TOTAL_BYTES = 20 * 1024 * 1024;
+// Inbound (user → bot) per-file cap. Telegram's cloud Bot API hard-caps
+// 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; 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$/,
@@ -109,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/ipc/file-validator.js

@@ -50,7 +50,14 @@ function validateIpcFileParam(method, params = {}) {
   const fileParam = FILE_PARAM_BY_METHOD[method];
   if (!fileParam) return null;
   const val = params[fileParam];
-  if (typeof val !== 'string') return null;       // envelope/Buffer/etc — pass through
+  // { source: '/abs/path' } envelope — now coerced to a grammy InputFile in
+  // tg() (coerceFileParams). Validate it has a usable absolute source, else
+  // pass through (Buffer / stream / InputFile shapes).
+  if (val && typeof val === 'object' && typeof val.source === 'string') {
+    if (val.source.length === 0) return `polygram IPC: ${fileParam}.source is empty`;
+    return null;
+  }
+  if (typeof val !== 'string') return null;       // Buffer/InputFile/etc — pass through
   if (val.length === 0) return `polygram IPC: ${fileParam} is empty`;
 
   const looksUrl = /^(https?|ftp):\/\//i.test(val);

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);
@@ -203,7 +218,10 @@ function createChannelsToolDispatcher({
             const fieldName = isImage ? 'photo' : 'document';
             const params = {
               chat_id: chatId,
-              [fieldName]: { source: check.resolved },
+              // { source } envelope → grammy InputFile in tg()'s coerceFileParams.
+              // Pre-fix this bare object reached grammy unrecognized and every
+              // upload 400'd with "Wrong port number" (file-send never worked).
+              [fieldName]: { source: check.resolved, filename: path.basename(check.resolved) },
             };
             if (threadId) params.message_thread_id = threadId;
             await send(bot, method, params, { source: 'channels-tool-dispatcher', sessionKey });

package/lib/process/cli-process.js

@@ -48,6 +48,11 @@ const { Process, UnsupportedOperationError } = require('./process');
 const { ChannelsBridgeServer } = require('./channels-bridge-server');
 const { writeHookFiles, removeHookFiles } = require('./hook-settings');
 const { createHookTail } = require('./hook-event-tail');
+// File-send staging: reuse the dispatcher's allowlist root so the dir we
+// 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');
 
@@ -251,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
@@ -297,6 +306,23 @@ class CliProcess extends Process {
     // permit files under the agent's workspace.
     this.sessionCwd = opts.cwd || null;
 
+    // File-send staging dir (2026-06 file-send feature). The dispatcher
+    // allowlist always permits <DEFAULT_ATTACHMENT_BASE>/<sessionKey>/, but
+    // nothing ever CREATED it — so claude's reply(files) attempts at
+    // /tmp/polygram-attachments failed (dir absent / realpath mismatch) and
+    // it flailed across other paths. Create it here and surface it to the
+    // prompt so claude has one blessed, always-allowed place to stage a file
+    // before sending. realpathSync so the stored path matches what the
+    // validator resolves (the /tmp ↔ /private/tmp fix).
+    try {
+      const dir = path.join(DEFAULT_ATTACHMENT_BASE, String(this.sessionKey));
+      fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+      this.attachmentStagingDir = fs.realpathSync(dir);
+    } catch (err) {
+      this.attachmentStagingDir = null;
+      this.logger.warn?.(`[${this.label}] channels: staging dir create failed: ${err.message}`);
+    }
+
     // Opaque random token for socket filename — do NOT leak sessionKey to /tmp.
     const socketToken = crypto.randomBytes(16).toString('hex');
     this.sockPath = path.join(os.tmpdir(), `polygram-${socketToken}.sock`);
@@ -472,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
@@ -598,6 +636,28 @@ class CliProcess extends Process {
       'Internal tool calls (Bash, Edit, Write, Read, etc.) are fine to use',
       'as normal — only the FINAL user-visible message needs to go through',
       'the reply tool.',
+      '',
+      '### Sending FILES (tracks, images, docs) to the user',
+      '',
+      'The `mcp__polygram-bridge__reply` tool takes an optional `files` array of',
+      'absolute paths. This is the ONLY way to send a file. Do NOT use Bash,',
+      'curl, the Telegram Bot API, or polygram-ipc to send files — those fail.',
+      '',
+      ...(this.attachmentStagingDir ? [
+        `To send a file: COPY it into the staging dir \`${this.attachmentStagingDir}\`,`,
+        'then call reply with its absolute path, e.g.:',
+        `  reply(chat_id="<id>", text="Here's the track", files=["${this.attachmentStagingDir}/track.flac"])`,
+        'polygram auto-deletes staged files after the turn — you do not need to clean up.',
+        'You may also send directly from the agent workspace (cwd); other paths are rejected.',
+      ] : [
+        'Copy the file somewhere under your workspace (cwd) and pass its absolute',
+        'path in `files`. Paths outside the workspace are rejected for safety.',
+      ]),
+      '',
+      `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
@@ -942,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 });
@@ -1203,6 +1264,27 @@ class CliProcess extends Process {
     pending.resolve(result);
     this.emit('result', { subtype: 'success' }, { streamText: text });
     this.emit('idle');
+    // File-send staging auto-purge (your choice — no "claude must delete").
+    // Once the LAST turn settles, wipe the staging dir's contents so files
+    // claude copied in to send don't accumulate on disk across turns. Only
+    // when fully idle, so a file staged for a still-pending concurrent turn
+    // isn't yanked mid-send.
+    if (this.pendingTurns.size === 0) this._purgeStagingDir();
+  }
+
+  /**
+   * Empty the per-session file-send staging dir (keep the dir itself).
+   * Best-effort; never throws. Called when the session goes idle and on kill.
+   */
+  _purgeStagingDir() {
+    if (!this.attachmentStagingDir) return;
+    let entries;
+    try { entries = fs.readdirSync(this.attachmentStagingDir); }
+    catch { return; }
+    for (const name of entries) {
+      try { fs.rmSync(path.join(this.attachmentStagingDir, name), { recursive: true, force: true }); }
+      catch { /* best-effort */ }
+    }
   }
 
   // ─── public Process API ──────────────────────────────────────────
@@ -1861,6 +1943,12 @@ class CliProcess extends Process {
     if (this.botName && this.claudeSessionId) {
       try { removeHookFiles({ botName: this.botName, sessionId: this.claudeSessionId }); } catch {}
     }
+    // File-send staging: remove the whole per-session dir on kill (purge only
+    // empties it between turns; kill is end-of-life so drop it entirely).
+    if (this.attachmentStagingDir) {
+      try { fs.rmSync(this.attachmentStagingDir, { recursive: true, force: true }); } catch {}
+      this.attachmentStagingDir = null;
+    }
 
     this.emit('close', 0);
   }

package/lib/telegram/api.js

@@ -28,6 +28,7 @@ const {
   getRetryAfterMs,
 } = require('./format');
 const { isSafeToRetry, redactBotToken } = require('../error/net');
+const { coerceFileParams } = require('./input-file');
 
 // Topic deletion race: a user can delete a forum topic while a turn is in
 // flight, turning a valid `message_thread_id` into a 404. Telegram's error
@@ -112,6 +113,14 @@ async function send({ bot, method, params, db = null, meta = {}, logger = consol
   const chatId = params.chat_id != null ? String(params.chat_id) : null;
   const threadId = params.message_thread_id != null ? String(params.message_thread_id) : null;
 
+  // File-upload bug fix (2026-05-31): coerce a `{ source: '/abs/path' }`
+  // file param into a grammy InputFile so local-file uploads actually work.
+  // grammy doesn't recognize the bare envelope → it failed every send with
+  // "Wrong port number". Single choke point: fixes channels reply(files)
+  // AND the IPC send path at once. No-op for non-file methods / file_id /
+  // URL strings / existing InputFile instances.
+  coerceFileParams(method, params);
+
   // 0.7.4: empty-text short-circuit. Pre-fix, an empty params.text on
   // sendMessage/editMessageText reached Telegram and 400'd with
   // "message text is empty"; the row was marked failed and propagated

package/lib/telegram/input-file.js

@@ -0,0 +1,76 @@
+/**
+ * input-file — coerce file-upload params into grammy InputFile instances.
+ *
+ * The bug (2026-05-31, shumorobot Music): callers passed a Telegraf-style
+ * `{ source: '/abs/path' }` envelope as the file param (document/photo/…).
+ * grammy 1.x does NOT recognize that shape — it's not an InputFile, so
+ * grammy serializes it as a plain object and Telegram tries to read it as
+ * a URL/file_id, failing with "invalid file HTTP URL: Wrong port number".
+ * Result: file-send NEVER worked (channels reply(files) AND the IPC path
+ * both produced this exact error). The existing dispatcher test used a fake
+ * `send` and only asserted the METHOD, so it couldn't catch the bad shape.
+ *
+ * grammy uploads a local file only when the param is `new InputFile(path)`.
+ * This helper normalizes, at the single send choke point (tg()), the
+ * `{ source: <abs path> }` envelope → `new InputFile(path)`, leaving every
+ * other shape untouched:
+ *   - string file_id / https URL  → pass through (Telegram resolves)
+ *   - existing InputFile instance → pass through (already correct)
+ *   - Buffer / stream            → pass through (grammy handles)
+ *
+ * Only the explicit `{ source: string }` envelope is transformed — bare
+ * path strings are intentionally NOT coerced (a Telegram file_id is also a
+ * bare string; coercing would break sends-by-id).
+ */
+
+'use strict';
+
+const { InputFile } = require('grammy');
+
+// method → the params field that carries the file.
+const FILE_FIELD_BY_METHOD = {
+  sendPhoto: 'photo',
+  sendDocument: 'document',
+  sendAudio: 'audio',
+  sendVideo: 'video',
+  sendAnimation: 'animation',
+  sendVoice: 'voice',
+  sendVideoNote: 'video_note',
+};
+
+/**
+ * Return a grammy-uploadable value for a single file param, or the original
+ * value unchanged if it's not the `{ source }` envelope we coerce.
+ */
+function coerceFileValue(val) {
+  if (val && typeof val === 'object' && !(val instanceof InputFile)
+      && typeof val.source === 'string' && val.source.length > 0) {
+    // { source: '/abs/path' } | { source: 'https://…', filename } → InputFile
+    return new InputFile(val.source, val.filename);
+  }
+  return val;
+}
+
+/**
+ * Mutate `params` in place so its file field (if any) is grammy-uploadable.
+ * No-op for non-file methods and for params with no file field set.
+ *
+ * @param {string} method
+ * @param {object} params
+ * @returns {object} the same params object (for chaining)
+ */
+function coerceFileParams(method, params) {
+  if (!params || typeof params !== 'object') return params;
+  const field = FILE_FIELD_BY_METHOD[method];
+  if (!field) return params;
+  if (params[field] != null) {
+    params[field] = coerceFileValue(params[field]);
+  }
+  return params;
+}
+
+module.exports = {
+  coerceFileParams,
+  coerceFileValue,
+  FILE_FIELD_BY_METHOD,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polygram",
-  "version": "0.12.0-rc.6",
+  "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 });
@@ -1672,9 +1688,23 @@ function shouldHandle(msg, chatConfig, botUsername) {
 }
 
 function createBot(token) {
+  // Optional self-hosted Telegram Bot API server. When config.bot.apiRoot is
+  // set (e.g. "http://localhost:8081" from a local `telegram-bot-api`
+  // process), grammy routes all Bot API calls there instead of
+  // api.telegram.org — which lifts file send/receive from cloud's 50 MB-out /
+  // 20 MB-in to 2 GB both ways. Omit it (default) → cloud Telegram, unchanged.
+  // The local server is a separate companion daemon; this is just the knob
+  // that points polygram at it. See docs/0.12.0-file-send.md.
+  const apiRoot = config.bot?.apiRoot;
   const bot = new Bot(token, {
-    client: { timeoutSeconds: 60 },
+    client: {
+      timeoutSeconds: 60,
+      ...(apiRoot ? { apiRoot } : {}),
+    },
   });
+  if (apiRoot) {
+    console.log(`[polygram] using local Telegram Bot API server: ${apiRoot} (2GB file limit)`);
+  }
   let botUsername = '';
   // Cached once @botUsername is known — was recompiling per inbound msg.
   let mentionRe = null;