minionsai 0.1.0

package/dist/server/server/agent-settings.d.ts

@@ -0,0 +1,12 @@
+import { type ReasoningEffort, type Task } from '../shared/types.js';
+import type { AgentRunSettings } from './adapters/types.js';
+export interface AgentSettingsUpdate {
+    agent_model?: string | null;
+    reasoning_effort?: ReasoningEffort | null;
+}
+export interface ParsedRunSettings {
+    taskFields: AgentSettingsUpdate;
+    hasFields: boolean;
+}
+export declare function taskRunSettings(task: Task): AgentRunSettings;
+export declare function parseRunSettingsBody(body: unknown): ParsedRunSettings;

package/dist/server/server/agent-settings.js

@@ -0,0 +1,56 @@
+import { REASONING_EFFORTS } from '../shared/types.js';
+import { isRecord } from './errors.js';
+function hasOwn(record, key) {
+    return Object.prototype.hasOwnProperty.call(record, key);
+}
+function firstPresent(record, keys) {
+    for (const key of keys) {
+        if (hasOwn(record, key))
+            return record[key];
+    }
+    return undefined;
+}
+function normalizeModel(value) {
+    if (value === undefined)
+        return undefined;
+    if (value === null)
+        return null;
+    if (typeof value !== 'string')
+        throw new Error('model must be a string or null');
+    const trimmed = value.trim();
+    return trimmed || null;
+}
+function normalizeReasoningEffort(value) {
+    if (value === undefined)
+        return undefined;
+    if (value === null)
+        return null;
+    if (typeof value !== 'string' || !REASONING_EFFORTS.includes(value)) {
+        throw new Error(`reasoningEffort must be one of: ${REASONING_EFFORTS.join(', ')}`);
+    }
+    return value;
+}
+function parseSettingsFields(body) {
+    const record = isRecord(body) ? body : {};
+    const model = normalizeModel(firstPresent(record, ['agentModel', 'agent_model', 'model']));
+    const reasoningEffort = normalizeReasoningEffort(firstPresent(record, ['reasoningEffort', 'reasoning_effort']));
+    return {
+        ...(model !== undefined ? { agent_model: model } : {}),
+        ...(reasoningEffort !== undefined ? { reasoning_effort: reasoningEffort } : {}),
+    };
+}
+export function taskRunSettings(task) {
+    return {
+        model: task.agent_model,
+        reasoningEffort: task.reasoning_effort,
+    };
+}
+export function parseRunSettingsBody(body) {
+    const record = isRecord(body) ? body : {};
+    const source = hasOwn(record, 'settings') ? record.settings : record;
+    if (hasOwn(record, 'settings') && !isRecord(source)) {
+        throw new Error('settings must be an object');
+    }
+    const taskFields = parseSettingsFields(source);
+    return { taskFields, hasFields: Object.keys(taskFields).length > 0 };
+}

package/dist/server/server/app.d.ts

@@ -0,0 +1,5 @@
+import { HermesWorkerAdapter } from './adapters/hermes-worker.js';
+declare const app: import("express-serve-static-core").Express;
+declare const adapter: HermesWorkerAdapter;
+export { adapter };
+export default app;

package/dist/server/server/app.js

