claude-notification-plugin 1.1.84 → 1.1.86

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-notification-plugin",
-  "version": "1.1.84",
+  "version": "1.1.86",
   "description": "Claude Code task-completion notifications: Telegram, desktop notifications (Windows/macOS/Linux), sound, and voice",
   "author": {
     "name": "Viacheslav Makarov",

package/bin/listener-cli.js

@@ -31,6 +31,7 @@ function getLogFile () {
     return path.join(CLAUDE_DIR, LISTENER_LOG_FILENAME);
   }
 }
+
 const LISTENER_SCRIPT = path.join(__dirname, '..', 'listener', 'listener.js');
 
 const command = process.argv[2];
@@ -69,15 +70,20 @@ Commands:
 }
 
 async function startDaemon () {
-  // Check if already running
+  // Replace any prior instance — both stale PID-files and live processes.
+  // Telegram allows exactly one getUpdates consumer per token, so a zombie
+  // listener (terminal closed, taskkill failed mid-stop, etc.) holds the
+  // long-poll slot and blocks the new one with 409 Conflict. Active SIGTERM
+  // makes `start` idempotent: user typed `start` → listener is running.
   const existingPid = readPid();
-  if (existingPid && isProcessAlive(existingPid)) {
-    console.log(`Listener is already running (PID: ${existingPid})`);
-    process.exit(1);
-  }
-
-  // Clean stale PID file
   if (existingPid) {
+    if (isProcessAlive(existingPid)) {
+      console.log(`Replacing prior listener (PID: ${existingPid})...`);
+      if (!terminatePid(existingPid)) {
+        console.error(`Failed to stop prior listener (PID: ${existingPid}). Exiting.`);
+        process.exit(1);
+      }
+    }
     try {
       fs.unlinkSync(PID_PATH);
     } catch {
@@ -167,7 +173,20 @@ function stopDaemon () {
   }
 
   console.log(`Stopping listener (PID: ${pid})...`);
+  if (terminatePid(pid)) {
+    cleanPid();
+    console.log('Listener stopped');
+  } else {
+    console.error(`Failed to stop listener (PID: ${pid})`);
+  }
+}
 
+/**
+ * Best-effort process termination. Returns true if the target is gone after
+ * the call, false otherwise. Used both by `stop` and by `start` (to evict a
+ * stale prior instance holding the Telegram long-poll slot).
+ */
+function terminatePid (pid) {
   try {
     if (process.platform === 'win32') {
       execSync(`taskkill /PID ${pid} /T /F`, {
@@ -176,7 +195,6 @@ function stopDaemon () {
       });
     } else {
       process.kill(pid, 'SIGTERM');
-      // Wait for graceful shutdown
       let tries = 10;
       while (tries-- > 0 && isProcessAlive(pid)) {
         execSync('sleep 0.5', { stdio: 'ignore' });
@@ -186,11 +204,9 @@ function stopDaemon () {
       }
     }
   } catch {
-    // Process may already be dead
+    // Already dead, or no permission — fall through to the alive check.
   }
-
-  cleanPid();
-  console.log('Listener stopped');
+  return !isProcessAlive(pid);
 }
 
 async function showStatus () {

package/commit-sha

@@ -1 +1 @@
-642d44de740e6e85d391634789966980a389d893
+84cbba88a79b9dd591d9a047174b93d28e04caa6

package/listener/telegram-poller.js

@@ -2,6 +2,10 @@
 
 const POLL_TIMEOUT = 30; // seconds
 const MAX_MESSAGE_LENGTH = 4096;
+// Telegram allows exactly one getUpdates consumer per token. If we keep seeing
+// 409 it means another instance is polling — exit so the user notices instead
+// of looping silently.
+const MAX_CONSECUTIVE_409 = 8;
 
 export class TelegramPoller {
   constructor (token, chatId, logger) {
@@ -12,6 +16,7 @@ export class TelegramPoller {
     this.offset = 0;
     this._errorBackoff = 0; // current backoff in ms (0 = no backoff)
     this._consecutiveErrors = 0;
+    this._consecutive409 = 0;
   }
 
   async flush () {
@@ -38,7 +43,23 @@ export class TelegramPoller {
       const res = await fetch(url, { signal: AbortSignal.timeout((POLL_TIMEOUT + 10) * 1000) });
       const data = await res.json();
       if (!data.ok) {
-        this.logger.error(`getUpdates failed: ${JSON.stringify(data)}`);
+        if (data.error_code === 409) {
+          this._consecutive409++;
+          if (this._consecutive409 >= MAX_CONSECUTIVE_409) {
+            this.logger.error(
+              `409 Conflict persists after ${this._consecutive409} attempts — `
+              + 'another listener is holding the bot token. Exiting.',
+            );
+            console.error(
+              `409 Conflict persists after ${this._consecutive409} attempts — `
+              + 'another listener (or stray getUpdates consumer) is holding the bot token. Exiting.',
+            );
+            process.exit(2);
+          }
+          this.logger.warn(`getUpdates 409 Conflict (attempt ${this._consecutive409}/${MAX_CONSECUTIVE_409})`);
+        } else {
+          this.logger.error(`getUpdates failed: ${JSON.stringify(data)}`);
+        }
         this._applyBackoff();
         return [];
       }
@@ -47,6 +68,7 @@ export class TelegramPoller {
         this.logger.info('getUpdates recovered after errors');
       }
       this._consecutiveErrors = 0;
+      this._consecutive409 = 0;
       this._errorBackoff = 0;
 
       const messages = [];
@@ -268,7 +290,9 @@ function splitMessage (text) {
     return [`${head}\n\n<i>... (truncated ${text.length} chars) ...</i>\n\n${tail}`];
   }
 
-  // Split into chunks preserving line boundaries
+  // Split into chunks with tiered preference: paragraph → line → space → hard.
+  // Each tier is accepted only if it falls past the midpoint, otherwise
+  // we'd produce a tiny chunk followed by a huge one.
   const chunks = [];
   let remaining = text;
   while (remaining.length > 0) {
@@ -276,12 +300,22 @@ function splitMessage (text) {
       chunks.push(remaining);
       break;
     }
-    let splitAt = remaining.lastIndexOf('\n', MAX_MESSAGE_LENGTH);
-    if (splitAt <= 0) {
+    const para = remaining.lastIndexOf('\n\n', MAX_MESSAGE_LENGTH);
+    const line = remaining.lastIndexOf('\n', MAX_MESSAGE_LENGTH);
+    const space = remaining.lastIndexOf(' ', MAX_MESSAGE_LENGTH);
+    const half = MAX_MESSAGE_LENGTH / 2;
+    let splitAt;
+    if (para > half) {
+      splitAt = para;
+    } else if (line > half) {
+      splitAt = line;
+    } else if (space > 0) {
+      splitAt = space;
+    } else {
       splitAt = MAX_MESSAGE_LENGTH;
     }
     chunks.push(remaining.slice(0, splitAt));
-    remaining = remaining.slice(splitAt + 1);
+    remaining = remaining.slice(splitAt).replace(/^\n+/, '');
   }
   return chunks;
 }

package/listener/work-queue.js

@@ -263,12 +263,21 @@ export class WorkQueue {
   }
 
   _load () {
+    if (!fs.existsSync(QUEUE_FILE)) {
+      return;
+    }
     try {
-      if (fs.existsSync(QUEUE_FILE)) {
-        this.queues = JSON.parse(fs.readFileSync(QUEUE_FILE, 'utf-8'));
-      }
+      this.queues = JSON.parse(fs.readFileSync(QUEUE_FILE, 'utf-8'));
     } catch (err) {
-      this.logger.error(`Failed to load queue file: ${err.message}`);
+      // Move aside corrupt file (truncated by crash mid-write, ENOSPC, etc.)
+      // so the next start succeeds instead of looping on a parse error.
+      const corrupt = `${QUEUE_FILE}.corrupt-${Date.now()}`;
+      try {
+        fs.renameSync(QUEUE_FILE, corrupt);
+        this.logger.error(`Queue file corrupt, moved to ${corrupt}: ${err.message}`);
+      } catch (renameErr) {
+        this.logger.error(`Queue file corrupt and rename failed: ${err.message} / ${renameErr.message}`);
+      }
       this.queues = {};
     }
   }
@@ -277,7 +286,11 @@ export class WorkQueue {
     try {
       const dir = path.dirname(QUEUE_FILE);
       fs.mkdirSync(dir, { recursive: true });
-      fs.writeFileSync(QUEUE_FILE, JSON.stringify(this.queues, null, 2));
+      // Atomic write: tmp + rename. Crash mid-write leaves the tmp orphan,
+      // not a half-written QUEUE_FILE.
+      const tmp = `${QUEUE_FILE}.${process.pid}.tmp`;
+      fs.writeFileSync(tmp, JSON.stringify(this.queues, null, 2));
+      fs.renameSync(tmp, QUEUE_FILE);
     } catch (err) {
       this.logger.error(`Failed to save queue file: ${err.message}`);
     }
@@ -290,20 +303,29 @@ export class WorkQueue {
       history.shift();
     }
     try {
-      fs.writeFileSync(HISTORY_FILE, JSON.stringify(history, null, 2));
+      const tmp = `${HISTORY_FILE}.${process.pid}.tmp`;
+      fs.writeFileSync(tmp, JSON.stringify(history, null, 2));
+      fs.renameSync(tmp, HISTORY_FILE);
     } catch {
       // ignore
     }
   }
 
   _loadHistory () {
+    if (!fs.existsSync(HISTORY_FILE)) {
+      return [];
+    }
     try {
-      if (fs.existsSync(HISTORY_FILE)) {
-        return JSON.parse(fs.readFileSync(HISTORY_FILE, 'utf-8'));
+      return JSON.parse(fs.readFileSync(HISTORY_FILE, 'utf-8'));
+    } catch (err) {
+      const corrupt = `${HISTORY_FILE}.corrupt-${Date.now()}`;
+      try {
+        fs.renameSync(HISTORY_FILE, corrupt);
+        this.logger.error(`History file corrupt, moved to ${corrupt}: ${err.message}`);
+      } catch {
+        // ignore
       }
-    } catch {
-      // ignore
+      return [];
     }
-    return [];
   }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "claude-notification-plugin",
   "productName": "claude-notification-plugin",
-  "version": "1.1.84",
+  "version": "1.1.86",
   "description": "Claude Code task-completion notifications: Telegram, desktop notifications (Windows/macOS/Linux), sound, and voice",
   "type": "module",
   "engines": {