claude-notification-plugin 1.0.59 → 1.0.63

package/listener/message-parser.js

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+
+const COMMANDS = [
+  '/status', '/queue', '/cancel', '/drop', '/clear',
+  '/projects', '/worktrees', '/worktree', '/rmworktree',
+  '/history', '/stop', '/help',
+];
+
+/**
+ * Parse a Telegram message into a command or task.
+ *
+ * Formats:
+ *   /command args           → { type: 'command', cmd, args }
+ *   @project/branch text    → { type: 'task', project, branch, text }
+ *   @project text           → { type: 'task', project, branch: null, text }
+ *   text                    → { type: 'task', project: 'default', branch: null, text }
+ */
+export function parseMessage (text) {
+  if (!text || typeof text !== 'string') {
+    return null;
+  }
+
+  const trimmed = text.trim();
+  if (!trimmed) {
+    return null;
+  }
+
+  // Check for commands
+  if (trimmed.startsWith('/')) {
+    const parts = trimmed.split(/\s+/);
+    const cmd = parts[0].toLowerCase().replace(/@\w+$/, ''); // strip @botname
+    if (COMMANDS.includes(cmd)) {
+      return {
+        type: 'command',
+        cmd,
+        args: parts.slice(1).join(' '),
+      };
+    }
+  }
+
+  // Check for @project/branch or @project prefix
+  const projectMatch = trimmed.match(/^@(\S+)\s+([\s\S]+)$/);
+  if (projectMatch) {
+    const target = projectMatch[1];
+    const taskText = projectMatch[2].trim();
+
+    // Split target into project and optional branch
+    const slashIndex = target.indexOf('/');
+    if (slashIndex > 0) {
+      return {
+        type: 'task',
+        project: target.substring(0, slashIndex),
+        branch: target.substring(slashIndex + 1),
+        text: taskText,
+      };
+    }
+    return {
+      type: 'task',
+      project: target,
+      branch: null,
+      text: taskText,
+    };
+  }
+
+  // Plain text → default project
+  return {
+    type: 'task',
+    project: 'default',
+    branch: null,
+    text: trimmed,
+  };
+}
+
+/**
+ * Parse @project or @project/branch from command args.
+ * Returns { project, branch } or null.
+ */
+export function parseTarget (args) {
+  if (!args) {
+    return null;
+  }
+  const match = args.trim().match(/^@(\S+)/);
+  if (!match) {
+    return null;
+  }
+  const target = match[1];
+  const slashIndex = target.indexOf('/');
+  if (slashIndex > 0) {
+    return {
+      project: target.substring(0, slashIndex),
+      branch: target.substring(slashIndex + 1),
+      rest: args.trim().substring(match[0].length).trim(),
+    };
+  }
+  return {
+    project: target,
+    branch: null,
+    rest: args.trim().substring(match[0].length).trim(),
+  };
+}

package/listener/task-runner.js