@@ -0,0 +1,41 @@
+import express from 'express';
+import cors from 'cors';
+import { tasksRouter } from './routes/tasks.js';
+import { chatRouter } from './routes/chat.js';
+import { createAgentRouter, createTaskAgentSettingsRouter } from './routes/agent.js';
+import { createCronRouter, createTaskCronRouter } from './routes/cron.js';
+import { skillsRouter } from './routes/skills.js';
+import { filesRouter } from './routes/files.js';
+import { HermesWorkerAdapter } from './adapters/hermes-worker.js';
+import { initSSE, addClient, sendEvent } from './events.js';
+import { getRunStatuses } from './live-chat.js';
+const app = express();
+app.use(cors());
+const adapter = new HermesWorkerAdapter();
+app.get('/api/health', async (_req, res) => {
+    const hermes = await adapter.healthCheck();
+    res.json({ ok: true, hermes });
+});
+app.get('/api/events', (req, res) => {
+    initSSE(res);
+    addClient(res);
+    sendEvent(res, { type: 'task_runs_snapshot', runs: getRunStatuses() });
+});
+app.use('/api/files', express.json({ limit: '25mb' }), filesRouter);
+app.use(express.json());
+app.use('/api/tasks', tasksRouter);
+app.use('/api/tasks', createTaskCronRouter(adapter));
+app.use('/api/tasks', createTaskAgentSettingsRouter(adapter));
+app.use('/api/tasks', chatRouter);
+app.use('/api/agent', createAgentRouter(adapter));
+app.use('/api/cron', createCronRouter(adapter));
+app.use('/api/skills', skillsRouter);
+app.use((error, _req, res, next) => {
+    if (!res.headersSent && error && typeof error === 'object' && error.type === 'entity.too.large') {
+        res.status(413).json({ error: 'Request body is too large', code: 'PAYLOAD_TOO_LARGE' });
+        return;
+    }
+    next(error);
+});
+export { adapter };
+export default app;

package/dist/server/server/db/index.d.ts

@@ -0,0 +1,2 @@
+declare const db: import('better-sqlite3').Database;
+export default db;

package/dist/server/server/db/index.js

