dsh-tg-bridge 1.2.7 → 1.2.9

package/bridge.mjs

@@ -22,6 +22,7 @@ import dns from 'node:dns';
 import net from 'node:net';
 dns.setDefaultResultOrder('ipv4first');
 net.setDefaultAutoSelectFamily(false);
+import { noticeIsObsolete } from './queue-notice.mjs';
 import { handleControl, CONTROL_COMMANDS } from './control.mjs';
 import { renderPrices } from './prices.mjs';
 import { t, resolveLang } from './i18n.mjs';
@@ -607,6 +608,7 @@ export function toTelegramHtml(input) {
 async function send(chatId, text, threadId = 0, replyTo = 0) {
   const html = config.plainText === true ? '' : toTelegramHtml(text);
   const parts = html ? chunk(html, 3800) : chunk(toPlainText(text) || '(пусто)');
+  let lastId = 0;
   for (const part of parts) {
     const body = { chat_id: chatId, text: part, disable_web_page_preview: true };
     if (html) body.parse_mode = 'HTML';
@@ -627,7 +629,9 @@ async function send(chatId, text, threadId = 0, replyTo = 0) {
       res = await tg('sendMessage', body);
     }
     log(`sent chat=${chatId}${threadId ? ` topic=${threadId}` : ''} msg=${res.message_id} len=${part.length}${html ? ' html' : ''}`);
+    lastId = res.message_id;
   }
+  return lastId;
 }
 
 /** Remember which topics already got their seed message, so it happens once. */
@@ -1398,12 +1402,33 @@ function maybeExitForRestart() {
   setTimeout(() => process.exit(75), 300).unref?.();
 }
 
+/**
+ * Queue notices, one per topic. A notice exists only while the person is
+ * waiting: the moment the queued turn starts it is deleted, so a long session
+ * does not leave a column of "идёт уже 7 мин" messages behind (it did).
+ */
+const busyNotices = new Map();
+
+async function clearBusyNotice(key) {
+  const notice = busyNotices.get(key);
+  if (!notice) return;
+  busyNotices.delete(key);
+  try {
+    await tg('deleteMessage', { chat_id: notice.chatId, message_id: notice.messageId });
+  } catch (error) {
+    log(`busy notice delete failed: ${error.message}`);
+  }
+}
+
 function enqueue(key, task, onBusy) {
   const prev = queues.get(key) || Promise.resolve();
   const queued = queues.has(key);
   const run = prev
     .then(() => acquire())
-    .then(() => {
+    .then(async () => {
+      // The person was told "your message is queued"; that notice has done its
+      // job the moment the turn starts and must not linger in the chat.
+      await clearBusyNotice(key);
       // Remember when the turn actually started: the queue notice has to say
       // "идёт уже 24 мин", not just "занято" — silence is what reads as a hang.
       turnStartedAt.set(key, Date.now());
@@ -1412,6 +1437,7 @@ function enqueue(key, task, onBusy) {
     .catch((error) => log(`turn queue error ${key}: ${error.message}`))
     .finally(() => {
       turnStartedAt.delete(key);
+      clearBusyNotice(key).catch(() => {});
       release();
       if (queues.get(key) === run) queues.delete(key);
       // A deferred restart waits for exactly this moment: the answer is out and
@@ -1726,18 +1752,31 @@ async function main() {
       // handled inline and must stay silent about it.
       msg.text || msg.caption
         ? async () => {
+            // Which turn was running when this message was queued: if that
+            // value changes, the queued turn has started and the notice is
+            // already obsolete.
+            const turnWhenQueued = turnStartedAt.get(queueKey);
             await new Promise((resolve) => setTimeout(resolve, Number(config.busyNoticeMs ?? 45000)));
             if (!queues.has(queueKey)) return; // already finished
+            // One notice per topic: a second queued message must not add a
+            // second copy of the same line.
+            if (busyNotices.has(queueKey)) return;
             const started = turnStartedAt.get(queueKey);
             const mins = started ? Math.max(1, Math.round((Date.now() - started) / 60000)) : 0;
             const notice = mins > 0
               ? t(lang, 'msg.busy.since', { min: mins })
               : t(lang, 'msg.busy.now');
-            await send(
+            const messageId = await send(
               msg.chat.id,
               `⏳ ${notice}`,
               thread,
             );
+            if (messageId) busyNotices.set(queueKey, { chatId: msg.chat.id, messageId });
+            // The queued turn may have started while the notice was in flight;
+            // in that case nothing else will delete it until the turn ends.
+            if (noticeIsObsolete(turnWhenQueued, turnStartedAt.get(queueKey), queues.has(queueKey))) {
+              await clearBusyNotice(queueKey);
+            }
           }
         : undefined,
     );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-tg-bridge",
-  "version": "1.2.7",
+  "version": "1.2.9",
   "description": "Telegram bridge for DeepSeek Harness: text, voice, photos and project-per-topic sessions without opening the desktop app",
   "type": "module",
   "main": "bridge.mjs",
@@ -12,7 +12,8 @@
     "setup": "node setup.mjs",
     "check": "node setup.mjs --check",
     "menu": "node bot-menu.mjs",
-    "doctor": "node bridge-kick.mjs"
+    "doctor": "node bridge-kick.mjs",
+    "test": "node --test"
   },
   "engines": {
     "node": ">=20"
@@ -43,6 +44,7 @@
     "README.md",
     "LICENSE",
     "config.example.json",
-    "patches/"
+    "patches/",
+    "queue-notice.mjs"
   ]
 }

package/queue-notice.mjs

@@ -0,0 +1,10 @@
+// When is a "your message is queued" notice already obsolete?
+//
+// It was written for a specific running turn (`turnWhenQueued`). It must go as
+// soon as that turn is no longer the one in front: either the queue drained, or
+// the queued turn started (its start time differs). Kept in its own module so
+// the rule can be tested without starting the bridge or talking to Telegram.
+
+export function noticeIsObsolete(turnWhenQueued, turnNow, stillQueued) {
+  return !stillQueued || turnNow !== turnWhenQueued;
+}