polygram 0.4.2 → 0.4.6

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://anthropic.com/claude-code/plugin.schema.json",
   "name": "polygram",
-  "version": "0.4.2",
+  "version": "0.4.6",
   "description": "Telegram integration for Claude Code that preserves the OpenClaw per-chat session model. Migration target for OpenClaw users. Multi-bot, multi-chat, per-topic isolation; SQLite transcripts; inline-keyboard approvals. Bundles /polygram:status|logs|pair-code|approvals admin commands and a history skill.",
   "keywords": [
     "telegram",

package/lib/process-manager.js

@@ -281,9 +281,17 @@ class ProcessManager {
       entry.pending = { resolve, reject };
       entry.streamText = '';
 
+      // Timer handles kept in closure vars (not entry.pending), because
+      // the result-event handler in rl.on('line') sets entry.pending = null
+      // BEFORE calling the wrapped resolve. Reading from entry.pending
+      // after null-out gave undefined → clearTimeout was never called →
+      // the default 30-min maxTurnMs timer stayed armed and held Node's
+      // event loop open, hanging the test runner on CI.
+      let idleTimer = null;
+      let maxTimer = null;
       const clearTimers = () => {
-        if (entry.pending?.idleTimer) clearTimeout(entry.pending.idleTimer);
-        if (entry.pending?.maxTimer) clearTimeout(entry.pending.maxTimer);
+        if (idleTimer) { clearTimeout(idleTimer); idleTimer = null; }
+        if (maxTimer) { clearTimeout(maxTimer); maxTimer = null; }
       };
 
       // Timer fire path. New in 0.3.9: after rejecting, SIGTERM the
@@ -308,19 +316,25 @@ class ProcessManager {
       // Idle timeout: counts N seconds of SILENCE from Claude. Reset on
       // every assistant event so long productive turns (multi-tool
       // reasoning) don't falsely trip.
-      // .unref() so these timers don't hold the node event loop open in
-      // tests or when the parent process wants to exit. Real-world polygram
-      // stays alive via grammy's poll loop + stdin/stdout pipes; the timers
-      // don't need to keep it alive on their own.
+      // Note on .unref(): an earlier revision called unref() on both
+      // timers to avoid holding the node event loop open in tests. That
+      // broke Node's test runner on CI ("Promise resolution is still
+      // pending but the event loop has already resolved") — the runner
+      // detects unref'd timers as a drained loop and cancels awaiters
+      // before the timer can fire. Production polygram stays alive via
+      // grammy's poll loop + child process pipes; we don't need unref.
       const armIdle = () => setTimeout(
         () => fireTimeout(`Timeout: ${timeoutMs / 1000}s idle with no Claude activity`),
         timeoutMs,
-      ).unref();
-      entry.pending.idleTimer = armIdle();
+      );
+      idleTimer = armIdle();
+      entry.pending.idleTimer = idleTimer;
       entry.pending.resetIdleTimer = () => {
-        if (!entry.pending) return;
-        clearTimeout(entry.pending.idleTimer);
-        entry.pending.idleTimer = armIdle();
+        if (idleTimer) clearTimeout(idleTimer);
+        if (entry.pending) {
+          idleTimer = armIdle();
+          entry.pending.idleTimer = idleTimer;
+        }
       };
 
       // Wall-clock ceiling: fires at maxTurnMs regardless of activity.
@@ -328,13 +342,14 @@ class ProcessManager {
       // idle timer alive) but never produce a result. OpenClaw's only
       // timer was wall-clock; polygram's 0.3.5 change replaced it with
       // idle-reset, creating a gap this restores as a last-resort.
-      entry.pending.maxTimer = setTimeout(
+      maxTimer = setTimeout(
         () => fireTimeout(`Turn exceeded ${maxTurnMs / 1000}s wall-clock ceiling`),
         maxTurnMs,
-      ).unref();
+      );
+      entry.pending.maxTimer = maxTimer;
 
       // Legacy alias: some callers / tests refer to entry.pending.timer.
-      entry.pending.timer = entry.pending.idleTimer;
+      entry.pending.timer = idleTimer;
 
       const wrappedResolve = entry.pending.resolve;
       const wrappedReject = entry.pending.reject;
@@ -351,6 +366,7 @@ class ProcessManager {
         entry.pending = null;
         entry.inFlight = false;
         reject(err);
+        return;
       }
     });
   }

package/lib/telegram.js

@@ -76,7 +76,18 @@ function nextPendingId() {
   return -(v + 1);
 }
 
-const METHODS_WITHOUT_MSG = new Set(['setMessageReaction', 'deleteMessage', 'editMessageReplyMarkup']);
+// Methods we don't insert a `messages` row for. Reactions/deletes/markup
+// edits never produced a chat message in the first place. editMessageText
+// DOES modify a message, but creating a new DB row per edit collides with
+// the UNIQUE(chat_id, msg_id) constraint on the 2nd edit — the stream
+// edits one bubble N times in a single turn. The initial sendMessage
+// already persisted the row; edits just update the live bubble.
+const METHODS_WITHOUT_MSG = new Set([
+  'setMessageReaction',
+  'deleteMessage',
+  'editMessageReplyMarkup',
+  'editMessageText',
+]);
 
 // Derive the row's `text` column. sendSticker has no text/caption, so we
 // synthesize `[sticker:<name>]` (or file_id as fallback) — without this the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polygram",
-  "version": "0.4.2",
+  "version": "0.4.6",
   "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

