claude-notification-plugin 1.1.52 → 1.1.55

package/listener/pty-runner.js

@@ -68,12 +68,9 @@ export class PtyRunner extends EventEmitter {
 
   /**
    * Check for new marker files in the signal directory.
+   * Handles typed signals: stop (default), error, ready, activity, compact.
    */
   _checkMarkerFiles () {
-    if (this.pendingMarkers.size === 0) {
-      return;
-    }
-
     let files;
     try {
       files = fs.readdirSync(PTY_SIGNAL_DIR);
@@ -94,26 +91,96 @@ export class PtyRunner extends EventEmitter {
         continue;
       }
 
-      // Try to match by cwd (primary matching for PTY runner)
       const cwd = marker.cwd;
-      if (cwd) {
+      if (!cwd) {
+        continue;
+      }
+
+      const type = marker.type || 'stop';
+
+      if (type === 'stop') {
+        // Completion signal — resolve pending marker
+        if (this.pendingMarkers.size === 0) {
+          continue;
+        }
         for (const [pid, resolve] of this.pendingMarkers) {
           const session = this._findSessionByPendingId(pid);
           if (session && this._normalizePath(session.workDir) === this._normalizePath(cwd)) {
             this.pendingMarkers.delete(pid);
-            try {
-              fs.unlinkSync(filePath);
-            } catch {
-              // ignore
-            }
+            this._unlinkSafe(filePath);
             resolve(marker);
             break;
           }
         }
+      } else if (type === 'error') {
+        // StopFailure — emit error, abort task
+        this._unlinkSafe(filePath);
+        for (const [workDir, session] of this.sessions) {
+          if (session.state === 'busy' && this._normalizePath(session.workDir) === this._normalizePath(cwd)) {
+            if (session._pendingId && this.pendingMarkers.has(session._pendingId)) {
+              this.pendingMarkers.delete(session._pendingId);
+            }
+            const task = session.currentTask;
+            session.state = 'idle';
+            session.currentTask = null;
+            this._destroyPty(workDir);
+            const errorMsg = `API error: ${marker.error}${marker.errorDetails ? ' — ' + marker.errorDetails : ''}`;
+            this.logger.error(`Hook signal: ${errorMsg} in ${workDir}`);
+            if (this.taskLogger) {
+              this.taskLogger.logAnswer(task?.project || 'unknown', task?.branch || 'main', errorMsg, 1);
+            }
+            this.emit('error', workDir, task, errorMsg);
+            break;
+          }
+        }
+      } else if (type === 'ready') {
+        // SessionStart — emit ready event
+        this._unlinkSafe(filePath);
+        for (const [workDir, session] of this.sessions) {
+          if (this._normalizePath(session.workDir) === this._normalizePath(cwd)) {
+            session._model = marker.model || '';
+            this.emit('ready', workDir, marker);
+            break;
+          }
+        }
+      } else if (type === 'activity') {
+        // PostToolUse — update activity data (don't delete, gets overwritten)
+        for (const [, session] of this.sessions) {
+          if (this._normalizePath(session.workDir) === this._normalizePath(cwd)) {
+            session._lastActivity = {
+              toolName: marker.toolName,
+              toolInput: marker.toolInput,
+              timestamp: marker.timestamp,
+            };
+            break;
+          }
+        }
+      } else if (type === 'compact') {
+        // PostCompact — update compaction info
+        this._unlinkSafe(filePath);
+        for (const [workDir, session] of this.sessions) {
+          if (this._normalizePath(session.workDir) === this._normalizePath(cwd)) {
+            session._lastCompact = {
+              summary: marker.summary,
+              trigger: marker.trigger,
+              timestamp: marker.timestamp,
+            };
+            this.emit('compact', workDir, marker);
+            break;
+          }
+        }
       }
     }
   }
 
+  _unlinkSafe (filePath) {
+    try {
+      fs.unlinkSync(filePath);
+    } catch {
+      // ignore
+    }
+  }
+
   _normalizePath (p) {
     return p.replace(/\\/g, '/').replace(/\/+$/, '').toLowerCase();
   }
@@ -261,65 +328,11 @@ export class PtyRunner extends EventEmitter {
     writeLines();
     this.logger.info(`PTY task sent to ${workDir}: ${task.text.slice(0, 100)}`);
 
-    // Monitor PTY output for fatal errors that prevent task completion.
-    // Some patterns (e.g. "auto mode temporarily unavailable") can appear in the
-    // Claude CLI status bar while Claude is still actively working. To avoid false
-    // positives we require the buffer to stop growing for two consecutive checks
-    // before treating the match as a real error.
-    const errorPatterns = [
-      { pattern: 'auto mode temporarily unavailable', msg: 'Claude auto mode temporarily unavailable — retry later' },
-      { pattern: 'Session expired', msg: 'Claude session expired' },
-      { pattern: 'Authentication required', msg: 'Claude authentication required' },
-    ];
-    let errorCandidate = null; // { msg, bufLen } — suspected error awaiting confirmation
-    let checkedUpTo = 0; // buffer offset already scanned — avoids re-matching the same text
-    const errorCheckInterval = setInterval(() => {
-      const buf = session._buffer || '';
-      const bufLen = buf.length;
-
-      // If we have a candidate from the previous cycle, confirm it
-      if (errorCandidate) {
-        if (bufLen === errorCandidate.bufLen) {
-          // Buffer did not grow — Claude stopped, treat as real error
-          clearInterval(errorCheckInterval);
-          this.logger.error(`PTY fatal: ${errorCandidate.msg} in ${workDir}`);
-          if (session._pendingId && this.pendingMarkers.has(session._pendingId)) {
-            this.pendingMarkers.delete(session._pendingId);
-          }
-          session.state = 'idle';
-          session.currentTask = null;
-          this._destroyPty(workDir);
-          this.emit('error', workDir, task, errorCandidate.msg);
-          return;
-        }
-        // Buffer grew — Claude is still working, false positive
-        this.logger.info(`PTY error candidate dismissed (buffer grew) in ${workDir}`);
-        errorCandidate = null;
-        checkedUpTo = bufLen;
-        return;
-      }
-
-      // Scan only new buffer content for pattern matches
-      if (bufLen <= checkedUpTo) {
-        return;
-      }
-      const fresh = buf.slice(checkedUpTo);
-      for (const { pattern, msg } of errorPatterns) {
-        if (fresh.includes(pattern)) {
-          this.logger.warn(`PTY error candidate detected: "${pattern}" in ${workDir}, waiting to confirm…`);
-          errorCandidate = { msg, bufLen };
-          return;
-        }
-      }
-      checkedUpTo = bufLen;
-    }, 3000);
-
-    // Clean up error monitor when task completes normally
-    const clearErrorCheck = () => clearInterval(errorCheckInterval);
+    // Error detection is now handled by the StopFailure hook signal,
+    // which writes an error signal file processed by _checkMarkerFiles.
 
     // Handle completion asynchronously
     markerPromise.then((marker) => {
-      clearErrorCheck();
       session.state = 'idle';
       session.currentTask = null;
       session.sessionId = marker.sessionId;
@@ -341,7 +354,6 @@ export class PtyRunner extends EventEmitter {
       }
       this.emit('complete', workDir, task, result);
     }).catch((err) => {
-      clearErrorCheck();
       session.state = 'idle';
       session.currentTask = null;
 
@@ -381,8 +393,8 @@ export class PtyRunner extends EventEmitter {
     // Reduce PTY output noise: disable animations, progress bar, tips
     if (!args.includes('--settings')) {
       args.push('--settings', JSON.stringify({
-        prefersReducedMotion: true,
-        outputStyle: 'plain',
+        // prefersReducedMotion: true,
+        // outputStyle: 'plain',
         terminalProgressBarEnabled: false,
         spinnerTipsEnabled: false,
         showTurnDuration: false,
@@ -418,44 +430,18 @@ export class PtyRunner extends EventEmitter {
       _buffer: '',
     };
 
-    // Auto-answer permission prompts: track buffer position and cooldown to
-    // prevent double-fire when Claude re-renders the same prompt on screen.
-    let lastPermissionAnswerAt = 0;
-    let lastPermissionAnswerTime = 0;
-    const PERMISSION_COOLDOWN_MS = 5000;
+    // Permission auto-approval is now handled by the PermissionRequest hook
+    // (returns auto-approve JSON when CLAUDE_NOTIFY_FROM_LISTENER=1).
 
     ptyProcess.onData((data) => {
       session._buffer += data;
       // Keep buffer reasonable size
       if (session._buffer.length > 50000) {
         session._buffer = session._buffer.slice(-25000);
-        lastPermissionAnswerAt = Math.max(0, lastPermissionAnswerAt - 25000);
       }
       if (session._logStream) {
         session._logStream.write(data);
       }
-
-      // Auto-answer interactive permission prompts that appear when
-      // "auto mode temporarily unavailable". The prompt looks like:
-      //   Do you want to proceed?
-      //   ❯ 1. Yes
-      //   2. Yes, and always allow …
-      //   3. No
-      // We send Enter to approve (cursor ❯ is already on "1. Yes").
-      // Cooldown prevents double-fire from screen redraws.
-      const now = Date.now();
-      if (session.state === 'busy'
-        && session._buffer.length - lastPermissionAnswerAt > 50
-        && now - lastPermissionAnswerTime > PERMISSION_COOLDOWN_MS) {
-        const tail = session._buffer.slice(lastPermissionAnswerAt);
-        const clean = tail.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '').replace(/\s/g, '');
-        if (clean.includes('Doyouwanttoproceed') && clean.includes('1.Yes')) {
-          lastPermissionAnswerAt = session._buffer.length;
-          lastPermissionAnswerTime = now;
-          this.logger.info(`Auto-answering permission prompt in ${session.workDir}`);
-          session.pty.write('\r');
-        }
-      }
     });
 
     ptyProcess.onExit(({ exitCode }) => {
@@ -609,6 +595,44 @@ export class PtyRunner extends EventEmitter {
     return session?._buffer || '';
   }
 
+  /**
+   * Get last tool activity for a workDir (from PostToolUse hook signals).
+   */
+  getActivity (workDir) {
+    const session = this.sessions.get(workDir);
+    return session?._lastActivity || null;
+  }
+
+  /**
+   * Clean up activity signal file for a workDir.
+   */
+  cleanActivitySignal (workDir) {
+    const session = this.sessions.get(workDir);
+    if (session) {
+      session._lastActivity = null;
+    }
+    // Also try to delete any activity files matching this workDir
+    try {
+      const files = fs.readdirSync(PTY_SIGNAL_DIR);
+      for (const f of files) {
+        if (!f.startsWith('act_') || !f.endsWith('.json')) {
+          continue;
+        }
+        const filePath = path.join(PTY_SIGNAL_DIR, f);
+        try {
+          const data = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+          if (data.cwd && this._normalizePath(data.cwd) === this._normalizePath(workDir)) {
+            fs.unlinkSync(filePath);
+          }
+        } catch {
+          // ignore
+        }
+      }
+    } catch {
+      // ignore
+    }
+  }
+
   /**
    * Get diagnostic info about a PTY session.
    */

package/notifier/NOTIFIER-DETAILED.md

@@ -0,0 +1,82 @@
+# Notifier Hook Events - Detailed Guide
+
+The notifier (`notifier/notifier.js`) is the plugin's hook handler — a single script invoked by Claude Code for every registered hook event. It reads JSON from stdin, determines the event type and operating mode, and dispatches accordingly.
+
+## Operating modes
+
+| Mode | Condition | Behavior |
+|---|---|---|
+| **Disabled** | `CLAUDE_NOTIFY_DISABLE=1` | Exit immediately |
+| **Listener-only** | `CLAUDE_NOTIFY_FROM_LISTENER=1` (and `CLAUDE_NOTIFY_AFTER_LISTENER` not `1`) | Write signal files to `~/.claude/pty-signals/`, no user notifications |
+| **Normal** | Default | Send notifications (Telegram, desktop, sound, voice, webhook) |
+
+## Hook events
+
+| Hook Event | Mode | Sync | Purpose |
+|---|---|---|---|
+| `UserPromptSubmit` | Normal | sync | Starts the notification timer (records session start time) |
+| `Stop` | Both | sync | Normal: sends completion notification. Listener: writes completion signal file |
+| `StopFailure` | Both | async | Normal: sends error notification. Listener: writes error signal file |
+| `Notification` | Normal | sync | Sends waiting-for-input notification (when `notifyOnWaiting` is enabled) |
+| `SessionStart` | Listener | async | Writes session ready signal (model name, startup/resume source) |
+| `PermissionRequest` | Listener | sync | Auto-approves permission prompts via JSON output to stdout |
+| `PostToolUse` | Listener | async | Writes tool activity signal (tool name, input parameters) |
+| `PostCompact` | Listener | async | Writes context compaction signal (summary, trigger type) |
+
+**Sync** hooks block Claude until the script completes (Claude waits for the response).
+**Async** hooks run in the background (Claude continues immediately).
+
+## Normal mode flow
+
+```
+UserPromptSubmit
+  → Record session start time in state file
+  → Send webhook (if configured)
+
+Stop / StopFailure / Notification
+  → Check elapsed time since session start
+  → Skip if duration < notifyAfterSeconds (default 15s)
+  → Build notification text (project, branch, duration, last message)
+  → Send: Telegram, desktop toast, sound, voice, webhook
+  → Clean up old Telegram messages (deleteAfterHours)
+```
+
+## Listener-only mode flow
+
+```
+PermissionRequest
+  → Output auto-approve JSON to stdout:
+    { hookSpecificOutput: { hookEventName: "PermissionRequest",
+      decision: { behavior: "allow" } } }
+
+Stop
+  → Write ~/.claude/pty-signals/{sessionId}.json
+    { sessionId, cwd, lastAssistantMessage, cost, numTurns, durationMs }
+
+StopFailure
+  → Write ~/.claude/pty-signals/err_{sessionId}.json
+    { type: "error", cwd, error, errorDetails, lastAssistantMessage }
+
+SessionStart
+  → Write ~/.claude/pty-signals/rdy_{sessionId}.json
+    { type: "ready", cwd, model, source }
+
+PostToolUse
+  → Write ~/.claude/pty-signals/act_{sessionId}.json (overwritten each call)
+    { type: "activity", cwd, toolName, toolInput }
+
+PostCompact
+  → Write ~/.claude/pty-signals/cmp_{sessionId}.json
+    { type: "compact", cwd, summary, trigger }
+```
+
+## Configuration
+
+See the main [README](../README.md) for configuration options.
+
+Key settings affecting notifier behavior:
+- `notifyAfterSeconds` (default: 15) — minimum task duration to trigger notifications
+- `notifyOnWaiting` (default: false) — send notifications for idle/waiting events
+- `telegram.includeLastCcMessageInTelegram` (default: true) — include Claude's last message in Telegram notification
+- `telegram.deleteAfterHours` (default: 24) — auto-delete old notification messages
+- `debug` (default: false) — include hook event JSON and trigger type in notifications

package/notifier/notifier.js

@@ -158,26 +158,73 @@ function isNotifierDisabled () {
   return false;
 }
 
-function writePtySignalFile (event) {
-  const sessionId = event.session_id || 'unknown';
-  const cwd = event.cwd || process.cwd();
+function writeSignalFile (name, data) {
   try {
     fs.mkdirSync(PTY_SIGNAL_DIR, { recursive: true });
-    const signalFile = path.join(PTY_SIGNAL_DIR, `${sessionId}.json`);
-    fs.writeFileSync(signalFile, JSON.stringify({
-      sessionId,
-      cwd,
-      lastAssistantMessage: event.last_assistant_message || '',
-      cost: event.total_cost_usd || 0,
-      numTurns: event.num_turns || 0,
-      durationMs: event.duration_ms || 0,
-      timestamp: Date.now(),
-    }));
+    fs.writeFileSync(path.join(PTY_SIGNAL_DIR, name), JSON.stringify(data));
   } catch {
     // silent fail
   }
 }
 
+function writePtySignalFile (event) {
+  const sessionId = event.session_id || 'unknown';
+  writeSignalFile(`${sessionId}.json`, {
+    sessionId,
+    cwd: event.cwd || process.cwd(),
+    lastAssistantMessage: event.last_assistant_message || '',
+    cost: event.total_cost_usd || 0,
+    numTurns: event.num_turns || 0,
+    durationMs: event.duration_ms || 0,
+    timestamp: Date.now(),
+  });
+}
+
+function writeErrorSignalFile (event) {
+  const sessionId = event.session_id || 'unknown';
+  writeSignalFile(`err_${sessionId}.json`, {
+    type: 'error',
+    cwd: event.cwd || process.cwd(),
+    error: event.error || 'unknown',
+    errorDetails: event.error_details || '',
+    lastAssistantMessage: event.last_assistant_message || '',
+    timestamp: Date.now(),
+  });
+}
+
+function writeReadySignalFile (event) {
+  const sessionId = event.session_id || 'unknown';
+  writeSignalFile(`rdy_${sessionId}.json`, {
+    type: 'ready',
+    cwd: event.cwd || process.cwd(),
+    model: event.model || '',
+    source: event.source || '',
+    timestamp: Date.now(),
+  });
+}
+
+function writeActivitySignalFile (event) {
+  const sessionId = event.session_id || 'unknown';
+  writeSignalFile(`act_${sessionId}.json`, {
+    type: 'activity',
+    cwd: event.cwd || process.cwd(),
+    toolName: event.tool_name || '',
+    toolInput: event.tool_input || {},
+    timestamp: Date.now(),
+  });
+}
+
+function writeCompactSignalFile (event) {
+  const sessionId = event.session_id || 'unknown';
+  writeSignalFile(`cmp_${sessionId}.json`, {
+    type: 'compact',
+    cwd: event.cwd || process.cwd(),
+    summary: event.compact_summary || '',
+    trigger: event.trigger || '',
+    timestamp: Date.now(),
+  });
+}
+
 // ----------------------
 // STATE FILE
 // ----------------------
@@ -659,10 +706,32 @@ process.stdin.on('end', async () => {
     process.exit(0);
   }
 
-  // For listener-only mode: write PTY signal file on Stop, then exit
+  // For listener-only mode: handle events via signal files, then exit
   if (disabled === 'listener-only') {
-    if (eventType === 'Stop') {
-      writePtySignalFile(event);
+    switch (eventType) {
+      case 'PermissionRequest':
+        process.stdout.write(JSON.stringify({
+          hookSpecificOutput: {
+            hookEventName: 'PermissionRequest',
+            decision: { behavior: 'allow' },
+          },
+        }));
+        break;
+      case 'Stop':
+        writePtySignalFile(event);
+        break;
+      case 'StopFailure':
+        writeErrorSignalFile(event);
+        break;
+      case 'SessionStart':
+        writeReadySignalFile(event);
+        break;
+      case 'PostToolUse':
+        writeActivitySignalFile(event);
+        break;
+      case 'PostCompact':
+        writeCompactSignalFile(event);
+        break;
     }
     process.exit(0);
   }
@@ -691,7 +760,7 @@ process.stdin.on('end', async () => {
   // STOP / NOTIFICATION EVENT
   // ----------------------
 
-  if (eventType !== 'Stop' && eventType !== 'Notification') {
+  if (eventType !== 'Stop' && eventType !== 'Notification' && eventType !== 'StopFailure') {
     process.exit(0);
   }
 
@@ -709,8 +778,8 @@ process.stdin.on('end', async () => {
     process.exit(0);
   }
 
-  const statusEmoji = eventType === 'Notification' ? '⏸' : '✅';
-  const desktopStatus = eventType === 'Notification' ? 'Waiting' : 'Finished';
+  const statusEmoji = eventType === 'Notification' ? '⏸' : eventType === 'StopFailure' ? '❌' : '✅';
+  const desktopStatus = eventType === 'Notification' ? 'Waiting' : eventType === 'StopFailure' ? `Error: ${event.error || 'unknown'}` : 'Finished';
 
   const branch = getBranch(cwd);
   let label = `/${project}`;

package/package.json

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