@@ -0,0 +1,14 @@
+import Database from 'better-sqlite3';
+import { readFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { resolveMinionsDbPath, ensureMinionsStateDirs } from '../paths.js';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+ensureMinionsStateDirs();
+const dbPath = resolveMinionsDbPath();
+const db = new Database(dbPath);
+db.pragma('journal_mode = WAL');
+db.pragma('foreign_keys = ON');
+const schema = readFileSync(join(__dirname, 'schema.sql'), 'utf-8');
+db.exec(schema);
+export default db;

package/dist/server/server/db/queries.d.ts

@@ -0,0 +1,22 @@
+import { type Task, type TaskStatus, type ReasoningEffort, type ContextUsage } from '../../shared/types.js';
+export declare function getAllTasks(status?: TaskStatus): Task[];
+export declare function getTask(id: string): Task | undefined;
+export declare function insertTask(task: {
+    title: string;
+    description?: string | null;
+    status: TaskStatus;
+    agent_model?: string | null;
+    reasoning_effort?: ReasoningEffort | null;
+    last_agent_response_at?: number | null;
+}): Task;
+type TaskUpdateFields = Pick<Task, 'title' | 'description' | 'status' | 'agent_model' | 'reasoning_effort' | 'last_agent_response_at' | 'last_context_used_tokens' | 'last_context_window_tokens'>;
+export declare function updateTask(id: string, fields: Partial<TaskUpdateFields>): Task | undefined;
+export declare function touchTask(id: string): void;
+export declare function contextFromTask(task: Task): ContextUsage | null;
+export declare function recordAgentResponse(taskId: string, at?: number, context?: ContextUsage | null): Task | undefined;
+export declare function markTaskViewed(id: string): {
+    task: Task | undefined;
+    changed: boolean;
+};
+export declare function deleteTask(id: string): boolean;
+export {};

package/dist/server/server/db/queries.js

@@ -0,0 +1,116 @@
+import { v4 as uuid } from 'uuid';
+import db from './index.js';
+const stmtAllTasks = db.prepare('SELECT * FROM tasks ORDER BY updated_at DESC');
+const stmtTasksByStatus = db.prepare('SELECT * FROM tasks WHERE status = ? ORDER BY updated_at DESC');
+const stmtGetTask = db.prepare('SELECT * FROM tasks WHERE id = ?');
+const stmtInsertTask = db.prepare(`
+  INSERT INTO tasks (
+    id, title, description, status, agent_model, reasoning_effort,
+    created_at, updated_at, last_agent_response_at, last_viewed_at,
+    last_context_used_tokens, last_context_window_tokens
+  )
+  VALUES (
+    @id, @title, @description, @status, @agent_model, @reasoning_effort,
+    @created_at, @updated_at, @last_agent_response_at, @last_viewed_at,
+    @last_context_used_tokens, @last_context_window_tokens
+  )
+`);
+const stmtDeleteTask = db.prepare('DELETE FROM tasks WHERE id = ?');
+const stmtTouchTask = db.prepare('UPDATE tasks SET updated_at = ? WHERE id = ?');
+const stmtMarkTaskViewed = db.prepare(`
+  UPDATE tasks
+  SET last_viewed_at = last_agent_response_at
+  WHERE id = ?
+    AND last_agent_response_at IS NOT NULL
+    AND (last_viewed_at IS NULL OR last_viewed_at < last_agent_response_at)
+`);
+export function getAllTasks(status) {
+    return status ? stmtTasksByStatus.all(status) : stmtAllTasks.all();
+}
+export function getTask(id) {
+    return stmtGetTask.get(id);
+}
+export function insertTask(task) {
+    const id = uuid();
+    const now = Date.now();
+    const row = {
+        id,
+        title: task.title,
+        description: task.description ?? null,
+        status: task.status,
+        agent_model: task.agent_model ?? null,
+        reasoning_effort: task.reasoning_effort ?? null,
+        created_at: now,
+        updated_at: now,
+        last_agent_response_at: task.last_agent_response_at ?? null,
+        last_viewed_at: null,
+        last_context_used_tokens: null,
+        last_context_window_tokens: null,
+    };
+    stmtInsertTask.run(row);
+    return row;
+}
+const ALLOWED_UPDATE_FIELDS = new Set([
+    'title',
+    'description',
+    'status',
+    'agent_model',
+    'reasoning_effort',
+    'last_agent_response_at',
+    'last_context_used_tokens',
+    'last_context_window_tokens',
+]);
+const updateStmtCache = new Map();
+function getUpdateStmt(fieldKeys) {
+    const key = fieldKeys.join(',');
+    let stmt = updateStmtCache.get(key);
+    if (!stmt) {
+        const sets = fieldKeys.map(f => `${f} = @${f}`).join(', ');
+        stmt = db.prepare(`UPDATE tasks SET ${sets}, updated_at = @updated_at WHERE id = @id`);
+        updateStmtCache.set(key, stmt);
+    }
+    return stmt;
+}
+export function updateTask(id, fields) {
+    const fieldKeys = [];
+    const values = { id };
+    for (const [key, value] of Object.entries(fields)) {
+        if (!ALLOWED_UPDATE_FIELDS.has(key))
+            continue;
+        fieldKeys.push(key);
+        values[key] = value ?? null;
+    }
+    if (fieldKeys.length === 0)
+        return getTask(id);
+    values.updated_at = Date.now();
+    getUpdateStmt(fieldKeys).run(values);
+    return getTask(id);
+}
+export function touchTask(id) {
+    stmtTouchTask.run(Date.now(), id);
+}
+export function contextFromTask(task) {
+    if (task.last_context_used_tokens == null || task.last_context_window_tokens == null)
+        return null;
+    return { used_tokens: task.last_context_used_tokens, window_tokens: task.last_context_window_tokens };
+}
+export function recordAgentResponse(taskId, at = Date.now(), context) {
+    return updateTask(taskId, {
+        last_agent_response_at: at,
+        ...(context !== undefined ? {
+            last_context_used_tokens: context?.used_tokens ?? null,
+            last_context_window_tokens: context?.window_tokens ?? null,
+        } : {}),
+    });
+}
+export function markTaskViewed(id) {
+    const result = stmtMarkTaskViewed.run(id);
+    return {
+        task: getTask(id),
+        changed: result.changes > 0,
+    };
+}
+export function deleteTask(id) {
+    const result = stmtDeleteTask.run(id);
+    return result.changes > 0;
+}

package/dist/server/server/db/schema.sql

@@ -0,0 +1,16 @@
+CREATE TABLE IF NOT EXISTS tasks (
+  id                TEXT PRIMARY KEY,
+  title             TEXT NOT NULL,
+  description       TEXT,
+  status            TEXT NOT NULL DEFAULT 'in_progress',
+  agent_model       TEXT,
+  reasoning_effort  TEXT,
+  created_at        INTEGER NOT NULL,
+  updated_at        INTEGER NOT NULL,
+  last_agent_response_at  INTEGER,
+  last_viewed_at    INTEGER,
+  last_context_used_tokens   INTEGER,
+  last_context_window_tokens INTEGER
+);
+
+CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);

