polygram 0.3.5 → 0.4.0

package/polygram.js

@@ -32,6 +32,9 @@ const { parseBotArg, parseDbArg, filterConfigToBot } = require('./lib/config-sco
 const { createStore: createPairingsStore, parseTtl: parsePairingTtl } = require('./lib/pairings');
 const { transcribe: transcribeVoice, isVoiceAttachment } = require('./lib/voice');
 const { createStreamer } = require('./lib/stream-reply');
+const { isAbortRequest } = require('./lib/abort-detector');
+const { startTyping } = require('./lib/typing-indicator');
+const { createReactionManager, classifyToolName } = require('./lib/status-reactions');
 const {
   createStore: createApprovalsStore,
   matchesAnyPattern: matchesApprovalPattern,
@@ -79,6 +82,7 @@ let ipcCloser = null;
 let BOT_NAME = null;  // string, frozen after boot
 let bot = null;       // grammy Bot for BOT_NAME
 let streamers = new Map();  // sessionKey -> active Streamer (while turn is in flight)
+let reactors = new Map();   // sessionKey -> active ReactionManager (while turn is in flight)
 
 // Allowlist of env var names passed through to spawned Claude processes.
 // Anything not listed here is dropped to prevent leaked secrets/ssh agents
@@ -515,7 +519,12 @@ async function sendToProcess(sessionKey, prompt) {
   const chatId = getChatIdFromKey(sessionKey);
   const chatConfig = config.chats[chatId];
   const timeoutMs = (chatConfig.timeout || config.defaults.timeout) * 1000;
-  return pm.send(sessionKey, prompt, { timeoutMs });
+  // Wall-clock ceiling (seconds). Overridable per-chat via chatConfig.maxTurn
+  // or globally via config.defaults.maxTurn. 30 min default is generous for
+  // long audits; stuck API calls rarely run that long without firing the
+  // idle timer first. Unit: seconds → milliseconds.
+  const maxTurnMs = (chatConfig.maxTurn || config.defaults?.maxTurn || 1800) * 1000;
+  return pm.send(sessionKey, prompt, { timeoutMs, maxTurnMs });
 }
 
 // ─── Message queue (per-chat) ───────────────────────────────────────
@@ -572,15 +581,10 @@ async function processQueue(sessionKey) {
 
 const drainQueuesForChat = (chatId) => drainQueuesForChatImpl(queues, chatId);
 
-// ─── Typing indicator ───────────────────────────────────────────────
-
-function startTyping(bot, chatId, threadId) {
-  const opts = threadId ? { message_thread_id: threadId } : {};
-  const send = () => bot.api.sendChatAction(chatId, 'typing', opts).catch(() => {});
-  send();
-  const interval = setInterval(send, 4000);
-  return () => clearInterval(interval);
-}
+// Typing indicator is imported from lib/typing-indicator — it adds a
+// per-chat circuit breaker with exponential backoff so a chat that
+// permanently 401s (bot blocked, chat deleted) doesn't have us
+// hammering sendChatAction every 4s for the full turn duration.
 
 // ─── Response parsing (stickers, reactions) ─────────────────────────
 
@@ -736,7 +740,7 @@ async function handleApprovalRequest(req) {
         chat_id: apprCfg.adminChatId,
         text: approvalCardText(row),
         reply_markup: buildApprovalKeyboard(row.id, row.callback_token),
-      }, { source: 'approval-request', botName: BOT_NAME });
+      }, { source: 'approval-request', botName: BOT_NAME, plainText: true });
       if (sent?.message_id) {
         approvals.setApproverMsgId(row.id, sent.message_id);
       }
@@ -1106,46 +1110,77 @@ async function handleMessage(sessionKey, chatId, msg, bot) {
   });
 
   const prompt = formatPrompt(msg, sessionCtx, downloaded);
