nothumanallowed 15.1.62 → 15.1.63

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nothumanallowed",
-  "version": "15.1.62",
+  "version": "15.1.63",
   "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 = '15.1.62';
+export const VERSION = '15.1.63';
 export const BASE_URL = 'https://nothumanallowed.com/cli';
 export const API_BASE = 'https://nothumanallowed.com/api/v1';
 

package/src/services/message-responder.mjs

@@ -9,7 +9,7 @@
  */
 
 import { callAgent, callLLM } from './llm.mjs';
-import { buildSystemPrompt, parseActions, executeTool, TOOL_DEFINITIONS, LIARA_TOOL_DEFINITIONS } from './tool-executor.mjs';
+import { buildSystemPrompt, parseActions, executeTool, TOOL_DEFINITIONS, LIARA_TOOL_DEFINITIONS, DESTRUCTIVE_ACTIONS } from './tool-executor.mjs';
 import https from 'https';
 import http from 'http';
 import { URL } from 'url';
@@ -1047,13 +1047,17 @@ class TelegramResponder {
         this._lastDirectAuditChatId = chatId;
         // Run the per-domain direct-action dispatcher. First match wins; falls
         // through to LLM if no handler claims the message.
+        // Fast-path specialised handlers (regex-driven, lower latency for the
+        // common cases), then the universal dispatcher that covers ALL 50+
+        // mutation tools via a single LLM-NLU+deterministic-execute pass.
         const directFresh =
           await this._tryDirectFreshCalendarAction(cleanText, this.config) ||
           await this._tryDirectFreshEmailAction(cleanText, this.config) ||
           await this._tryDirectFreshTaskAction(cleanText, this.config) ||
           await this._tryDirectFreshNoteAction(cleanText, this.config) ||
           await this._tryDirectFreshReminderAction(cleanText, this.config) ||
-          await this._tryDirectFreshSlackAction(cleanText, this.config);
+          await this._tryDirectFreshSlackAction(cleanText, this.config) ||
+          await this._tryDirectFreshUniversalAction(cleanText, this.config);
         if (directFresh) {
           this.log(`[Telegram] ${fromUser}: direct-fresh ${directFresh.action} → ${directFresh.success ? 'OK' : 'FAIL'}`);
           const personaName = this.config.responder?.telegram?.botName || this.config.responder?.botName || '';
@@ -1663,6 +1667,181 @@ class TelegramResponder {
     try { return this._extractJsonObject(await callLLM(config, sys, userMessage, { temperature: 0, maxTokens: 300 })); } catch { return null; }
   }
 
+  // ════════════════════════════════════════════════════════════════════════
+  // UNIVERSAL DIRECT-ACTION DISPATCHER
+  // ════════════════════════════════════════════════════════════════════════
+  // Covers ALL 22 mutation tools in `DESTRUCTIVE_ACTIONS` (gmail, imap,
+  // calendar, contacts, tasks, slack, github, file, drive, notify).
+  // The LLM is used ONLY to (a) decide if the message maps to a tool and
+  // (b) extract the params as JSON. Tool execution is then deterministic
+  // server-side. No tool block is parsed from natural language by the
+  // model — the model can never "say done" without us actually doing it.
+  async _tryDirectFreshUniversalAction(userMessage, config) {
+    if (!userMessage || typeof userMessage !== 'string' || userMessage.length < 3) return null;
+
+    const todayIso = new Date().toISOString().slice(0, 10);
+    const sys =
+      `You are a tool-routing classifier. Given a user message in any language, decide whether it ` +
+      `requests a state-changing action that maps to ONE of these tools, and extract the params.\n\n` +
+      `ALLOWED TOOLS (you MUST pick one of these OR return null):\n` +
+      // Calendar
+      `- calendar_create(summary, start, end, description?)    — start/end ISO "YYYY-MM-DDTHH:MM:00"\n` +
+      `- calendar_move(eventId? OR title, newStart, newEnd?)   — if no eventId, title is used to find it\n` +
+      `- calendar_update(eventId? OR title, summary?, start?, end?, description?)\n` +
+      `- calendar_delete(eventId? OR title, date?)\n` +
+      // Email Gmail
+      `- gmail_send(to, subject, body)                         — primary email account\n` +
+      `- gmail_reply(messageId? OR threadHint, body)\n` +
+      `- gmail_delete(messageId? OR query)\n` +
+      `- gmail_mark_read(messageId, isRead?)\n` +
+      `- gmail_mark_starred(messageId, starred?)\n` +
+      `- gmail_archive(messageId)\n` +
+      // Email IMAP
+      `- imap_send(accountId?, to, subject, body)              — custom IMAP account\n` +
+      `- imap_reply(accountId?, messageId, body)\n` +
+      `- imap_trash(messageId)\n` +
+      `- imap_mark_read(messageId, isRead?)\n` +
+      `- imap_draft(accountId?, to, subject, body)\n` +
+      // Contacts
+      `- contact_add(name, email?, phone?, company?, address?)\n` +
+      `- contact_update(query, email?, phone?, company?, address?)\n` +
+      `- contact_delete(query)\n` +
+      // Tasks
+      `- task_add(title, priority?, due?)\n` +
+      `- task_done(title)\n` +
+      `- task_delete(title)\n` +
+      // Google Tasks
+      `- gtask_add(title, notes?, due?)\n` +
+      `- gtask_complete(title)\n` +
+      // Notes
+      `- note_add(title, content?)\n` +
+      // Reminders
+      `- notify_remind(message, when)                          — when = ISO datetime\n` +
+      `- reminder_create(message, when)\n` +
+      // Slack
+      `- slack_send(channel, text, threadTs?)                  — channel "#name"\n` +
+      `- slack_dm(user, text)                                  — user = name, id, or email\n` +
+      `- slack_react(channel, ts, emoji)\n` +
+      `- slack_mark_read(channel, ts)\n` +
+      // Notion
+      `- notion_page(title, content)                           — create a new Notion page\n` +
+      // GitHub
+      `- github_create_issue(repo, title, body?, labels?)      — repo "owner/name"\n` +
+      // File system (local to user)
+      `- file_write(path, content)\n` +
+      `- file_move(from, to)\n` +
+      `- file_delete(path)\n` +
+      `- file_mkdir(path)\n` +
+      // Google Drive
+      `- drive_upload(name, content, mimeType?)                — Google Drive\n` +
+      `- drive_update(fileId, content)\n` +
+      `- drive_delete(fileId? OR name)\n` +
+      `- drive_move(fileId, newParentFolderId? OR newName?)\n` +
+      `- drive_share(fileId, email, role?)                     — role = "reader"|"writer"|"commenter"\n` +
+      // Birthdays
+      `- birthday_add(name, date)                              — date "YYYY-MM-DD" or "MM-DD"\n` +
+      `- birthday_delete(name)\n` +
+      // Alexandria E2E
+      `- alexandria_send(channel, message)\n` +
+      // Cron
+      `- cron_create(name, schedule, command)                  — schedule = cron expression\n` +
+      `- cron_delete(name)\n\n` +
+      `Today is ${todayIso}. Relative dates: "domani" = ${this._addDaysIso(todayIso, 1).slice(0, 10)}, ` +
+      `"dopodomani" = ${this._addDaysIso(todayIso, 2).slice(0, 10)}, "lunedì/martedì/..." resolve to next occurrence.\n\n` +
+      `OUTPUT FORMAT (strict JSON, no markdown, no prose, no fences):\n` +
+      `{"tool": "tool_name" | null, "params": { ... }}\n\n` +
+      `If the message is a READ/LIST/QUERY operation (e.g. "mostra…", "che ho oggi", "leggi email", "trova"), ` +
+      `OR is conversational chat (greetings, questions, opinions) OR is ambiguous → return {"tool": null}.\n` +
+      `If a required param is genuinely missing AND not inferable → return {"tool": null}.\n` +
+      `Never invent emails, eventIds, or recipient addresses.`;
+
+    let raw;
+    try {
+      raw = await callLLM(config, sys, userMessage, { temperature: 0, maxTokens: 400 });
+    } catch (e) {
+      this.log(`[direct-universal] LLM call failed: ${e.message}`);
+      return null;
+    }
+    const parsed = this._extractJsonObject(raw);
+    if (!parsed || !parsed.tool || !DESTRUCTIVE_ACTIONS.has(parsed.tool)) return null;
+    if (!parsed.params || typeof parsed.params !== 'object') return null;
+
+    // Per-tool param normalization (matches the executor's accepted shapes).
+    const params = { ...parsed.params };
+    if (parsed.tool === 'calendar_create' && !params.summary) params.summary = params.title || params.name || params.subject;
+    if (parsed.tool === 'calendar_create' && params.start && !params.end) params.end = this._addMinutesIso(params.start, 60);
+
+    try {
+      const result = await executeTool(parsed.tool, params, config);
+      const resultStr = typeof result === 'string' ? result : JSON.stringify(result);
+      const ok = !/error|failed|not\s+found|invalid|does\s+not\s+exist|placeholder/i.test(resultStr);
+
+      if (this._lastDirectAuditChatId) {
+        this._recordAudit(this._lastDirectAuditChatId, {
+          tool: parsed.tool,
+          success: ok,
+          summary: this._summarizeParamsForAudit(parsed.tool, params),
+        });
+      }
+      const message = ok
+        ? this._formatActionResultIT(parsed.tool, params, resultStr)
+        : `Non sono riuscito a eseguire ${parsed.tool}: ${resultStr.slice(0, 240)}`;
+      return { action: parsed.tool, success: ok, message };
+    } catch (e) {
+      return { action: parsed.tool, success: false, message: `Errore durante ${parsed.tool}: ${e.message}` };
+    }
+  }
+
+  /** Natural-language Italian summary for the audit log entry. */
+  _summarizeParamsForAudit(tool, params) {
+    if (tool.startsWith('calendar_')) {
+      const t = params.summary || params.title || '';
+      const s = params.start ? this._formatDateIT(String(params.start).slice(0, 10)) + ` ${String(params.start).slice(11, 16)}` : '';
+      return `"${t}"${s ? ` · ${s}` : ''}`;
+    }
+    if (tool === 'gmail_send' || tool === 'imap_send') return `→ ${params.to || '?'} · "${(params.subject || '').slice(0, 60)}"`;
+    if (tool === 'gmail_reply' || tool === 'imap_reply') return `reply → ${params.to || params.messageId || '?'}`;
+    if (tool === 'slack_send') return `→ ${params.channel || '?'} · "${(params.text || '').slice(0, 60)}"`;
+    if (tool === 'notify_remind') return `"${params.message || ''}" @ ${params.when || '?'}`;
+    if (tool === 'github_create_issue') return `${params.repo || '?'}: "${params.title || ''}"`;
+    if (tool === 'file_write') return `${params.path || '?'} (${(params.content || '').length} chars)`;
+    if (tool === 'drive_upload') return `${params.name || '?'} (${(params.content || '').length} chars)`;
+    if (tool === 'task_done' || tool === 'task_delete' || tool === 'contact_delete') return `"${params.title || params.name || '?'}"`;
+    return JSON.stringify(params).slice(0, 80);
+  }
+
+  /** Italian-language natural response for a successful action. */
+  _formatActionResultIT(tool, params, result) {
+    switch (tool) {
+      case 'calendar_create': {
+        const t = params.summary || params.title || 'evento';
+        const when = params.start ? `${this._formatDateIT(String(params.start).slice(0, 10))} alle ${String(params.start).slice(11, 16)}` : '';
+        return `Fatto. Ho creato l'appuntamento "${t}"${when ? ` il ${when}` : ''}.`;
+      }
+      case 'calendar_move':   return `Fatto. Appuntamento spostato.`;
+      case 'calendar_update': return `Fatto. Appuntamento aggiornato.`;
+      case 'calendar_delete': return `Fatto. Appuntamento cancellato.`;
+      case 'gmail_send':
+      case 'imap_send':       return `Fatto. Email inviata a ${params.to}.`;
+      case 'gmail_reply':
+      case 'imap_reply':      return `Fatto. Risposta inviata.`;
+      case 'gmail_delete':    return `Fatto. Email eliminata.`;
+      case 'imap_trash':      return `Fatto. Email spostata nel cestino.`;
+      case 'contact_delete':  return `Fatto. Contatto "${params.name || ''}" cancellato.`;
+      case 'task_done':       return `Fatto. Task "${params.title || ''}" completato.`;
+      case 'task_delete':     return `Fatto. Task "${params.title || ''}" cancellato.`;
+      case 'task_clear':      return `Fatto. Task list pulita.`;
+      case 'notify_remind':   return `Promemoria impostato: "${params.message || ''}" per ${params.when || ''}.`;
+      case 'slack_send':      return `Fatto. Messaggio inviato a ${params.channel || ''}.`;
+      case 'github_create_issue': return `Issue creata su ${params.repo}: "${params.title}".`;
+      case 'file_write':      return `Fatto. File ${params.path} scritto (${(params.content || '').length} caratteri).`;
+      case 'drive_upload':    return `Fatto. "${params.name}" caricato su Google Drive.`;
+      case 'drive_update':    return `Fatto. File Drive aggiornato.`;
+      case 'drive_delete':    return `Fatto. File Drive eliminato.`;
+      default: return `Fatto. ${result.slice(0, 200)}`;
+    }
+  }
+
   // ── Direct fresh calendar action (no LLM) ─────────────────────────────────
   // Detects DELETE / LIST_MONTH / LIST_WEEK / LIST_DAY / LIST_TODAY /
   // LIST_TOMORROW intents from a fresh user message and runs the proper tool

package/src/services/tool-executor.mjs

@@ -63,30 +63,39 @@ function getTsxPath() {
 
 /** Actions that mutate external state and require user confirmation. */
 export const DESTRUCTIVE_ACTIONS = new Set([
-  'gmail_send',
-  'gmail_send_attach',
-  'gmail_reply',
-  'gmail_delete',
-  'imap_send',
-  'imap_reply',
-  'imap_bulk_send',
-  'imap_send_template',
-  'imap_trash',
-  'calendar_create',
-  'calendar_move',
-  'calendar_update',
-  'calendar_delete',
-  'contact_delete',
-  'task_done',
-  'task_delete',
-  'task_clear',
-  'notify_remind',
-  'slack_send',
-  'github_create_issue',
-  'file_write',
-  'drive_upload',
-  'drive_update',
-  'drive_delete',
+  // Gmail
+  'gmail_send', 'gmail_send_attach', 'gmail_reply', 'gmail_delete',
+  'gmail_mark_read', 'gmail_mark_starred', 'gmail_archive', 'gmail_trash',
+  // IMAP (custom email accounts)
+  'imap_send', 'imap_reply', 'imap_bulk_send', 'imap_send_template',
+  'imap_trash', 'imap_mark_read', 'imap_mark_starred', 'imap_draft',
+  // Calendar
+  'calendar_create', 'calendar_move', 'calendar_update', 'calendar_delete',
+  // Contacts
+  'contact_add', 'contact_update', 'contact_delete',
+  // Tasks (local) + Google Tasks
+  'task_add', 'task_done', 'task_delete', 'task_clear',
+  'gtask_add', 'gtask_complete', 'gtask_delete',
+  // Notes
+  'note_add',
+  // Reminders / notifications
+  'notify_remind', 'reminder_create',
+  // Slack
+  'slack_send', 'slack_dm', 'slack_react', 'slack_mark_read',
+  // Notion
+  'notion_page', 'notion_update',
+  // GitHub
+  'github_create_issue', 'github_comment',
+  // File system (local)
+  'file_write', 'file_move', 'file_delete', 'file_mkdir',
+  // Google Drive
+  'drive_upload', 'drive_update', 'drive_delete', 'drive_move', 'drive_share',
+  // Birthdays
+  'birthday_add', 'birthday_update', 'birthday_delete',
+  // Alexandria messaging
+  'alexandria_send',
+  // Cron / scheduling
+  'cron_create', 'cron_delete',
 ]);
 
 // ── Tool Definitions (for system prompt) ─────────────────────────────────────