polygram 0.6.2 → 0.6.4

package/lib/db.js

@@ -463,6 +463,24 @@ function wrap(db) {
       return db.prepare(sql).all(...args);
     },
 
+    // Re-FK every attachment whose (chat_id, msg_id) is in `msg_ids` over
+    // to a single primary message row. Used when the media-group buffer
+    // coalesces N Telegram messages (each carrying one photo of an album)
+    // into one synthetic turn — siblings were recorded under their own
+    // msg_ids by recordInbound, but Claude needs to see them all under
+    // the primary message so handleMessage's per-message attachment
+    // lookup returns the full album.
+    reassignAttachmentsToMessage({ chat_id, msg_ids, target_message_id }) {
+      if (!Array.isArray(msg_ids) || msg_ids.length === 0) return { changes: 0 };
+      const placeholders = msg_ids.map(() => '?').join(',');
+      return db.prepare(`
+        UPDATE attachments
+           SET message_id = ?, msg_id = (SELECT msg_id FROM messages WHERE id = ?)
+         WHERE chat_id = ? AND msg_id IN (${placeholders})
+           AND message_id != ?
+      `).run(target_message_id, target_message_id, String(chat_id), ...msg_ids, target_message_id);
+    },
+
     // Look up the messages.id auto-pk for an inbound message. Used by
     // recordInbound to FK attachments to the just-inserted message even
     // when an ON-CONFLICT update happened (lastInsertRowid is 0 in that

package/migrations/007-attachments-table.sql

@@ -64,6 +64,19 @@ CREATE INDEX IF NOT EXISTS idx_attachments_unique_id
 -- mime_type, size, file_id, file_unique_id, and optionally transcription.
 -- Pre-0.5.x rows may not have file_unique_id. We pull what's there and
 -- leave the rest NULL.
+--
+-- Robustness: json_each() raises on malformed JSON or on a non-array
+-- root, which would roll back the entire migration transaction (one bad
+-- row blocks the upgrade). The `json_valid(...) AND json_type(...) =
+-- 'array'` guards skip those rows so the rest still backfill. Rows
+-- without a `file_id` are also skipped — the schema declares file_id
+-- NOT NULL and we'd rather drop a corrupt entry than materialise a
+-- permanently un-redownloadable row with file_id=''.
+-- Pre-filter messages in a subquery so json_each() only runs on valid
+-- JSON arrays. SQLite's json_each raises on malformed JSON or on a
+-- non-array root, and that error rolls back the whole migration. The
+-- subquery materialises only rows that pass json_valid + json_type
+-- before the join expands them.
 INSERT INTO attachments (
   message_id, chat_id, msg_id, thread_id, bot_name,
   file_id, file_unique_id, kind, name, mime_type, size_bytes,
@@ -71,7 +84,7 @@ INSERT INTO attachments (
 )
 SELECT
   m.id, m.chat_id, m.msg_id, m.thread_id, m.bot_name,
-  COALESCE(json_extract(att.value, '$.file_id'), ''),
+  json_extract(att.value, '$.file_id'),
   json_extract(att.value, '$.file_unique_id'),
   COALESCE(json_extract(att.value, '$.kind'), 'document'),
   json_extract(att.value, '$.name'),
@@ -81,9 +94,14 @@ SELECT
   'downloaded',
   json_extract(att.value, '$.transcription.text'),
   m.ts
-FROM messages m, json_each(m.attachments_json) att
-WHERE m.attachments_json IS NOT NULL
-  AND m.direction = 'in'
-  AND NOT EXISTS (
-    SELECT 1 FROM attachments a WHERE a.message_id = m.id
-  );
+FROM (
+  SELECT id, chat_id, msg_id, thread_id, bot_name, attachments_json, ts
+    FROM messages
+   WHERE direction = 'in'
+     AND attachments_json IS NOT NULL
+     AND json_valid(attachments_json) = 1
+     AND json_type(attachments_json) = 'array'
+     AND NOT EXISTS (SELECT 1 FROM attachments a WHERE a.message_id = id)
+) m, json_each(m.attachments_json) att
+WHERE json_extract(att.value, '$.file_id') IS NOT NULL
+  AND json_extract(att.value, '$.file_id') != '';

package/package.json

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

@@ -208,7 +208,13 @@ function recordInbound(msg) {
   const chatConfig = config.chats[chatId];
   const ts = (msg.date || Math.floor(Date.now() / 1000)) * 1000;
 
-  dbWrite(() => {
+  // Atomic message + attachments write: all-or-nothing so a half-applied
+  // record can never leave a message row with zero (or partial) attachment
+  // rows that boot replay would silently treat as "no media." Wrapping in
+  // db.raw.transaction also collapses the message + N-attachment fsyncs
+  // into one commit (perf win for media groups: 7-attachment albums go
+  // from 8 sync writes to 1).
+  const writeInbound = db.raw.transaction(() => {
     db.insertMessage({
       chat_id: chatId,
       thread_id: threadId,
@@ -231,6 +237,13 @@ function recordInbound(msg) {
     // the upsert path; an explicit lookup is cheap and always correct.
     const messageId = db.getInboundMessageId({ chat_id: chatId, msg_id: msg.message_id });
     if (!messageId) return;
+    // Edit-safe insert: Telegram edited_message events re-fire
+    // recordInbound with the same (chat_id, msg_id). Telegram doesn't
+    // permit replacing media in an edit (only text/caption), so if rows
+    // already exist for this message_id they're correct as-is —
+    // re-inserting would (a) duplicate them, (b) reset download_status
+    // back to 'pending' and lose the local_path we already fetched.
+    if (db.getAttachmentsByMessage(messageId).length > 0) return;
     for (const att of attachments) {
       db.insertAttachment({
         message_id: messageId,
@@ -247,7 +260,9 @@ function recordInbound(msg) {
         ts,
       });
     }
-  }, `insert inbound ${chatId}/${msg.message_id}`);
+  });
+
+  dbWrite(() => writeInbound(), `insert inbound ${chatId}/${msg.message_id}`);
 }
 
 
@@ -1930,6 +1945,29 @@ function createBot(token) {
       // all-media-no-text groups.
       const primary = messages.find((m) => m.text || m.caption) || messages[0];
       const merged = messages.flatMap((m) => extractAttachments(m));
+
+      // 0.6.0 attachment-table regression fix: recordInbound (called per
+      // sibling on bot.on('message')) inserted each photo's row under its
+      // OWN msg_id. handleMessage looks up attachments via
+      // getAttachmentsByMessage(primary.message_id) — which only returns
+      // the primary's row. Without re-FK'ing the siblings we'd silently
+      // drop N-1 of N photos in any album, exactly the umi-assistant bug
+      // the user hit (saw 1 of 2 photos sent in a Telegram album).
+      const chatId = String(primary.chat.id);
+      const primaryDbId = db.getInboundMessageId({
+        chat_id: chatId, msg_id: primary.message_id,
+      });
+      const siblingMsgIds = messages
+        .filter((m) => m.message_id !== primary.message_id)
+        .map((m) => m.message_id);
+      if (primaryDbId && siblingMsgIds.length) {
+        dbWrite(() => db.reassignAttachmentsToMessage({
+          chat_id: chatId,
+          msg_ids: siblingMsgIds,
+          target_message_id: primaryDbId,
+        }), 'reassign media-group sibling attachments');
+      }
+
       const synthetic = { ...primary, _mergedAttachments: merged };
       // Carry the primary's text verbatim (dispatchRegularMessage re-cleans
       // the mention). Caption → text so downstream sees it uniformly.