hive-am 1.4.0 → 1.6.0

package/server/dist/connections/manager.js

@@ -2,6 +2,7 @@ import { readFileSync } from 'node:fs';
 import { agents } from '../db.js';
 import { liveOrigin, notifyAgentsChanged } from '../runtime.js';
 import { cleanInbox } from './files.js';
+import { retentionPass, retentionTouched } from '../retention.js';
 import { resolveSendable } from './outbound.js';
 import { syncChannelSkill } from './channel-skill.js';
 import { handleInbound } from './router.js';
@@ -59,10 +60,21 @@ export async function stopConnection(id) {
     catch { /* already down */ }
 }
 let cleaner;
-export const startAll = () => {
-    // Received files are kept for a while, then removed.
+/** Received files are kept for a while, then removed; and what hive-am keeps of its own record is aged out (retention.ts). */
+function housekeeping() {
     cleanInbox();
-    cleaner ??= setInterval(() => cleanInbox(), 6 * 3_600_000).unref();
+    try {
+        const r = retentionPass();
+        if (retentionTouched(r))
+            console.log(`[retention] removed ${r.messages} messages, ${r.dispatches} dispatches, ${r.sessions} sessions; emptied ${r.files} file records`);
+    }
+    catch (e) {
+        console.error('[retention]', e);
+    }
+}
+export const startAll = () => {
+    housekeeping();
+    cleaner ??= setInterval(housekeeping, 6 * 3_600_000).unref();
     return Promise.all(connections.list().filter((c) => c.enabled).map((c) => startConnection(c.id)));
 };
 export const stopAll = () => Promise.all([...running.keys()].map(stopConnection));
@@ -114,7 +126,7 @@ export async function channelReply(agentId, text) {
         console.warn(`[connections] blocked a reply of agent ${agentId}: it seemed to contain ${leak}`);
         throw new ChannelError(SECRET_REFUSAL(leak));
     }
-    const { externalId } = await adapter.send(thread.target, text);
+    const { externalId } = await adapter.send(origin.target ?? thread.target, text);
     threadMessages.record(thread.id, 'out', externalId, { name: agents.get(agentId)?.name }, text);
     origin.replied = true;
     return { sent: true, parts: 1 };
@@ -136,7 +148,7 @@ export async function channelReact(agentId, emoji) {
     if (!thread)
         throw new ChannelError('The thread no longer exists.');
     try {
-        await adapter.react(thread.target, origin.messageId, e);
+        await adapter.react(origin.target ?? thread.target, origin.messageId, e);
     }
     catch (err) {
         throw new ChannelError(err instanceof Error ? err.message : 'The reaction failed');
@@ -164,7 +176,7 @@ export async function channelSendFile(agentId, path, caption) {
         console.warn(`[connections] blocked a file of agent ${agentId}: it seemed to contain ${leak}`);
         throw new ChannelError(SECRET_REFUSAL(leak).replace('the message', `the ${caption && findSecret(caption) ? 'caption' : 'file'}`));
     }
-    const { externalId } = await adapter.sendFile(thread.target, file, caption?.trim() || undefined);
+    const { externalId } = await adapter.sendFile(origin.target ?? thread.target, file, caption?.trim() || undefined);
     threadMessages.record(thread.id, 'out', externalId, { name: agent.name }, `${caption?.trim() ? `${caption.trim()} ` : ''}[sent file: ${file.name}]`);
     origin.replied = true;
     return { sent: true, name: file.name, kind: file.kind };

package/server/dist/connections/router.js

@@ -10,9 +10,11 @@ import { connections, threadMessages, threads } from './store.js';
 const MAX_INPUT = 8000;
 const DEFAULT_RATE = 20; // messages per user per minute
 const DEFAULT_CHATTER_PER_MINUTE = 10; // times per minute that chatter nobody aimed at the agent may wake it, per thread
+const DENIED_PER_MINUTE = 5; // access notices per person and chat per minute, so a stranger can't make the bot spam a chat
+const DENIED_CHAT_PER_MINUTE = 20; // access notices per chat per minute, whoever asks
 /** Sent once when a turn aimed at the agent ended without a reply. */
 const NUDGE = '[hive:channel] System reminder: your last turn ended without calling `channel_reply`, so the person received nothing. If you had an answer, send it now with `channel_reply` (if the tool says it is unknown, call it again: it was still connecting). If you chose not to answer, say so in one short sentence with `channel_reply`.';
-export const EFFORTS = ['low', 'medium', 'high'];
+import { validEffort } from '../efforts.js';
 const QUIET_MS = 4000; // group chatter is handed over once it pauses this long, so a burst is one turn
 const LONG_TURN_MS = 45_000; // an unaddressed turn this long did real work: if it never replied, remind it
 const QUIET_RETRIES = 15; // while the agent is busy the hand-over waits (about a minute); after this it is left as context for the next turn
@@ -34,8 +36,15 @@ const T = {
     newDone: { es: '🆕 Conversación nueva.', en: '🆕 New conversation.' },
     muted: { es: '🔇 Me quedo callado en este hilo. Menciónenme o respondan a un mensaje mío para que vuelva a hablar.', en: '🔇 I\'ll stay quiet in this thread. Mention me or reply to one of my messages to bring me back.' },
     unmuted: { es: '🔊 Listo, vuelvo a participar en este hilo.', en: '🔊 Done, I\'m back in this thread.' },
+    help: { es: 'Comandos: /new (o /clear, /reset) empieza una conversación nueva (solo administradores) · /stop detiene el turno en curso · /status estado del agente · /mute y /unmute me callan o me reactivan en este hilo · /id tu id y el de este chat · /help esta ayuda.', en: 'Commands: /new (or /clear, /reset) starts a new conversation (admins only) · /stop stops the turn in progress · /status the agent\'s state · /mute and /unmute silence me or bring me back in this thread · /id your id and this chat\'s · /help this help.' },
+    ids: (user, chat) => ({ es: `Tu id: ${user} · este chat: ${chat}`, en: `Your id: ${user} · this chat: ${chat}` }),
     notAllowedChat: (user, chat) => ({ es: `No tienes acceso. Para usarme aquí, añade tu id (${user}) o este chat (${chat}) en la conexión.`, en: `You don't have access. To use me here, add your id (${user}) or this chat (${chat}) to the connection.` }),
+    notAllowedMember: (user, chat, slack) => slack
+        ? { es: `Este canal solo admite a personas de su lista. Para usarme aquí, añade tu id (${user}) a los miembros de este canal (${chat}).`, en: `This channel only admits the people on its list. To use me here, add your id (${user}) to this channel's members (${chat}).` }
+        : { es: `Este chat solo admite a personas de su lista. Para usarme aquí, añade tu id (${user}) a los miembros de este chat (${chat}).`, en: `This chat only admits the people on its list. To use me here, add your id (${user}) to this chat's members (${chat}).` },
 };
+/** The same commands on every platform; these are other names for them. */
+const COMMAND_ALIASES = { clear: 'new', reset: 'new' };
 const say = (c, m) => (c.config.lang === 'en' ? m.en : m.es);
 const hits = new Map();
 function tooFast(connId, user, limit) {
@@ -45,8 +54,20 @@ function tooFast(connId, user, limit) {
     hits.set(key, arr);
     return arr.length > limit;
 }
-const told = new Set(); // users already told how to get access, so strangers can't make us spam them
 const chatsOf = (c) => (Array.isArray(c.config.chats) ? c.config.chats : []);
+/** Who may talk: in a DM and in a group with no entry of its own, the connection's people list (with their admin flag); in a listed group, that group's own rule: everyone in it, or only its members (the people list does not open it, and an empty list admits nobody). A member keeps admin only if the people list gives it. The chat is `target.chat`, so a rule covers every topic and thread in it. */
+export function senderOf(c, m) {
+    const listed = c.allowed.find((u) => u.id === m.userId);
+    if (!m.group)
+        return listed;
+    const chat = chatsOf(c).find((x) => x.id === m.target.chat);
+    if (!chat)
+        return listed;
+    if (chat.mode !== 'members')
+        return listed ?? { id: m.userId, name: m.userName };
+    const member = (Array.isArray(chat.members) ? chat.members : []).find((x) => x.id === m.userId);
+    return member ? { id: m.userId, name: member.name ?? m.userName, ...(listed?.admin ? { admin: true } : {}) } : undefined;
+}
 const aliasesOf = (c) => (Array.isArray(c.config.aliases) ? c.config.aliases : []).map((a) => String(a).trim()).filter(Boolean);
 /** Group chatter that speaks TO the agent by one of its aliases counts as aimed at it, even without @mention. */
 const selfNames = (c) => { const n = (c.agent_id ? agents.get(c.agent_id)?.name : '') ?? ''; return n ? [n, n.split(/\s+/)[0]] : []; };
@@ -72,16 +93,16 @@ export async function handleInbound(connectionId, adapter, m) {
     // Group chatter is only heard when the connection is open to it.
     if (group && !addressed && conn.config.group_mode !== 'open')
         return;
-    const user = conn.allowed.find((u) => u.id === m.userId)
-        ?? (group && chatsOf(conn).some((c) => c.id === m.target.chat) ? { id: m.userId, name: m.userName } : undefined);
+    const user = senderOf(conn, m);
     if (!user) {
         if (!addressed)
             return; // never answer strangers' chatter
-        const key = `${connectionId}:${m.userId}`;
-        if (!told.has(key)) {
-            told.add(key);
-            await reply(say(conn, group ? T.notAllowedChat(m.userId, m.target.chat) : T.notAllowed(m.userId)));
+        // Told at every message, so the bot never looks dead; capped per person and per chat (topics and threads share it) so nobody can make it flood a chat.
+        if (!allow(`denied:${connectionId}:${m.userId}:${m.target.chat}`, DENIED_PER_MINUTE) || !allow(`denied-chat:${connectionId}:${m.target.chat}`, DENIED_CHAT_PER_MINUTE)) {
+            return;
         }
+        const restricted = group && chatsOf(conn).some((c) => c.id === m.target.chat && c.mode === 'members');
+        await reply(say(conn, restricted ? T.notAllowedMember(m.userId, m.target.chat, conn.kind === 'slack') : group ? T.notAllowedChat(m.userId, m.target.chat) : T.notAllowed(m.userId)));
         return;
     }
     const thread = threads.touch(connectionId, m.externalKey, { title: m.place, target: m.target, user: m.userName });
@@ -117,7 +138,16 @@ export async function handleInbound(connectionId, adapter, m) {
         } // only files, and none could be saved: nothing to hand over
     }
     if (m.command) {
-        const { name, args } = m.command;
+        const { args } = m.command;
+        const name = COMMAND_ALIASES[m.command.name] ?? m.command.name;
+        if (name === 'help') {
+            await reply(say(conn, T.help));
+            return;
+        }
+        if (name === 'id') {
+            await reply(say(conn, T.ids(m.userId, m.target.chat)));
+            return;
+        }
         if (name === 'stop') {
             await reply(say(conn, stopAgent(agent.id) ? T.stopped : T.nothingToStop));
             return;
@@ -190,7 +220,7 @@ async function deliver(conn, adapter, thread, m, msgId, addressed, scheduled = f
         return;
     const reply = (text) => adapter.send(m.target, text).catch(() => undefined);
     const fresh = threads.get(thread.id) ?? thread;
-    if (m.text.length > MAX_INPUT) {
+    if (!scheduled && m.text.length > MAX_INPUT) {
         if (addressed)
             await reply(say(conn, T.tooLong));
         return;
@@ -205,7 +235,7 @@ async function deliver(conn, adapter, thread, m, msgId, addressed, scheduled = f
         await reply(say(conn, T.queued(ahead)));
     const unseen = threadMessages.unseen(thread.id, fresh.seen_id, msgId).map((r) => ({ name: r.user_name ?? r.user_id ?? '?', text: r.text, files: r.files ? parseJson(r.files, undefined, `thread message ${r.id} files`) : undefined }));
     threads.markSeen(thread.id, msgId);
-    const origin = { connectionId: conn.id, threadId: thread.id, externalKey: m.externalKey, platform: conn.kind, place: m.place, userName: m.userName, userId: m.userId, group: !!m.group, mention: m.mention, addressed, replied: false, messageId: m.externalId, effort: EFFORTS.includes(conn.config.effort) ? conn.config.effort : undefined };
+    const origin = { connectionId: conn.id, threadId: thread.id, externalKey: m.externalKey, platform: conn.kind, place: m.place, userName: m.userName, userId: m.userId, group: !!m.group, mention: m.mention, addressed, replied: false, messageId: m.externalId, target: m.target, effort: validEffort(conn.config.effort) ? conn.config.effort : undefined };
     if (addressed)
         await adapter.busy(m.target, 'working', m.externalId).catch(() => undefined);
     const startedAt = Date.now();
@@ -248,10 +278,10 @@ async function deliver(conn, adapter, thread, m, msgId, addressed, scheduled = f
             await adapter.busy(m.target, 'done', m.externalId).catch(() => undefined);
     }
 }
-/** A message the agent asked to receive later (a wake-up, a schedule): it reaches the agent like a message of that thread, so it can answer there. */
+/** A message the agent asked to receive later (a wake-up, a schedule): it reaches the agent like a message of that thread, so it can answer there (on Slack, in the channel: see `ChannelAdapter.proactive`). */
 export async function deliverScheduled(conn, adapter, thread, text, mention) {
     const m = {
-        externalId: `sched-${Date.now()}`, externalKey: thread.external_key, userId: '', userName: 'hive-am (scheduled)', place: thread.title || 'chat', target: thread.target, addressed: true, text, mention,
+        externalId: `sched-${Date.now()}`, externalKey: thread.external_key, userId: '', userName: 'hive-am (scheduled)', place: thread.title || 'chat', target: adapter.proactive?.(thread.target) ?? thread.target, addressed: true, text, mention,
     };
     await deliver(conn, adapter, thread, m, threadMessages.lastId(thread.id), true, true);
 }

package/server/dist/connections/secrets.js

@@ -1,4 +1,5 @@
 import { connections } from './store.js';
+import { objectsStore } from '../objects/store.js';
 /**
  * Last line of defence for text an agent sends to a chat. The instructions tell the agent never to share secrets, but a model can be
  * talked into it (by anyone in a group, or by an admin who does not realise what the output holds), so the text is checked here
@@ -10,7 +11,7 @@ const SHAPES = [
     [/\b\d{8,10}:[A-Za-z0-9_-]{30,}\b/, 'a Telegram bot token'],
     [/\b(?:AKIA|ASIA)[A-Z0-9]{16}\b/, 'an AWS access key'],
     [/\bgh[pousr]_[A-Za-z0-9]{30,}\b|\bgithub_pat_[A-Za-z0-9_]{30,}\b/, 'a GitHub token'],
-    [/\bxox[abprs]-[A-Za-z0-9-]{10,}\b/, 'a Slack token'],
+    [/\bxox[abprs]-[A-Za-z0-9-]{10,}\b|\bxapp-\d+-[A-Za-z0-9-]{10,}\b/, 'a Slack token'],
     [/\b(?:sk|rk)_(?:live|test)_[A-Za-z0-9]{16,}\b/, 'a Stripe key'],
     [/\bsk-[A-Za-z0-9_-]{32,}\b/, 'an API key'],
     [/\bAIza[0-9A-Za-z_-]{35}\b/, 'a Google API key'],
@@ -31,6 +32,13 @@ function knownSecrets() {
             if (typeof v === 'string' && v.length >= 8)
                 out.add(v);
         }
+    // The password of a database resource: an agent can use it to connect, but it must never be repeated in a chat.
+    for (const o of objectsStore.list())
+        if (o.kind === 'database') {
+            const pw = o.config.password;
+            if (typeof pw === 'string' && pw.length >= 6)
+                out.add(pw);
+        }
     for (const [k, v] of Object.entries(process.env))
         if (v && v.length >= 12 && SECRET_ENV.test(k))
             out.add(v);