hermes-web-ui 0.3.0 → 0.3.2

package/dist/server/services/hermes/hermes-cli.js

@@ -0,0 +1,488 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listSessions = listSessions;
+exports.getSession = getSession;
+exports.deleteSession = deleteSession;
+exports.renameSession = renameSession;
+exports.getVersion = getVersion;
+exports.startGateway = startGateway;
+exports.startGatewayBackground = startGatewayBackground;
+exports.restartGateway = restartGateway;
+exports.stopGateway = stopGateway;
+exports.listLogFiles = listLogFiles;
+exports.readLogs = readLogs;
+exports.listProfiles = listProfiles;
+exports.getProfile = getProfile;
+exports.createProfile = createProfile;
+exports.deleteProfile = deleteProfile;
+exports.renameProfile = renameProfile;
+exports.useProfile = useProfile;
+exports.exportProfile = exportProfile;
+exports.setupReset = setupReset;
+exports.importProfile = importProfile;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const util_1 = require("util");
+const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
+const execOpts = { windowsHide: true };
+const isDocker = (0, fs_1.existsSync)('/.dockerenv');
+function resolveHermesBin() {
+    const envBin = process.env.HERMES_BIN?.trim();
+    if (envBin)
+        return envBin;
+    return 'hermes';
+}
+const HERMES_BIN = resolveHermesBin();
+/**
+ * List sessions from Hermes CLI (without messages)
+ */
+async function listSessions(source, limit) {
+    const args = ['sessions', 'export', '-'];
+    if (source)
+        args.push('--source', source);
+    try {
+        const { stdout } = await execFileAsync(HERMES_BIN, args, {
+            maxBuffer: 50 * 1024 * 1024, // 50MB
+            timeout: 30000,
+            ...execOpts,
+        });
+        const lines = stdout.trim().split('\n').filter(Boolean);
+        const sessions = [];
+        for (const line of lines) {
+            try {
+                const raw = JSON.parse(line);
+                let title = raw.title;
+                if (!title && raw.messages) {
+                    const firstUser = raw.messages.find((m) => m.role === 'user');
+                    if (firstUser?.content) {
+                        const t = String(firstUser.content).slice(0, 40);
+                        title = t + (String(firstUser.content).length > 40 ? '...' : '');
+                    }
+                }
+                sessions.push({
+                    id: raw.id,
+                    source: raw.source,
+                    user_id: raw.user_id,
+                    model: raw.model,
+                    title,
+                    started_at: raw.started_at,
+                    ended_at: raw.ended_at,
+                    end_reason: raw.end_reason,
+                    message_count: raw.message_count,
+                    tool_call_count: raw.tool_call_count,
+                    input_tokens: raw.input_tokens,
+                    output_tokens: raw.output_tokens,
+                    cache_read_tokens: raw.cache_read_tokens || 0,
+                    cache_write_tokens: raw.cache_write_tokens || 0,
+                    reasoning_tokens: raw.reasoning_tokens || 0,
+                    billing_provider: raw.billing_provider,
+                    estimated_cost_usd: raw.estimated_cost_usd,
+                    actual_cost_usd: raw.actual_cost_usd ?? null,
+                    cost_status: raw.cost_status || '',
+                });
+            }
+            catch { /* skip malformed lines */ }
+        }
+        // Sort by started_at descending
+        sessions.sort((a, b) => b.started_at - a.started_at);
+        if (limit && limit > 0) {
+            return sessions.slice(0, limit);
+        }
+        return sessions;
+    }
+    catch (err) {
+        console.error('[Hermes CLI] sessions export failed:', err.message);
+        throw new Error(`Failed to list sessions: ${err.message}`);
+    }
+}
+/**
+ * Get a single session with messages from Hermes CLI
+ */
+async function getSession(id) {
+    const args = ['sessions', 'export', '-', '--session-id', id];
+    try {
+        const { stdout } = await execFileAsync(HERMES_BIN, args, {
+            maxBuffer: 50 * 1024 * 1024,
+            timeout: 30000,
+            ...execOpts,
+        });
+        const lines = stdout.trim().split('\n').filter(Boolean);
+        if (lines.length === 0)
+            return null;
+        if (!lines[0].startsWith('{'))
+            return null;
+        const raw = JSON.parse(lines[0]);
+        return {
+            id: raw.id,
+            source: raw.source,
+            user_id: raw.user_id,
+            model: raw.model,
+            title: raw.title,
+            started_at: raw.started_at,
+            ended_at: raw.ended_at,
+            end_reason: raw.end_reason,
+            message_count: raw.message_count,
+            tool_call_count: raw.tool_call_count,
+            input_tokens: raw.input_tokens,
+            output_tokens: raw.output_tokens,
+            cache_read_tokens: raw.cache_read_tokens || 0,
+            cache_write_tokens: raw.cache_write_tokens || 0,
+            reasoning_tokens: raw.reasoning_tokens || 0,
+            billing_provider: raw.billing_provider,
+            estimated_cost_usd: raw.estimated_cost_usd,
+            actual_cost_usd: raw.actual_cost_usd ?? null,
+            cost_status: raw.cost_status || '',
+            messages: raw.messages,
+        };
+    }
+    catch (err) {
+        if (err.code === 1 || err.status === 1)
+            return null;
+        console.error('[Hermes CLI] session export failed:', err.message);
+        throw new Error(`Failed to get session: ${err.message}`);
+    }
+}
+/**
+ * Delete a session from Hermes CLI
+ */
+async function deleteSession(id) {
+    try {
+        await execFileAsync(HERMES_BIN, ['sessions', 'delete', id, '--yes'], {
+            timeout: 10000,
+            ...execOpts,
+        });
+        return true;
+    }
+    catch (err) {
+        console.error('[Hermes CLI] session delete failed:', err.message);
+        return false;
+    }
+}
+/**
+ * Rename a session title via Hermes CLI
+ */
+async function renameSession(id, title) {
+    try {
+        await execFileAsync(HERMES_BIN, ['sessions', 'rename', id, title], {
+            timeout: 10000,
+            ...execOpts,
+        });
+        return true;
+    }
+    catch (err) {
+        console.error('[Hermes CLI] session rename failed:', err.message);
+        return false;
+    }
+}
+/**
+ * Get Hermes version
+ */
+async function getVersion() {
+    try {
+        const { stdout } = await execFileAsync(HERMES_BIN, ['--version'], { timeout: 5000, ...execOpts });
+        return stdout.trim();
+    }
+    catch {
+        return '';
+    }
+}
+/**
+ * Start Hermes gateway (uses launchd/systemd)
+ */
+async function startGateway() {
+    if (isDocker) {
+        const pid = await startGatewayBackground();
+        return pid ? `Gateway started (PID: ${pid})` : 'Gateway start triggered';
+    }
+    const { stdout, stderr } = await execFileAsync(HERMES_BIN, ['gateway', 'start'], {
+        timeout: 30000,
+        ...execOpts,
+    });
+    return stdout || stderr;
+}
+/**
+ * Start Hermes gateway in background (for WSL where launchd/systemd is unavailable)
+ * Uses "hermes gateway run" as a detached background process
+ */
+async function startGatewayBackground() {
+    const { spawn } = require('child_process');
+    const child = spawn(HERMES_BIN, ['gateway', 'run'], {
+        detached: true,
+        stdio: 'ignore',
+        windowsHide: true,
+    });
+    child.unref();
+    return child.pid ?? null;
+}
+/**
+ * Restart Hermes gateway
+ */
+async function restartGateway() {
+    if (isDocker) {
+        try {
+            await stopGateway();
+        }
+        catch { }
+        const pid = await startGatewayBackground();
+        return pid ? `Gateway restarted (PID: ${pid})` : 'Gateway restart triggered';
+    }
+    const { stdout, stderr } = await execFileAsync(HERMES_BIN, ['gateway', 'restart'], {
+        timeout: 30000,
+        ...execOpts,
+    });
+    return stdout || stderr;
+}
+/**
+ * Stop Hermes gateway
+ */
+async function stopGateway() {
+    const { stdout, stderr } = await execFileAsync(HERMES_BIN, ['gateway', 'stop'], {
+        timeout: 30000,
+        ...execOpts,
+    });
+    return stdout || stderr;
+}
+/**
+ * List available log files
+ */
+async function listLogFiles() {
+    try {
+        const { stdout } = await execFileAsync(HERMES_BIN, ['logs', 'list'], {
+            timeout: 10000,
+            ...execOpts,
+        });
+        const files = [];
+        const lines = stdout.trim().split('\n').filter(l => l.includes('.log'));
+        for (const line of lines) {
+            const match = line.match(/^\s+(\S+)\s+([\d.]+\w+)\s+(.+)$/);
+            if (match) {
+                const rawName = match[1];
+                const name = rawName.replace(/\.log$/, '');
+                if (['agent', 'errors', 'gateway'].includes(name)) {
+                    files.push({ name, size: match[2], modified: match[3].trim() });
+                }
+            }
+        }
+        return files;
+    }
+    catch (err) {
+        console.error('[Hermes CLI] logs list failed:', err.message);
+        return [];
+    }
+}
+/**
+ * Read log lines
+ */
+async function readLogs(logName = 'agent', lines = 100, level, session, since) {
+    const args = ['logs', logName, '-n', String(lines)];
+    if (level)
+        args.push('--level', level);
+    if (session)
+        args.push('--session', session);
+    if (since)
+        args.push('--since', since);
+    try {
+        const { stdout } = await execFileAsync(HERMES_BIN, args, {
+            maxBuffer: 10 * 1024 * 1024,
+            timeout: 15000,
+            ...execOpts,
+        });
+        return stdout;
+    }
+    catch (err) {
+        console.error('[Hermes CLI] logs read failed:', err.message);
+        throw new Error(`Failed to read logs: ${err.message}`);
+    }
+}
+/**
+ * List all profiles
+ */
+async function listProfiles() {
+    try {
+        const { stdout } = await execFileAsync(HERMES_BIN, ['profile', 'list'], {
+            timeout: 10000,
+            ...execOpts,
+        });
+        const lines = stdout.trim().split('\n').filter(Boolean);
+        const profiles = [];
+        // Skip header lines (starts with " Profile" or " ─")
+        for (const line of lines) {
+            if (line.startsWith(' Profile') || line.match(/^ ─/))
+                continue;
+            const match = line.match(/^\s+(◆)?(\S+)\s{2,}(\S+)\s{2,}(\S+)\s{2,}(.*)$/);
+            if (match) {
+                profiles.push({
+                    name: match[2],
+                    active: !!match[1],
+                    model: match[3],
+                    gateway: match[4],
+                    alias: match[5].trim() === '—' ? '' : match[5].trim(),
+                });
+            }
+        }
+        return profiles;
+    }
+    catch (err) {
+        console.error('[Hermes CLI] profile list failed:', err.message);
+        throw new Error(`Failed to list profiles: ${err.message}`);
+    }
+}
+/**
+ * Get profile details
+ */
+async function getProfile(name) {
+    try {
+        const { stdout } = await execFileAsync(HERMES_BIN, ['profile', 'show', name], {
+            timeout: 10000,
+            ...execOpts,
+        });
+        const result = {};
+        for (const line of stdout.trim().split('\n')) {
+            const match = line.match(/^(\w[\w\s]*?):\s+(.+)$/);
+            if (match) {
+                result[match[1].trim().toLowerCase().replace(/\s+/g, '_')] = match[2].trim();
+            }
+        }
+        const modelFull = result.model || '';
+        const providerMatch = modelFull.match(/\((.+)\)/);
+        const model = providerMatch ? modelFull.replace(/\s*\(.+\)/, '').trim() : modelFull;
+        return {
+            name: result.profile || name,
+            path: result.path || '',
+            model,
+            provider: providerMatch ? providerMatch[1] : '',
+            gateway: result.gateway || '',
+            skills: parseInt(result.skills || '0', 10),
+            hasEnv: result['.env'] === 'exists',
+            hasSoulMd: result.soul_md === 'exists',
+        };
+    }
+    catch (err) {
+        if (err.code === 1 || err.status === 1) {
+            throw new Error(`Profile "${name}" not found`);
+        }
+        console.error('[Hermes CLI] profile show failed:', err.message);
+        throw new Error(`Failed to get profile: ${err.message}`);
+    }
+}
+/**
+ * Create a new profile
+ */
+async function createProfile(name, clone) {
+    const args = ['profile', 'create', name];
+    if (clone)
+        args.push('--clone');
+    try {
+        const { stdout, stderr } = await execFileAsync(HERMES_BIN, args, {
+            timeout: 15000,
+            ...execOpts,
+        });
+        return stdout || stderr;
+    }
+    catch (err) {
+        console.error('[Hermes CLI] profile create failed:', err.message);
+        throw new Error(`Failed to create profile: ${err.message}`);
+    }
+}
+/**
+ * Delete a profile
+ */
+async function deleteProfile(name) {
+    try {
+        await execFileAsync(HERMES_BIN, ['profile', 'delete', name, '--yes'], {
+            timeout: 10000,
+            ...execOpts,
+        });
+        return true;
+    }
+    catch (err) {
+        console.error('[Hermes CLI] profile delete failed:', err.message);
+        return false;
+    }
+}
+/**
+ * Rename a profile
+ */
+async function renameProfile(oldName, newName) {
+    try {
+        await execFileAsync(HERMES_BIN, ['profile', 'rename', oldName, newName], {
+            timeout: 10000,
+            ...execOpts,
+        });
+        return true;
+    }
+    catch (err) {
+        console.error('[Hermes CLI] profile rename failed:', err.message);
+        return false;
+    }
+}
+/**
+ * Switch active profile
+ */
+async function useProfile(name) {
+    try {
+        const { stdout, stderr } = await execFileAsync(HERMES_BIN, ['profile', 'use', name], {
+            timeout: 10000,
+            ...execOpts,
+        });
+        return stdout || stderr;
+    }
+    catch (err) {
+        console.error('[Hermes CLI] profile use failed:', err.message);
+        throw new Error(`Failed to switch profile: ${err.message}`);
+    }
+}
+/**
+ * Export profile to archive
+ */
+async function exportProfile(name, outputPath) {
+    const args = ['profile', 'export', name];
+    if (outputPath)
+        args.push('--output', outputPath);
+    try {
+        const { stdout, stderr } = await execFileAsync(HERMES_BIN, args, {
+            timeout: 60000,
+            ...execOpts,
+        });
+        return stdout || stderr;
+    }
+    catch (err) {
+        console.error('[Hermes CLI] profile export failed:', err.message);
+        throw new Error(`Failed to export profile: ${err.message}`);
+    }
+}
+/**
+ * Run hermes setup --non-interactive --reset to generate default config for current profile
+ */
+async function setupReset() {
+    try {
+        const { stdout, stderr } = await execFileAsync(HERMES_BIN, ['setup', '--non-interactive', '--reset'], {
+            timeout: 30000,
+            ...execOpts,
+        });
+        return stdout || stderr;
+    }
+    catch (err) {
+        console.error('[Hermes CLI] setup reset failed:', err.message);
+        throw new Error(`Failed to reset config: ${err.message}`);
+    }
+}
+/**
+ * Import profile from archive
+ */
+async function importProfile(archivePath, name) {
+    const args = ['profile', 'import', archivePath];
+    if (name)
+        args.push('--name', name);
+    try {
+        const { stdout, stderr } = await execFileAsync(HERMES_BIN, args, {
+            timeout: 60000,
+            ...execOpts,
+        });
+        return stdout || stderr;
+    }
+    catch (err) {
+        console.error('[Hermes CLI] profile import failed:', err.message);
+        throw new Error(`Failed to import profile: ${err.message}`);
+    }
+}

