nothumanallowed 15.1.35 → 15.1.37

package/package.json

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

package/src/server/routes/integrations.mjs

@@ -102,22 +102,87 @@ export function register(router) {
     } catch (e) { sendError(res, 500, e.message); }
   });
 
-  // ── Slack ─────────────────────────────────────────────────────────────
+  // ── Slack (enterprise UI: rich channels, search, threads, reactions) ──
 
   router.get('/api/slack/channels', async (_req, res) => {
     try {
-      const { listChannels } = await import('../../services/slack.mjs');
+      const { listChannelsRich, getWorkspaceInfo } = await import('../../services/slack.mjs');
       const config = loadConfig();
-      sendJSON(res, 200, { channels: await listChannels(config) });
-    } catch (e) { sendError(res, 500, e.message); }
+      const [channels, workspace] = await Promise.all([
+        listChannelsRich(config, { maxResults: 200 }),
+        getWorkspaceInfo(config),
+      ]);
+      sendJSON(res, 200, { channels, workspace: workspace?.name || '', workspaceIcon: workspace?.icon || '' });
+    } catch (e) { sendJSON(res, 200, { channels: [], error: e.message }); }
   });
 
   router.get('/api/slack/messages', async (req, res) => {
     try {
-      const { getChannelMessages } = await import('../../services/slack.mjs');
+      const { listMessagesRich } = await import('../../services/slack.mjs');
       const config = loadConfig();
       const url = new URL(req.url, 'http://localhost');
-      sendJSON(res, 200, { messages: await getChannelMessages(config, url.searchParams.get('channel')) });
+      const channel = url.searchParams.get('channel');
+      const limit = parseInt(url.searchParams.get('limit') || '50', 10);
+      if (!channel) return sendError(res, 400, 'channel param required');
+      sendJSON(res, 200, { messages: await listMessagesRich(config, channel, { limit }) });
+    } catch (e) { sendError(res, 500, e.message); }
+  });
+
+  router.get('/api/slack/thread', async (req, res) => {
+    try {
+      const { getThreadReplies } = await import('../../services/slack.mjs');
+      const config = loadConfig();
+      const url = new URL(req.url, 'http://localhost');
+      const channel = url.searchParams.get('channel');
+      const ts = url.searchParams.get('ts');
+      if (!channel || !ts) return sendError(res, 400, 'channel and ts required');
+      sendJSON(res, 200, { messages: await getThreadReplies(config, channel, ts) });
+    } catch (e) { sendError(res, 500, e.message); }
+  });
+
+  router.get('/api/slack/search', async (req, res) => {
+    try {
+      const { searchMessages } = await import('../../services/slack.mjs');
+      const config = loadConfig();
+      const url = new URL(req.url, 'http://localhost');
+      const q = url.searchParams.get('q') || '';
+      if (!q.trim()) return sendJSON(res, 200, { results: [] });
+      const count = parseInt(url.searchParams.get('count') || '20', 10);
+      sendJSON(res, 200, { results: await searchMessages(config, q, { count }) });
+    } catch (e) { sendJSON(res, 200, { results: [], error: e.message }); }
+  });
+
+  router.post('/api/slack/react', async (req, res) => {
+    try {
+      const { addReaction } = await import('../../services/slack.mjs');
+      const config = loadConfig();
+      const body = await parseBody(req);
+      if (!body.channel || !body.ts || !body.emoji) return sendError(res, 400, 'channel, ts, emoji required');
+      await addReaction(config, body.channel, body.ts, body.emoji);
+      sendJSON(res, 200, { ok: true });
+    } catch (e) { sendError(res, 500, e.message); }
+  });
+
+  router.post('/api/slack/mark-read', async (req, res) => {
+    try {
+      const { markRead } = await import('../../services/slack.mjs');
+      const config = loadConfig();
+      const body = await parseBody(req);
+      if (!body.channel) return sendError(res, 400, 'channel required');
+      await markRead(config, body.channel, body.ts);
+      sendJSON(res, 200, { ok: true });
+    } catch (e) { sendError(res, 500, e.message); }
+  });
+
+  router.post('/api/slack/dm', async (req, res) => {
+    try {
+      const { openDM, sendMessage } = await import('../../services/slack.mjs');
+      const config = loadConfig();
+      const body = await parseBody(req);
+      if (!body.user) return sendError(res, 400, 'user required (id or name or email)');
+      const channelId = await openDM(config, body.user);
+      if (body.text) await sendMessage(config, channelId, body.text);
+      sendJSON(res, 200, { ok: true, channelId });
     } catch (e) { sendError(res, 500, e.message); }
   });
 