-  const stopTyping = startTyping(bot, chatId, threadId);
+  const stopTyping = startTyping({
+    bot, chatId, threadId,
+    logger: { error: (m) => console.error(`[${label}] ${m}`) },
+    onEvent: (e) => dbWrite(() => db.logEvent(e.kind, {
+      bot: BOT_NAME, chat_id: e.chat_id, ...(e.detail || {}),
+    }), `log ${e.kind}`),
+  });
 
   const botCfg = config.bot || {};
-  const streamEnabled = botCfg.streamReplies === true;
   const outMetaBase = {
-    source: streamEnabled ? 'bot-reply-stream' : 'bot-reply',
+    source: 'bot-reply-stream',
     botName: BOT_NAME,
     model: chatConfig.model,
     effort: chatConfig.effort,
   };
 
-  let streamer = null;
-  if (streamEnabled) {
-    streamer = createStreamer({
-      send: async (text) => tg(bot, 'sendMessage', {
-        chat_id: chatId, text,
-        reply_parameters: { message_id: msg.message_id },
-        ...(threadId && { message_thread_id: threadId }),
-      }, outMetaBase),
-      edit: async (messageId, text) => {
-        try {
-          return await bot.api.editMessageText(chatId, messageId, text);
-        } catch (err) {
-          // Stream-edit failures would otherwise be invisible — edits bypass
-          // tg() so there's no messages row reflecting the attempt. Log to
-          // events so stuck streams leave a forensic trail.
-          dbWrite(() => db.logEvent('telegram-edit-failed', {
-            chat_id: chatId, msg_id: messageId,
-            api_error: err.message?.slice(0, 200),
-            bot: BOT_NAME,
-          }), 'log telegram-edit-failed');
-          throw err;
-        }
-      },
-      minChars: botCfg.streamMinChars,
-      throttleMs: botCfg.streamThrottleMs,
-      logger: { error: (m) => console.error(`[${label}] ${m}`) },
-    });
-    streamers.set(sessionKey, streamer);
-  }
+  // Streaming is unconditional as of 0.4.0 — matches OpenClaw's model and
+  // eliminates the "stuck at 15min typing" complaint from the non-streaming
+  // code path. For short responses the streamer stays idle and we fall
+  // through to the normal send path via finalize() returning streamed=false.
+  const streamer = createStreamer({
+    send: async (text) => tg(bot, 'sendMessage', {
+      chat_id: chatId, text,
+      // allow_sending_without_reply: long-running turns give the user
+      // plenty of time to delete their original message. Without this
+      // flag, Telegram rejects the reply with MESSAGE_NOT_FOUND and the
+      // whole streamed answer is lost. With it, the reply simply lands
+      // as a standalone message.
+      reply_parameters: { message_id: msg.message_id, allow_sending_without_reply: true },
+      ...(threadId && { message_thread_id: threadId }),
+    }, outMetaBase),
+    edit: async (messageId, text) => {
+      try {
+        return await bot.api.editMessageText(chatId, messageId, text);
+      } catch (err) {
+        // Stream-edit failures would otherwise be invisible — edits bypass
+        // tg() so there's no messages row reflecting the attempt. Log to
+        // events so stuck streams leave a forensic trail.
+        dbWrite(() => db.logEvent('telegram-edit-failed', {
+          chat_id: chatId, msg_id: messageId,
+          api_error: err.message?.slice(0, 200),
+          bot: BOT_NAME,
+        }), 'log telegram-edit-failed');
+        throw err;
+      }
+    },
+    minChars: botCfg.streamMinChars,
+    throttleMs: botCfg.streamThrottleMs,
+    logger: { error: (m) => console.error(`[${label}] ${m}`) },
+  });
+  streamers.set(sessionKey, streamer);
+
+  // Status reactions on the user's message: 👀 queued → 🤔 thinking →
+  // 👨‍💻 coding / ⚡ web / 🔥 tool → 👍 done / 🤯 error. Silent (no
+  // notifications), updates in place, one emoji per message. Uses
+  // setMessageReaction which skips the DB row (the tg() wrapper
+  // short-circuits that method), so no transcript spam.
+  const reactor = createReactionManager({
+    apply: async (emoji) => {
+      const params = {
+        chat_id: chatId,
+        message_id: msg.message_id,
+        reaction: emoji ? [{ type: 'emoji', emoji }] : [],
+      };
+      await tg(bot, 'setMessageReaction', params,
+        { source: 'status-reaction', botName: BOT_NAME });
+    },
+    logError: (m) => console.error(`[${label}] ${m}`),
+  });
+  reactors.set(sessionKey, reactor);
+  reactor.setState('THINKING');
 
   try {
     const result = await sendToProcess(sessionKey, prompt);
@@ -1155,7 +1190,10 @@ async function handleMessage(sessionKey, chatId, msg, bot) {
 
     if (result.error) {
       console.error(`[${label}] Error (${elapsed}s):`, result.error);
+      reactor.setState('ERROR');
       if (!result.text) return;
+    } else {
+      reactor.setState('DONE');
     }
 
     if (!result.text || result.text === 'NO_REPLY') return;
@@ -1165,7 +1203,7 @@ async function handleMessage(sessionKey, chatId, msg, bot) {
 
     // Streamed text path: finalise the live-edit and, if the full response
     // overflows Telegram's 4096 cap, send remainder as follow-up chunks.
-    if (streamer && parsed.text) {
+    if (parsed.text) {
       const fin = await streamer.finalize(parsed.text);
       if (fin.streamed) {
         if (parsed.text.length > TG_MAX_LEN) {
@@ -1221,14 +1259,24 @@ async function handleMessage(sessionKey, chatId, msg, bot) {
 
     console.log(`[${label}] ${elapsed}s | ${result.text.length} chars | ${chatConfig.model}/${chatConfig.effort} | $${result.cost?.toFixed(4) || '?'}`);
   } catch (err) {
-    if (streamer) {
-      // Generic suffix — err.message can leak internal paths/state.
-      await streamer.finalize('', { errorSuffix: 'stream interrupted' }).catch(() => {});
+    // Generic suffix — err.message can leak internal paths/state.
+    await streamer.finalize('', { errorSuffix: 'stream interrupted' }).catch(() => {});
+    // Signal the failure to the user's message reaction. Timeout gets its
+    // own face; anything else is generic error.
+    if (/wall-clock ceiling|idle with no Claude activity/i.test(err?.message || '')) {
+      reactor.setState('TIMEOUT');
+    } else {
+      reactor.setState('ERROR');
     }
     throw err;
   } finally {
     stopTyping();
-    if (streamer) streamers.delete(sessionKey);
+    streamers.delete(sessionKey);
+    // Give the reactor a beat to flush the terminal state (DONE/ERROR/TIMEOUT
+    // bypass throttle so this is instant in practice; the stop() below
+    // guards against any late transition leaking after the turn ends).
+    reactor.stop();
+    reactors.delete(sessionKey);
   }
 }
 
@@ -1271,6 +1319,87 @@ function createBot(token) {
   // not another bot's problem.
   const knownChat = (chatId) => !!config.chats[chatId];
 
+  // Claim a pair code from an unconfigured private chat and persist a new
+  // chat entry so subsequent messages go through the normal flow. Replies
+  // to the user on both success and failure. Returns the new chatConfig on
+  // success, null on any failure.
+  //
+  // The new chat inherits cwd/agent from bot-level pairedChatDefaults if
+  // present, otherwise from the first existing chat the bot owns — on the
+  // reasonable assumption that paired DMs should behave like other DMs for
+  // this bot. Operator can override by setting config.bots.<bot>.pairedChatDefaults.
+  async function onboardPairedChat(ctx, code) {
+    const chatId = ctx.chat.id.toString();
+    const userId = ctx.message.from?.id;
+    const send = (text) => bot.api.sendMessage(chatId, text).catch(() => {});
+
+    if (!userId) {
+      await send('No user id on request.');
+      return null;
+    }
+
+    const res = pairings.claimCode({
+      code, claimer_user_id: userId,
+      chat_id: chatId, bot_name: BOT_NAME,
+    });
+    dbWrite(() => db.logEvent('pair-claim-attempt', {
+      bot: BOT_NAME, user_id: userId, chat_id: chatId,
+      ok: res.ok, reason: res.reason, via: 'auto-onboard',
+    }), 'log pair-claim-attempt');
+
+    if (!res.ok) {
+      const reply = res.reason === 'rate-limited'
+        ? 'Too many attempts. Try again later.'
+        : 'Invalid or expired code.';
+      await send(reply);
+      return null;
+    }
+
+    const paired = config.bot?.pairedChatDefaults || {};
+    const globals = config.defaults || {};
+    const firstChat = Object.values(config.chats)[0] || {};
+    const chatName = paired.name
+      || (ctx.chat.username && `@${ctx.chat.username}`)
+      || ctx.chat.first_name
+      || `User ${userId}`;
+
+    const cwd = paired.cwd || firstChat.cwd;
+    if (!cwd) {
+      dbWrite(() => db.logEvent('auto-onboard-failed', {
+        bot: BOT_NAME, chat_id: chatId, user_id: userId,
+        reason: 'no-cwd',
+      }), 'log auto-onboard-failed');
+      await send('Paired, but no working directory is configured. Ask the operator to set pairedChatDefaults.cwd.');
+      return null;
+    }
+
+    const newChat = {
+      name: chatName,
+      bot: BOT_NAME,
+      agent: paired.agent || firstChat.agent,
+      model: paired.model || globals.model || 'sonnet',
+      effort: paired.effort || globals.effort || 'medium',
+      cwd,
+      timeout: paired.timeout || globals.timeout || 600,
+    };
+    if (paired.requireMention != null) newChat.requireMention = paired.requireMention;
+
+    config.chats[chatId] = newChat;
+    try { saveConfig(); }
+    catch (err) {
+      console.error(`[${BOT_NAME}] saveConfig on auto-onboard failed: ${err.message}`);
+    }
+    dbWrite(() => db.logEvent('chat-auto-created', {
+      bot: BOT_NAME, chat_id: chatId, user_id: userId,
+      source: 'pair-claim', model: newChat.model, effort: newChat.effort,
+    }), 'log chat-auto-created');
+
+    const chatLabel = res.chat_id ? `chat ${res.chat_id}` : `every chat ${BOT_NAME} is in`;
+    const suffix = res.note ? `\n(${res.note})` : '';
+    await send(`Paired. You can use me in ${chatLabel}.${suffix}`);
+    return newChat;
+  }
+
   bot.on('message', async (ctx) => {
     if (!isWellFormedMessage(ctx.message)) {
       dbWrite(() => db.logEvent('malformed-update', {
@@ -1281,7 +1410,25 @@ function createBot(token) {
       return;
     }
     const chatId = ctx.chat.id.toString();
-    const chatConfig = config.chats[chatId];
+    let chatConfig = config.chats[chatId];
+
+    // Auto-onboarding: /pair <CODE> from an unconfigured private chat.
+    // Without this, the !chatConfig drop below would silently eat pair
+    // claims from DMs the operator hasn't pre-listed — defeating the
+    // whole point of pair codes (which exist to grant access without
+    // pre-configuration). Group chats are not auto-onboarded: they must
+    // still be added to config.json by the operator, because adding a
+    // group can affect multiple users.
+    if (!chatConfig && ctx.chat.type === 'private') {
+      const probe = (ctx.message.text || '').trim();
+      const pairMatch = /^\/pair(?:@\S+)?\s+(\S+)\s*$/.exec(probe);
+      if (pairMatch) {
+        chatConfig = await onboardPairedChat(ctx, pairMatch[1]);
+        if (!chatConfig) return;
+        recordInbound(ctx.message);
+        return;
+      }
+    }
     if (!chatConfig) return;
 
     // Record every inbound msg, even unaddressed ones — needed for reply-to
@@ -1291,6 +1438,36 @@ function createBot(token) {
     const rawText = ctx.message.text || '';
     const cleanText = mentionRe ? rawText.replace(mentionRe, '').trim() : rawText.trim();
 
+    // Abort: skip the queue entirely. Matches bilingual natural-language
+    // cues ("stop" / "стоп" / "cancel" / "отмена" / …) and explicit
+    // slash commands (/stop, /abort, /cancel). Kills the active Claude
+    // subprocess and drains queued messages for this chat. Replies so
+    // the user sees the bot heard them — silent abort is worse than
+    // acknowledged abort.
+    if (isAbortRequest(cleanText)) {
+      const threadId = ctx.message.message_thread_id?.toString();
+      const sessionKey = getSessionKey(chatId, threadId, chatConfig);
+      const hadActive = pm.has(sessionKey) && !!pm.get(sessionKey)?.inFlight;
+      const dropped = drainQueuesForChat(chatId);
+      await pm.killChat(chatId).catch(() => {});
+      dbWrite(() => db.logEvent('abort-requested', {
+        chat_id: chatId, user_id: ctx.message.from?.id || null,
+        had_active: hadActive, queued_dropped: dropped,
+        trigger: cleanText.slice(0, 40),
+      }), 'log abort-requested');
+      const reply = hadActive || dropped
+        ? (dropped ? `Остановлено. Очередь очищена (${dropped}).` : 'Остановлено.')
+        : 'Нечего останавливать.';
+      try {
+        await tg(bot, 'sendMessage', {
+          chat_id: chatId, text: reply,
+          reply_parameters: { message_id: ctx.message.message_id, allow_sending_without_reply: true },
+          ...(threadId && { message_thread_id: threadId }),
+        }, { source: 'abort-ack', botName: BOT_NAME });
+      } catch {}
+      return;
+    }
+
     const botAllowsCommands = !!config.bot?.allowConfigCommands;
     const isAdminCmd = botAllowsCommands && ADMIN_CMD_RE.test(cleanText);
     const isPairClaim = PAIR_CLAIM_RE.test(cleanText);
@@ -1409,7 +1586,21 @@ async function pollBot(bot) {
 
   await bot.api.deleteWebhook();
 
+  // Restore polling offset from DB so a restart doesn't re-process the
+  // backlog Telegram has accumulated while we were down. Grammy's in-memory
+  // offset resets to 0 each boot, which makes getUpdates return every
+  // un-confirmed update since the last ack — for an overnight outage that
+  // can mean replaying dozens of stale messages.
   let offset = 0;
+  try {
+    const saved = db?.getPollingOffset?.(BOT_NAME);
+    if (saved && saved > 0) {
+      offset = saved + 1;
+      console.log(`[${BOT_NAME}] resuming polling from update_id ${saved}`);
+    }
+  } catch (err) {
+    console.error(`[${BOT_NAME}] getPollingOffset failed: ${err.message}`);
+  }
   let running = true;
   bot._lastPollTs = Date.now();
 
@@ -1446,6 +1637,13 @@ async function pollBot(bot) {
           console.error(`[${BOT_NAME}] Handler error:`, err.message);
         }
       }
+      // Persist offset after batch dispatch so a crash mid-batch only risks
+      // re-processing the unacked updates. We write only on non-empty batches
+      // to avoid churning the row on every 25s idle poll.
+      if (updates.length > 0) {
+        dbWrite(() => db.savePollingOffset(BOT_NAME, updates[updates.length - 1].update_id),
+          'save polling offset');
+      }
       // No sleep on the success path: long-poll already blocks up to 25s
       // when idle. Sleeping here would add latency with no gain.
     } catch (err) {
@@ -1567,6 +1765,10 @@ async function main() {
       const s = streamers.get(sessionKey);
       if (s) s.onChunk(partial).catch(() => {});
     },
+    onToolUse: (sessionKey, toolName) => {
+      const r = reactors.get(sessionKey);
+      if (r) r.setState(classifyToolName(toolName));
+    },
   });
 
   console.log(`polygram (LRU cap=${cap}, SQLite source of truth)`);