minionsai 0.1.0

package/dist/server/server/adapters/hermes-worker.js

@@ -0,0 +1,525 @@
+import { spawn, execFileSync } from 'node:child_process';
+import { existsSync, mkdirSync, realpathSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { createInterface } from 'node:readline';
+import { fileURLToPath } from 'node:url';
+import { randomUUID } from 'node:crypto';
+import { expandHomePrefix, resolveMinionsWorkspaceDir } from '../paths.js';
+const WORKER_READY_TIMEOUT_MS = 10_000;
+function resolveAgentDirFromHermesCli() {
+    try {
+        const hermesBin = execFileSync('which', ['hermes'], { encoding: 'utf8' }).trim();
+        const real = realpathSync(hermesBin);
+        // Typical layout: <agent-dir>/venv/bin/hermes → agent dir is 3 levels up
+        const candidate = resolve(dirname(real), '..', '..');
+        if (existsSync(join(candidate, 'run_agent.py')))
+            return candidate;
+    }
+    catch {
+        // `which` failed or path doesn't resolve — not installed via standard installer
+    }
+    return undefined;
+}
+function resolvePython() {
+    if (process.env.HERMES_PYTHON)
+        return expandHomePrefix(process.env.HERMES_PYTHON);
+    const candidates = [];
+    if (process.env.HERMES_AGENT_DIR) {
+        candidates.push(join(expandHomePrefix(process.env.HERMES_AGENT_DIR), 'venv/bin/python'));
+    }
+    const hermesHome = process.env.HERMES_HOME?.trim();
+    if (hermesHome) {
+        candidates.push(join(expandHomePrefix(hermesHome), 'hermes-agent/venv/bin/python'));
+    }
+    candidates.push(expandHomePrefix('~/.hermes/hermes-agent/venv/bin/python'));
+    const found = candidates.find((candidate) => existsSync(candidate));
+    if (found)
+        return found;
+    const cliAgentDir = resolveAgentDirFromHermesCli();
+    if (cliAgentDir) {
+        const venvPython = join(cliAgentDir, 'venv/bin/python');
+        if (existsSync(venvPython))
+            return venvPython;
+    }
+    return 'python3';
+}
+function resolveWorkerScript() {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const candidates = [
+        resolve(here, '../workers/hermes_worker.py'),
+        resolve(here, '../../server/workers/hermes_worker.py'),
+        resolve(process.cwd(), 'server/workers/hermes_worker.py'),
+    ];
+    const found = candidates.find((candidate) => existsSync(candidate));
+    if (!found)
+        throw new Error(`Hermes worker script not found. Tried: ${candidates.join(', ')}`);
+    return found;
+}
+function formatWorkerError(error) {
+    if (!error)
+        return 'Hermes worker error';
+    if (typeof error === 'string')
+        return error;
+    const code = error.code ? `[${error.code}] ` : '';
+    const hint = error.hint ? ` ${error.hint}` : '';
+    return `${code}${error.message}${hint}`;
+}
+function workerErrorCode(error) {
+    return typeof error === 'object' ? error.code : undefined;
+}
+class HermesWorkerError extends Error {
+    code;
+    constructor(error) {
+        super(formatWorkerError(error));
+        this.name = 'HermesWorkerError';
+        this.code = workerErrorCode(error);
+    }
+}
+function createAsyncQueue() {
+    const values = [];
+    const waiters = [];
+    let ended = false;
+    let failure = null;
+    return {
+        push(value) {
+            const waiter = waiters.shift();
+            if (waiter)
+                waiter.resolve({ value, done: false });
+            else
+                values.push(value);
+        },
+        end() {
+            ended = true;
+            while (waiters.length > 0) {
+                waiters.shift()?.resolve({ value: undefined, done: true });
+            }
+        },
+        fail(error) {
+            failure = error;
+            while (waiters.length > 0) {
+                waiters.shift()?.reject(error);
+            }
+        },
+        [Symbol.asyncIterator]() {
+            return {
+                next() {
+                    if (values.length > 0) {
+                        return Promise.resolve({ value: values.shift(), done: false });
+                    }
+                    if (failure)
+                        return Promise.reject(failure);
+                    if (ended)
+                        return Promise.resolve({ value: undefined, done: true });
+                    return new Promise((resolveNext, reject) => {
+                        waiters.push({ resolve: resolveNext, reject });
+                    });
+                },
+                return() {
+                    ended = true;
+                    values.length = 0;
+                    return Promise.resolve({ value: undefined, done: true });
+                },
+            };
+        },
+    };
+}
+class HermesWorkerClient {
+    child = null;
+    readline = null;
+    pending = new Map();
+    ready = false;
+    readyPromise = null;
+    async start() {
+        this.ensureStarted();
+        if (this.ready)
+            return;
+        if (!this.readyPromise) {
+            const request = { id: randomUUID(), type: 'health' };
+            this.readyPromise = this.sendRequest(request, WORKER_READY_TIMEOUT_MS)
+                .then((result) => {
+                if (!result.ok)
+                    throw new Error('Hermes worker healthcheck failed');
+                this.ready = true;
+            })
+                .catch((error) => {
+                this.ready = false;
+                if (this.child && !this.child.killed)
+                    this.child.kill();
+                throw error;
+            })
+                .finally(() => {
+                this.readyPromise = null;
+            });
+        }
+        await this.readyPromise;
+    }
+    async stop(signal = 'SIGTERM') {
+        const child = this.child;
+        this.child = null;
+        this.ready = false;
+        this.readyPromise = null;
+        if (this.readline) {
+            this.readline.close();
+            this.readline = null;
+        }
+        this.failPending(new Error('Hermes worker stopped'));
+        if (!child || child.exitCode !== null)
+            return;
+        await new Promise((resolve) => {
+            let settled = false;
+            let forceTimer = null;
+            const done = () => {
+                if (settled)
+                    return;
+                settled = true;
+                if (forceTimer)
+                    clearTimeout(forceTimer);
+                resolve();
+            };
+            forceTimer = setTimeout(() => {
+                if (child.exitCode === null)
+                    child.kill('SIGKILL');
+                done();
+            }, 500);
+            forceTimer.unref();
+            child.once('exit', done);
+            child.once('error', done);
+            try {
+                if (!child.stdin.destroyed)
+                    child.stdin.end();
+            }
+            catch {
+                // The worker may already be exiting because the terminal delivered SIGINT.
+            }
+            if (!child.killed)
+                child.kill(signal);
+        });
+    }
+    async request(input) {
+        await this.start();
+        const id = randomUUID();
+        const request = typeof input === 'string'
+            ? { id, type: input }
+            : { ...input, id };
+        return await this.sendRequest(request);
+    }
+    async *stream(request) {
+        await this.start();
+        const id = randomUUID();
+        const queue = createAsyncQueue();
+        try {
+            this.pending.set(id, {
+                kind: 'stream',
+                push: queue.push,
+                end: queue.end,
+                fail: queue.fail,
+            });
+            this.write({ ...request, id });
+            for await (const event of queue) {
+                yield event;
+            }
+        }
+        finally {
+            this.pending.delete(id);
+        }
+    }
+    async sendRequest(request, timeoutMs) {
+        this.ensureStarted();
+        return await new Promise((resolveRequest, reject) => {
+            let timeout = null;
+            const clearRequestTimeout = () => {
+                if (timeout) {
+                    clearTimeout(timeout);
+                    timeout = null;
+                }
+            };
+            this.pending.set(request.id, {
+                kind: 'request',
+                resolve: (value) => {
+                    clearRequestTimeout();
+                    resolveRequest(value);
+                },
+                reject: (error) => {
+                    clearRequestTimeout();
+                    reject(error);
+                },
+            });
+            if (timeoutMs) {
+                timeout = setTimeout(() => {
+                    this.pending.delete(request.id);
+                    reject(new Error(`Hermes worker did not become ready within ${timeoutMs}ms`));
+                }, timeoutMs);
+            }
+            try {
+                this.write(request);
+            }
+            catch (error) {
+                clearRequestTimeout();
+                this.pending.delete(request.id);
+                reject(error instanceof Error ? error : new Error(String(error)));
+            }
+        });
+    }
+    ensureStarted() {
+        if (this.child && !this.child.killed && this.child.exitCode === null)
+            return;
+        const python = resolvePython();
+        const script = resolveWorkerScript();
+        const workspace = resolveMinionsWorkspaceDir();
+        mkdirSync(workspace, { recursive: true });
+        const child = spawn(python, [script], {
+            cwd: workspace,
+            env: {
+                ...process.env,
+                HERMES_QUIET: '1',
+                HERMES_YOLO_MODE: '1',
+            },
+        });
+        this.child = child;
+        this.ready = false;
+        this.readline = createInterface({ input: child.stdout });
+        this.readline.on('line', (line) => this.handleLine(line));
+        child.stderr.on('data', (chunk) => process.stderr.write(String(chunk)));
+        child.on('error', (error) => this.handleExit(error));
+        child.on('exit', (code, signal) => {
+            this.handleExit(new Error(`Hermes worker exited (${signal ?? code ?? 'unknown'})`));
+        });
+    }
+    handleLine(line) {
+        let event;
+        try {
+            event = JSON.parse(line);
+        }
+        catch {
+            process.stderr.write(`[hermes-worker] non-json stdout: ${line}\n`);
+            return;
+        }
+        const pending = this.pending.get(event.id);
+        if (!pending)
+            return;
+        if (pending.kind === 'request') {
+            if (event.type === 'result') {
+                this.pending.delete(event.id);
+                pending.resolve(event.data);
+            }
+            else if (event.type === 'error') {
+                this.pending.delete(event.id);
+                pending.reject(new HermesWorkerError(event.error));
+            }
+            return;
+        }
+        if (pending.kind !== 'stream')
+            return;
+        pending.push(event);
+        if (event.type === 'done') {
+            this.pending.delete(event.id);
+            pending.end();
+        }
+    }
+    handleExit(error) {
+        if (this.readline) {
+            this.readline.close();
+            this.readline = null;
+        }
+        this.child = null;
+        this.ready = false;
+        this.failPending(new Error(`Hermes worker crashed: ${error.message}`));
+    }
+    write(request) {
+        if (!this.child || !this.child.stdin.writable) {
+            throw new Error('Hermes worker is not running');
+        }
+        this.child.stdin.write(`${JSON.stringify(request)}\n`);
+    }
+    failPending(error) {
+        for (const [id, pending] of this.pending) {
+            if (pending.kind === 'request')
+                pending.reject(error);
+            else
+                pending.fail(error);
+            this.pending.delete(id);
+        }
+    }
+}
+export class HermesWorkerAdapter {
+    client = new HermesWorkerClient();
+    async start() {
+        await this.client.start();
+    }
+    async stop() {
+        await this.client.stop();
+    }
+    async chat(sessionId, message, options) {
+        let text = '';
+        let resolvedSessionId = sessionId;
+        let error = null;
+        let errorCode;
+        for await (const event of this.chatStream(sessionId, message, options)) {
+            if (event.type === 'text_delta')
+                text += event.content ?? '';
+            if (event.type === 'done' && event.sessionId)
+                resolvedSessionId = event.sessionId;
+            if (event.type === 'error') {
+                error = event.error ?? 'Hermes worker error';
+                errorCode = event.code;
+            }
+        }
+        if (error) {
+            const err = new Error(error);
+            if (errorCode)
+                Object.assign(err, { code: errorCode });
+            throw err;
+        }
+        return { text, sessionId: resolvedSessionId };
+    }
+    async *chatStream(sessionId, message, options) {
+        for await (const event of this.client.stream({
+            type: 'chat',
+            sessionId,
+            message,
+            systemMessage: options?.systemMessage,
+            settings: options?.settings ?? {},
+            taskId: options?.task?.id,
+            taskTitle: options?.task?.title ?? null,
+        })) {
+            switch (event.type) {
+                case 'text_delta':
+                    yield { type: 'text_delta', content: event.content ?? '' };
+                    break;
+                case 'thinking_delta':
+                    yield { type: 'thinking_delta', content: event.content ?? '' };
+                    break;
+                case 'tool_progress':
+                    yield {
+                        type: 'tool_progress',
+                        tool: event.tool ?? 'tool',
+                        status: event.status ?? 'running',
+                        duration: event.duration,
+                        label: event.label ?? undefined,
+                    };
+                    break;
+                case 'error':
+                    yield { type: 'error', error: formatWorkerError(event.error), code: workerErrorCode(event.error) };
+                    break;
+                case 'done':
+                    yield { type: 'done', sessionId: event.sessionId ?? sessionId, context: event.context };
+                    break;
+                case 'result':
+                    break;
+            }
+        }
+    }
+    async healthCheck() {
+        try {
+            await this.client.start();
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async getMessages(sessionId, taskId) {
+        const result = await this.client.request({
+            type: 'session.messages.get',
+            sessionId,
+            taskId,
+        });
+        return result.messages;
+    }
+    async getSessionMetadata(sessionId) {
+        const result = await this.client.request({
+            type: 'session.get',
+            sessionId,
+        });
+        return result.session;
+    }
+    async getDefaults() {
+        return await this.client.request('settings.get');
+    }
+    async setDefaults(updates) {
+        return await this.client.request({
+            type: 'settings.set',
+            ...updates,
+        });
+    }
+    async getModels() {
+        return await this.client.request('models.list');
+    }
+    async listCronJobs(includeDisabled = false) {
+        const result = await this.client.request({
+            type: 'cron.jobs.list',
+            includeDisabled,
+        });
+        return result.jobs;
+    }
+    async getCronJob(jobId) {
+        const result = await this.client.request({
+            type: 'cron.jobs.get',
+            jobId,
+        });
+        return result.job;
+    }
+    async getCronRuns(jobId, limit = 20) {
+        const result = await this.client.request({
+            type: 'cron.jobs.runs',
+            jobId,
+            limit,
+        });
+        return result.runs;
+    }
+    async getCronRunContent(jobId, runId) {
+        const result = await this.client.request({
+            type: 'cron.jobs.run.content',
+            jobId,
+            runId,
+        });
+        return result.content;
+    }
+    async pauseCronJob(jobId, reason) {
+        const result = await this.client.request({
+            type: 'cron.jobs.pause',
+            jobId,
+            reason,
+        });
+        return result.job;
+    }
+    async resumeCronJob(jobId) {
+        const result = await this.client.request({
+            type: 'cron.jobs.resume',
+            jobId,
+        });
+        return result.job;
+    }
+    async runCronJob(jobId) {
+        const result = await this.client.request({
+            type: 'cron.jobs.run',
+            jobId,
+        });
+        return result.job;
+    }
+    async removeCronJob(jobId) {
+        const result = await this.client.request({
+            type: 'cron.jobs.remove',
+            jobId,
+        });
+        return result.ok;
+    }
+    async tickCron() {
+        const result = await this.client.request({ type: 'cron.tick' });
+        return result.executed;
+    }
+    async judgeCompletion(taskTitle, taskDescription, responseText) {
+        return await this.client.request({
+            type: 'judge.completion',
+            taskTitle,
+            taskDescription,
+            responseText,
+        });
+    }
+    async generateTitle(description) {
+        return await this.client.request({
+            type: 'title.generate',
+            description,
+        });
+    }
+}

package/dist/server/server/adapters/types.d.ts

@@ -0,0 +1,39 @@
+import type { AgentRunSettings, ContextUsage, SessionMetadata, TaskMessage } from '../../shared/types.js';
+export type { AgentRunSettings, ContextUsage };
+export interface AgentRunOptions {
+    systemMessage?: string;
+    settings?: AgentRunSettings;
+    task?: {
+        id: string;
+        title?: string | null;
+    };
+}
+export interface StreamEvent {
+    type: 'text_delta' | 'thinking_delta' | 'tool_progress' | 'done' | 'error';
+    content?: string;
+    error?: string;
+    code?: string;
+    sessionId?: string;
+    tool?: string;
+    status?: 'running' | 'completed' | 'error';
+    duration?: number;
+    label?: string;
+    context?: ContextUsage | null;
+}
+export interface AgentAdapter {
+    chat(sessionId: string, message: string, options?: AgentRunOptions): Promise<{
+        text: string;
+        sessionId: string;
+    }>;
+    chatStream(sessionId: string, message: string, options?: AgentRunOptions): AsyncIterable<StreamEvent>;
+    healthCheck(): Promise<boolean>;
+    getMessages(sessionId: string, taskId: string): Promise<TaskMessage[]>;
+    getSessionMetadata(sessionId: string): Promise<SessionMetadata | null>;
+    judgeCompletion(taskTitle: string, taskDescription: string | null, responseText: string): Promise<{
+        done: boolean;
+        reason: string;
+    }>;
+    generateTitle(description: string): Promise<{
+        title: string;
+    }>;
+}

package/dist/server/server/adapters/types.js

@@ -0,0 +1 @@
+export {};

package/dist/server/server/adapters/worker-protocol.d.ts

@@ -0,0 +1,141 @@
+import type { AgentDefaults, AgentModelsResponse, CronJob, CronRun, SessionMetadata, TaskMessage, ContextUsage } from '../../shared/types.js';
+import type { AgentRunSettings } from './types.js';
+export type WorkerRequest = {
+    id: string;
+    type: 'health';
+} | {
+    id: string;
+    type: 'settings.get';
+} | {
+    id: string;
+    type: 'settings.set';
+    model?: string | null;
+    reasoningEffort?: string | null;
+} | {
+    id: string;
+    type: 'models.list';
+} | {
+    id: string;
+    type: 'cron.jobs.list';
+    includeDisabled?: boolean;
+} | {
+    id: string;
+    type: 'cron.jobs.get';
+    jobId: string;
+} | {
+    id: string;
+    type: 'cron.jobs.runs';
+    jobId: string;
+    limit?: number;
+} | {
+    id: string;
+    type: 'cron.jobs.run.content';
+    jobId: string;
+    runId: string;
+} | {
+    id: string;
+    type: 'cron.jobs.pause';
+    jobId: string;
+    reason?: string;
+} | {
+    id: string;
+    type: 'cron.jobs.resume';
+    jobId: string;
+} | {
+    id: string;
+    type: 'cron.jobs.run';
+    jobId: string;
+} | {
+    id: string;
+    type: 'cron.jobs.remove';
+    jobId: string;
+} | {
+    id: string;
+    type: 'cron.tick';
+} | {
+    id: string;
+    type: 'session.messages.get';
+    sessionId: string;
+    taskId?: string;
+} | {
+    id: string;
+    type: 'session.get';
+    sessionId: string;
+} | {
+    id: string;
+    type: 'chat';
+    sessionId: string;
+    message: string;
+    systemMessage?: string;
+    settings: AgentRunSettings;
+    taskId?: string;
+    taskTitle?: string | null;
+} | {
+    id: string;
+    type: 'judge.completion';
+    taskTitle: string;
+    taskDescription?: string | null;
+    responseText: string;
+} | {
+    id: string;
+    type: 'title.generate';
+    description: string;
+};
+export interface WorkerErrorPayload {
+    message: string;
+    code?: string;
+    hint?: string;
+}
+export type WorkerResult = {
+    ok: boolean;
+    agentDir?: string | null;
+    python?: string | null;
+} | AgentDefaults | AgentModelsResponse | {
+    jobs: CronJob[];
+} | {
+    job: CronJob | null;
+} | {
+    runs: CronRun[];
+} | {
+    content: string;
+} | {
+    executed: number;
+} | {
+    messages: TaskMessage[];
+} | {
+    session: SessionMetadata | null;
+} | {
+    done: boolean;
+    reason: string;
+} | {
+    title: string;
+};
+export type WorkerEvent = {
+    id: string;
+    type: 'result';
+    data: WorkerResult;
+} | {
+    id: string;
+    type: 'text_delta';
+    content?: string;
+} | {
+    id: string;
+    type: 'thinking_delta';
+    content?: string;
+} | {
+    id: string;
+    type: 'tool_progress';
+    tool?: string;
+    status?: 'running' | 'completed' | 'error';
+    duration?: number;
+    label?: string | null;
+} | {
+    id: string;
+    type: 'done';
+    sessionId?: string;
+    context?: ContextUsage | null;
+} | {
+    id: string;
+    type: 'error';
+    error: string | WorkerErrorPayload;
+};

package/dist/server/server/adapters/worker-protocol.js

@@ -0,0 +1 @@
+export {};