minionsai 0.1.0

package/dist/server/server/routes/tasks.js

@@ -0,0 +1,107 @@
+import { Router } from 'express';
+import { getAllTasks, getTask, insertTask, updateTask, deleteTask, markTaskViewed } from '../db/queries.js';
+import { broadcast } from '../events.js';
+import { adapter } from '../app.js';
+import { TASK_STATUSES } from '../../shared/types.js';
+export const tasksRouter = Router();
+const LOW_INFORMATION_TITLES = new Set(['?', 'hi', 'hello', 'hey', 'yo']);
+tasksRouter.get('/', (req, res) => {
+    const status = req.query.status;
+    const tasks = getAllTasks(status);
+    res.json({ tasks });
+});
+tasksRouter.get('/:id', (req, res) => {
+    const task = getTask(req.params.id);
+    if (!task)
+        return res.status(404).json({ error: 'Task not found' });
+    res.json({ task });
+});
+function generateTitle(text) {
+    const firstLine = text.split(/\n/)[0].trim();
+    const normalizedFirstLine = firstLine.toLowerCase().replace(/\s+/g, ' ').replace(/[.!?]+$/g, '').trim();
+    if (!normalizedFirstLine || LOW_INFORMATION_TITLES.has(normalizedFirstLine))
+        return 'Untitled task';
+    const firstSentence = firstLine.split(/[.!?]/)[0].trim();
+    if (!firstSentence)
+        return text.slice(0, 60).trim() || 'Untitled task';
+    if (firstSentence.length <= 60)
+        return firstSentence;
+    return firstSentence.slice(0, 57) + '...';
+}
+async function enrichTaskTitle(taskId, fallbackTitle, description) {
+    try {
+        const { title } = await adapter.generateTitle(description);
+        const cleaned = title.trim();
+        if (!cleaned || cleaned === fallbackTitle)
+            return;
+        const current = getTask(taskId);
+        if (!current || current.title !== fallbackTitle)
+            return;
+        const updated = updateTask(taskId, { title: cleaned });
+        if (updated)
+            broadcast({ type: 'task_updated', task: updated });
+    }
+    catch {
+        // Best-effort: leave the fallback title in place if the LLM call fails.
+    }
+}
+tasksRouter.post('/', (req, res) => {
+    const { description, title } = req.body;
+    if (!description || typeof description !== 'string') {
+        return res.status(400).json({ error: 'description is required' });
+    }
+    const userTitle = typeof title === 'string' ? title.trim() : '';
+    const resolvedTitle = userTitle || generateTitle(description);
+    const task = insertTask({
+        title: resolvedTitle,
+        description,
+        status: 'in_progress',
+    });
+    broadcast({ type: 'task_created', task });
+    res.status(201).json({ task });
+    if (!userTitle) {
+        void enrichTaskTitle(task.id, resolvedTitle, description);
+    }
+});
+tasksRouter.patch('/:id', (req, res) => {
+    const allowed = ['title', 'description', 'status'];
+    const fields = {};
+    for (const key of allowed) {
+        if (req.body[key] !== undefined)
+            fields[key] = req.body[key];
+    }
+    if (fields.status && !TASK_STATUSES.includes(fields.status)) {
+        return res.status(400).json({ error: `status must be one of: ${TASK_STATUSES.join(', ')}` });
+    }
+    const updated = updateTask(req.params.id, fields);
+    if (!updated)
+        return res.status(404).json({ error: 'Task not found' });
+    broadcast({ type: 'task_updated', task: updated });
+    res.json({ task: updated });
+});
+tasksRouter.post('/:id/viewed', (req, res) => {
+    const { task, changed } = markTaskViewed(req.params.id);
+    if (!task)
+        return res.status(404).json({ error: 'Task not found' });
+    if (changed)
+        broadcast({ type: 'task_updated', task });
+    res.json({ task });
+});
+tasksRouter.delete('/:id', (req, res) => {
+    const deleted = deleteTask(req.params.id);
+    if (!deleted)
+        return res.status(404).json({ error: 'Task not found' });
+    broadcast({ type: 'task_deleted', taskId: req.params.id });
+    res.json({ ok: true });
+});
+tasksRouter.post('/:id/move', (req, res) => {
+    const { status } = req.body;
+    if (!TASK_STATUSES.includes(status)) {
+        return res.status(400).json({ error: `status must be one of: ${TASK_STATUSES.join(', ')}` });
+    }
+    const updated = updateTask(req.params.id, { status });
+    if (!updated)
+        return res.status(404).json({ error: 'Task not found' });
+    broadcast({ type: 'task_updated', task: updated });
+    res.json({ task: updated });
+});

