claude-notification-plugin 1.1.83 → 1.1.86

package/.claude-plugin/plugin.json

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

package/README.md

@@ -265,6 +265,27 @@ Projects are referenced with the `&` prefix (e.g. `&api`, `&api/branch`).
 | `/menu`                        | Show help with inline buttons        |
 | `/help`                        | Show help with inline buttons        |
 
+#### Raw REPL commands (`%cmd`)
+
+To forward a slash-command straight into the live Claude Code REPL (instead of
+letting the listener intercept it), prefix it with `%`:
+
+| Telegram message        | What gets sent to Claude PTY                 |
+|-------------------------|----------------------------------------------|
+| `%clear`                | `/clear` in the default project              |
+| `&api %compact`         | `/compact` in the `&api` main worktree       |
+| `&api/feature %cost`    | `/cost` in the `&api/feature` worktree       |
+| `%%foo`                 | literal task starting with `%foo` (escape)   |
+
+Useful for `/clear`, `/compact`, `/cost`, `/model`, `/status` etc. — commands
+that act on the running Claude session without going through the listener's
+command router. The PTY session is **kept alive**, so subsequent tasks
+continue in the same conversation (with cleared context after `/clear`).
+
+Because REPL commands usually don't produce a `Stop` hook event, raw tasks
+complete after ~8 s of PTY inactivity; the last chunk of output is included
+in the confirmation reply.
+
 #### Registering projects on the fly (`/addproject` + `/seen`)
 
 Whenever the notifier fires for a folder, it records the absolute path,

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 @@
-0567928a0b6df6aaefebbb8e507bc8fef8ae5942
+84cbba88a79b9dd591d9a047174b93d28e04caa6

package/listener/listener.js

