polygram 0.7.1 → 0.7.3

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://anthropic.com/claude-code/plugin.schema.json",
   "name": "polygram",
-  "version": "0.7.1",
+  "version": "0.7.3",
   "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/README.md

@@ -364,7 +364,7 @@ foreign-chat clicks are rejected. Default-deny on IPC error.
 ## Development
 
 ```bash
-npm test           # 638 tests, 158 suites, node:test, no external services
+npm test           # 643 tests, 158 suites, node:test, no external services
 npm run coverage   # native test coverage (Node 22+, no devDeps)
 npm start -- --bot my-bot
 npm run split-db -- --config config.json --dry-run

package/config.example.json

@@ -15,6 +15,8 @@
       "attachmentConcurrency": 6,
       "queueWarnThreshold": 20,
       "replayWindowMs": 180000,
+      "_comment_chrome": "Opt-in to Claude Code's Chrome-extension browser-automation integration. Default false. Requires the 'Claude in Chrome' extension installed in the daemon-user's Chrome browser AND a live GUI session (Chrome must be running). See https://code.claude.com/docs/en/chrome. Per-chat override via `config.chats.<id>.chrome`.",
+      "chrome": false,
       "_comment_pairedChatDefaults": "When a user sends /pair <CODE> from a private chat that isn't in config.chats yet, polygram auto-creates a chat entry using these defaults (merged over top-level `defaults`). Leave out `cwd` at your peril — without it, auto-onboarded DMs have no working directory and pairing will fail.",
       "pairedChatDefaults": {
         "agent": "admin",

package/lib/stream-reply.js

@@ -57,6 +57,13 @@ function createStreamer({
   let lastEditTs = 0;
   let pendingEdit = null;   // timer id
   let flushPromise = null;  // ongoing edit promise (for back-pressure)
+  // 0.7.2: msg_ids of bubbles that have been superseded by
+  // forceNewMessage(). The caller (polygram.js handleMessage at
+  // end-of-turn) reads getArchived() and issues deleteMessage on
+  // each — matches OpenClaw's archivedAnswerPreviews cleanup so
+  // the user sees only the final answer's bubble, not every
+  // "thinking out loud" intermediate from a tool-heavy turn.
+  const archived = [];
 
   // LIVE-EDIT truncation only — used during streaming when latestText
   // overshoots maxLen. The trailing "..." signals to the user that more
@@ -148,6 +155,11 @@ function createStreamer({
     if (pendingEdit) { cancel(pendingEdit); pendingEdit = null; }
     // Don't await flushPromise — the caller has decided to start a new
     // message; whatever the old bubble shows is "done".
+    // 0.7.2: track the previous bubble's msgId for end-of-turn cleanup.
+    // Without this, every intermediate "thinking out loud" assistant
+    // message in a tool-heavy turn leaves a permanent bubble in the
+    // chat — the user wants only the final answer's bubble visible.
+    if (msgId != null) archived.push(msgId);
     msgId = null;
     currentText = '';
     latestText = '';
@@ -239,6 +251,11 @@ function createStreamer({
     }
   }
 
+  // 0.7.2: snapshot of bubble msgIds that forceNewMessage() superseded.
+  // Returns a copy so callers can't mutate internal state. polygram.js
+  // reads this at end-of-turn and issues deleteMessage on each.
+  function getArchived() { return archived.slice(); }
+
   return {
     onChunk,
     finalize,
@@ -246,6 +263,7 @@ function createStreamer({
     forceNewMessage,
     discard,
     archive,
+    getArchived,
     // Introspection for tests:
     get state() { return state; },
     get msgId() { return msgId; },

package/package.json

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

@@ -640,6 +640,19 @@ let pm = null; // ProcessManager, created in main()
 
 function spawnClaude(sessionKey, ctx) {
   const { chatConfig, existingSessionId, label, chatId } = ctx;
+  // 0.7.3: Claude Code's Chrome-extension integration (browser
+  // automation via the "Claude in Chrome" extension) is OPT-IN and
+  // NOT enabled by default in `claude`. Polygram lets chats turn it
+  // on via `config.chats.<id>.chrome: true` (chat-level wins) or
+  // `config.bot.chrome: true` (per-bot default). When opting in, the
+  // extension must be installed in the daemon-user's Chrome and the
+  // user must have a live Aqua session (so Chrome is running). Falls
+  // back to --no-chrome for chats that don't opt in (matches our
+  // pre-0.7.3 default — defensive against any "enabled by default"
+  // that might have been set in claude's persistent state).
+  const wantChrome = chatConfig.chrome != null
+    ? chatConfig.chrome === true
+    : config.bot?.chrome === true;
   const args = [
     '-p',
     '--input-format', 'stream-json',
@@ -648,7 +661,7 @@ function spawnClaude(sessionKey, ctx) {
     '--model', chatConfig.model || config.defaults.model,
     '--effort', chatConfig.effort || config.defaults.effort,
     '--permission-mode', 'bypassPermissions',
-    '--no-chrome',
+    wantChrome ? '--chrome' : '--no-chrome',
   ];
   if (chatConfig.agent) args.push('--agent', chatConfig.agent);
   if (existingSessionId) args.push('--resume', existingSessionId);
@@ -1664,21 +1677,34 @@ async function handleMessage(sessionKey, chatId, msg, bot) {
     ...(linkPreview === false ? { linkPreview: false } : {}),
   };
 
+  // 0.7.2: only the FIRST bubble in a turn quotes the user's message
+  // via reply_parameters. When a tool-heavy turn produces multiple
+  // assistant messages (each spawning its own bubble via
+  // forceNewMessage), subsequent bubbles shouldn't re-quote the user
+  // — the chat would show N copies of the same quoted message stacked
+  // vertically. After the first send, the flag flips and subsequent
+  // initial-sends omit reply_parameters.
+  let firstBubbleSent = false;
   // 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),
+    send: async (text) => {
+      const params = {
+        chat_id: chatId, text,
+        ...(threadId && { message_thread_id: threadId }),
+      };
+      if (!firstBubbleSent) {
+        // 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.
+        params.reply_parameters = { message_id: msg.message_id, allow_sending_without_reply: true };
+        firstBubbleSent = true;
+      }
+      return tg(bot, 'sendMessage', params, outMetaBase);
+    },
     edit: async (messageId, text) => {
       try {
         // Route edits through tg() so applyFormatting runs (MarkdownV2
@@ -1725,6 +1751,34 @@ async function handleMessage(sessionKey, chatId, msg, bot) {
   });
   // streamer is registered with this turn via pm.send's context (below)
 
+  // 0.7.2: clean up bubbles superseded by forceNewMessage() — the
+  // intermediate "thinking out loud" assistant messages that fired in
+  // a tool-heavy turn. Without this, every tool-result cycle leaves a
+  // permanent bubble in the chat (see the screenshot from the post-
+  // 0.7.1 deploy where six bubbles appeared for one logical turn).
+  // Matches OpenClaw's archivedAnswerPreviews end-of-turn cleanup.
+  // Call AFTER finalize/discard decisions so we never delete the
+  // bubble that's the final reply.
+  async function cleanupArchivedBubbles() {
+    const archived = streamer.getArchived?.() || [];
+    if (archived.length === 0) return;
+    for (const messageId of archived) {
+      try {
+        await tg(bot, 'deleteMessage', {
+          chat_id: chatId, message_id: messageId,
+        }, { source: 'bot-reply-archived-cleanup', botName: BOT_NAME });
+      } catch (err) {
+        // Non-fatal — message may be >48h old or already gone.
+        // Operator-visible only via the events table.
+        console.error(`[${label}] archived-cleanup ${messageId}: ${err.message}`);
+      }
+    }
+    logEvent('telegram-archived-cleanup', {
+      chat_id: chatId, msg_id: msg.message_id, count: archived.length,
+      bot: BOT_NAME,
+    });
+  }
+
   // 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
@@ -1853,6 +1907,7 @@ async function handleMessage(sessionKey, chatId, msg, bot) {
         if (fin.finalEditOk) {
           // Preview was successfully edited to the final text.
           // No follow-up messages needed.
+          await cleanupArchivedBubbles();
           console.log(`[${label}] ${elapsed}s | ${result.text.length} chars | streamed | ${chatConfig.model}/${chatConfig.effort} | $${result.cost?.toFixed(4) || '?'}`);
           markReplied();
           return;
@@ -1897,6 +1952,7 @@ async function handleMessage(sessionKey, chatId, msg, bot) {
             console.error(`[${label}] partial-delivery warning failed: ${warnErr.message}`);
           }
         }
+        await cleanupArchivedBubbles();
         console.log(`[${label}] ${elapsed}s | ${result.text.length} chars | streamed-redeliver(${reason}, ${chunks.length} chunks${r.failed.length ? `, ${r.failed.length} failed` : ''}) | ${chatConfig.model}/${chatConfig.effort} | $${result.cost?.toFixed(4) || '?'}`);
         markReplied();
         return;