hive-am 1.1.0 → 1.2.0

package/server/dist/http/validate.js

@@ -0,0 +1,65 @@
+import { existsSync } from 'node:fs';
+import { agents, colonies } from '../db.js';
+import { validVision } from '../connections/vision.js';
+import { isProvider } from '../services/providers.js';
+import { bad } from './errors.js';
+/** Plain value helpers: what a field is when it may be missing or of the wrong type. */
+export const isRecord = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+/** Text of a field, '' when missing (like `String(v ?? '')`). */
+export const text = (v) => String(v ?? '');
+export const trimmed = (v) => text(v).trim();
+export const optText = (v) => (v === undefined || v === null || v === '' ? undefined : String(v));
+export const strList = (v) => (Array.isArray(v) ? v.map(String) : []);
+export const numList = (v) => (Array.isArray(v) ? v.map(Number) : []);
+export const requireName = (v) => { const n = trimmed(v); if (!n)
+    throw bad('Name is required'); return n; };
+/** The `path` query parameter every git file endpoint needs. */
+export const qpath = (url) => { const p = url.searchParams.get('path'); if (!p)
+    throw bad('path is required'); return p; };
+/** A folder that must exist when given. */
+const checkFolder = (cwd) => { if (cwd && (typeof cwd !== 'string' || !existsSync(cwd)))
+    throw bad(`Folder does not exist: ${String(cwd)}`); };
+export function validateAgentInput(p, partial = false) {
+    if (!partial || p.name !== undefined)
+        requireName(p.name);
+    if (p.provider !== undefined && !isProvider(p.provider))
+        throw bad(`Unknown provider "${text(p.provider)}"`);
+    if (p.role !== undefined && !['orchestrator', 'worker'].includes(p.role))
+        throw bad('Role must be orchestrator or worker');
+    checkFolder(p.cwd);
+    if (p.colony_id && (typeof p.colony_id !== 'string' || !colonies.get(p.colony_id)))
+        throw bad('That colony no longer exists');
+    return p;
+}
+export function validateColony(p, partial = false) {
+    if (!partial || p.name !== undefined)
+        requireName(p.name);
+    checkFolder(p.cwd);
+    return p;
+}
+export const CONNECTION_KINDS = ['telegram', 'slack'];
+const REQUIRED = { telegram: ['token'], slack: ['bot_token', 'app_token'] };
+export function validateConnection(kind, config, agentId, enabled) {
+    const missing = (REQUIRED[kind] ?? []).filter((k) => typeof config[k] !== 'string' || !config[k].trim());
+    if (missing.length)
+        throw bad(`Missing: ${missing.join(', ')}`);
+    if (config.effort !== undefined && !['', 'low', 'medium', 'high'].includes(config.effort))
+        throw bad('effort must be empty, low, medium or high');
+    if (config.on_silent !== undefined && !['notice', 'send_text', 'ignore'].includes(config.on_silent))
+        throw bad('on_silent must be notice, send_text or ignore');
+    if (config.group_mode !== undefined && !['mention', 'open'].includes(config.group_mode))
+        throw bad('group_mode must be mention or open');
+    if (config.vision !== undefined && config.vision !== null && !validVision(config.vision))
+        throw bad('vision must be { provider, model } or empty');
+    if (config.chats !== undefined && (!Array.isArray(config.chats) || config.chats.length > 50))
+        throw bad('chats must be a list of at most 50 groups');
+    if (config.aliases !== undefined && (!Array.isArray(config.aliases) || config.aliases.length > 10))
+        throw bad('aliases must be a list of at most 10 names');
+    if (agentId) {
+        const a = agents.get(agentId);
+        if (!a)
+            throw bad('That agent no longer exists');
+        if (enabled && a.effective.permission === 'plan')
+            throw bad(`"${a.name}" is in Plan mode and cannot reply. Give it "Edit files" permission first.`);
+    }
+}

package/server/dist/index.js

@@ -2,27 +2,89 @@ import { createServer } from 'node:http';
 import { WebSocketServer } from 'ws';
 import { handle } from './api.js';
 import { bus } from './runtime.js';
