claude-notification-plugin 1.1.35 → 1.1.39

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-notification-plugin",
-  "version": "1.1.35",
+  "version": "1.1.39",
   "description": "Claude Code task-completion notifications: Telegram, desktop notifications (Windows/macOS/Linux), sound, and voice",
   "author": {
     "name": "Viacheslav Makarov",
@@ -9,5 +9,12 @@
   "homepage": "https://github.com/Bazilio-san/claude-notification-plugin#readme",
   "repository": "https://github.com/Bazilio-san/claude-notification-plugin",
   "license": "MIT",
-  "keywords": ["notification", "telegram", "windows", "sound", "voice", "hooks"]
+  "keywords": [
+    "notification",
+    "telegram",
+    "windows",
+    "sound",
+    "voice",
+    "hooks"
+  ]
 }

package/README.md

@@ -96,7 +96,9 @@ Config file: `~/.claude/claude-notify.config.json`
     "maxQueuePerWorkDir": 10,
     "maxTotalTasks": 50,
     "logDir": "abs-path-to-listener-logs",
-    "taskLogDir": "abs-path-to-task-logs"
+    "taskLogDir": "abs-path-to-task-logs",
+    "liveConsole": true,
+    "liveConsoleInterval": 5
   }
 }
 ```
@@ -246,6 +248,7 @@ All commands start with `/` and execute instantly (not queued).
 | `/worktrees /project`         | List worktrees                       |
 | `/worktree /project/branch`   | Create a worktree                    |
 | `/rmworktree /project/branch` | Remove a worktree                    |
+| `/pty [/project[/branch]]`    | PTY session diagnostics (state, buffer, output) |
 | `/history`                    | Recent task history                  |
 | `/stop`                       | Stop the listener                    |
 | `/help`                       | Show help                            |
@@ -264,6 +267,9 @@ All commands start with `/` and execute instantly (not queued).
 | `maxTotalTasks`      | `50`                  | Max tasks across all queues                                                            |
 | `logDir`             | `~/.claude`           | Listener log directory                                                                 |
 | `taskLogDir`         | same as `logDir`      | Task Q&A log directory                                                                 |
+| `liveConsole`        | `true`                | Stream PTY output to the "Running..." Telegram message in real-time                    |
+| `liveConsoleInterval`| `5`                   | Live console update interval in seconds                                                |
+
 
 ### Projects and worktrees
 

package/commit-sha

@@ -1 +1 @@
-0c61ed57e3d709a6379f00009d55d8f6093f1cbc
+99358845aa9de2dfad99bbc5091580dcc91df4ed

package/listener/LISTENER-DETAILED.md

@@ -20,6 +20,7 @@ and executes them on your machine via an interactive Claude Code PTY session. Th
 - [Projects and worktrees](#projects-and-worktrees)
 - [Task queues](#task-queues)
 - [Bot commands](#bot-commands)
+- [Live console and PTY diagnostics](#live-console-and-pty-diagnostics)
 - [Task lifecycle](#task-lifecycle)
 - [State files](#state-files)
 - [Security](#security)
@@ -722,12 +723,75 @@ Bot: 👋 Listener is shutting down...
 
 All active tasks will be terminated. Queues are saved to disk and will be restored on the next startup.
 
+### /pty — PTY diagnostics
+
+Shows real-time information about PTY sessions: state, buffer size, live console status, and the last 15 lines of cleaned output.
+
+```
+You: /pty
+Bot: 🖥 PTY Sessions:
+
+     /api
+     State: busy
+     Buffer: 12480 bytes
+     Elapsed: 2m 35s
+     Live console: ✅
+     PTY log: writing
+
+     ◐ Reading src/auth.js
+     ● Editing src/middleware.js
+       Added JWT validation...
+```
+
+```
+You: /pty /api
+Bot: (same, but for a specific project)
+```
+
 ### /help — help
 
 Shows a brief reference for all commands.
 
 ---
 
+## Live console and PTY diagnostics
+
+### Live console
+
+When **`liveConsole`** is enabled (default: `true`), the "⏳ Running..." message in Telegram is periodically updated with the cleaned tail of Claude Code's PTY output, so you can see what Claude is doing in real-time.
+
+The output is cleaned from ANSI escape codes and Claude Code UI chrome (logo, status bar, prompts), leaving only meaningful content.
+
+Configuration:
+- `liveConsole` — enable/disable (default: `true`)
+- `liveConsoleInterval` — update interval in seconds (default: `5`)
+
+### PTY logs
+
+Each running task writes raw PTY output to a file: `{taskLogDir}/{project}_{branch}_pty.log`.
+The file is overwritten when a new task starts for the same project/branch.
+
+Monitor in real-time:
+```bash
+# Linux / macOS / Git Bash
+tail -f ~/.claude/myproject_main_pty.log
+
+# Windows PowerShell
+Get-Content ~/.claude/myproject_main_pty.log -Wait -Tail 50
+```
+
+### /pty command
+
+Send `/pty` or `/pty /project` in Telegram to get instant diagnostics:
+- Session state (`busy` / `idle` / `starting`)
+- Buffer size in bytes
+- Elapsed time since task start
+- Whether live console interval is active
+- Whether PTY log stream is writing
+- Last 15 lines of cleaned output
+
+---
+
 ## Task lifecycle
 
 ### Path of a task from message to result

package/listener/listener.js

@@ -6,7 +6,7 @@ import path from 'path';
 import process from 'process';
 import { createLogger } from './logger.js';
 import { createTaskLogger } from './task-logger.js';
-import { TelegramPoller, escapeHtml } from './telegram-poller.js';
+import { TelegramPoller, escapeHtml, cleanPtyOutput } from './telegram-poller.js';
 import { WorkQueue } from './work-queue.js';
 import { PtyRunner } from './pty-runner.js';
 import { WorktreeManager } from './worktree-manager.js';
@@ -100,20 +100,27 @@ const taskLogDir = config.listener?.taskLogDir || listenerLogDir;
 fs.mkdirSync(taskLogDir, { recursive: true });
 const taskLogger = createTaskLogger(taskLogDir);
 
-const runner = new PtyRunner(logger, taskTimeout, taskLogger);
+const runner = new PtyRunner(logger, taskTimeout, taskLogger, taskLogDir);
 
 const worktreeManager = new WorktreeManager(config, logger);
 
+const liveConsoleEnabled = listenerConfig.liveConsole !== false; // default: true
+const liveConsoleInterval = (listenerConfig.liveConsoleInterval || 5) * 1000;
+const LIVE_CONSOLE_MAX_OUTPUT = 3000;
+
 const startTime = Date.now();
 
 // Session tracking per workDir: { taskCount, lastSessionId, lastContextPct }
 const sessions = new Map();
 // WorkDirs that should start a fresh session on next task
 const freshSessionDirs = new Set();
+// Live console intervals per workDir
+const liveConsoleTimers = new Map();
 
 logger.info('Listener started');
 logger.info(`Projects: ${JSON.stringify(Object.keys(listenerConfig.projects))}`);
 logger.info(`Session continuity: ${continueSessionEnabled ? 'enabled' : 'disabled'}`);
+logger.info(`Live console: ${liveConsoleEnabled ? `enabled (${liveConsoleInterval / 1000}s interval)` : 'disabled'}`);
 
 // ----------------------
 // DISCOVER WORKTREES ON START
@@ -139,6 +146,7 @@ for (const { workDir, next } of recovered) {
 // ----------------------
 
 runner.on('complete', async (workDir, task, result) => {
+  stopLiveConsole(workDir);
   const entry = queue.queues[workDir];
   const label = formatLabel(entry);
 
@@ -209,6 +217,7 @@ runner.on('complete', async (workDir, task, result) => {
 });
 
 runner.on('error', async (workDir, task, errorMsg) => {
+  stopLiveConsole(workDir);
   const entry = queue.queues[workDir];
   const label = formatLabel(entry);
 
@@ -227,6 +236,7 @@ runner.on('error', async (workDir, task, errorMsg) => {
 });
 
 runner.on('timeout', async (workDir, task) => {
+  stopLiveConsole(workDir);
   const entry = queue.queues[workDir];
   const label = formatLabel(entry);
   const timeoutMin = Math.round(taskTimeout / 60000);
@@ -278,6 +288,52 @@ function shouldContinueSession (workDir) {
   return sessions.has(workDir);
 }
 
+function startLiveConsole (workDir, messageId, header) {
+  stopLiveConsole(workDir);
+  if (!liveConsoleEnabled || !messageId) {
+    return;
+  }
+  let lastSentText = '';
+  const timer = setInterval(async () => {
+    try {
+      const raw = runner.getBuffer(workDir);
+      if (!raw) {
+        return;
+      }
+      const cleaned = cleanPtyOutput(raw);
+      if (!cleaned) {
+        return;
+      }
+      // Take the tail that fits
+      const tail = cleaned.length > LIVE_CONSOLE_MAX_OUTPUT
+        ? cleaned.slice(-LIVE_CONSOLE_MAX_OUTPUT)
+        : cleaned;
+      // Trim to last complete line if we sliced mid-line
+      const output = cleaned.length > LIVE_CONSOLE_MAX_OUTPUT
+        ? tail.slice(tail.indexOf('\n') + 1)
+        : tail;
+      if (!output || output === lastSentText) {
+        return;
+      }
+      lastSentText = output;
+      const elapsed = formatDuration(Date.now() - new Date(runner.getActive(workDir)?.startedAt || Date.now()).getTime());
+      const text = `${header}\n<i>${elapsed}</i>\n\n<pre>${escapeHtml(output)}</pre>`;
+      await poller.editMessage(messageId, text);
+    } catch (err) {
+      logger.warn(`Live console edit error: ${err.message}`);
+    }
+  }, liveConsoleInterval);
+  liveConsoleTimers.set(workDir, timer);
+}
+
+function stopLiveConsole (workDir) {
+  const timer = liveConsoleTimers.get(workDir);
+  if (timer) {
+    clearInterval(timer);
+    liveConsoleTimers.delete(workDir);
+  }
+}
+
 async function startTask (workDir, task) {
   const entry = queue.queues[workDir];
   const label = formatLabel(entry);
@@ -308,6 +364,7 @@ async function startTask (workDir, task) {
   }
 
   task.runningMessageId = runningMsgId;
+  startLiveConsole(workDir, runningMsgId, runningFull);
   const claudeArgs = getClaudeArgs(entry?.project);
   try {
     runner.run(workDir, task, claudeArgs, continueSession);
@@ -355,6 +412,8 @@ async function handleCommand (cmd, args) {
       return handleRemoveWorktree(args);
     case '/history':
       return handleHistory();
+    case '/pty':
+      return handlePty(args);
     case '/stop':
       return handleStop();
     case '/help':
@@ -631,6 +690,63 @@ function handleRemoveWorktree (args) {
   }
 }
 
+function handlePty (args) {
+  const target = parseTarget(args);
+
+  if (target) {
+    let workDir;
+    try {
+      workDir = worktreeManager.resolveWorkDir(target.project, target.branch);
+    } catch (err) {
+      return `❌ ${escapeHtml(err.message)}`;
+    }
+    const info = runner.getSessionInfo(workDir);
+    if (!info) {
+      return `🖥 No PTY session for /${escapeHtml(target.project)}${target.branch ? '/' + escapeHtml(target.branch) : ''}`;
+    }
+    return formatPtyInfo(target.project, target.branch, workDir, info);
+  }
+
+  // All sessions
+  const allInfo = runner.getAllSessionInfo();
+  if (Object.keys(allInfo).length === 0) {
+    return '🖥 No active PTY sessions';
+  }
+
+  let text = '🖥 <b>PTY Sessions:</b>\n';
+  for (const [workDir, info] of Object.entries(allInfo)) {
+    const entry = queue.queues[workDir];
+    const project = entry?.project || '?';
+    const branch = entry?.branch || null;
+    text += '\n' + formatPtyInfo(project, branch, workDir, info);
+  }
+  return text;
+}
+
+function formatPtyInfo (project, branch, workDir, info) {
+  const label = branch && branch !== 'main' && branch !== 'master'
+    ? `/${project}/${branch}`
+    : `/${project}`;
+  const elapsed = info.startedAt
+    ? formatDuration(Date.now() - new Date(info.startedAt).getTime())
+    : '-';
+  const liveTimer = liveConsoleTimers.has(workDir) ? '✅' : '❌';
+  const raw = runner.getBuffer(workDir);
+  const cleaned = raw ? cleanPtyOutput(raw) : '';
+  const lastLines = cleaned
+    ? cleaned.split('\n').slice(-15).join('\n')
+    : '(empty)';
+
+  return `<b>${escapeHtml(label)}</b>
+State: <code>${info.state}</code>
+Buffer: <code>${info.bufferSize}</code> bytes
+Elapsed: ${elapsed}
+Live console: ${liveTimer}
+PTY log: <code>${info.hasLogStream ? 'writing' : 'off'}</code>
+
+<pre>${escapeHtml(lastLines)}</pre>`;
+}
+
 function handleHistory () {
   const history = queue.getHistory(10);
   if (history.length === 0) {
@@ -669,6 +785,7 @@ function handleHelp () {
 /worktrees /project — project worktrees
 /worktree /project/branch — create worktree
 /rmworktree /project/branch — remove worktree
+/pty [/project[/branch]] — PTY session diagnostics
 /history — task history
 /stop — stop listener
 /help — this help
@@ -752,6 +869,9 @@ let running = true;
 process.on('SIGTERM', () => {
   logger.info('Received SIGTERM');
   running = false;
+  for (const wd of liveConsoleTimers.keys()) {
+    stopLiveConsole(wd);
+  }
   runner.cancelAll();
   setTimeout(() => process.exit(0), 2000);
 });
@@ -759,6 +879,9 @@ process.on('SIGTERM', () => {
 process.on('SIGINT', () => {
   logger.info('Received SIGINT');
   running = false;
+  for (const wd of liveConsoleTimers.keys()) {
+    stopLiveConsole(wd);
+  }
   runner.cancelAll();
   setTimeout(() => process.exit(0), 2000);
 });

package/listener/pty-runner.js

@@ -13,12 +13,13 @@ const DEFAULT_TIMEOUT = 600_000; // 10 minutes
  * receives completion signals via marker files written by the notifier hook.
  */
 export class PtyRunner extends EventEmitter {
-  constructor (logger, timeout, taskLogger) {
+  constructor (logger, timeout, taskLogger, ptyLogDir) {
     super();
     this.logger = logger;
     this.timeout = timeout || DEFAULT_TIMEOUT;
     this.taskLogger = taskLogger || null;
-    // workDir -> { pty, state, currentTask, sessionId, workDir, _pendingId, _buffer }
+    this.ptyLogDir = ptyLogDir || null;
+    // workDir -> { pty, state, currentTask, sessionId, workDir, _pendingId, _buffer, _logStream }
     this.sessions = new Map();
     this.pendingMarkers = new Map(); // pendingId -> resolve callback
     this._pty = null; // lazy-loaded node-pty module
@@ -196,6 +197,27 @@ export class PtyRunner extends EventEmitter {
     });
   }
 
+  _openPtyLog (session, task) {
+    if (session._logStream) {
+      session._logStream.end();
+      session._logStream = null;
+    }
+    if (!this.ptyLogDir) {
+      return;
+    }
+    try {
+      const project = task.project || 'unknown';
+      const branch = (task.branch || 'main').replace(/[/\\:*?"<>|]/g, '_');
+      const logFile = path.join(this.ptyLogDir, `${project}_${branch}_pty.log`);
+      session._logStream = fs.createWriteStream(logFile, { flags: 'w' });
+      session._logStream.on('error', () => {
+        session._logStream = null;
+      });
+    } catch {
+      // ignore — logging is best-effort
+    }
+  }
+
   /**
    * Send a task to an existing PTY session and wait for completion.
    */
@@ -205,12 +227,16 @@ export class PtyRunner extends EventEmitter {
     session.state = 'busy';
     session.currentTask = task;
     session._pendingId = pendingId;
+    session._buffer = '';
+    this._openPtyLog(session, task);
 
     // Set up marker wait + timeout
     const markerPromise = this._waitForMarker(pendingId, this.timeout);
 
-    // Send the task text to the PTY
-    session.pty.write(task.text + '\r');
+    // Send the task text to the PTY using bracketed paste mode.
+    // Without this, newlines in the text are interpreted as Enter keypresses,
+    // splitting the prompt into multiple submissions and breaking the flow.
+    session.pty.write(`\x1b[200~${task.text}\x1b[201~\r`);
     this.logger.info(`PTY task sent to ${workDir}: ${task.text.slice(0, 100)}`);
 
     // Handle completion asynchronously
@@ -302,6 +328,9 @@ export class PtyRunner extends EventEmitter {
       if (session._buffer.length > 50000) {
         session._buffer = session._buffer.slice(-25000);
       }
+      if (session._logStream) {
+        session._logStream.write(data);
+      }
     });
 
     ptyProcess.onExit(({ exitCode }) => {
@@ -380,6 +409,11 @@ export class PtyRunner extends EventEmitter {
       this.pendingMarkers.delete(session._pendingId);
     }
 
+    if (session._logStream) {
+      session._logStream.end();
+      session._logStream = null;
+    }
+
     try {
       if (session.pty) {
         session.pty.kill();
@@ -430,6 +464,50 @@ export class PtyRunner extends EventEmitter {
     return session?.currentTask || null;
   }
 
+  /**
+   * Get the raw PTY buffer for a workDir.
+   */
+  getBuffer (workDir) {
+    const session = this.sessions.get(workDir);
+    return session?._buffer || '';
+  }
+
+  /**
+   * Get diagnostic info about a PTY session.
+   */
+  getSessionInfo (workDir) {
+    const session = this.sessions.get(workDir);
+    if (!session) {
+      return null;
+    }
+    return {
+      state: session.state,
+      bufferSize: session._buffer?.length || 0,
+      hasLogStream: !!session._logStream,
+      taskText: session.currentTask?.text || null,
+      startedAt: session.currentTask?.startedAt || null,
+      sessionId: session.sessionId || null,
+      pendingId: session._pendingId || null,
+    };
+  }
+
+  /**
+   * Get diagnostic info for all sessions.
+   */
+  getAllSessionInfo () {
+    const result = {};
+    for (const [workDir, session] of this.sessions) {
+      result[workDir] = {
+        state: session.state,
+        bufferSize: session._buffer?.length || 0,
+        hasLogStream: !!session._logStream,
+        taskText: session.currentTask?.text || null,
+        startedAt: session.currentTask?.startedAt || null,
+      };
+    }
+    return result;
+  }
+
   /**
    * Cancel all active tasks (for graceful shutdown).
    */

package/listener/telegram-poller.js

@@ -145,6 +145,43 @@ export class TelegramPoller {
     }
   }
 
+  async editMessage (messageId, text) {
+    if (!messageId) {
+      return false;
+    }
+    try {
+      const res = await fetch(`${this.baseUrl}/editMessageText`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          chat_id: this.chatId,
+          message_id: messageId,
+          text,
+          parse_mode: 'HTML',
+        }),
+      });
+      const data = await res.json();
+      if (!data.ok) {
+        // Retry without HTML parse mode if formatting fails
+        const res2 = await fetch(`${this.baseUrl}/editMessageText`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            chat_id: this.chatId,
+            message_id: messageId,
+            text,
+          }),
+        });
+        const data2 = await res2.json();
+        return data2.ok;
+      }
+      return true;
+    } catch (err) {
+      this.logger.error(`editMessage error: ${err.message}`);
+      return false;
+    }
+  }
+
   async sendDocument (buffer, filename, caption) {
     try {
       const formData = new FormData();
@@ -200,4 +237,74 @@ function splitMessage (text) {
   return chunks;
 }
 
-export { escapeHtml };
+// Strip ANSI escape codes and terminal control sequences from PTY output
+function stripAnsi (text) {
+  return text
+    // CSI sequences: \x1b[ followed by optional ?/>/! prefix, params, and terminator
+    .replace(/\x1b\[[?>=!]?[0-9;]*[a-zA-Z~]/g, '')
+    // OSC sequences: \x1b] ... (terminated by BEL or ST)
+    .replace(/\x1b][^\x07\x1b]*(?:\x07|\x1b\\)/g, '')
+    // Other two-char escape sequences (\x1b followed by any single char)
+    .replace(/\x1b[^[\]]/g, '')
+    // Carriage returns (overwrite lines)
+    .replace(/\r/g, '')
+    // Remaining control chars except newline and tab
+    .replace(/[\x00-\x08\x0b\x0c\x0e-\x1f]/g, '');
+}
+
+// Clean PTY output for display: strip ANSI + remove Claude Code UI chrome
+function cleanPtyOutput (raw) {
+  const stripped = stripAnsi(raw);
+  const lines = stripped.split('\n');
+  const cleaned = [];
+  for (const line of lines) {
+    const trimmed = line.trimEnd();
+    // Skip empty lines
+    if (!trimmed) {
+      continue;
+    }
+    // Skip Claude Code UI: logo, banner, horizontal rules, prompts, status
+    if (/^[▐▝▘▛▜█▌▀▄░▒▓\s]+$/.test(trimmed)) {
+      continue;
+    }
+    if (/^[─━═╌┄]+$/.test(trimmed)) {
+      continue;
+    }
+    if (/^❯\s/.test(trimmed)) {
+      continue;
+    }
+    if (/^[⏵⏴]\s*[⏵⏴]?\s*(bypass|auto|plan|permissions?)/i.test(trimmed)) {
+      continue;
+    }
+    if (/^◐\s/.test(trimmed) || /^\s*◐\s/.test(trimmed)) {
+      continue;
+    }
+    if (/Pasting\s*text/i.test(trimmed)) {
+      continue;
+    }
+    if (/^Claude\s*Code\s*v/i.test(trimmed)) {
+      continue;
+    }
+    if (/Opus|Sonnet|Haiku|Claude\s*Max/i.test(trimmed) && trimmed.length < 80) {
+      continue;
+    }
+    if (/shift\+tab\s*to\s*cycle/i.test(trimmed)) {
+      continue;
+    }
+    if (/ctrl\+[a-z]\s+to\s/i.test(trimmed)) {
+      continue;
+    }
+    if (/^Try\s*"/.test(trimmed)) {
+      continue;
+    }
+    // Skip lines that are mostly box-drawing or block chars (>50%)
+    const specialChars = (trimmed.match(/[▐▝▘▛▜█▌▀▄░▒▓─━═╌┄│┃┌┐└┘├┤┬┴┼╔╗╚╝╠╣╦╩╬]/g) || []).length;
+    if (specialChars > trimmed.length * 0.5) {
+      continue;
+    }
+    cleaned.push(trimmed);
+  }
+  return cleaned.join('\n');
+}
+
+export { escapeHtml, stripAnsi, cleanPtyOutput };

package/package.json

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