@@ -555,6 +555,18 @@ async function enqueue(sessionKey, chatId, msg, bot) {
   if (!processing[sessionKey]) processQueue(sessionKey);
 }
 
+// Sessions the operator just /stop'd (or natural-language "стоп"). Entries
+// suppress the generic "Sorry, I couldn't process" reply below — the abort
+// handler already sent its own "Остановлено." ack, and the subsequent
+// handleMessage rejection from the killed subprocess would otherwise
+// spam a second contradictory message. Cleared on first use; long-lived
+// only if the abort kills something that never finishes rejecting.
+const abortedSessions = new Set();
+
+function markSessionAborted(sessionKey) {
+  abortedSessions.add(sessionKey);
+}
+
 async function processQueue(sessionKey) {
   processing[sessionKey] = true;
   while (queues[sessionKey]?.length > 0) {
@@ -562,6 +574,8 @@ async function processQueue(sessionKey) {
     try {
       await handleMessage(sessionKey, chatId, msg, bot);
     } catch (err) {
+      const wasAborted = abortedSessions.has(sessionKey);
+      if (wasAborted) abortedSessions.delete(sessionKey);
       // Raw err.message can carry host paths, DB columns, internal state.
       // Surface a generic message to the user; log the detail to events
       // so operators can still debug.
@@ -571,15 +585,18 @@ async function processQueue(sessionKey) {
         msg_id: msg?.message_id,
         error: err.message?.slice(0, 500),
         stack: err.stack?.split('\n').slice(0, 5).join('\n'),
+        aborted: wasAborted || undefined,
       }), 'log handler-error');
-      try {
-        await tg(bot, 'sendMessage', {
-          chat_id: chatId,
-          text: `Sorry, I couldn't process that message. The operator has been notified.`,
-          reply_parameters: { message_id: msg.message_id },
-        }, { source: 'error-reply', botName: BOT_NAME });
-      } catch (replyErr) {
-        console.error(`[${sessionKey}] failed to send error reply: ${replyErr.message}`);
+      if (!wasAborted) {
+        try {
+          await tg(bot, 'sendMessage', {
+            chat_id: chatId,
+            text: `Sorry, I couldn't process that message. The operator has been notified.`,
+            reply_parameters: { message_id: msg.message_id },
+          }, { source: 'error-reply', botName: BOT_NAME });
+        } catch (replyErr) {
+          console.error(`[${sessionKey}] failed to send error reply: ${replyErr.message}`);
+        }
       }
     }
   }
@@ -1150,11 +1167,21 @@ async function handleMessage(sessionKey, chatId, msg, bot) {
     }, outMetaBase),
     edit: async (messageId, text) => {
       try {
-        return await bot.api.editMessageText(chatId, messageId, text);
+        // Route edits through tg() so applyFormatting runs (MarkdownV2
+        // + escape). Going direct to bot.api.editMessageText would
+        // skip formatting and leave every edit rendering literal
+        // **bold** / `code` in the bubble — which was the visible bug
+        // in 0.4.2 where the initial send was formatted and every
+        // subsequent edit overwrote it with plain text.
+        return await tg(bot, 'editMessageText', {
+          chat_id: chatId,
+          message_id: messageId,
+          text,
+        }, { source: 'bot-reply-stream-edit', botName: BOT_NAME });
       } 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.
+        // Stream-edit failures would otherwise be invisible — edits
+        // don't insert a messages row by default (tg() does, but we
+        // want the failure path specifically surfaced). Log to events.
         dbWrite(() => db.logEvent('telegram-edit-failed', {
           chat_id: chatId, msg_id: messageId,
           api_error: err.message?.slice(0, 200),
@@ -1428,15 +1455,35 @@ function createBot(token) {
       const sessionKey = getSessionKey(chatId, threadId, chatConfig);
       const hadActive = pm.has(sessionKey) && !!pm.get(sessionKey)?.inFlight;
       const dropped = drainQueuesForChat(chatId);
+      // Mark BEFORE killing: the 'close' event fires almost immediately
+      // after SIGTERM, and processQueue's catch needs to see the flag to
+      // skip the generic error-reply. If we marked after, there'd be a
+      // race where the error-reply slips through.
+      if (hadActive) markSessionAborted(sessionKey);
       await pm.killChat(chatId).catch(() => {});
       dbWrite(() => db.logEvent('abort-requested', {
         chat_id: chatId, user_id: msg.from?.id || null,
         had_active: hadActive, queued_dropped: dropped,
         trigger: cleanText.slice(0, 40),
       }), 'log abort-requested');
+      // Reply in the same language the user aborted in. Cyrillic-detection
+      // is crude but reliable for ru/en (the only two cue sets we ship).
+      const lang = /[а-яё]/i.test(cleanText) ? 'ru' : 'en';
+      const strs = {
+        en: {
+          stopped: 'Stopped.',
+          withDropped: (n) => `Stopped. Cleared ${n} queued message${n === 1 ? '' : 's'}.`,
+          nothing: 'Nothing to stop.',
+        },
+        ru: {
+          stopped: 'Остановлено.',
+          withDropped: (n) => `Остановлено. Очередь очищена (${n}).`,
+          nothing: 'Нечего останавливать.',
+        },
+      }[lang];
       const reply = hadActive || dropped
-        ? (dropped ? `Остановлено. Очередь очищена (${dropped}).` : 'Остановлено.')
-        : 'Нечего останавливать.';
+        ? (dropped ? strs.withDropped(dropped) : strs.stopped)
+        : strs.nothing;
       try {
         await tg(bot, 'sendMessage', {
           chat_id: chatId, text: reply,