claude-notification-plugin 1.1.81 → 1.1.84

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-notification-plugin",
-  "version": "1.1.81",
+  "version": "1.1.84",
   "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/commit-sha

@@ -1 +1 @@
-5028775e89c41e96abd523526de5ff59ab1bb1e7
+642d44de740e6e85d391634789966980a389d893

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);
@@ -406,9 +436,10 @@ export class PtyRunner extends EventEmitter {
     // Filter out pipe-mode-specific args
     const args = claudeArgs.filter(a => a !== '-p' && a !== '--output-format' && a !== 'json');
 
-    // Ensure --permission-mode is set (default: auto) to prevent interactive permission prompts
-    if (!args.includes('--permission-mode')) {
-      args.push('--permission-mode', 'auto');
+    // Ensure --permission-mode is set to prevent interactive permission prompts.
+    // Use bypassPermissions as default — "auto" is not available on all plans/providers.
+    if (!args.includes('--permission-mode') && !args.includes('--dangerously-skip-permissions')) {
+      args.push('--permission-mode', 'bypassPermissions');
     }
 
     // Reduce PTY output noise: disable animations, progress bar, tips

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(),
     };
 

package/package.json

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