@@ -0,0 +1,148 @@
+#!/usr/bin/env node
+
+import { spawn } from 'child_process';
+import { EventEmitter } from 'events';
+
+const DEFAULT_TIMEOUT = 600_000; // 10 minutes
+
+/**
+ * Runs claude CLI tasks and emits events on completion.
+ */
+export class TaskRunner extends EventEmitter {
+  constructor (logger, timeout) {
+    super();
+    this.logger = logger;
+    this.timeout = timeout || DEFAULT_TIMEOUT;
+    this.activeProcesses = new Map(); // workDir → { child, timer, task }
+  }
+
+  /**
+   * Run a task in a specific workDir.
+   * @param {string} workDir - Working directory
+   * @param {object} task - Task object { id, text, telegramMessageId, ... }
+   * @returns {object} task with pid
+   */
+  run (workDir, task) {
+    if (this.activeProcesses.has(workDir)) {
+      throw new Error(`Already running a task in ${workDir}`);
+    }
+
+    this.logger.info(`Running task "${task.text}" in ${workDir}`);
+
+    const args = ['-p', task.text, '--output-format', 'text'];
+    const child = spawn('claude', args, {
+      cwd: workDir,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      windowsHide: true,
+      shell: process.platform === 'win32',
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    child.stdout.on('data', (chunk) => {
+      stdout += chunk.toString();
+    });
+
+    child.stderr.on('data', (chunk) => {
+      stderr += chunk.toString();
+    });
+
+    const timer = setTimeout(() => {
+      this.logger.warn(`Task "${task.id}" timed out in ${workDir}`);
+      this._killProcess(workDir);
+      this.emit('timeout', workDir, task);
+    }, this.timeout);
+
+    child.on('close', (code) => {
+      clearTimeout(timer);
+      this.activeProcesses.delete(workDir);
+
+      if (code === null) {
+        // Process was killed (timeout or cancel)
+        return;
+      }
+
+      if (code === 0) {
+        this.logger.info(`Task "${task.id}" completed in ${workDir}`);
+        this.emit('complete', workDir, task, stdout.trim());
+      } else {
+        const errorMsg = stderr.trim() || `Process exited with code ${code}`;
+        this.logger.error(`Task "${task.id}" failed in ${workDir}: ${errorMsg}`);
+        this.emit('error', workDir, task, errorMsg);
+      }
+    });
+
+    child.on('error', (err) => {
+      clearTimeout(timer);
+      this.activeProcesses.delete(workDir);
+      this.logger.error(`Task "${task.id}" spawn error: ${err.message}`);
+      this.emit('error', workDir, task, err.message);
+    });
+
+    task.pid = child.pid;
+    task.startedAt = new Date().toISOString();
+    this.activeProcesses.set(workDir, { child, timer, task });
+
+    return task;
+  }
+
+  /**
+   * Cancel the active task in a workDir.
+   */
+  cancel (workDir) {
+    this._killProcess(workDir);
+  }
+
+  /**
+   * Check if a task is running in a workDir.
+   */
+  isRunning (workDir) {
+    return this.activeProcesses.has(workDir);
+  }
+
+  /**
+   * Get active task info for a workDir.
+   */
+  getActive (workDir) {
+    const entry = this.activeProcesses.get(workDir);
+    return entry?.task || null;
+  }
+
+  /**
+   * Cancel all active tasks (for graceful shutdown).
+   */
+  cancelAll () {
+    for (const workDir of this.activeProcesses.keys()) {
+      this._killProcess(workDir);
+    }
+  }
+
+  _killProcess (workDir) {
+    const entry = this.activeProcesses.get(workDir);
+    if (!entry) {
+      return;
+    }
+    clearTimeout(entry.timer);
+    try {
+      if (process.platform === 'win32') {
+        spawn('taskkill', ['/PID', String(entry.child.pid), '/T', '/F'], {
+          stdio: 'ignore',
+          windowsHide: true,
+        });
+      } else {
+        entry.child.kill('SIGTERM');
+        setTimeout(() => {
+          try {
+            entry.child.kill('SIGKILL');
+          } catch {
+            // already dead
+          }
+        }, 3000);
+      }
+    } catch {
+      // process already dead
+    }
+    this.activeProcesses.delete(workDir);
+  }
+}

package/listener/telegram-poller.js

@@ -0,0 +1,142 @@
+#!/usr/bin/env node
+
+const POLL_TIMEOUT = 30; // seconds
+const MAX_MESSAGE_LENGTH = 4096;
+
+export class TelegramPoller {
+  constructor (token, chatId, logger) {
+    this.token = token;
+    this.chatId = String(chatId);
+    this.logger = logger;
+    this.baseUrl = `https://api.telegram.org/bot${token}`;
+    this.offset = 0;
+  }
+
+  async getUpdates () {
+    try {
+      const url = `${this.baseUrl}/getUpdates?offset=${this.offset}&timeout=${POLL_TIMEOUT}&allowed_updates=["message"]`;
+      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)}`);
+        return [];
+      }
+      const messages = [];
+      for (const update of data.result || []) {
+        this.offset = update.update_id + 1;
+        const msg = update.message;
+        if (!msg || !msg.text) {
+          continue;
+        }
+        if (String(msg.chat.id) !== this.chatId) {
+          this.logger.warn(`Ignored message from chat ${msg.chat.id} (expected ${this.chatId})`);
+          continue;
+        }
+        messages.push({
+          messageId: msg.message_id,
+          text: msg.text,
+          chatId: msg.chat.id,
+          date: msg.date,
+        });
+      }
+      return messages;
+    } catch (err) {
+      if (err.name !== 'TimeoutError' && err.name !== 'AbortError') {
+        this.logger.error(`getUpdates error: ${err.message}`);
+      }
+      return [];
+    }
+  }
+
+  async sendMessage (text, replyToMessageId) {
+    const chunks = splitMessage(text);
+    for (const chunk of chunks) {
+      try {
+        const body = {
+          chat_id: this.chatId,
+          text: chunk,
+          parse_mode: 'HTML',
+        };
+        if (replyToMessageId) {
+          body.reply_to_message_id = replyToMessageId;
+        }
+        const res = await fetch(`${this.baseUrl}/sendMessage`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify(body),
+        });
+        const data = await res.json();
+        if (!data.ok) {
+          // Retry without HTML parse mode
+          await fetch(`${this.baseUrl}/sendMessage`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+              chat_id: this.chatId,
+              text: chunk,
+              ...(replyToMessageId ? { reply_to_message_id: replyToMessageId } : {}),
+            }),
+          });
+        }
+      } catch (err) {
+        this.logger.error(`sendMessage error: ${err.message}`);
+      }
+    }
+  }
+
+  async sendDocument (buffer, filename, caption) {
+    try {
+      const formData = new FormData();
+      formData.append('chat_id', this.chatId);
+      formData.append('document', new Blob([buffer]), filename);
+      if (caption) {
+        formData.append('caption', caption.slice(0, 1024));
+      }
+      await fetch(`${this.baseUrl}/sendDocument`, {
+        method: 'POST',
+        body: formData,
+      });
+    } catch (err) {
+      this.logger.error(`sendDocument error: ${err.message}`);
+    }
+  }
+}
+
+function escapeHtml (text) {
+  return text
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;');
+}
+
+function splitMessage (text) {
+  if (text.length <= MAX_MESSAGE_LENGTH) {
+    return [text];
+  }
+
+  // For very long messages, send summary + file
+  if (text.length > 20000) {
+    const head = text.slice(0, 2000);
+    const tail = text.slice(-2000);
+    return [`${head}\n\n<i>... (truncated ${text.length} chars) ...</i>\n\n${tail}`];
+  }
+
+  // Split into chunks preserving line boundaries
+  const chunks = [];
+  let remaining = text;
+  while (remaining.length > 0) {
+    if (remaining.length <= MAX_MESSAGE_LENGTH) {
+      chunks.push(remaining);
+      break;
+    }
+    let splitAt = remaining.lastIndexOf('\n', MAX_MESSAGE_LENGTH);
+    if (splitAt <= 0) {
+      splitAt = MAX_MESSAGE_LENGTH;
+    }
+    chunks.push(remaining.slice(0, splitAt));
+    remaining = remaining.slice(splitAt + 1);
+  }
+  return chunks;
+}
+
+export { escapeHtml };

package/listener/work-queue.js

@@ -0,0 +1,306 @@
+#!/usr/bin/env node
+
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const QUEUE_FILE = path.join(os.homedir(), '.claude', '.task_queues.json');
+const HISTORY_FILE = path.join(os.homedir(), '.claude', '.task_history.json');
+const MAX_HISTORY = 50;
+
+let idCounter = 0;
+
+function generateId () {
+  return `task_${Date.now()}_${(++idCounter).toString(36)}`;
+}
+
+/**
+ * Per-workDir task queue with FIFO ordering and single-active-task lock.
+ */
+export class WorkQueue {
+  constructor (logger, maxQueuePerWorkDir = 10, maxTotalTasks = 50) {
+    this.logger = logger;
+    this.maxQueuePerWorkDir = maxQueuePerWorkDir;
+    this.maxTotalTasks = maxTotalTasks;
+    this.queues = {}; // workDir → { project, branch, active, queue }
+    this._load();
+  }
+
+  /**
+   * 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) {
+    if (!this.queues[workDir]) {
+      this.queues[workDir] = {
+        project,
+        branch: branch || 'main',
+        active: null,
+        queue: [],
+      };
+    }
+
+    const entry = this.queues[workDir];
+    const totalPending = this._countTotal();
+
+    if (totalPending >= this.maxTotalTasks) {
+      return { error: `Total task limit reached (${this.maxTotalTasks})` };
+    }
+
+    if (entry.queue.length >= this.maxQueuePerWorkDir) {
+      return { error: `Queue limit reached for this workDir (${this.maxQueuePerWorkDir})` };
+    }
+
+    const task = {
+      id: generateId(),
+      text,
+      telegramMessageId,
+      addedAt: new Date().toISOString(),
+    };
+
+    if (!entry.active) {
+      // Ready to run immediately
+      entry.active = task;
+      this._save();
+      return { task, position: 0, immediate: true };
+    }
+
+    // Add to queue
+    entry.queue.push(task);
+    this._save();
+    return {
+      task,
+      position: entry.queue.length,
+      immediate: false,
+      activeTask: entry.active,
+    };
+  }
+
+  /**
+   * Mark active task as started (update PID and startedAt).
+   */
+  markStarted (workDir, pid) {
+    const entry = this.queues[workDir];
+    if (entry?.active) {
+      entry.active.pid = pid;
+      entry.active.startedAt = new Date().toISOString();
+      this._save();
+    }
+  }
+
+  /**
+   * Complete the active task. Returns next task if available, or null.
+   */
+  onTaskComplete (workDir, result) {
+    const entry = this.queues[workDir];
+    if (!entry) {
+      return null;
+    }
+
+    // Record in history
+    if (entry.active) {
+      this._addHistory({
+        ...entry.active,
+        project: entry.project,
+        branch: entry.branch,
+        workDir,
+        completedAt: new Date().toISOString(),
+        result: result ? result.slice(0, 500) : '',
+      });
+    }
+
+    // Get next task
+    if (entry.queue.length > 0) {
+      entry.active = entry.queue.shift();
+      this._save();
+      return entry.active;
+    }
+
+    entry.active = null;
+    this._save();
+    return null;
+  }
+
+  /**
+   * Cancel the active task in a workDir. Returns next task if available.
+   */
+  cancelActive (workDir) {
+    const entry = this.queues[workDir];
+    if (!entry?.active) {
+      return null;
+    }
+
+    this._addHistory({
+      ...entry.active,
+      project: entry.project,
+      branch: entry.branch,
+      workDir,
+      completedAt: new Date().toISOString(),
+      result: 'CANCELLED',
+    });
+
+    if (entry.queue.length > 0) {
+      entry.active = entry.queue.shift();
+      this._save();
+      return entry.active;
+    }
+
+    entry.active = null;
+    this._save();
+    return null;
+  }
+
+  /**
+   * Remove a task from the queue by index (1-based).
+   */
+  removeFromQueue (workDir, index) {
+    const entry = this.queues[workDir];
+    if (!entry) {
+      return null;
+    }
+    const idx = index - 1;
+    if (idx < 0 || idx >= entry.queue.length) {
+      return null;
+    }
+    const removed = entry.queue.splice(idx, 1)[0];
+    this._save();
+    return removed;
+  }
+
+  /**
+   * Clear all queued (non-active) tasks for a workDir.
+   */
+  clearQueue (workDir) {
+    const entry = this.queues[workDir];
+    if (!entry) {
+      return 0;
+    }
+    const count = entry.queue.length;
+    entry.queue = [];
+    this._save();
+    return count;
+  }
+
+  /**
+   * Get status for a project (all workDirs).
+   */
+  getProjectStatus (projectAlias) {
+    const results = [];
+    for (const [workDir, entry] of Object.entries(this.queues)) {
+      if (entry.project === projectAlias) {
+        results.push({
+          workDir,
+          branch: entry.branch,
+          active: entry.active,
+          queueLength: entry.queue.length,
+          queue: entry.queue,
+        });
+      }
+    }
+    return results;
+  }
+
+  /**
+   * Get status for all projects.
+   */
+  getAllStatus () {
+    const results = {};
+    for (const [workDir, entry] of Object.entries(this.queues)) {
+      if (!results[entry.project]) {
+        results[entry.project] = [];
+      }
+      results[entry.project].push({
+        workDir,
+        branch: entry.branch,
+        active: entry.active,
+        queueLength: entry.queue.length,
+      });
+    }
+    return results;
+  }
+
+  /**
+   * Get recent task history.
+   */
+  getHistory (limit = 10) {
+    return this._loadHistory().slice(-limit);
+  }
+
+  /**
+   * Watchdog: clean up stale active tasks (dead PIDs, expired timeouts).
+   */
+  watchdog (taskTimeout) {
+    const now = Date.now();
+    const recovered = [];
+    for (const [workDir, entry] of Object.entries(this.queues)) {
+      if (!entry.active) {
+        continue;
+      }
+      const startedAt = entry.active.startedAt ? new Date(entry.active.startedAt).getTime() : 0;
+      const isStale = startedAt > 0 && (now - startedAt) > taskTimeout;
+
+      if (isStale) {
+        this.logger.warn(`Watchdog: stale task "${entry.active.id}" in ${workDir}`);
+        const next = this.onTaskComplete(workDir, 'STALE (watchdog cleanup)');
+        recovered.push({ workDir, next });
+      }
+    }
+    return recovered;
+  }
+
+  _countTotal () {
+    let count = 0;
+    for (const entry of Object.values(this.queues)) {
+      if (entry.active) {
+        count++;
+      }
+      count += entry.queue.length;
+    }
+    return count;
+  }
+
+  _load () {
+    try {
+      if (fs.existsSync(QUEUE_FILE)) {
+        this.queues = JSON.parse(fs.readFileSync(QUEUE_FILE, 'utf-8'));
+      }
+    } catch (err) {
+      this.logger.error(`Failed to load queue file: ${err.message}`);
+      this.queues = {};
+    }
+  }
+
+  _save () {
+    try {
+      const dir = path.dirname(QUEUE_FILE);
+      fs.mkdirSync(dir, { recursive: true });
+      fs.writeFileSync(QUEUE_FILE, JSON.stringify(this.queues, null, 2));
+    } catch (err) {
+      this.logger.error(`Failed to save queue file: ${err.message}`);
+    }
+  }
+
+  _addHistory (entry) {
+    const history = this._loadHistory();
+    history.push(entry);
+    while (history.length > MAX_HISTORY) {
+      history.shift();
+    }
+    try {
+      fs.writeFileSync(HISTORY_FILE, JSON.stringify(history, null, 2));
+    } catch {
+      // ignore
+    }
+  }
+
+  _loadHistory () {
+    try {
+      if (fs.existsSync(HISTORY_FILE)) {
+        return JSON.parse(fs.readFileSync(HISTORY_FILE, 'utf-8'));
+      }
+    } catch {
+      // ignore
+    }
+    return [];
+  }
+}