nothumanallowed 16.0.21 → 16.0.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nothumanallowed",
-  "version": "16.0.21",
+  "version": "16.0.23",
   "description": "NotHumanAllowed — 38 AI agents, 80 tools, Studio (visual agentic workflows). Email, calendar, browser automation, screen capture, canvas, cron/heartbeat, Alexandria E2E messaging, GitHub, Notion, Slack, voice chat, free AI (Liara), 28 languages. Zero-dependency CLI.",
   "type": "module",
   "bin": {

package/src/constants.mjs

@@ -5,7 +5,7 @@ import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
-export const VERSION = '16.0.21';
+export const VERSION = '16.0.23';
 export const BASE_URL = 'https://nothumanallowed.com/cli';
 export const API_BASE = 'https://nothumanallowed.com/api/v1';
 

package/src/services/message-responder.mjs

@@ -752,7 +752,9 @@ class TelegramResponder {
   async start() {
     if (!this.enabled) return;
     this.running = true;
-    this.log('[Telegram] Responder started — polling for messages');
+    // Explicit version log at boot so the user can verify what's running.
+    // Critical when chasing "bot still mentes" — answers "are you on v16.0.21?".
+    this.log(`[Telegram] Responder started — VERSION ${VERSION} — polling for messages`);
     this._pollLoop();
     // Check for npm updates after 60s, then every 24h
     this._updateCheckTimer = setTimeout(() => this._scheduleUpdateCheck(), 60 * 1000);
@@ -772,10 +774,80 @@ class TelegramResponder {
     this.log('[Telegram] Responder stopped');
   }
 
+  /**
+   * Send a Telegram message that may exceed the 4096-char API limit.
+   * Splits on paragraph/line boundaries when possible, never on a multi-byte
+   * sequence. Sends in order with a small delay to avoid rate-limit 429.
+   * Returns the array of message IDs sent.
+   */
+  async _sendMessageSafe(chatId, text, extraOpts = {}) {
+    const TG_MAX = 4000; // safety margin from 4096 to account for emoji weight
+    const str = String(text == null ? '' : text);
+    if (str.length <= TG_MAX) {
+      return [await this._telegramCall('sendMessage', { chat_id: chatId, text: str, ...extraOpts })];
+    }
+    // Split intelligently: try paragraph breaks, then lines, then hard slice.
+    const chunks = [];
+    let remaining = str;
+    while (remaining.length > TG_MAX) {
+      let cutAt = remaining.lastIndexOf('\n\n', TG_MAX);
+      if (cutAt < TG_MAX / 2) cutAt = remaining.lastIndexOf('\n', TG_MAX);
+      if (cutAt < TG_MAX / 2) cutAt = remaining.lastIndexOf(' ', TG_MAX);
+      if (cutAt < TG_MAX / 2) cutAt = TG_MAX;
+      chunks.push(remaining.slice(0, cutAt).trim());
+      remaining = remaining.slice(cutAt).trim();
+    }
+    if (remaining) chunks.push(remaining);
+    const ids = [];
+    for (let i = 0; i < chunks.length; i++) {
+      const part = chunks.length > 1 ? `(${i + 1}/${chunks.length})\n${chunks[i]}` : chunks[i];
+      try {
+        ids.push(await this._telegramCall('sendMessage', { chat_id: chatId, text: part, ...extraOpts }));
+      } catch (e) {
+        this.log(`[Telegram] sendMessage chunk ${i + 1}/${chunks.length} failed: ${e.message}`);
+      }
+      await this._sleep(180); // avoid 429 rate limit
+    }
+    return ids;
+  }
+
   async _scheduleUpdateCheck() {
     await this._checkAndNotifyUpdate();
-    // Then every 24h
+    await this._checkLocalUpdateAndRestart();
+    // Then every 24h for the npm registry check + every 5 min for local install check
     this._updateCheckTimer = setInterval(() => this._checkAndNotifyUpdate(), 24 * 60 * 60 * 1000);
+    setInterval(() => this._checkLocalUpdateAndRestart(), 5 * 60 * 1000);
+  }
+
+  /**
+   * Detect that a NEW version of nha-cli has been installed on disk while
+   * this process is still running the OLD code in memory. When detected,
+   * exit cleanly so PM2 / launchd / the dispatcher respawns us on the
+   * latest code. Without this, the user runs `npm i -g nothumanallowed@latest`
+   * but the Telegram bot keeps mentes-ing with the old logic forever.
+   */
+  async _checkLocalUpdateAndRestart() {
+    try {
+      const fileURL = await import('url');
+      const here = fileURL.fileURLToPath(import.meta.url);
+      // ../../package.json relative to this file (services/message-responder.mjs)
+      const pkgPath = path.join(path.dirname(here), '..', '..', 'package.json');
+      if (!fs.existsSync(pkgPath)) return;
+      const onDisk = JSON.parse(fs.readFileSync(pkgPath, 'utf-8')).version;
+      if (!onDisk || onDisk === VERSION) return;
+      this.log(`[Telegram] Detected new install: running v${VERSION}, on-disk v${onDisk}. Restarting to pick up new code…`);
+      // Notify any active chat that we're restarting (best-effort, fire and forget)
+      try {
+        const chatIds = getAllTelegramChatIds();
+        for (const chatId of chatIds.slice(0, 3)) {
+          this._telegramCall('sendMessage', { chat_id: parseInt(chatId, 10), text: `🔄 Aggiornamento NHA v${VERSION} → v${onDisk} in corso. Torno tra 2 secondi.` }).catch(() => {});
+        }
+      } catch {}
+      // Give the message a moment to flush, then exit. PM2 / dispatcher restarts us.
+      setTimeout(() => process.exit(0), 800);
+    } catch (e) {
+      this.log(`[Telegram] Local update check failed: ${e.message}`);
+    }
   }
 
   async _checkAndNotifyUpdate() {
@@ -799,14 +871,10 @@ class TelegramResponder {
 
       for (const chatId of chatIds) {
         try {
-          await this._telegramCall('sendMessage', {
-            chat_id: parseInt(chatId, 10),
-            text: msg,
-          });
+          await this._sendMessageSafe(parseInt(chatId, 10), msg);
         } catch {
           // User blocked bot or chat no longer exists — ignore
         }
-        // Small delay to avoid Telegram rate limits
         await this._sleep(300);
       }
     } catch (err) {
@@ -1002,12 +1070,11 @@ class TelegramResponder {
         const prefix = personaMode === 'persona-only' && personaName ? ''
                      : personaName ? `[${personaName}]\n\n`
                      : `[HERALD]\n\n`;
-        await this._telegramCall('sendMessage', { chat_id: chatId, text: prefix + truncated });
+        await this._sendMessageSafe(chatId, prefix + description);
         this.log(`[Telegram] Image vision response to ${fromUser} (${buf.length} bytes, ${description.length} chars)`);
       } catch (err) {
         this.log(`[Telegram] Vision failed: ${err.message}`);
-        await this._telegramCall('sendMessage', { chat_id: chatId,
-          text: `Non riesco ad analizzare l'immagine: ${err.message}` }).catch(() => {});
+        await this._sendMessageSafe(chatId, `Non riesco ad analizzare l'immagine: ${err.message}`).catch(() => {});
       }
       return;
     }
@@ -1020,16 +1087,13 @@ class TelegramResponder {
         await this._telegramCall('sendChatAction', { chat_id: chatId, action: 'typing' });
         rawText = await this._transcribeVoice(fileId);
         if (!rawText.trim()) {
-          await this._telegramCall('sendMessage', { chat_id: chatId, text: 'Non ho capito il vocale. Riprova.' });
+          await this._sendMessageSafe(chatId, 'Non ho capito il vocale. Riprova.');
           return;
         }
         this.log(`[Telegram] Voice transcribed for ${fromUser}: "${rawText.slice(0, 80)}"`);
       } catch (err) {
         this.log(`[Telegram] Voice transcription failed: ${err.message}`);
-        await this._telegramCall('sendMessage', {
-          chat_id: chatId,
-          text: `Non riesco a trascrivere il vocale (${err.message}).\n\nPer abilitare la trascrizione vocale gratuita, dal computer esegui:\nnha config set groqKey TUA_CHIAVE_GROQ\n\nLa chiave si ottiene gratis su https://console.groq.com/keys`,
-        });
+        await this._sendMessageSafe(chatId, `Non riesco a trascrivere il vocale (${err.message}).\n\nPer abilitare la trascrizione vocale gratuita, dal computer esegui:\nnha config set groqKey TUA_CHIAVE_GROQ\n\nLa chiave si ottiene gratis su https://console.groq.com/keys`);
         return;
       }
     }
@@ -1047,10 +1111,7 @@ class TelegramResponder {
 
     // If voice: show transcription so user knows what was understood
     if (isVoice) {
-      await this._telegramCall('sendMessage', {
-        chat_id: chatId,
-        text: `🎤 "${cleanText}"`,
-      }).catch(() => {});
+      await this._sendMessageSafe(chatId, `🎤 "${cleanText}"`).catch(() => {});
     }
 
     this.pendingRequests++;
@@ -1148,7 +1209,7 @@ class TelegramResponder {
             } else {
               reply = `[HERALD]\n\n${directResult.message}`;
             }
-            await this._telegramCall('sendMessage', { chat_id: chatId, text: reply });
+            await this._sendMessageSafe(chatId, reply);
 
             // Update rolling memory + reset pending action (so a follow-up
             // "Si" doesn't try to delete a second time).
@@ -1275,7 +1336,7 @@ class TelegramResponder {
           } else {
             reply = `[HERALD]\n\n${directFresh.message}`;
           }
-          await this._telegramCall('sendMessage', { chat_id: chatId, text: reply });
+          await this._sendMessageSafe(chatId, reply);
           const MAX = 20;
           const prevLog = (lastCtx && Array.isArray(lastCtx.conversationLog)) ? lastCtx.conversationLog : [];
           this._lastContextByChatId[chatId] = {
@@ -1402,19 +1463,13 @@ class TelegramResponder {
         prefixedText = `[${agentLabel}]\n\n${truncated}`;
       }
 
-      await this._telegramCall('sendMessage', {
-        chat_id: chatId,
-        text: prefixedText,
-      });
+      await this._sendMessageSafe(chatId, prefixedText);
 
       this.log(`[Telegram] Responded to ${fromUser} via ${agentLabel}${personaName ? ` (as "${personaName}")` : ''} (${responseText.length} chars)${isCompletedAction(responseText) ? ' [action completed — context reset]' : ''}`);
     } catch (err) {
       this.log(`[Telegram] Agent call failed: ${err.message}`);
       // Send error message to user
-      await this._telegramCall('sendMessage', {
-        chat_id: chatId,
-        text: `Error: ${err.message}`,
-      }).catch(() => {});
+      await this._sendMessageSafe(chatId, `Error: ${err.message}`).catch(() => {});
     } finally {
       this.pendingRequests--;
     }
@@ -2563,6 +2618,63 @@ class TelegramResponder {
     const chatId = this._lastDirectAuditChatId;
     const { executeTool: _executeToolPre } = await import('./tool-executor.mjs');
 
+    // ─── PAGINATION: "mostra i prossimi / vai avanti / i restanti" ─────────
+    // Deterministic next-page fetch from the cached lastCalendarEvents instead
+    // of letting the LLM hallucinate "the remaining events" (Giovanni
+    // Santaniello's bug: NHA inventing fake events when asked for page 2).
+    const isPaginationRequest = /\b(mostra(?:mi)?\s+(?:i\s+)?(?:prossimi|altri|restanti|seguenti)|vai\s+avanti|continua\s+(?:l[ai']\s+)?(?:lista|elenco)|i\s+(?:prossimi|altri|restanti|seguenti)\s+\d*|gli\s+altri|dammi\s+(?:i\s+)?(?:prossimi|restanti|altri)|next\s+page|next\s+\d+|show\s+more|continue\b)/i.test(userMessage);
+    if (isPaginationRequest) {
+      // Pull from list-cache (works across all kinds) — calendar first.
+      try {
+        const cacheFile = path.join(os.homedir(), '.nha', 'list-cache.json');
+        if (fs.existsSync(cacheFile)) {
+          const cache = JSON.parse(fs.readFileSync(cacheFile, 'utf-8'));
+          // Find the most recent calendar list across all chats
+          let allItems = []; let shown = 0; let foundChatKey = null;
+          for (const [k, v] of Object.entries(cache)) {
+            if (Array.isArray(v?.lastList_calendar) && v.lastList_calendar.length > 0) {
+              if (!foundChatKey || (v.lastList_calendar_at || 0) > (cache[foundChatKey]?.lastList_calendar_at || 0)) {
+                foundChatKey = k;
+                allItems = v.lastList_calendar;
+                shown = v.lastList_calendar_shownCount || 0;
+              }
+            }
+          }
+          if (allItems.length > 0 && shown < allItems.length) {
+            // Page size from regex capture or default 8
+            const numMatch = userMessage.match(/\b(\d+)\b/);
+            const pageSize = numMatch ? Math.min(parseInt(numMatch[1], 10), 20) : 8;
+            const nextSlice = allItems.slice(shown, shown + pageSize);
+            const lines = [`📅 Eventi ${shown + 1}-${shown + nextSlice.length} di ${allItems.length}:`];
+            const byDay = new Map();
+            for (const e of nextSlice) {
+              const day = e.date || (e.start || '').slice(0, 10) || 'misc';
+              if (!byDay.has(day)) byDay.set(day, []);
+              byDay.get(day).push(e);
+            }
+            for (const [day, evs] of [...byDay.entries()].sort()) {
+              const d = day !== 'misc' ? new Date(day + 'T12:00:00').toLocaleDateString('it-IT', { weekday: 'short', day: 'numeric', month: 'short' }) : '';
+              if (d) lines.push(`\n${d}:`);
+              for (const e of evs) lines.push(`  ${e.time || '—'} — ${e.summary}`);
+            }
+            const newShown = shown + nextSlice.length;
+            const remaining = allItems.length - newShown;
+            if (remaining > 0) lines.push(`\n... ${remaining} eventi rimanenti. Scrivi "mostra i prossimi" per continuare.`);
+            else lines.push(`\n✓ Fine elenco.`);
+            // Update shownCount in cache
+            cache[foundChatKey].lastList_calendar_shownCount = newShown;
+            fs.writeFileSync(cacheFile, JSON.stringify(cache, null, 2));
+            this.log(`[direct] PAGINATION calendar: shown ${shown}→${newShown} of ${allItems.length}`);
+            return { action: 'calendar_page', success: true, message: lines.join('\n') };
+          }
+          if (allItems.length > 0 && shown >= allItems.length) {
+            return { action: 'calendar_page', success: true, message: '✓ Hai già visto tutti gli eventi. Scrivi "appuntamenti di oggi/settimana/maggio" per una nuova ricerca.' };
+          }
+        }
+      } catch (e) { this.log(`[direct] pagination failed: ${e.message}`); }
+      // Fall through if no cached list
+    }
+
     // ─── ANAPHORIC delete + CONFIRMATION yes ────────────────────────────────
     // If the previous turn ran a LIST/LAST-SHOWN and the user now says
     // "cancellalo / eliminalo / quello / si / conferma / fallo", resolve the
@@ -2840,6 +2952,16 @@ class TelegramResponder {
       const runListAndRemember = async (toolName, args, actionKey) => {
         try {
           const out = await executeTool(toolName, args, config);
+          // Reset pagination state for this kind: a NEW list starts fresh.
+          try {
+            const cacheFile = path.join(os.homedir(), '.nha', 'list-cache.json');
+            if (fs.existsSync(cacheFile)) {
+              const cache = JSON.parse(fs.readFileSync(cacheFile, 'utf-8'));
+              const persistKey = chatId || '__last_list__';
+              if (cache[persistKey]) delete cache[persistKey].lastList_calendar_shownCount;
+              fs.writeFileSync(cacheFile, JSON.stringify(cache, null, 2));
+            }
+          } catch {}
           // Parse from text first (cheap, works when tools include event IDs).
           let events = this._parseEventsFromToolOutput(String(out));
           // Fallback: tools like calendar_month don't print event IDs in their
@@ -2874,6 +2996,37 @@ class TelegramResponder {
           };
           this.log(`[direct] LIST stored: chatId=${persistKey} eventsCount=${events.length} tool=${toolName}`);
           try { saveTelegramContext(this._lastContextByChatId); } catch (e) { this.log(`[direct] persist FAILED: ${e.message}`); }
+
+          // ── PAGINATION CAP (Giovanni's bug, v16.0.23) ──
+          // Telegram limits messages to 4096 chars. If the list has many events,
+          // show first 8 with footer "scrivi 'mostra i prossimi' per continuare"
+          // and persist shownCount in list-cache so pagination is deterministic.
+          const PAGE_SIZE = 8;
+          if (events.length > PAGE_SIZE) {
+            const firstPage = events.slice(0, PAGE_SIZE);
+            const lines = [`📅 ${firstPage.length} eventi (di ${events.length} totali):`];
+            const byDay = new Map();
+            for (const e of firstPage) {
+              const day = e.date || (e.start || '').slice(0, 10) || 'misc';
+              if (!byDay.has(day)) byDay.set(day, []);
+              byDay.get(day).push(e);
+            }
+            for (const [day, evs] of [...byDay.entries()].sort()) {
+              const d = day !== 'misc' ? new Date(day + 'T12:00:00').toLocaleDateString('it-IT', { weekday: 'short', day: 'numeric', month: 'short' }) : '';
+              if (d) lines.push(`\n${d}:`);
+              for (const e of evs) lines.push(`  ${e.time || '—'} — ${e.summary}`);
+            }
+            lines.push(`\n... ${events.length - PAGE_SIZE} eventi rimanenti. Scrivi "mostra i prossimi" per continuare.`);
+            // Mark shownCount in list-cache so the pagination handler picks up from here.
+            try {
+              const cacheFile = path.join(os.homedir(), '.nha', 'list-cache.json');
+              const cache = fs.existsSync(cacheFile) ? JSON.parse(fs.readFileSync(cacheFile, 'utf-8')) : {};
+              cache[persistKey] = cache[persistKey] || {};
+              cache[persistKey].lastList_calendar_shownCount = PAGE_SIZE;
+              fs.writeFileSync(cacheFile, JSON.stringify(cache, null, 2));
+            } catch {}
+            return { action: actionKey, success: true, message: lines.join('\n') };
+          }
           return { action: actionKey, success: true, message: String(out) };
         } catch (e) { return { action: actionKey, success: false, message: `Errore: ${e.message}` }; }
       };

package/src/services/tool-executor.mjs

@@ -2018,11 +2018,45 @@ export async function executeTool(action, params, config) {
 
     case 'calendar_move': {
       const tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
-      await updateEvent(config, 'primary', params.eventId, {
-        start: { dateTime: new Date(params.newStart).toISOString(), timeZone: tz },
-        end: { dateTime: new Date(params.newEnd).toISOString(), timeZone: tz },
+      // ── Resolve eventId from optional query/oldDate (v16.0.22) ──
+      // Agent models often pass {query: 'BMW', newStart} without an eventId.
+      // Instead of failing, resolve it here via listEvents so the move
+      // actually happens. Returns honest error if multiple/no matches.
+      let eventId = params.eventId;
+      if (!eventId && (params.query || params.title || params.oldDate)) {
+        const range = (() => {
+          if (params.oldDate && /^\d{4}-\d{2}-\d{2}$/.test(params.oldDate)) {
+            const [yy, mm, dd] = params.oldDate.split('-').map(n => parseInt(n, 10));
+            const from = new Date(yy, mm - 1, dd);
+            return { from, to: new Date(from.getTime() + 86400000) };
+          }
+          const from = new Date();
+          return { from, to: new Date(from.getTime() + 90 * 86400000) };
+        })();
+        const candidates = await listEvents(config, 'primary', range.from, range.to);
+        const q = String(params.query || params.title || '').toLowerCase();
+        const matching = q
+          ? candidates.filter(e => String(e.summary || '').toLowerCase().includes(q))
+          : candidates;
+        if (matching.length === 0) {
+          return `Error: no event found matching "${q || params.oldDate}" — calendar_move did NOT execute.`;
+        }
+        if (matching.length > 1) {
+          const list = matching.slice(0, 5).map((e, i) =>
+            `${i + 1}. ${(e.start || '').slice(0, 10)} ${e.summary}`).join('\n');
+          return `Error: multiple events match "${q}" — be more specific. Candidates:\n${list}`;
+        }
+        eventId = matching[0].id;
+      }
+      if (!eventId) return 'Error: eventId or query/title required.';
+      if (!params.newStart) return 'Error: newStart required.';
+      const newStartISO = new Date(params.newStart).toISOString();
+      const newEndISO = new Date(params.newEnd || (new Date(params.newStart).getTime() + 3600000)).toISOString();
+      await updateEvent(config, 'primary', eventId, {
+        start: { dateTime: newStartISO, timeZone: tz },
+        end:   { dateTime: newEndISO,   timeZone: tz },
       });
-      return `Event rescheduled to ${formatTime(params.newStart)} - ${formatTime(params.newEnd)}.`;
+      return `Event rescheduled to ${formatTime(newStartISO)} - ${formatTime(newEndISO)}.`;
     }
 
     case 'calendar_week': {