package/dist/server/server/skills/catalog.d.ts

@@ -0,0 +1,21 @@
+export interface BundledSkillMeta {
+    id: string;
+    name: string;
+    description: string;
+    key: string;
+    source: 'Minions bundled';
+    bundled: true;
+    readOnly: true;
+    autoIncluded: true;
+}
+export interface BundledSkill extends BundledSkillMeta {
+    filePath: string;
+}
+export declare function resolveBundledSkillsDir(): string;
+export declare function listBundledSkills(): Promise<BundledSkill[]>;
+export declare function getBundledSkillWithContent(id: string): Promise<{
+    skill: BundledSkill;
+    content: string;
+} | null>;
+export declare function toSkillMeta(skill: BundledSkill): BundledSkillMeta;
+export declare function ensureBundledSkillsLinked(): void;

package/dist/server/server/skills/catalog.js

@@ -0,0 +1,160 @@
+import { existsSync, lstatSync, mkdirSync, readlinkSync, symlinkSync, unlinkSync } from 'node:fs';
+import { readdir, readFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { dirname, join, relative, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { expandHomePrefix } from '../paths.js';
+const VALID_SKILL_ID = /^[a-z0-9][a-z0-9._-]*$/;
+function serverDir() {
+    return dirname(fileURLToPath(import.meta.url));
+}
+export function resolveBundledSkillsDir() {
+    const here = serverDir();
+    const candidates = [
+        resolve(process.cwd(), 'skills'),
+        resolve(here, '../../skills'),
+        resolve(here, '../../../skills'),
+        resolve(here, '../../../../skills'),
+    ];
+    return candidates.find((candidate) => existsSync(candidate)) ?? candidates[0];
+}
+function stripQuotes(value) {
+    const trimmed = value.trim();
+    if ((trimmed.startsWith('"') && trimmed.endsWith('"'))
+        || (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+        return trimmed.slice(1, -1);
+    }
+    return trimmed;
+}
+function parseFrontmatter(content) {
+    if (!content.startsWith('---\n'))
+        return {};
+    const end = content.indexOf('\n---', 4);
+    if (end === -1)
+        return {};
+    const fields = {};
+    const raw = content.slice(4, end);
+    for (const line of raw.split('\n')) {
+        const match = /^([A-Za-z0-9_-]+):\s*(.*)$/.exec(line);
+        if (!match)
+            continue;
+        fields[match[1]] = stripQuotes(match[2]);
+    }
+    return fields;
+}
+function bodyWithoutFrontmatter(content) {
+    if (!content.startsWith('---\n'))
+        return content;
+    const end = content.indexOf('\n---', 4);
+    return end === -1 ? content : content.slice(end + 4);
+}
+function firstBodyLine(body) {
+    for (const line of body.split('\n')) {
+        const trimmed = line.trim();
+        if (trimmed && !trimmed.startsWith('#'))
+            return trimmed;
+    }
+    return '';
+}
+function firstHeading(body) {
+    for (const line of body.split('\n')) {
+        const match = /^#\s+(.+)$/.exec(line.trim());
+        if (match)
+            return match[1].trim();
+    }
+    return null;
+}
+function humanizeSkillId(id) {
+    return id
+        .split(/[-_]+/)
+        .filter(Boolean)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join(' ');
+}
+function parseSkillContent(id, filePath, content) {
+    const frontmatter = parseFrontmatter(content);
+    const body = bodyWithoutFrontmatter(content);
+    const name = firstHeading(body) || humanizeSkillId(frontmatter.name || id);
+    const description = frontmatter.description || firstBodyLine(body);
+    return {
+        id,
+        name,
+        description,
+        key: `minions/${id}`,
+        source: 'Minions bundled',
+        bundled: true,
+        readOnly: true,
+        autoIncluded: true,
+        filePath,
+    };
+}
+export async function listBundledSkills() {
+    const root = resolveBundledSkillsDir();
+    let entries;
+    try {
+        entries = await readdir(root, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const skills = await Promise.all(entries
+        .filter((entry) => entry.isDirectory() && VALID_SKILL_ID.test(entry.name))
+        .map(async (entry) => {
+        const id = entry.name;
+        const filePath = join(root, id, 'SKILL.md');
+        try {
+            const content = await readFile(filePath, 'utf-8');
+            return parseSkillContent(id, filePath, content);
+        }
+        catch {
+            return null;
+        }
+    }));
+    return skills
+        .filter((skill) => skill !== null)
+        .sort((a, b) => a.name.localeCompare(b.name));
+}
+export async function getBundledSkillWithContent(id) {
+    if (!VALID_SKILL_ID.test(id))
+        return null;
+    const root = resolveBundledSkillsDir();
+    const filePath = join(root, id, 'SKILL.md');
+    try {
+        const content = await readFile(filePath, 'utf-8');
+        return { skill: parseSkillContent(id, filePath, content), content };
+    }
+    catch {
+        return null;
+    }
+}
+export function toSkillMeta(skill) {
+    const { filePath: _filePath, ...meta } = skill;
+    return meta;
+}
+export function ensureBundledSkillsLinked() {
+    const source = resolveBundledSkillsDir();
+    if (!existsSync(source))
+        return;
+    const hermesHome = process.env.HERMES_HOME
+        ? expandHomePrefix(process.env.HERMES_HOME)
+        : join(homedir(), '.hermes');
+    const target = join(hermesHome, 'skills', 'minions');
+    mkdirSync(dirname(target), { recursive: true });
+    try {
+        const stat = lstatSync(target);
+        if (!stat.isSymbolicLink()) {
+            console.warn(`Bundled skills not linked: ${target} already exists and is not a symlink.`);
+            return;
+        }
+        const current = readlinkSync(target);
+        const resolvedCurrent = resolve(dirname(target), current);
+        if (relative(source, resolvedCurrent) === '')
+            return;
+        unlinkSync(target);
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+    symlinkSync(source, target, 'dir');
+}

package/dist/server/server/workers/hermes_cron.py

@@ -0,0 +1,241 @@
+"""Cron job operations and run-output projection for the Hermes worker.
+
+Wraps Hermes's `cron.jobs` / `cron.scheduler` modules with input validation,
+shape normalization, and a background ticker thread.
+"""
+
+from __future__ import annotations
+
+import stat
+import sys
+import threading
+import time
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+from hermes_worker_utils import (
+    WorkerError,
+    json_safe,
+    string_or_none,
+    truncate_with_ellipsis,
+)
+
+
+_CRON_TICKER_STARTED = False
+_CRON_TICKER_LOCK = threading.Lock()
+
+
+def _ensure_imports() -> None:
+    # Lazy import so this module does not need a top-level dep on hermes_worker.
+    # `hermes_worker._ensure_imports()` adds the Hermes agent dir to sys.path,
+    # making `cron.jobs` / `cron.scheduler` importable below.
+    import hermes_worker
+
+    hermes_worker._ensure_imports()
+
+
+def _normalize_cron_job(job: dict[str, Any] | None) -> dict[str, Any] | None:
+    if not isinstance(job, dict):
+        return None
+
+    job_id = string_or_none(job.get("id")) or ""
+    raw_schedule = job.get("schedule")
+    raw_origin = job.get("origin")
+    raw_skills = job.get("skills")
+    if raw_skills is None and job.get("skill"):
+        raw_skills = [job.get("skill")]
+
+    return {
+        "id": job_id,
+        "name": string_or_none(job.get("name")) or job_id,
+        "prompt": string_or_none(job.get("prompt")),
+        "schedule": json_safe(raw_schedule) if isinstance(raw_schedule, dict) else None,
+        "scheduleDisplay": string_or_none(job.get("schedule_display")),
+        "enabled": bool(job.get("enabled", True)),
+        "state": string_or_none(job.get("state")),
+        "nextRunAt": string_or_none(job.get("next_run_at")),
+        "lastRunAt": string_or_none(job.get("last_run_at")),
+        "lastStatus": string_or_none(job.get("last_status")),
+        "lastError": string_or_none(job.get("last_error")),
+        "lastDeliveryError": string_or_none(job.get("last_delivery_error")),
+        "model": string_or_none(job.get("model")),
+        "provider": string_or_none(job.get("provider")),
+        "baseUrl": string_or_none(job.get("base_url")),
+        "deliver": string_or_none(job.get("deliver")),
+        "origin": json_safe(raw_origin) if isinstance(raw_origin, dict) else None,
+        "skills": [str(item) for item in raw_skills] if isinstance(raw_skills, list) else [],
+        "createdAt": string_or_none(job.get("created_at")),
+    }
+
+
+def _validate_path_segment(value: Any, label: str) -> str:
+    raw = string_or_none(value)
+    if not raw:
+        raise WorkerError(f"{label} is required.", code="bad_request")
+    if "/" in raw or "\\" in raw or ".." in raw:
+        raise WorkerError(f"Invalid {label}.", code="bad_request")
+    return raw
+
+
+def list_cron_jobs(include_disabled: bool = False) -> dict[str, Any]:
+    _ensure_imports()
+    from cron.jobs import list_jobs
+
+    jobs = [_normalize_cron_job(job) for job in list_jobs(include_disabled=include_disabled)]
+    return {"jobs": [job for job in jobs if job is not None]}
+
+
+def get_cron_job(job_id: Any) -> dict[str, Any]:
+    _ensure_imports()
+    from cron.jobs import get_job
+
+    job = _normalize_cron_job(get_job(_validate_path_segment(job_id, "Cron job ID")))
+    return {"job": job}
+
+
+def pause_cron_job(job_id: Any, reason: Any = None) -> dict[str, Any]:
+    _ensure_imports()
+    from cron.jobs import pause_job
+
+    raw_reason = string_or_none(reason)
+    job = _normalize_cron_job(pause_job(_validate_path_segment(job_id, "Cron job ID"), reason=raw_reason))
+    return {"job": job}
+
+
+def resume_cron_job(job_id: Any) -> dict[str, Any]:
+    _ensure_imports()
+    from cron.jobs import resume_job
+
+    job = _normalize_cron_job(resume_job(_validate_path_segment(job_id, "Cron job ID")))
+    return {"job": job}
+
+
+def trigger_cron_job(job_id: Any) -> dict[str, Any]:
+    _ensure_imports()
+    from cron.jobs import trigger_job
+
+    job = _normalize_cron_job(trigger_job(_validate_path_segment(job_id, "Cron job ID")))
+    return {"job": job}
+
+
+def remove_cron_job(job_id: Any) -> dict[str, Any]:
+    _ensure_imports()
+    from cron.jobs import remove_job
+
+    removed = bool(remove_job(_validate_path_segment(job_id, "Cron job ID")))
+    return {"ok": removed}
+
+
+def _run_preview(content: str, max_chars: int = 420) -> str:
+    lines = [line.strip() for line in content.splitlines() if line.strip()]
+    return truncate_with_ellipsis("\n".join(lines[:6]), max_chars)
+
+
+def _run_timestamp_from_stem(stem: str) -> str | None:
+    try:
+        return datetime.strptime(stem, "%Y-%m-%d_%H-%M-%S").isoformat()
+    except ValueError:
+        return None
+
+
+def _cron_run_status(content: str) -> str:
+    first_line = next((line.strip() for line in content.splitlines() if line.strip()), "")
+    if first_line.startswith("# Cron Job:") and "(FAILED)" in first_line:
+        return "error"
+    if first_line.startswith("# Cron Job:"):
+        return "ok"
+    return "unknown"
+
+
+def _read_run_head(path: Path, max_bytes: int = 2048) -> str:
+    try:
+        with open(path, "r", encoding="utf-8", errors="replace") as f:
+            return f.read(max_bytes)
+    except OSError:
+        return ""
+
+
+def list_cron_runs(job_id: Any, limit: Any = 20) -> dict[str, Any]:
+    _ensure_imports()
+    from cron.jobs import OUTPUT_DIR
+
+    cron_job_id = _validate_path_segment(job_id, "Cron job ID")
+    try:
+        parsed_limit = int(limit)
+    except (TypeError, ValueError):
+        parsed_limit = 20
+    parsed_limit = max(1, min(parsed_limit, 100))
+
+    output_dir = Path(OUTPUT_DIR) / cron_job_id
+    entries: list[tuple[float, Path]] = []
+    for path in output_dir.glob("*.md"):
+        try:
+            st = path.stat()
+        except OSError:
+            continue
+        if not stat.S_ISREG(st.st_mode):
+            continue
+        entries.append((st.st_mtime, path))
+    entries.sort(key=lambda entry: (entry[0], entry[1].name), reverse=True)
+
+    runs: list[dict[str, Any]] = []
+    for _, path in entries[:parsed_limit]:
+        head = _read_run_head(path)
+        runs.append({
+            "id": path.stem,
+            "jobId": cron_job_id,
+            "ranAt": _run_timestamp_from_stem(path.stem),
+            "path": str(path),
+            "status": _cron_run_status(head),
+            "preview": _run_preview(head),
+        })
+
+    return {"runs": runs}
+
+
+def get_cron_run_content(job_id: Any, run_id: Any) -> dict[str, Any]:
+    _ensure_imports()
+    from cron.jobs import OUTPUT_DIR
+
+    cron_job_id = _validate_path_segment(job_id, "Cron job ID")
+    raw_run_id = _validate_path_segment(run_id, "Run ID")
+
+    path = Path(OUTPUT_DIR) / cron_job_id / f"{raw_run_id}.md"
+    if not path.is_file():
+        raise WorkerError("Cron run output not found.", code="not_found")
+
+    try:
+        content = path.read_text(encoding="utf-8")
+    except UnicodeDecodeError:
+        content = path.read_text(encoding="utf-8", errors="replace")
+
+    return {"content": content}
+
+
+def tick_cron() -> int:
+    _ensure_imports()
+    from cron.scheduler import tick
+
+    return int(tick(verbose=False) or 0)
+
+
+def _cron_ticker_loop() -> None:
+    while True:
+        try:
+            executed = tick_cron()
+            if executed:
+                print(f"[hermes-worker] cron tick executed {executed} job(s)", file=sys.stderr, flush=True)
+        except Exception as exc:
+            print(f"[hermes-worker] cron tick failed: {exc}", file=sys.stderr, flush=True)
+        time.sleep(60)
+
+
+def start_cron_ticker() -> None:
+    global _CRON_TICKER_STARTED
+    with _CRON_TICKER_LOCK:
+        if _CRON_TICKER_STARTED:
+            return
+        thread = threading.Thread(target=_cron_ticker_loop, name="hermes-cron-ticker", daemon=True)
+        thread.start()
+        _CRON_TICKER_STARTED = True