dsh-tg-bridge 1.2.8 → 1.2.10

package/bridge.mjs

@@ -22,6 +22,8 @@ import dns from 'node:dns';
 import net from 'node:net';
 dns.setDefaultResultOrder('ipv4first');
 net.setDefaultAutoSelectFamily(false);
+import { noticeIsObsolete } from './queue-notice.mjs';
+import { immediateKind } from './immediate.mjs';
 import { handleControl, CONTROL_COMMANDS } from './control.mjs';
 import { renderPrices } from './prices.mjs';
 import { t, resolveLang } from './i18n.mjs';
@@ -473,33 +475,13 @@ function commandOf(text) {
   return `/${match[1].toLowerCase().replace(/[.-]+/g, '')}`;
 }
 
-/**
- * Commands that must run *now*, not behind the turn they are about.
- *
- * Everything in a topic used to be queued, so `/stop` waited for the very turn
- * it was supposed to kill — on 2026-10-24 a 26-minute turn swallowed `/stop`
- * and the person got "ход уже идёт" instead of an interruption. These few
- * commands touch no turn state, so they can run concurrently with one.
- */
-const IMMEDIATE_COMMANDS = new Set([
-  'stop',
-  'logs',
-  'status',
-  'help',
-  'doctor',
-  'restart',
-]);
-
 /** Canonical immediate command name for a message, or '' when it must queue. */
 function immediateCommandOf(text) {
   const trimmed = String(text ?? '').trim();
   if (!trimmed.startsWith('/')) return '';
-  const head = trimmed.split(/\s+/)[0];
+  const [head, ...rest] = trimmed.split(/\s+/);
   const collapsed = commandOf(head).replace(/^\//, '');
-  if (collapsed === 'apprestart' || collapsed === 'apprestartconfirm' || collapsed === 'restartconfirm') {
-    return 'restart';
-  }
-  return IMMEDIATE_COMMANDS.has(collapsed) ? collapsed : '';
+  return immediateKind(collapsed, rest);
 }
 
 /**
@@ -1751,6 +1733,10 @@ 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
@@ -1767,8 +1753,11 @@ async function main() {
               thread,
             );
             if (messageId) busyNotices.set(queueKey, { chatId: msg.chat.id, messageId });
-            // The turn may have started while the notice was in flight.
-            if (!queues.has(queueKey)) await clearBusyNotice(queueKey);
+            // 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/immediate.mjs

@@ -0,0 +1,56 @@
+// Which control commands may run while a turn is still working?
+//
+// Everything in a topic used to be queued, so `/stop` waited for the very turn
+// it was supposed to kill. The rule here is not "important commands", it is
+// "commands that neither read nor write the state of the running turn".
+//
+// Groups:
+//   * always immediate — read-only reports and turn control;
+//   * immediate only without arguments — the bare form reports, the form with
+//     an argument changes state (`/soul <text>`, `/lang en`);
+//   * `/plugins` without an action — the list; with add/remove/disable/enable
+//     it installs plugins, which must queue like any other mutation;
+//   * everything else queues, because it changes the session the turn is using
+//     (`/model`, `/new`, `/resume`, `/cd`, `/send`, `/seed`, `/plugin`).
+
+const PLUGIN_ACTIONS = new Set(['add', 'remove', 'disable', 'enable']);
+
+const ALWAYS = new Set([
+  // Turn control.
+  'stop',
+  'restart',
+  // Reports: they read profiles, sessions, skills and the price table, but
+  // touch neither the queue nor the session of the running turn.
+  'status',
+  'logs',
+  'help',
+  'doctor',
+  'models',
+  'sessions',
+  'skills',
+  'prices',
+]);
+
+const BARE_ONLY = new Set([
+  'soul', // `/soul` reads AGENTS.md, `/soul <text>` rewrites it
+  'lang', // `/lang` reports the current language, `/lang en` switches it
+]);
+
+/**
+ * Canonical immediate command name, or '' when the message must queue.
+ * `name` is the command without the slash and without a bot mention,
+ * `args` is everything after it, already split.
+ */
+export function immediateKind(name, args = []) {
+  const command = String(name ?? '').toLowerCase();
+  if (command === 'apprestart' || command === 'apprestartconfirm' || command === 'restartconfirm') {
+    return 'restart';
+  }
+  if (ALWAYS.has(command)) return command;
+  if (command === 'plugins') {
+    const [action = ''] = args;
+    return PLUGIN_ACTIONS.has(String(action).toLowerCase()) ? '' : 'plugins';
+  }
+  if (BARE_ONLY.has(command) && args.length === 0) return command;
+  return '';
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-tg-bridge",
-  "version": "1.2.8",
+  "version": "1.2.10",
   "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,8 @@
     "README.md",
     "LICENSE",
     "config.example.json",
-    "patches/"
+    "patches/",
+    "queue-notice.mjs",
+    "immediate.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;
+}