package/dist/server/server/errors.d.ts

@@ -0,0 +1,3 @@
+export declare function toErrorMessage(error: unknown, fallback?: string): string;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function errorCode(error: unknown): string | undefined;

package/dist/server/server/errors.js

@@ -0,0 +1,12 @@
+export function toErrorMessage(error, fallback = 'Something went wrong') {
+    return error instanceof Error ? error.message : fallback;
+}
+export function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+export function errorCode(error) {
+    if (!(error instanceof Error))
+        return undefined;
+    const code = error.code;
+    return typeof code === 'string' ? code : undefined;
+}

package/dist/server/server/events.d.ts

@@ -0,0 +1,7 @@
+import type { Response } from 'express';
+import type { BoardEvent } from '../shared/types.js';
+export type { BoardEvent };
+export declare function initSSE(res: Response): void;
+export declare function addClient(res: Response): void;
+export declare function sendEvent(res: Response, event: BoardEvent): void;
+export declare function broadcast(event: BoardEvent): void;

package/dist/server/server/events.js

@@ -0,0 +1,50 @@
+const clients = new Set();
+const KEEPALIVE_INTERVAL_MS = 30_000;
+let keepaliveTimer = null;
+function startKeepalive() {
+    if (keepaliveTimer)
+        return;
+    keepaliveTimer = setInterval(() => {
+        for (const client of clients) {
+            try {
+                client.write(':keepalive\n\n');
+            }
+            catch {
+                clients.delete(client);
+            }
+        }
+        if (clients.size === 0) {
+            clearInterval(keepaliveTimer);
+            keepaliveTimer = null;
+        }
+    }, KEEPALIVE_INTERVAL_MS);
+}
+export function initSSE(res) {
+    res.setHeader('Content-Type', 'text/event-stream');
+    res.setHeader('Cache-Control', 'no-cache');
+    res.setHeader('Connection', 'keep-alive');
+    res.flushHeaders();
+}
+export function addClient(res) {
+    clients.add(res);
+    res.on('close', () => clients.delete(res));
+    startKeepalive();
+}
+function writeEvent(res, event) {
+    const data = `data: ${JSON.stringify(event)}\n\n`;
+    try {
+        return res.write(data);
+    }
+    catch {
+        return false;
+    }
+}
+export function sendEvent(res, event) {
+    writeEvent(res, event);
+}
+export function broadcast(event) {
+    for (const client of clients) {
+        if (!writeEvent(client, event))
+            clients.delete(client);
+    }
+}

package/dist/server/server/frontend.d.ts

@@ -0,0 +1,4 @@
+import { type Express } from 'express';
+import type { Server } from 'node:http';
+export type FrontendCleanup = () => Promise<void> | void;
+export declare function mountFrontend(app: Express, httpServer: Server): Promise<FrontendCleanup>;

package/dist/server/server/frontend.js

@@ -0,0 +1,32 @@
+import express from 'express';
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const CLIENT_DIR = path.resolve(__dirname, '..', 'client');
+const CLIENT_DIST_DIR = path.join(CLIENT_DIR, 'dist');
+const CLIENT_INDEX = path.join(CLIENT_DIST_DIR, 'index.html');
+export async function mountFrontend(app, httpServer) {
+    if (process.env.NODE_ENV !== 'production') {
+        const { createServer: createViteServer } = await import('vite');
+        const vite = await createViteServer({
+            configFile: path.join(CLIENT_DIR, 'vite.config.ts'),
+            root: CLIENT_DIR,
+            appType: 'spa',
+            server: {
+                middlewareMode: true,
+                hmr: { server: httpServer },
+            },
+        });
+        app.use(vite.middlewares);
+        return () => vite.close();
+    }
+    if (!existsSync(CLIENT_INDEX)) {
+        throw new Error(`Client build not found at ${CLIENT_INDEX}. Run npm run build first.`);
+    }
+    app.use(express.static(CLIENT_DIST_DIR));
+    app.get('*', (_req, res) => {
+        res.sendFile(CLIENT_INDEX);
+    });
+    return () => { };
+}