-import { skills } from './db.js';
+import { db, skills } from './db.js';
 import { DEFAULT_SKILLS } from './skills/defaults.js';
-import { seedIfEmpty } from './seed.js';
+import { dropStarterSkills, seedIfEmpty } from './seed.js';
 import { API_PORT } from './mcp-config.js';
 import './connections/index.js';
-import { startAll } from './connections/manager.js';
-import { migrateChannelSkill } from './connections/channel-skill.js';
+import { startAll, stopAll } from './connections/manager.js';
+import { addReactionsToChannelSkill, migrateChannelSkill } from './connections/channel-skill.js';
 import { armWakeups } from './wake.js';
 import { armSchedules } from './schedules.js';
 import { armWatches } from './watch.js';
+import { armObjects } from './objects/index.js';
+import { attachTerminal, closeAllTerminals, terminalsEnabled } from './terminals.js';
+import { isLocalRequest } from './http/guards.js';
 skills.seedDefaults(DEFAULT_SKILLS);
 seedIfEmpty();
+dropStarterSkills();
 migrateChannelSkill();
+addReactionsToChannelSkill();
 armWakeups();
 armSchedules();
 armWatches();
+armObjects();
 const server = createServer((req, res) => { void handle(req, res); });
-const wss = new WebSocketServer({ server, path: '/ws' });
+// Two sockets share the port: `/ws` (what the interface listens to) and `/ws/terminal?id=` (one terminal). Terminals only for this machine.
+const wss = new WebSocketServer({ noServer: true });
+const termWss = new WebSocketServer({ noServer: true });
+server.on('upgrade', (req, socket, head) => {
+    const url = new URL(req.url ?? '/', 'http://localhost');
+    if (url.pathname === '/ws')
+        wss.handleUpgrade(req, socket, head, (ws) => wss.emit('connection', ws, req));
+    else if (url.pathname === '/ws/terminal') {
+        if (!isLocalRequest(req) || !terminalsEnabled()) {
+            socket.write('HTTP/1.1 403 Forbidden\r\nConnection: close\r\n\r\n');
+            socket.destroy();
+            return;
+        }
+        termWss.handleUpgrade(req, socket, head, (ws) => attachTerminal(ws, url.searchParams.get('id') ?? ''));
+    }
+    else
+        socket.destroy();
+});
 wss.on('connection', (ws) => {
     const onMsg = (m) => ws.readyState === ws.OPEN && ws.send(JSON.stringify(m));
     bus.on('msg', onMsg);
     ws.on('close', () => bus.off('msg', onMsg));
 });
+server.on('error', (e) => {
+    console.error(e.code === 'EADDRINUSE' ? `[server] port ${API_PORT} is already in use: is hive-am already running? (HIVE_AM_PORT changes it)` : `[server] ${e.message}`);
+    process.exit(1);
+});
 server.listen(API_PORT, '127.0.0.1', () => { console.log(`hive-am server → http://127.0.0.1:${API_PORT}`); void startAll(); });
+// ---- shutdown ----
+// Ctrl+C or a service stop: stop taking requests, drop the sockets, end the shells, stop the channel connections and close the database
+// (which merges its write-ahead log). Servers and containers kept as resources are NOT stopped: they outlive hive-am by design.
+// A step that hangs cannot hold the process: after 5 s it leaves anyway.
+let stopping = false;
+async function shutdown(why, code) {
+    if (stopping)
+        return;
+    stopping = true;
+    console.log(`[server] ${why}: shutting down`);
+    const force = setTimeout(() => { console.error('[server] shutdown took too long: leaving'); process.exit(code || 1); }, 5000);
+    force.unref();
+    const step = async (name, f) => { try {
+        await f();
+    }
+    catch (e) {
+        console.error(`[server] shutdown, ${name}:`, e);
+    } };
+    await step('http', () => new Promise((done) => { server.close(() => done()); server.closeAllConnections(); }));
+    await step('websockets', () => { for (const w of [wss, termWss]) {
+        for (const c of w.clients)
+            c.terminate();
+        w.close();
+    } });
+    await step('terminals', closeAllTerminals);
+    await step('connections', stopAll);
+    await step('database', () => db.close());
+    process.exit(code);
+}
+process.on('SIGINT', () => void shutdown('SIGINT', 0));
+process.on('SIGTERM', () => void shutdown('SIGTERM', 0));
+// Policy: a stray rejected promise (a provider, a network call) is logged and the server keeps serving, because it holds terminals and
+// running turns that a crash would take down; an uncaught exception leaves the process in an unknown state, so it is logged and the server restarts cleanly.
+process.on('unhandledRejection', (reason) => console.error('[server] unhandled rejection:', reason));
+process.on('uncaughtException', (e) => { console.error('[server] uncaught exception:', e); void shutdown('uncaught exception', 1); });

