nothumanallowed 15.1.36 → 15.1.38

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nothumanallowed",
-  "version": "15.1.36",
+  "version": "15.1.38",
   "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.36';
+export const VERSION = '15.1.38';
 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,37 @@ class TelegramResponder {
     saveTelegramContext(this._lastContextByChatId);
   }
 
+  /**
+   * Language-agnostic intent classifier (15.1.38).
+   *
+   * Previous versions hard-coded confirmation/reaction keywords for Italian
+   * and English. That couldn't scale — every new language ("schedule it"
+   * in Spanish, German, Japanese, Polish, Turkish, ...) would need a new
+   * keyword list. Now we delegate to a tiny LLM call: 16 tokens output,
+   * works in any human language the model knows.
+   *
+   * Fast path: if the keyword matcher already returned a confident verdict,
+   * skip the LLM. Only ambiguous cases (short messages, no obvious keyword)
+   * pay the ~50ms LLM cost.
+   *
+   * @returns 'continuation' | 'new_request' | 'unknown'
+   */
+  async _classifyIntent(text, lastCtx) {
+    if (!lastCtx) return 'new_request';
+    const hasKey = !!(this.config.llm?.apiKey || this.config.llm?.openaiKey || this.config.llm?.geminiKey || (this.config.llm?.provider === 'nha'));
+    if (!hasKey) return 'unknown';
+    try {
+      const prev = (lastCtx.agentReply || '').slice(0, 600);
+      const sys = 'You are a binary intent classifier for a chat assistant. Reply with EXACTLY one word: "continuation" or "new_request". Use "continuation" when the user is confirming, denying, reacting to, or refining the assistant\'s previous message (in any language). Use "new_request" when the user is starting an unrelated topic. Do not output anything else.';
+      const usr = `Assistant just said:\n"${prev}"\n\nUser now writes:\n"${text}"\n\nClassify the user\'s message: continuation or new_request?`;
+      const ans = await callLLM(this.config, sys, usr, { max_tokens: 8 });
+      const v = String(ans || '').trim().toLowerCase().replace(/[^a-z_]/g, '');
+      if (v === 'continuation' || v.startsWith('cont')) return 'continuation';
+      if (v === 'new_request' || v.startsWith('new')) return 'new_request';
+      return 'unknown';
+    } catch { return 'unknown'; }
+  }
+
   /**
    * Route a fresh message to the best agent.
    *
@@ -823,8 +854,27 @@ class TelegramResponder {
       const withinStickyWindow = stickyAge < 5 * 60 * 1000; // 5 min
 
       // Determine if this message is a continuation of the previous turn
-      // (confirmation, reaction, short reply) vs a new independent request
-      const isContinuation = withinStickyWindow && isContinuationMessage(cleanText, lastCtx);
+      // (confirmation, reaction, short reply) vs a new independent request.
+      //
+      // Two-stage detection:
+      //   1. Fast keyword path (IT + EN) — handles the obvious cases (~80%) with zero cost.
+      //   2. LLM classifier fallback — for ambiguous cases in any language
+      //      ("agéndalo", "termin verschieben", "schedule it",
+      //       "ya", "tamam", "harika", ...). Costs ~50 ms and 8 output tokens
+      //      but is language-agnostic by design.
+      let isContinuation = withinStickyWindow && isContinuationMessage(cleanText, lastCtx);
+      if (withinStickyWindow && !isContinuation && lastCtx) {
+        // Only invoke the LLM if keyword fast-path didn't flag continuation
+        // AND the message is short enough to plausibly be a reaction (≤ 12 words).
+        const wordCount = cleanText.trim().split(/\s+/).length;
+        if (wordCount <= 12) {
+          const verdict = await this._classifyIntent(cleanText, lastCtx);
+          if (verdict === 'continuation') {
+            isContinuation = true;
+            this.log(`[Telegram] ${fromUser}: LLM classifier overrode keyword → continuation`);
+          }
+        }
+      }
 
       // If last response was a completed action, don't carry history forward —
       // the next message is a fresh request even if it looks like a reaction

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

@@ -294,8 +294,34 @@ TOOLS:
 40. slack_messages(channel: string, maxResults?: number)
     List recent messages in a Slack channel (name or ID). Default max 15.
 
-41. slack_send(channel: string, text: string)
+41. slack_send(channel: string, text: string, threadTs?: string)
     Send a message to a Slack channel. ALWAYS confirm before sending.
+    If `threadTs` is provided, post as a thread reply instead of a top-level message.
+
+41b. slack_search(query: string, count?: number)
+     Full-text search messages across the whole Slack workspace. Returns the most
+     recent matches with channel, user, text and a Slack permalink each. Use this
+     for "find the message where X talked about Y", "trova il messaggio di Marco
+     su X", "did anyone post about the release", etc.
+
+41c. slack_dm(user: string, text?: string)
+     Open or send a direct message to a user. `user` accepts Slack user ID (Uxxx),
+     username, real name, or email — the tool resolves them automatically.
+     If `text` is provided, the message is sent immediately; otherwise the DM
+     channel is just opened.
+
+41d. slack_thread(channel: string, ts: string)
+     List all replies in a thread. `ts` is the parent message timestamp (returned
+     by slack_messages or slack_search). Use this before posting a contextual
+     reply with slack_send + threadTs.
+
+41e. slack_react(channel: string, ts: string, emoji: string)
+     Add an emoji reaction to a message. `emoji` is the name without colons
+     (e.g. "thumbsup", "rocket", "white_check_mark"). Confirm before reacting on
+     someone else's message.
+
+41f. slack_mark_read(channel: string, ts?: string)
+     Mark a Slack channel as read up to a given timestamp (default: now).
 
 --- FILE ATTACHMENT ---
 
@@ -752,7 +778,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 +2035,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 ──────────────────────────────────────────────────