package/dist/server/server/index.d.ts

@@ -0,0 +1,2 @@
+import 'dotenv/config';
+import './db/index.js';

package/dist/server/server/index.js

@@ -0,0 +1,63 @@
+import 'dotenv/config';
+import './db/index.js';
+import { once } from 'node:events';
+import { createServer } from 'node:http';
+import app, { adapter } from './app.js';
+import { mountFrontend } from './frontend.js';
+import { ensureBundledSkillsLinked } from './skills/catalog.js';
+const PORT = parseInt(process.env.PORT || '6969', 10);
+const httpServer = createServer(app);
+let closeFrontend = () => { };
+let shuttingDown = false;
+async function main() {
+    ensureBundledSkillsLinked();
+    closeFrontend = await mountFrontend(app, httpServer);
+    await adapter.start();
+    httpServer.listen(PORT);
+    await once(httpServer, 'listening');
+    console.log(`Hermes Agent Mission Control running on http://localhost:${PORT}`);
+}
+function closeHttpServer() {
+    return new Promise((resolveClose, rejectClose) => {
+        if (!httpServer.listening) {
+            resolveClose();
+            return;
+        }
+        httpServer.close((error) => {
+            if (error)
+                rejectClose(error);
+            else
+                resolveClose();
+        });
+        httpServer.closeAllConnections();
+    });
+}
+async function shutdown(reason, exitCode = 0) {
+    if (shuttingDown) {
+        httpServer.closeAllConnections();
+        process.exit(1);
+    }
+    shuttingDown = true;
+    const forceExit = setTimeout(() => {
+        console.error(`Forced shutdown after ${reason}`);
+        process.exit(1);
+    }, 5000);
+    forceExit.unref();
+    const results = await Promise.allSettled([
+        closeHttpServer(),
+        closeFrontend(),
+        adapter.stop(),
+    ]);
+    for (const result of results) {
+        if (result.status === 'rejected')
+            console.error(result.reason);
+    }
+    clearTimeout(forceExit);
+    process.exit(results.some((result) => result.status === 'rejected') ? 1 : exitCode);
+}
+process.on('SIGTERM', () => void shutdown('SIGTERM'));
+process.on('SIGINT', () => void shutdown('SIGINT'));
+main().catch((error) => {
+    console.error(error);
+    void shutdown('startup-error', 1);
+});

package/dist/server/server/live-chat.d.ts

@@ -0,0 +1,17 @@
+import type { Response } from 'express';
+import type { LiveChatRun, TaskRunState } from '../shared/types.js';
+import type { StreamEvent } from './adapters/types.js';
+export type LiveChatEvent = StreamEvent | {
+    type: 'snapshot';
+    run: LiveChatRun;
+};
+export declare function startRun(taskId: string, sessionId: string, userContent: string): LiveChatRun;
+export declare function applyEvent(taskId: string, event: StreamEvent): void;
+export declare function getRun(taskId: string): LiveChatRun | undefined;
+export declare function getRunContext(taskId: string): LiveChatRun['context'] | undefined;
+export declare function getRunStatus(taskId: string): TaskRunState | undefined;
+export declare function getRunStatuses(): TaskRunState[];
+export declare function subscribe(taskId: string, res: Response): void;
+export declare function sendSnapshot(res: Response, run: LiveChatRun): void;
+export declare function broadcast(taskId: string, event: LiveChatEvent): void;
+export declare function finishRun(taskId: string, ttlMs: number, runId: string): void;