@@ -308,7 +373,8 @@ export function register(router) {
       const body = await parseBody(req);
       const config = loadConfig();
       if (!body.channel || !body.text) return sendError(res, 400, 'channel and text required');
-      await sendMessage(config, body.channel, body.text);
+      // threadTs optional — if provided, the message is posted as a thread reply
+      await sendMessage(config, body.channel, body.text, body.threadTs || null);
       sendJSON(res, 200, { ok: true });
     } catch (e) { sendError(res, 500, e.message); }
   });

package/src/services/message-responder.mjs

@@ -530,6 +530,38 @@ class TelegramResponder {
     saveTelegramContext(this._lastContextByChatId);
   }
 
+  /**
+   * Route a fresh message to the best agent.
+   *
+   * Tier 1 — keyword table (fast, no LLM cost). Falls through to CONDUCTOR
+   * when nothing matches.
+   *
+   * Tier 2 — if Tier 1 returned the fallback CONDUCTOR AND the user has an
+   * LLM key configured, ask the LLM to pick the right agent given the
+   * conversation history. This rescues paraphrased queries like
+   * "mostrami quanto vale ora il metallo prezioso giallo" (no keyword match)
+   * which v13 used to route correctly because of a similar LLM router.
+   */
+  async _routeFreshMessage(text, lastCtx) {
+    const keywordAgent = routeMessage(text, this.autoRoute);
+    if (keywordAgent !== 'conductor') return keywordAgent;
+    // Tier 2 fallback
+    const hasKey = !!(this.config.llm?.apiKey || this.config.llm?.openaiKey || this.config.llm?.geminiKey || this.config.llm?.deepseekKey || (this.config.llm?.provider === 'nha'));
+    if (!hasKey) return keywordAgent;
+    try {
+      const AGENTS = ['herald', 'mercury', 'athena', 'oracle', 'forge', 'scheherazade', 'saber', 'sauron', 'conductor'];
+      const tail = (lastCtx?.conversationLog || []).slice(-6)
+        .map(t => `${t.role === 'user' ? 'User' : 'Bot'}: ${String(t.content).slice(0, 200)}`)
+        .join('\n');
+      const sys = 'You are a routing classifier. Reply with EXACTLY one lowercase agent name from this list and nothing else: ' + AGENTS.join(', ') + '. herald=calendar/email/weather/news, mercury=finance/markets/crypto, athena=audit/compliance, oracle=data/analytics, forge=code/architecture, scheherazade=writing/content, saber=security, sauron=monitoring, conductor=anything else.';
+      const usr = `Recent conversation (most recent last):\n${tail || '(none)'}\n\nUser message: "${text}"\n\nWhich agent? Reply with ONLY the lowercase agent name.`;
+      const ans = await callLLM(this.config, sys, usr, { max_tokens: 16 });
+      const picked = String(ans || '').trim().toLowerCase().split(/\s+/)[0];
+      if (AGENTS.includes(picked)) return picked;
+    } catch { /* LLM unavailable, keep keyword fallback */ }
+    return keywordAgent;
+  }
+
   get enabled() {
     return !!this.token;
   }