@@ -201,6 +201,29 @@ runner.on('complete', async (workDir, task, result) => {
   // Delete the "Running" message
   await poller.deleteMessage(task.runningMessageId);
 
+  const output = result.text || '';
+
+  if (task.raw) {
+    // Raw slash-command: compact "sent" confirmation, don't bump session counter.
+    // `/clear` wipes Claude's context — reset our counters too.
+    const normalized = (task.text || '').trim().toLowerCase();
+    if (normalized === '/clear') {
+      sessions.delete(workDir);
+    }
+    const headerShort = `📨 <code>${label}</code>  sent <code>${escapeHtml(task.text)}</code>`;
+    const tail = output ? output.slice(-1500) : '';
+    const body = tail ? `\n\n<pre>${escapeHtml(tail)}</pre>` : '';
+    const sentId = await poller.sendMessage(headerShort + body, task.telegramMessageId);
+    if (!sentId && task.telegramMessageId) {
+      await poller.sendMessage(headerShort + body);
+    }
+    const next = queue.onTaskComplete(workDir, output);
+    if (next) {
+      startTask(workDir, next);
+    }
+    return;
+  }
+
   // Update session tracking
   const session = sessions.get(workDir) || { taskCount: 0 };
   session.taskCount++;
@@ -231,7 +254,6 @@ runner.on('complete', async (workDir, task, result) => {
   const sessionIcon = task.continueSession ? '🔄' : '🆕';
 
   // Build result
-  const output = result.text || '';
   const headerShort = `✅ ${sessionIcon} <code>${label}</code>${sessionInfo}`;
   const headerFull = `${headerShort}\n\n${escapeHtml(task.text)}`;
   let body = '';
@@ -429,6 +451,29 @@ async function startTask (workDir, task) {
   const continueSession = shouldContinueSession(workDir);
   const session = sessions.get(workDir);
 
+  // Raw slash-commands get a compact running message and skip the live console.
+  if (task.raw) {
+    const runningRaw = `📨 <code>${label}</code>  sending <code>${escapeHtml(task.text)}</code>…`;
+    let runningMsgId = null;
+    if (task.telegramMessageId) {
+      runningMsgId = await poller.sendMessage(runningRaw, task.telegramMessageId);
+    }
+    if (!runningMsgId) {
+      runningMsgId = await poller.sendMessage(runningRaw);
+    }
+    task.runningMessageId = runningMsgId;
+    const claudeArgs = getClaudeArgs(entry?.project);
+    try {
+      runner.run(workDir, task, claudeArgs, continueSession);
+      queue.markStarted(workDir, task.pid || 0);
+    } catch (err) {
+      logger.error(`Failed to start raw task: ${err.message}`);
+      poller.sendMessage(`❌  <code>${label}</code>\nFailed to start: ${escapeHtml(err.message)}`);
+      queue.onTaskComplete(workDir, `START_ERROR: ${err.message}`);
+    }
+    return;
+  }
+
   // Build running message with session info
   let sessionTag = '';
   if (continueSession && session) {
@@ -1239,6 +1284,11 @@ function handleHelp () {
 <code>&amp;project/branch task</code> — worktree
 <code>task</code> — default project
 
+<b>Raw REPL commands (forward to live Claude session):</b>
+<code>%clear</code> — send <code>/clear</code> into the running Claude PTY
+<code>&amp;project %compact</code> — same, targeting project
+<code>%%foo</code> — literal task starting with <code>%foo</code> (escape)
+
 <b>Session:</b>
 🆕 = new session, 🔄 = continuing session
 ctx N% = context window usage`,
@@ -1286,6 +1336,7 @@ async function handleTask (parsed, telegramMessageId) {
     parsed.branch || 'main',
     parsed.text,
     telegramMessageId,
+    !!parsed.raw,
   );
 
   if (result.error) {

package/listener/message-parser.js

@@ -9,7 +9,12 @@
  *   &project text           → { type: 'task', project, branch: null, text }
  *   text                    → { type: 'task', project: <defaultProject>, branch: null, text }
  *
- * Any /word is treated as a command (known or unknown).
+ * Raw slash-commands forwarded to the live Claude REPL:
+ *   %cmd [args]             → task with raw:true, text='/cmd [args]'
+ *   &project %cmd [args]    → same, targeting the project's PTY
+ *   %%foo                   → literal task starting with "%foo" (escape)
+ *
+ * Any /word is treated as a listener command (known or unknown).
  * Project designation uses & prefix: &project or &project/branch.
  *
  * @param {string} text - The message text.
@@ -41,7 +46,8 @@ export function parseMessage (text, defaultProject) {
     const projectMatch = trimmed.match(/^&(\S+)\s+([\s\S]+)$/);
     if (projectMatch) {
       const target = projectMatch[1];
-      const taskText = projectMatch[2].trim();
+      const rawText = projectMatch[2].trim();
+      const { text: taskText, raw } = parseRawPrefix(rawText);
 
       const slashIndex = target.indexOf('/');
       if (slashIndex > 0) {
@@ -50,6 +56,7 @@ export function parseMessage (text, defaultProject) {
           project: target.substring(0, slashIndex),
           branch: target.substring(slashIndex + 1),
           text: taskText,
+          raw,
         };
       }
       return {
@@ -57,19 +64,38 @@ export function parseMessage (text, defaultProject) {
         project: target,
         branch: null,
         text: taskText,
+        raw,
       };
     }
   }
 
   // Plain text → default project
+  const { text: taskText, raw } = parseRawPrefix(trimmed);
   return {
     type: 'task',
     project: defaultProject || 'default',
     branch: null,
-    text: trimmed,
+    text: taskText,
+    raw,
   };
 }
 
+/**
+ * Detect `%cmd` / `%%literal` prefix.
+ * - `%%foo`  → plain task "%foo"
+ * - `%foo`   → raw task "/foo" (forwarded to PTY verbatim)
+ * - anything else → unchanged plain task
+ */
+function parseRawPrefix (text) {
+  if (text.startsWith('%%')) {
+    return { text: text.slice(1), raw: false };
+  }
+  if (text.startsWith('%')) {
+    return { text: '/' + text.slice(1), raw: true };
+  }
+  return { text, raw: false };
+}
+
 /**
  * Parse &project or &project/branch from command args.
  * Returns { project, branch, rest } or null.

package/listener/pty-runner.js

@@ -4,8 +4,12 @@ import fs from 'fs';
 import path from 'path';
 import { EventEmitter } from 'events';
 import { PTY_SIGNAL_DIR } from '../bin/constants.js';
+import { cleanPtyOutput } from './telegram-poller.js';
 
 const DEFAULT_TIMEOUT = 600_000; // 10 minutes
+// Built-in slash-commands (forwarded via %cmd) rarely emit a Stop hook event,
+// so we fall back to "done" after this much buffer inactivity.
+const RAW_INACTIVITY_MS = 8_000;
 
 /**
  * PTY-based runner for Claude Code.
@@ -318,8 +322,11 @@ export class PtyRunner extends EventEmitter {
     session._buffer = '';
     this._openPtyLog(session, task);
 
-    // Set up marker wait + inactivity timeout
-    const markerPromise = this._waitForMarker(pendingId, this.timeout, session);
+    // Set up marker wait + inactivity timeout. Raw slash-commands use a much
+    // shorter window because they typically don't trigger an agent turn and
+    // therefore never produce a Stop signal.
+    const inactivityMs = task.raw ? RAW_INACTIVITY_MS : this.timeout;
+    const markerPromise = this._waitForMarker(pendingId, inactivityMs, session);
 
     // Send the task text to the PTY.
     // Bracketed paste mode (\x1b[200~...\x1b[201~) causes Claude to hang in ConPTY,
@@ -379,6 +386,29 @@ export class PtyRunner extends EventEmitter {
       session.currentTask = null;
 
       if (err.message === 'Marker timeout') {
+        if (task.raw) {
+          // Slash commands (e.g. /clear, /cost) usually don't emit a Stop hook.
+          // Treat inactivity as successful completion and keep the PTY alive.
+          const cleaned = cleanPtyOutput(session._buffer || '').trim();
+          const tail = cleaned.length > 2000 ? cleaned.slice(-2000) : cleaned;
+          const result = {
+            text: tail,
+            sessionId: session.sessionId || null,
+            cost: 0,
+            numTurns: 0,
+            durationMs: 0,
+            contextWindow: 0,
+            totalTokens: 0,
+            isError: false,
+            raw: true,
+          };
+          this.logger.info(`PTY raw command finished (no Stop signal) in ${workDir}`);
+          if (this.taskLogger) {
+            this.taskLogger.logAnswer(task.project || 'unknown', task.branch || 'main', tail, 0);
+          }
+          this.emit('complete', workDir, task, result);
+          return;
+        }
         this.logger.warn(`PTY task timed out in ${workDir}`);
         this._destroyPty(workDir);
         this.emit('timeout', workDir, task);

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

@@ -30,7 +30,7 @@ export class WorkQueue {
    * Enqueue a task for a workDir. Returns the task object.
    * If no active task, marks it as ready to run immediately.
    */
-  enqueue (workDir, project, branch, text, telegramMessageId) {
+  enqueue (workDir, project, branch, text, telegramMessageId, raw = false) {
     if (!this.queues[workDir]) {
       this.queues[workDir] = {
         project,
@@ -57,6 +57,7 @@ export class WorkQueue {
       project,
       branch: branch || 'main',
       telegramMessageId,
+      raw: !!raw,
       addedAt: new Date().toISOString(),
     };
 
@@ -262,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 = {};
     }
   }
@@ -276,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}`);
     }
@@ -289,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.83",
+  "version": "1.1.86",
   "description": "Claude Code task-completion notifications: Telegram, desktop notifications (Windows/macOS/Linux), sound, and voice",
   "type": "module",
   "engines": {