package/dist/server/services/hermes/hermes-profile.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Get the active profile's home directory.
+ * default → ~/.hermes/
+ * other   → ~/.hermes/profiles/{name}/
+ */
+export declare function getActiveProfileDir(): string;
+/**
+ * Get the active profile's config.yaml path.
+ */
+export declare function getActiveConfigPath(): string;
+/**
+ * Get the active profile's auth.json path.
+ */
+export declare function getActiveAuthPath(): string;
+/**
+ * Get the active profile's .env path.
+ */
+export declare function getActiveEnvPath(): string;
+/**
+ * Get the active profile name.
+ */
+export declare function getActiveProfileName(): string;

package/dist/server/services/hermes/hermes-profile.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getActiveProfileDir = getActiveProfileDir;
+exports.getActiveConfigPath = getActiveConfigPath;
+exports.getActiveAuthPath = getActiveAuthPath;
+exports.getActiveEnvPath = getActiveEnvPath;
+exports.getActiveProfileName = getActiveProfileName;
+const path_1 = require("path");
+const os_1 = require("os");
+const fs_1 = require("fs");
+const HERMES_BASE = (0, path_1.resolve)((0, os_1.homedir)(), '.hermes');
+/**
+ * Get the active profile's home directory.
+ * default → ~/.hermes/
+ * other   → ~/.hermes/profiles/{name}/
+ */
+function getActiveProfileDir() {
+    const activeFile = (0, path_1.join)(HERMES_BASE, 'active_profile');
+    try {
+        const name = (0, fs_1.readFileSync)(activeFile, 'utf-8').trim();
+        if (name && name !== 'default') {
+            const dir = (0, path_1.join)(HERMES_BASE, 'profiles', name);
+            if ((0, fs_1.existsSync)(dir))
+                return dir;
+        }
+    }
+    catch { }
+    return HERMES_BASE;
+}
+/**
+ * Get the active profile's config.yaml path.
+ */
+function getActiveConfigPath() {
+    return (0, path_1.join)(getActiveProfileDir(), 'config.yaml');
+}
+/**
+ * Get the active profile's auth.json path.
+ */
+function getActiveAuthPath() {
+    return (0, path_1.join)(getActiveProfileDir(), 'auth.json');
+}
+/**
+ * Get the active profile's .env path.
+ */
+function getActiveEnvPath() {
+    return (0, path_1.join)(getActiveProfileDir(), '.env');
+}
+/**
+ * Get the active profile name.
+ */
+function getActiveProfileName() {
+    const activeFile = (0, path_1.join)(HERMES_BASE, 'active_profile');
+    try {
+        const name = (0, fs_1.readFileSync)(activeFile, 'utf-8').trim();
+        return name || 'default';
+    }
+    catch {
+        return 'default';
+    }
+}

package/dist/server/services/hermes/hermes.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Send an instruction to Hermes Agent via /v1/runs
+ */
+export declare function sendInstruction(params: {
+    input: string | any[];
+    instructions?: string;
+    conversationHistory?: any[];
+    sessionId?: string;
+    authToken?: string;
+}): Promise<{
+    run_id: string;
+    status: string;
+}>;
+/**
+ * Get run status (poll /v1/runs/:id if supported)
+ */
+export declare function getRunStatus(runId: string): Promise<any>;
+/**
+ * Subscribe to SSE events for a run
+ */
+export declare function streamRunEvents(runId: string, authToken?: string): AsyncGenerator<any>;
+/**
+ * Health check
+ */
+export declare function healthCheck(): Promise<{
+    status: string;
+    version?: string;
+}>;
+/**
+ * Fetch available models
+ */
+export declare function fetchModels(): Promise<{
+    data: Array<{
+        id: string;
+    }>;
+}>;
+type WebhookCallback = (payload: any) => void | Promise<void>;
+export declare function onWebhook(callback: WebhookCallback): void;
+export declare function emitWebhook(payload: any): void;
+export {};