@@ -802,10 +834,25 @@ class TelegramResponder {
       let enrichedMessage = cleanText;
       let preHistory = null;
 
+      // ── Always inject multi-turn rolling history (15.1.36) ─────────────
+      // Even when the new message isn't a "continuation" of the very last
+      // turn, the user may still be referring to something earlier in the
+      // conversation ("come ti avevo detto ieri", "ricorda che..."). Pass
+      // the full conversation log to the agent as preHistory.
+      const rollingLog = (lastCtx && Array.isArray(lastCtx.conversationLog) && lastCtx.conversationLog.length > 0)
+        ? lastCtx.conversationLog
+            .filter(t => t && (t.role === 'user' || t.role === 'assistant') && typeof t.content === 'string')
+            .map(t => ({ role: t.role, content: t.content }))
+        : null;
+
       if (isContinuation && !lastWasCompleted) {
         // Continue with same agent and inject full history for context
         agent = lastCtx.agent;
-        if (lastCtx.history && lastCtx.history.length > 0) {
+        // Prefer the rolling multi-turn log if available; fall back to the
+        // legacy single-turn `history` for older saved contexts.
+        if (rollingLog && rollingLog.length > 0) {
+          preHistory = rollingLog;
+        } else if (lastCtx.history && lastCtx.history.length > 0) {
           preHistory = lastCtx.history;
         }
 
@@ -870,9 +917,13 @@ class TelegramResponder {
 
         this.log(`[Telegram] ${fromUser}: continuation → ${agent.toUpperCase()} (ctx ${Math.round(stickyAge/1000)}s ago, history=${preHistory ? preHistory.length : 0})`);
       } else {
-        // Fresh request — route normally
-        agent = routeMessage(cleanText, this.autoRoute);
-        this.log(`[Telegram] ${fromUser}: new request → ${agent.toUpperCase()}${isVoice ? ' [voice]' : ''}${lastWasCompleted ? ' [prev completed]' : ''}`);
+        // Fresh request — route normally, but STILL pass the rolling log so
+        // the model has the conversation context even when the new message
+        // is on a fresh topic (e.g. user starts a new task but the previous
+        // session is still relevant for memory: names, preferences, etc.).
+        agent = await this._routeFreshMessage(cleanText, lastCtx);
+        if (rollingLog && rollingLog.length > 0) preHistory = rollingLog;
+        this.log(`[Telegram] ${fromUser}: new request → ${agent.toUpperCase()}${isVoice ? ' [voice]' : ''}${lastWasCompleted ? ' [prev completed]' : ''} (rolling history=${preHistory ? preHistory.length : 0})`);
       }
 
       // Broadcast event
@@ -906,12 +957,25 @@ class TelegramResponder {
         ? responseText.slice(0, 3950) + '\n\n... [truncated]'
         : responseText;
 
-      // Save context — if action was completed, mark it so next turn starts fresh
+      // ── Multi-turn rolling memory (15.1.36) ────────────────────────────
+      // v13 worked well partially because every chat retained a real
+      // conversation history. The v14 refactor reduced this to 1 turn —
+      // hence "Telegram doesn't understand me anymore". We now keep the
+      // last MAX_CONVERSATION_TURNS turns per chat, persisted to disk.
+      const MAX_CONVERSATION_TURNS = 20; // user+assistant pairs
+      const prevLog = (lastCtx && Array.isArray(lastCtx.conversationLog)) ? lastCtx.conversationLog : [];
+      const conversationLog = [
+        ...prevLog,
+        { role: 'user',      content: cleanText,    ts: Date.now() },
+        { role: 'assistant', content: responseText, ts: Date.now() },
+      ].slice(-MAX_CONVERSATION_TURNS * 2);
+
       this._lastContextByChatId[chatId] = {
         agent,
         userMsg: cleanText,
         agentReply: responseText,
-        history: isCompletedAction(responseText) ? null : responseHistory, // clear history after success
+        history: isCompletedAction(responseText) ? null : responseHistory, // single-turn (legacy)
+        conversationLog,                                                   // multi-turn (new)
         ts: Date.now(),
       };
       this._lastAgentByChatId[chatId] = agent;

package/src/services/slack.mjs

@@ -127,19 +127,181 @@ export async function listMessages(config, channel, maxResults = 15) {
 }
 
 /**
- * Send a message to a channel.
- * @returns {Promise<string>} formatted result
+ * Send a message to a channel — supports thread replies via threadTs.
+ * @returns {Promise<string>} formatted result with the new message ts
  */
-export async function sendMessage(config, channel, text) {
+export async function sendMessage(config, channel, text, threadTs = null) {
   if (!channel) return 'Channel name or ID required.';
   if (!text) return 'Message text required.';
 
   const channelId = await resolveChannelId(config, channel);
 
-  await slackFetch(config, 'chat.postMessage', {
-    channel: channelId,
-    text,
+  const params = { channel: channelId, text };
+  if (threadTs) params.thread_ts = threadTs;
+
+  const res = await slackFetch(config, 'chat.postMessage', params);
+
+  return `Message sent to #${channel}${threadTs ? ' (thread reply)' : ''}. ts=${res.ts}`;
+}
+
+// ── Advanced operations (15.1.37) ───────────────────────────────────────────
+
+/**
+ * Cache of user_id → display info to avoid re-fetching on every list call.
+ * Cleared when the responder restarts. TTL implicit per process lifetime.
+ */
+const _userCache = new Map();
+
+async function _resolveUsers(config, userIds) {
+  const unknown = [...new Set(userIds)].filter(u => u && !_userCache.has(u));
+  for (const uid of unknown.slice(0, 30)) {
+    try {
+      const u = await slackFetch(config, 'users.info', { user: uid });
+      _userCache.set(uid, {
+        id: uid,
+        name: u.user?.real_name || u.user?.name || uid,
+        avatar: u.user?.profile?.image_48 || '',
+        title: u.user?.profile?.title || '',
+        is_bot: !!u.user?.is_bot,
+      });
+    } catch {
+      _userCache.set(uid, { id: uid, name: uid, avatar: '', title: '', is_bot: false });
+    }
+  }
+  return _userCache;
+}
+
+/** Return raw channel objects with member-resolved metadata. */
+export async function listChannelsRich(config, { types = 'public_channel,private_channel,mpim,im', maxResults = 200, excludeArchived = true } = {}) {
+  const data = await slackFetch(config, 'conversations.list', {
+    types, limit: maxResults, exclude_archived: excludeArchived,
   });
+  const channels = data.channels || [];
+  // For DMs, resolve the other user's name
+  const dmUserIds = channels.filter(c => c.is_im).map(c => c.user).filter(Boolean);
+  if (dmUserIds.length) await _resolveUsers(config, dmUserIds);
+  return channels.map(c => ({
+    id: c.id,
+    name: c.is_im ? (`@${_userCache.get(c.user)?.name || c.user}`) : c.name,
+    is_member: c.is_member,
+    is_private: c.is_private,
+    is_im: c.is_im,
+    is_mpim: c.is_mpim,
+    is_archived: c.is_archived,
+    num_members: c.num_members,
+    purpose: c.purpose?.value || '',
+    topic: c.topic?.value || '',
+    unread_count: c.unread_count_display || 0,
+  }));
+}
 
-  return `Message sent to #${channel}.`;
+/** Return raw message objects with user names resolved + thread metadata. */
+export async function listMessagesRich(config, channel, { limit = 50, oldest, latest } = {}) {
+  const channelId = await resolveChannelId(config, channel);
+  const params = { channel: channelId, limit };
+  if (oldest) params.oldest = oldest;
+  if (latest) params.latest = latest;
+  const data = await slackFetch(config, 'conversations.history', params);
+  const messages = (data.messages || []).reverse();
+  const userIds = messages.map(m => m.user || m.bot_id).filter(Boolean);
+  await _resolveUsers(config, userIds);
+  return messages.map(m => ({
+    ts: m.ts,
+    user: _userCache.get(m.user)?.name || m.user || (m.username ? m.username : 'bot'),
+    user_id: m.user,
+    avatar: _userCache.get(m.user)?.avatar || '',
+    text: m.text || '',
+    type: m.type,
+    subtype: m.subtype,
+    thread_ts: m.thread_ts,
+    reply_count: m.reply_count || 0,
+    reactions: (m.reactions || []).map(r => ({ name: r.name, count: r.count })),
+    files: (m.files || []).map(f => ({ id: f.id, name: f.name, mimetype: f.mimetype, url: f.url_private })),
+  }));
 }
+
+/** Get all replies in a thread. */
+export async function getThreadReplies(config, channel, threadTs) {
+  const channelId = await resolveChannelId(config, channel);
+  const data = await slackFetch(config, 'conversations.replies', {
+    channel: channelId, ts: threadTs, limit: 100,
+  });
+  const messages = data.messages || [];
+  const userIds = messages.map(m => m.user || m.bot_id).filter(Boolean);
+  await _resolveUsers(config, userIds);
+  return messages.map(m => ({
+    ts: m.ts,
+    user: _userCache.get(m.user)?.name || m.user || 'bot',
+    text: m.text || '',
+    reactions: (m.reactions || []).map(r => ({ name: r.name, count: r.count })),
+  }));
+}
+
+/** Search messages across the workspace (requires search:read scope). */
+export async function searchMessages(config, query, { count = 20 } = {}) {
+  const data = await slackFetch(config, 'search.messages', { query, count, sort: 'timestamp', sort_dir: 'desc' });
+  const matches = data.messages?.matches || [];
+  const userIds = matches.map(m => m.user).filter(Boolean);
+  await _resolveUsers(config, userIds);
+  return matches.map(m => ({
+    ts: m.ts,
+    user: _userCache.get(m.user)?.name || m.user || m.username || 'unknown',
+    text: m.text || '',
+    channel: m.channel?.name || m.channel?.id,
+    channel_id: m.channel?.id,
+    permalink: m.permalink,
+  }));
+}
+
+/** Add an emoji reaction to a message. */
+export async function addReaction(config, channel, ts, emoji) {
+  const channelId = await resolveChannelId(config, channel);
+  await slackFetch(config, 'reactions.add', {
+    channel: channelId, timestamp: ts, name: emoji.replace(/^:|:$/g, ''),
+  });
+  return `Added :${emoji}: reaction.`;
+}
+
+/** Mark a channel as read up to a given ts (or now). */
+export async function markRead(config, channel, ts = null) {
+  const channelId = await resolveChannelId(config, channel);
+  await slackFetch(config, 'conversations.mark', {
+    channel: channelId, ts: ts || (Date.now() / 1000).toString(),
+  });
+  return `Marked #${channel} as read.`;
+}
+
+/** Open a DM with a user by ID or name lookup. */
+export async function openDM(config, userIdOrName) {
+  let uid = userIdOrName;
+  // If it doesn't look like a user ID (U...), try to look it up
+  if (!/^U[A-Z0-9]{8,}$/.test(uid)) {
+    const data = await slackFetch(config, 'users.list', { limit: 1000 });
+    const match = (data.members || []).find(u =>
+      u.real_name?.toLowerCase() === uid.toLowerCase() ||
+      u.name?.toLowerCase() === uid.toLowerCase() ||
+      u.profile?.email?.toLowerCase() === uid.toLowerCase(),
+    );
+    if (!match) throw new Error(`User "${userIdOrName}" not found in workspace.`);
+    uid = match.id;
+  }
+  const data = await slackFetch(config, 'conversations.open', { users: uid });
+  return data.channel?.id;
+}
+
+/** Workspace info (team name, icon). */
+export async function getWorkspaceInfo(config) {
+  try {
+    const data = await slackFetch(config, 'team.info', {});
+    return {
+      id: data.team?.id,
+      name: data.team?.name,
+      domain: data.team?.domain,
+      icon: data.team?.icon?.image_88,
+    };
+  } catch { return null; }
+}
+
+/** Update the cached user info — useful before listing messages. */
+export { _resolveUsers as resolveUsers };
+

package/src/services/tool-executor.mjs

@@ -752,7 +752,7 @@ browser_open(url) → returns sessionId. browser_screenshot(sessionId) · browse
 note_add(text) · note_list()
 github_issues(repo) · github_prs(repo) · github_notifications() · github_create_issue(repo, title, body)
 notion_search(query) · notion_page(pageId)
-slack_channels() · slack_messages(channel) · slack_send(channel, text)
+slack_channels() · slack_messages(channel) · slack_send(channel, text, threadTs?) · slack_search(query) · slack_dm(user, text?) · slack_thread(channel, ts) · slack_react(channel, ts, emoji) · slack_mark_read(channel, ts?)
 
 ### Files / Drive
 file_list(dir?) · file_read(path) · file_write(path, content) · file_info(path) · file_search(query)
@@ -2009,7 +2009,44 @@ export async function executeTool(action, params, config) {
 
     case 'slack_send': {
       const sl = await import('./slack.mjs');
-      return sl.sendMessage(config, params.channel, params.text);
+      return sl.sendMessage(config, params.channel, params.text, params.threadTs || null);
+    }
+
+    case 'slack_search': {
+      const sl = await import('./slack.mjs');
+      const results = await sl.searchMessages(config, params.query, { count: params.count || 20 });
+      if (!results.length) return `No messages match "${params.query}".`;
+      return results.map((r, i) =>
+        `${i + 1}. [#${r.channel}] ${r.user} (${new Date(parseFloat(r.ts) * 1000).toLocaleString()}): ${r.text.slice(0, 200)}${r.permalink ? `\n   → ${r.permalink}` : ''}`,
+      ).join('\n');
+    }
+
+    case 'slack_dm': {
+      const sl = await import('./slack.mjs');
+      const channelId = await sl.openDM(config, params.user);
+      if (params.text) await sl.sendMessage(config, channelId, params.text);
+      return params.text
+        ? `DM sent to ${params.user} (channel ${channelId}).`
+        : `Opened DM channel ${channelId} with ${params.user}.`;
+    }
+
+    case 'slack_thread': {
+      const sl = await import('./slack.mjs');
+      const replies = await sl.getThreadReplies(config, params.channel, params.ts);
+      if (!replies.length) return 'Thread has no replies.';
+      return replies.map((r, i) =>
+        `${i + 1}. ${r.user} (${new Date(parseFloat(r.ts) * 1000).toLocaleTimeString()}): ${r.text.slice(0, 200)}`,
+      ).join('\n');
+    }
+
+    case 'slack_react': {
+      const sl = await import('./slack.mjs');
+      return sl.addReaction(config, params.channel, params.ts, params.emoji || 'thumbsup');
+    }
+
+    case 'slack_mark_read': {
+      const sl = await import('./slack.mjs');
+      return sl.markRead(config, params.channel, params.ts || null);
     }
 
     // ── Maps Directions ──────────────────────────────────────────────────