claude-notification-plugin 1.0.80 → 1.0.88

package/bin/install.js

@@ -4,17 +4,246 @@ import fs from 'fs';
 import os from 'os';
 import path from 'path';
 import readline from 'readline';
+import { execSync } from 'child_process';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const PACKAGE_ROOT = path.resolve(__dirname, '..');
 
 const home = os.homedir();
 const claudeDir = path.join(home, '.claude');
+const pluginsDir = path.join(claudeDir, 'plugins');
 const configPath = path.join(claudeDir, 'notifier.config.json');
 const settingsPath = path.join(claudeDir, 'settings.json');
+const installedPluginsPath = path.join(pluginsDir, 'installed_plugins.json');
+const knownMarketplacesPath = path.join(pluginsDir, 'known_marketplaces.json');
+const marketplacesDir = path.join(pluginsDir, 'marketplaces');
+const RESOLVER_PATH = path.join(claudeDir, 'claude-notify-resolve.js');
 
 const HOOK_COMMAND = 'claude-notifier';
+const MARKETPLACE_KEY = 'bazilio-plugins';
+const PLUGIN_KEY = 'claude-notification-plugin@bazilio-plugins';
+const MARKETPLACE_REPO = 'https://github.com/Bazilio-san/claude-plugins.git';
+const MARKETPLACE_GITHUB = 'Bazilio-san/claude-plugins';
+
+const CLI_BINS = {
+  'claude-notify-listener': 'bin/listener-cli.js',
+  'claude-notify-install': 'bin/install.js',
+  'claude-notify-uninstall': 'bin/uninstall.js',
+};
+
+// ──────────────────────────────────────
+// Plugin registration
+// ──────────────────────────────────────
+
+function getVersion () {
+  const pkg = JSON.parse(fs.readFileSync(path.join(PACKAGE_ROOT, 'package.json'), 'utf-8'));
+  return pkg.version;
+}
+
+function copyToCache (version) {
+  const cacheBase = path.join(pluginsDir, 'cache', MARKETPLACE_KEY, 'claude-notification-plugin');
+  const dest = path.join(cacheBase, version);
+
+  if (fs.existsSync(dest)) {
+    fs.rmSync(dest, { recursive: true });
+  }
+  fs.mkdirSync(dest, { recursive: true });
+
+  const pkg = JSON.parse(fs.readFileSync(path.join(PACKAGE_ROOT, 'package.json'), 'utf-8'));
+  const entries = [...(pkg.files || []), 'package.json', 'package-lock.json'];
+
+  for (const entry of entries) {
+    const src = path.join(PACKAGE_ROOT, entry);
+    if (!fs.existsSync(src)) {
+      continue;
+    }
+    const target = path.join(dest, entry);
+    const stat = fs.statSync(src);
+    if (stat.isDirectory()) {
+      fs.cpSync(src, target, { recursive: true });
+    } else {
+      fs.mkdirSync(path.dirname(target), { recursive: true });
+      fs.copyFileSync(src, target);
+    }
+  }
+
+  try {
+    execSync('npm install --production --ignore-scripts', {
+      cwd: dest,
+      stdio: 'pipe',
+      windowsHide: true,
+    });
+  } catch {
+    console.warn('  Warning: could not install dependencies in plugin cache.');
+  }
+
+  return dest;
+}
+
+function updateInstalledPlugins (version, installPath) {
+  fs.mkdirSync(pluginsDir, { recursive: true });
+
+  let data = { version: 2, plugins: {} };
+  if (fs.existsSync(installedPluginsPath)) {
+    try {
+      data = JSON.parse(fs.readFileSync(installedPluginsPath, 'utf-8'));
+    } catch {
+      // ignore malformed file
+    }
+  }
+
+  const now = new Date().toISOString();
+  const existing = data.plugins[PLUGIN_KEY]?.[0];
+
+  data.plugins[PLUGIN_KEY] = [{
+    scope: 'user',
+    installPath,
+    version,
+    installedAt: existing?.installedAt || now,
+    lastUpdated: now,
+    gitCommitSha: existing?.gitCommitSha || '',
+  }];
+
+  fs.writeFileSync(installedPluginsPath, JSON.stringify(data, null, 2));
+}
+
+function updateKnownMarketplaces () {
+  let data = {};
+  if (fs.existsSync(knownMarketplacesPath)) {
+    try {
+      data = JSON.parse(fs.readFileSync(knownMarketplacesPath, 'utf-8'));
+    } catch {
+      // ignore malformed file
+    }
+  }
+
+  const installLocation = path.join(marketplacesDir, MARKETPLACE_KEY);
+
+  data[MARKETPLACE_KEY] = {
+    ...data[MARKETPLACE_KEY],
+    source: {
+      source: 'github',
+      repo: MARKETPLACE_GITHUB,
+    },
+    installLocation,
+    lastUpdated: data[MARKETPLACE_KEY]?.lastUpdated || new Date().toISOString(),
+    autoUpdate: true,
+  };
+
+  fs.writeFileSync(knownMarketplacesPath, JSON.stringify(data, null, 2));
+}
+
+function cloneOrUpdateMarketplace () {
+  const dest = path.join(marketplacesDir, MARKETPLACE_KEY);
+
+  if (fs.existsSync(path.join(dest, '.git'))) {
+    try {
+      execSync('git pull --ff-only', { cwd: dest, stdio: 'pipe', windowsHide: true });
+    } catch {
+      // offline or conflict — not fatal
+    }
+  } else {
+    fs.mkdirSync(marketplacesDir, { recursive: true });
+    try {
+      execSync(`git clone "${MARKETPLACE_REPO}" "${dest}"`, {
+        stdio: 'pipe',
+        windowsHide: true,
+      });
+    } catch {
+      console.warn('  Warning: could not clone marketplace repo (offline?).');
+    }
+  }
+}
+
+// ──────────────────────────────────────
+// CLI wrapper registration
+// ──────────────────────────────────────
+
+function writeResolver () {
+  const content = `#!/usr/bin/env node
+'use strict';
+const fs = require('fs');
+const path = require('path');
+const { execFileSync } = require('child_process');
+
+const pluginKey = 'claude-notification-plugin@bazilio-plugins';
+const home = process.env.USERPROFILE || process.env.HOME;
+const regPath = path.join(home, '.claude', 'plugins', 'installed_plugins.json');
+
+let installPath;
+try {
+  const reg = JSON.parse(fs.readFileSync(regPath, 'utf-8'));
+  const entries = reg.plugins[pluginKey];
+  if (entries && entries.length) installPath = entries[0].installPath;
+} catch {}
+
+if (!installPath) {
+  console.error('claude-notification-plugin is not installed.');
+  process.exit(1);
+}
 
-// ----------------------
-// HELPERS
-// ----------------------
+const target = path.join(installPath, process.argv[2]);
+const args = process.argv.slice(3);
+
+try {
+  execFileSync('node', [target, ...args], { stdio: 'inherit' });
+} catch (e) {
+  process.exit(e.status || 1);
+}
+`;
+  fs.writeFileSync(RESOLVER_PATH, content, { mode: 0o755 });
+}
+
+function findClaudeDir () {
+  try {
+    const cmd = process.platform === 'win32' ? 'where claude' : 'which claude';
+    const result = execSync(cmd, { encoding: 'utf-8', windowsHide: true }).trim();
+    const first = result.split('\n')[0].trim();
+    return path.dirname(first);
+  } catch {
+    return null;
+  }
+}
+
+function registerCli () {
+  const binDir = findClaudeDir();
+  if (!binDir) {
+    console.warn('  Warning: "claude" not found in PATH — CLI wrappers not registered.');
+    return;
+  }
+
+  writeResolver();
+
+  const isWindows = process.platform === 'win32';
+  const resolverNative = RESOLVER_PATH.replace(/\//g, path.sep);
+  const created = [];
+
+  for (const [name, relPath] of Object.entries(CLI_BINS)) {
+    if (isWindows) {
+      const cmdFile = path.join(binDir, `${name}.cmd`);
+      const content = `@echo off\r\nnode "${resolverNative}" ${relPath} %*\r\n`;
+      fs.writeFileSync(cmdFile, content);
+      created.push(cmdFile);
+    } else {
+      const shFile = path.join(binDir, name);
+      const content = `#!/bin/sh\nexec node "${RESOLVER_PATH}" "${relPath}" "$@"\n`;
+      fs.writeFileSync(shFile, content, { mode: 0o755 });
+      created.push(shFile);
+    }
+  }
+
+  if (created.length > 0) {
+    console.log('  CLI commands registered:');
+    for (const f of created) {
+      console.log(`    ${f}`);
+    }
+  }
+}
+
+// ──────────────────────────────────────
+// Helpers
+// ──────────────────────────────────────
 
 function ask (rl, question) {
   return new Promise((resolve) => {
@@ -65,11 +294,34 @@ function addHook (settings, event) {
   }
 }
 
-// ----------------------
-// MAIN
-// ----------------------
+// ──────────────────────────────────────
+// Main
+// ──────────────────────────────────────
 
 async function main () {
+  // 1. Register plugin in Claude Code
+  const version = getVersion();
+
+  console.log('');
+  console.log(`Registering plugin v${version} in Claude Code...`);
+
+  const installPath = copyToCache(version);
+  console.log(`  Cached: ${installPath}`);
+
+  updateInstalledPlugins(version, installPath);
+  console.log('  Updated installed_plugins.json');
+
+  updateKnownMarketplaces();
+  console.log('  Updated known_marketplaces.json');
+
+  cloneOrUpdateMarketplace();
+  console.log('  Marketplace synced');
+
+  registerCli();
+
+  console.log('  Plugin registered.');
+
+  // 2. Interactive Telegram setup
   const rl = readline.createInterface({
     input: process.stdin,
     output: process.stdout,
@@ -80,7 +332,6 @@ async function main () {
   console.log('==================================');
   console.log('');
 
-  // Load existing config
   let existing = {};
   if (fs.existsSync(configPath)) {
     try {
@@ -93,7 +344,6 @@ async function main () {
   const existingToken = existing.telegram?.token || '';
   const existingChatId = existing.telegram?.chatId || '';
 
-  // Telegram setup
   let token = existingToken;
   let chatId = existingChatId;
 
@@ -103,7 +353,7 @@ async function main () {
     const reuse = await ask(rl, 'Keep existing token? (Y/n): ');
     if (reuse.toLowerCase() === 'n') {
       token = await ask(rl, 'New Bot Token: ');
-      chatId = ''; // reset chatId when token changes
+      chatId = '';
     }
   } else {
     const useTelegram = await ask(rl, 'Configure Telegram? (y/N): ');
@@ -112,7 +362,6 @@ async function main () {
     }
   }
 
-  // Fetch chatId if we have a token but no chatId
   if (token && !chatId) {
     console.log('');
     console.log('Send any message to your bot in Telegram, then press Enter.');
@@ -133,7 +382,7 @@ async function main () {
 
   rl.close();
 
-  // Create / update config
+  // 3. Write config
   fs.mkdirSync(claudeDir, { recursive: true });
 
   const platform = process.platform;
@@ -178,16 +427,13 @@ async function main () {
     },
   };
 
-  // Merge defaults with existing config (user values take priority)
   const config = { ...defaults, ...existing };
-  // Deep-merge nested objects
   for (const key of Object.keys(defaults)) {
     if (defaults[key] && typeof defaults[key] === 'object' && !Array.isArray(defaults[key])) {
       config[key] = { ...defaults[key], ...(existing[key] || {}) };
     }
   }
 
-  // Apply Telegram credentials from this run (if provided)
   if (token) {
     config.telegram.token = token;
   }
@@ -197,7 +443,7 @@ async function main () {
 
   fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
 
-  // Patch settings.json
+  // 4. Register hooks
   let settings = {};
 
   if (fs.existsSync(settingsPath)) {
@@ -216,7 +462,7 @@ async function main () {
 
   fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
 
-  // Output
+  // 5. Summary
   console.log('');
   console.log('Installed!');
   console.log('');

package/bin/uninstall.js

@@ -40,8 +40,9 @@ if (fs.existsSync(settingsPath)) {
   }
 }
 
-// Remove config and state files
-for (const file of [configPath, statePath]) {
+// Remove config, state, and resolver files
+const resolverPath = path.join(claudeDir, 'claude-notify-resolve.js');
+for (const file of [configPath, statePath, resolverPath]) {
   if (fs.existsSync(file)) {
     fs.unlinkSync(file);
   }

package/listener/LISTENER-DETAILED.md

@@ -397,7 +397,7 @@ If the worktree doesn't exist, it will be created automatically.
 5. When Claude finishes → sends the result to Telegram
 6. If there's a next task in the queue → starts it
 
----RFr 
+---
 
 ## Projects and worktrees
 
@@ -847,7 +847,7 @@ exec(`claude -p "${userText}"`)
 
 - 10 tasks in the queue per workDir (spam protection)
 - 50 tasks total (overload protection)
-- 10-minute timeout per task (hang protection)
+- 30-minute timeout per task (hang protection)
 
 ---
 
@@ -863,7 +863,7 @@ claude-notify-listener status
 Check:
 
 1. Does the config exist? `cat ~/.claude/notifier.config.json`
-2. Are `telegramToken` and `telegramChatId` present?
+2. Are `telegram.token` and `telegram.chatId` present?
 3. Is there a `listener.projects` section?
 4. Logs: `claude-notify-listener logs`
 

package/listener/listener.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+// noinspection UnnecessaryLocalVariableJS
 
 import fs from 'fs';
 import os from 'os';
@@ -102,24 +103,35 @@ runner.on('complete', async (workDir, task, output) => {
   const entry = queue.queues[workDir];
   const label = formatLabel(entry);
 
-  // Send result
-  let text = `✅ [${label}] Done: ${escapeHtml(task.text)}`;
+  // Delete the "Running" message
+  await poller.deleteMessage(task.runningMessageId);
+
+  // Build result: try replying to user's original message without duplicating the task text.
+  // If reply fails (user deleted their message), resend with task text included.
+  const headerShort = `✅ [${label}] Done:`;
+  const headerFull = `✅ [${label}] Done: ${escapeHtml(task.text)}`;
+  let body = '';
   if (output) {
     if (output.length > 20000) {
       const head = output.slice(0, 2000);
       const tail = output.slice(-2000);
-      text += `\n\n<pre>${escapeHtml(head)}\n\n... (${output.length} chars) ...\n\n${escapeHtml(tail)}</pre>`;
-      // Also send as file
+      body = `\n\n<pre>${escapeHtml(head)}\n\n... (${output.length} chars) ...\n\n${escapeHtml(tail)}</pre>`;
       await poller.sendDocument(
         Buffer.from(output, 'utf-8'),
         `result_${task.id}.txt`,
         `Full output for: ${task.text.slice(0, 100)}`
       );
     } else {
-      text += `\n\n<pre>${escapeHtml(output)}</pre>`;
+      body = `\n\n<pre>${escapeHtml(output)}</pre>`;
     }
   }
-  await poller.sendMessage(text, task.telegramMessageId);
+
+  // Try reply to original message (short header, task text visible in quote)
+  const sentId = await poller.sendMessage(headerShort + body, task.telegramMessageId);
+  if (!sentId && task.telegramMessageId) {
+    // Reply failed — original message was deleted, send without reply but with full task text
+    await poller.sendMessage(headerFull + body);
+  }
 
   // Process next in queue
   const next = queue.onTaskComplete(workDir, output);
@@ -131,10 +143,14 @@ runner.on('complete', async (workDir, task, output) => {
 runner.on('error', async (workDir, task, errorMsg) => {
   const entry = queue.queues[workDir];
   const label = formatLabel(entry);
-  await poller.sendMessage(
-    `❌ [${label}] Error: ${escapeHtml(task.text)}\n\n<pre>${escapeHtml(errorMsg)}</pre>`,
-    task.telegramMessageId,
-  );
+
+  await poller.deleteMessage(task.runningMessageId);
+
+  const body = `\n\n<pre>${escapeHtml(errorMsg)}</pre>`;
+  const sentId = await poller.sendMessage(`❌ [${label}] Error:${body}`, task.telegramMessageId);
+  if (!sentId && task.telegramMessageId) {
+    await poller.sendMessage(`❌ [${label}] Error: ${escapeHtml(task.text)}${body}`);
+  }
 
   const next = queue.onTaskComplete(workDir, `ERROR: ${errorMsg}`);
   if (next) {
@@ -145,10 +161,16 @@ runner.on('error', async (workDir, task, errorMsg) => {
 runner.on('timeout', async (workDir, task) => {
   const entry = queue.queues[workDir];
   const label = formatLabel(entry);
-  await poller.sendMessage(
-    `⏰ [${label}] Task forcefully stopped — timeout exceeded (${Math.round(taskTimeout / 60000)} min): ${escapeHtml(task.text)}`,
-    task.telegramMessageId,
-  );
+  const timeoutMin = Math.round(taskTimeout / 60000);
+
+  await poller.deleteMessage(task.runningMessageId);
+
+  const headerShort = `⏰ [${label}] Task forcefully stopped — timeout exceeded (${timeoutMin} min)`;
+  const headerFull = `${headerShort}: ${escapeHtml(task.text)}`;
+  const sentId = await poller.sendMessage(headerShort, task.telegramMessageId);
+  if (!sentId && task.telegramMessageId) {
+    await poller.sendMessage(headerFull);
+  }
 
   const next = queue.onTaskComplete(workDir, 'TIMEOUT');
   if (next) {
@@ -170,10 +192,11 @@ function formatLabel (entry) {
   return `@${entry.project}`;
 }
 
-function startTask (workDir, task) {
+async function startTask (workDir, task) {
   const entry = queue.queues[workDir];
   const label = formatLabel(entry);
-  poller.sendMessage(`⏳ [${label}] Running: ${escapeHtml(task.text)}`, task.telegramMessageId);
+  const runningMsgId = await poller.sendMessage(`⏳ [${label}] Running: ${escapeHtml(task.text)}`, task.telegramMessageId);
+  task.runningMessageId = runningMsgId;
   try {
     const started = runner.run(workDir, task);
     queue.markStarted(workDir, started.pid);

package/listener/telegram-poller.js

@@ -50,6 +50,7 @@ export class TelegramPoller {
 
   async sendMessage (text, replyToMessageId) {
     const chunks = splitMessage(text);
+    let firstMessageId = null;
     for (const chunk of chunks) {
       try {
         const body = {
@@ -68,7 +69,7 @@ export class TelegramPoller {
         const data = await res.json();
         if (!data.ok) {
           // Retry without HTML parse mode
-          await fetch(`${this.baseUrl}/sendMessage`, {
+          const res2 = await fetch(`${this.baseUrl}/sendMessage`, {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
             body: JSON.stringify({
@@ -77,11 +78,36 @@ export class TelegramPoller {
               ...(replyToMessageId ? { reply_to_message_id: replyToMessageId } : {}),
             }),
           });
+          const data2 = await res2.json();
+          if (data2.ok && !firstMessageId) {
+            firstMessageId = data2.result.message_id;
+          }
+        } else if (!firstMessageId) {
+          firstMessageId = data.result.message_id;
         }
       } catch (err) {
         this.logger.error(`sendMessage error: ${err.message}`);
       }
     }
+    return firstMessageId;
+  }
+
+  async deleteMessage (messageId) {
+    if (!messageId) {
+      return;
+    }
+    try {
+      await fetch(`${this.baseUrl}/deleteMessage`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          chat_id: this.chatId,
+          message_id: messageId,
+        }),
+      });
+    } catch (err) {
+      this.logger.error(`deleteMessage error: ${err.message}`);
+    }
   }
 
   async sendDocument (buffer, filename, caption) {

package/package.json

@@ -1,60 +1,60 @@
-{
-  "name": "claude-notification-plugin",
-  "productName": "claude-notification-plugin",
-  "version": "1.0.80",
-  "description": "Claude Code task-completion notifications: Telegram, desktop notifications (Windows/macOS/Linux), sound, and voice",
-  "type": "module",
-  "engines": {
-    "node": ">=18.0.0"
-  },
-  "files": [
-    ".claude-plugin/",
-    "bin/",
-    "commands/",
-    "hooks/",
-    "listener/",
-    "notifier/",
-    "README.md",
-    "LICENSE"
-  ],
-  "bin": {
-    "claude-notify-install": "bin/install.js",
-    "claude-notify-uninstall": "bin/uninstall.js",
-    "claude-notifier": "notifier/notifier.js",
-    "claude-notify-listener": "bin/listener-cli.js",
-    "claude-notify-register": "bin/register-cli.js"
-  },
-  "scripts": {
-    "lint": "eslint .",
-    "lint:fix": "eslint --fix ."
-  },
-  "keywords": [
-    "claude",
-    "claude-code",
-    "notifications",
-    "telegram",
-    "hooks",
-    "macos",
-    "linux",
-    "cross-platform"
-  ],
-  "author": {
-    "name": "Viacheslav Makarov",
-    "email": "npmjs@bazilio.ru"
-  },
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/Bazilio-san/claude-notification-plugin.git"
-  },
-  "homepage": "https://github.com/Bazilio-san/claude-notification-plugin#readme",
-  "publishConfig": {
-    "access": "public"
-  },
-  "dependencies": {
-    "node-notifier": "^10.0.1"
-  },
-  "devDependencies": {
-    "eslint-plugin-import": "^2.31.0"
-  }
-}
+{
+  "name": "claude-notification-plugin",
+  "productName": "claude-notification-plugin",
+  "version": "1.0.88",
+  "description": "Claude Code task-completion notifications: Telegram, desktop notifications (Windows/macOS/Linux), sound, and voice",
+  "type": "module",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    ".claude-plugin/",
+    "bin/",
+    "hooks/",
+    "listener/",
+    "notifier/",
+    "README.md",
+    "LICENSE"
+  ],
+  "bin": {
+    "claude-notify-install": "bin/install.js",
+    "claude-notify-uninstall": "bin/uninstall.js",
+    "claude-notifier": "notifier/notifier.js",
+    "claude-notify-listener": "bin/listener-cli.js"
+  },
+  "scripts": {
+    "preuninstall": "node bin/uninstall.js",
+    "postinstall": "node bin/install.js",
+    "lint": "eslint .",
+    "lint:fix": "eslint --fix ."
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "notifications",
+    "telegram",
+    "hooks",
+    "macos",
+    "linux",
+    "cross-platform"
+  ],
+  "author": {
+    "name": "Viacheslav Makarov",
+    "email": "npmjs@bazilio.ru"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Bazilio-san/claude-notification-plugin.git"
+  },
+  "homepage": "https://github.com/Bazilio-san/claude-notification-plugin#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "node-notifier": "^10.0.1"
+  },
+  "devDependencies": {
+    "eslint-plugin-import": "^2.31.0"
+  }
+}