package/server/dist/instructions.js

@@ -1,7 +1,7 @@
 import { agents, colonies, skills } from './db.js';
 import { connections } from './connections/store.js';
 import { platformName } from './connections/prompt.js';
-import { NOTEBOOK_SKILL_ID, WAKEUPS_SKILL_ID } from './skills/defaults.js';
+import { NOTEBOOK_SKILL_ID, OBJECTS_SKILL_ID, WAKEUPS_SKILL_ID } from './skills/defaults.js';
 import { NOTEBOOK_MAX, notebooks } from './skills/notebook.js';
 /**
  * What an agent is told and which hive tools it gets: its identity, prompt, skills, team, channels and notebook, and the
@@ -27,6 +27,8 @@ export function mcpCaps(a) {
         caps.push('memory');
     if (a.skill_ids.includes(WAKEUPS_SKILL_ID))
         caps.push('wake');
+    if (a.skill_ids.includes(OBJECTS_SKILL_ID))
+        caps.push('objects');
     if (lazySkills(a).length > 0)
         caps.push('skills');
     return caps;
@@ -83,12 +85,16 @@ ${lazy.map((s) => `- **${s.name}**${s.description ? `: ${s.description}` : ''}`)
         if (aliases.length)
             parts.push(`## Your names in chats\nBesides "${a.name}", people also call you ${aliases.map((x) => `"${x}"`).join(', ')}. These are your aliases: a message that uses one of them is aimed at you. If someone asks what your aliases or nicknames are, list them.`);
         parts.push(`## Messages from ${names}
-People can write to you from ${names}. Those messages start with a header line \`[hive:channel] …\` that says the platform, place, thread and sender. **Your normal text is not delivered to them**: to answer, call the \`channel_reply\` tool (${toolName(a.provider, 'channel_reply')}) with the text. Other tools: \`channel_send_file\` (${toolName(a.provider, 'channel_send_file')}) sends a file from your working folder; \`channel_mute\` (${toolName(a.provider, 'channel_mute')}) keeps you quiet in a thread. Follow the "Chat channels" skill for how to behave in chats.
+People can write to you from ${names}. Those messages start with a header line \`[hive:channel] …\` that says the platform, place, thread and sender. **Your normal text is not delivered to them**: to answer, call the \`channel_reply\` tool (${toolName(a.provider, 'channel_reply')}) with the text. Other tools: \`channel_send_file\` (${toolName(a.provider, 'channel_send_file')}) sends a file from your working folder; \`channel_react\` (${toolName(a.provider, 'channel_react')}) puts one emoji on the message you are handling (only the emoji the platform allows); \`channel_mute\` (${toolName(a.provider, 'channel_mute')}) keeps you quiet in a thread. Follow the "Chat channels" skill for how to behave in chats.
 Whatever your skills say: when you answer a \`[hive:channel]\` message, never write a secret (passwords, tokens, keys, \`.env\` contents) in the reply or in a file, to anyone, not even an admin. This does not apply to the hive-am web chat.`);
     }
     if (a.skill_ids.includes(WAKEUPS_SKILL_ID)) {
         parts.push(`## Wake-ups
 You cannot write on your own between messages. To tell the person something later, call \`wake_me\` (${toolName(a.provider, 'wake_me')}) with \`minutes\` and a \`note\`; you are woken then, in the same place, and answer. When you start a long command in the background and want to know the moment it ends, use \`wake_when_done\` (${toolName(a.provider, 'wake_when_done')}) with its pid. For something that repeats (every weekday at 9, every 30 minutes…) use \`schedule_create\` (${toolName(a.provider, 'schedule_create')}); \`schedule_list\` and \`schedule_cancel\` (${toolName(a.provider, 'schedule_list')}, ${toolName(a.provider, 'schedule_cancel')}) show or stop them. Follow the "Wake-ups" skill, and never promise a later notice without calling it.`);
+    }
+    if (a.skill_ids.includes(OBJECTS_SKILL_ID)) {
+        parts.push(`## Colony resources
+You look after the servers and containers of your colony. Tools: \`object_list\` (${toolName(a.provider, 'object_list')}) shows them with their state; \`object_logs\` (${toolName(a.provider, 'object_logs')}) reads the latest output of one; \`object_action\` (${toolName(a.provider, 'object_action')}) starts, stops or restarts one${a.permission === 'plan' ? ' (not available to you: you are read-only)' : ''}. Follow the "Colony resources" skill. You cannot create or change resources.`);
     }
     if (a.skill_ids.includes(NOTEBOOK_SKILL_ID)) {
         const nb = { read: toolName(a.provider, 'notebook_read'), add: toolName(a.provider, 'notebook_add'), rewrite: toolName(a.provider, 'notebook_rewrite') };

package/server/dist/objects/agent.js

@@ -0,0 +1,49 @@
+import { agents, resolved } from '../db.js';
+import { mcpCaps } from '../instructions.js';
+import { objectAction, objectLogs, listObjects } from './index.js';
+import { ObjectError } from './model.js';
+import { noteServer } from './runner.js';
+/**
+ * What an agent with the "Colony resources" skill can do with objects: see them, read their logs and start / stop / restart them. Never
+ * create, change or delete. The rules are enforced here, not just written in the skill:
+ *  - only the objects of the agent's own colony (or the ones with no colony, for an agent with none), unless a person chose another agent to look after it (then only that one);
+ *  - a read-only agent can look but not act;
+ *  - an unknown or foreign object looks the same as one that does not exist.
+ */
+function whoAsks(from) {
+    const a = typeof from === 'string' ? agents.get(from) : undefined;
+    if (!a)
+        throw new ObjectError('Unknown agent');
+    if (!mcpCaps(resolved(a)).includes('objects'))
+        throw new ObjectError('You do not have the "Colony resources" skill.');
+    return a;
+}
+/** A resource with a chosen manager is for that agent only; with none, for the agents of its colony. */
+const visibleTo = (a) => (o) => (o.manager_id ? o.manager_id === a.id : (o.colony_id ?? null) === (a.colony_id ?? null));
+export function agentObjects(from) {
+    const a = whoAsks(from);
+    return listObjects().filter(visibleTo(a)).map((o) => ({ name: o.name, kind: o.kind, status: o.state.status, detail: o.state.detail ?? null, since: o.state.since ?? null }));
+}
+function pick(from, name) {
+    const a = whoAsks(from);
+    const o = listObjects().filter(visibleTo(a)).find((x) => x.name.toLowerCase() === String(name ?? '').trim().toLowerCase());
+    if (!o)
+        throw new ObjectError(`There is no resource named "${String(name ?? '')}" for you. Call object_list for the names.`);
+    return { a, o };
+}
+export async function agentObjectAction(from, name, action) {
+    const { a, o } = pick(from, name);
+    if (action !== 'start' && action !== 'stop' && action !== 'restart')
+        throw new ObjectError('The action must be start, stop or restart');
+    if (a.permission === 'plan')
+        throw new ObjectError('You are read-only: you can look at resources but not start, stop or restart them.');
+    if (o.kind === 'server')
+        noteServer(o.id, `${a.name} asked to ${action}`);
+    const v = await objectAction(o.id, action);
+    return { name: v.name, status: v.state.status, detail: v.state.detail ?? null };
+}
+export async function agentObjectLogs(from, name, tail) {
+    const { o } = pick(from, name);
+    const n = Number(tail);
+    return { name: o.name, text: (await objectLogs(o.id, { tail: Number.isFinite(n) && n > 0 ? Math.min(n, 500) : 80 })).text };
+}