hermes-web-ui 0.3.1 → 0.3.3

package/dist/server/routes/hermes/logs.js

@@ -38,7 +38,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.logRoutes = void 0;
 const router_1 = __importDefault(require("@koa/router"));
-const hermesCli = __importStar(require("../../services/hermes-cli"));
+const hermesCli = __importStar(require("../../services/hermes/hermes-cli"));
 exports.logRoutes = new router_1.default();
 // List available log files
 exports.logRoutes.get('/api/hermes/logs', async (ctx) => {

package/dist/server/routes/hermes/profiles.js

@@ -43,7 +43,7 @@ const promises_1 = require("fs/promises");
 const path_1 = require("path");
 const os_1 = require("os");
 const js_yaml_1 = __importDefault(require("js-yaml"));
-const hermesCli = __importStar(require("../../services/hermes-cli"));
+const hermesCli = __importStar(require("../../services/hermes/hermes-cli"));
 const apiServerDefaults = {
     enabled: true,
     host: '127.0.0.1',

package/dist/server/routes/hermes/sessions.js

@@ -38,7 +38,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sessionRoutes = void 0;
 const router_1 = __importDefault(require("@koa/router"));
-const hermesCli = __importStar(require("../../services/hermes-cli"));
+const hermesCli = __importStar(require("../../services/hermes/hermes-cli"));
 exports.sessionRoutes = new router_1.default();
 // List sessions from Hermes
 exports.sessionRoutes.get('/api/hermes/sessions', async (ctx) => {

package/dist/server/routes/hermes/weixin.js

@@ -8,8 +8,8 @@ const router_1 = __importDefault(require("@koa/router"));
 const axios_1 = __importDefault(require("axios"));
 const promises_1 = require("fs/promises");
 const promises_2 = require("fs/promises");
-const hermes_cli_1 = require("../../services/hermes-cli");
-const hermes_profile_1 = require("../../services/hermes-profile");
+const hermes_cli_1 = require("../../services/hermes/hermes-cli");
+const hermes_profile_1 = require("../../services/hermes/hermes-profile");
 const envPath = () => (0, hermes_profile_1.getActiveEnvPath)();
 const ILINK_BASE = 'https://ilinkai.weixin.qq.com';
 exports.weixinRoutes = new router_1.default();

package/dist/server/routes/webhook.js

@@ -5,7 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.webhookRoutes = void 0;
 const router_1 = __importDefault(require("@koa/router"));
-const hermes_1 = require("../services/hermes");
+const hermes_1 = require("../services/hermes/hermes");
 exports.webhookRoutes = new router_1.default();
 /**
  * POST /webhook — receive callbacks from Hermes Agent

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

@@ -0,0 +1,125 @@
+export interface HermesSession {
+    id: string;
+    source: string;
+    user_id: string | null;
+    model: string;
+    title: string | null;
+    started_at: number;
+    ended_at: number | null;
+    end_reason: string | null;
+    message_count: number;
+    tool_call_count: number;
+    input_tokens: number;
+    output_tokens: number;
+    cache_read_tokens: number;
+    cache_write_tokens: number;
+    reasoning_tokens: number;
+    billing_provider: string | null;
+    estimated_cost_usd: number;
+    actual_cost_usd: number | null;
+    cost_status: string;
+    messages?: any[];
+}
+/**
+ * List sessions from Hermes CLI (without messages)
+ */
+export declare function listSessions(source?: string, limit?: number): Promise<HermesSession[]>;
+/**
+ * Get a single session with messages from Hermes CLI
+ */
+export declare function getSession(id: string): Promise<HermesSession | null>;
+/**
+ * Delete a session from Hermes CLI
+ */
+export declare function deleteSession(id: string): Promise<boolean>;
+/**
+ * Rename a session title via Hermes CLI
+ */
+export declare function renameSession(id: string, title: string): Promise<boolean>;
+export interface LogFileInfo {
+    name: string;
+    size: string;
+    modified: string;
+}
+/**
+ * Get Hermes version
+ */
+export declare function getVersion(): Promise<string>;
+/**
+ * Start Hermes gateway (uses launchd/systemd)
+ */
+export declare function startGateway(): Promise<string>;
+/**
+ * Start Hermes gateway in background (for WSL where launchd/systemd is unavailable)
+ * Uses "hermes gateway run" as a detached background process
+ */
+export declare function startGatewayBackground(): Promise<number | null>;
+/**
+ * Restart Hermes gateway
+ */
+export declare function restartGateway(): Promise<string>;
+/**
+ * Stop Hermes gateway
+ */
+export declare function stopGateway(): Promise<string>;
+/**
+ * List available log files
+ */
+export declare function listLogFiles(): Promise<LogFileInfo[]>;
+/**
+ * Read log lines
+ */
+export declare function readLogs(logName?: string, lines?: number, level?: string, session?: string, since?: string): Promise<string>;
+export interface HermesProfile {
+    name: string;
+    active: boolean;
+    model: string;
+    gateway: string;
+    alias: string;
+}
+export interface HermesProfileDetail {
+    name: string;
+    path: string;
+    model: string;
+    provider: string;
+    gateway: string;
+    skills: number;
+    hasEnv: boolean;
+    hasSoulMd: boolean;
+}
+/**
+ * List all profiles
+ */
+export declare function listProfiles(): Promise<HermesProfile[]>;
+/**
+ * Get profile details
+ */
+export declare function getProfile(name: string): Promise<HermesProfileDetail>;
+/**
+ * Create a new profile
+ */
+export declare function createProfile(name: string, clone?: boolean): Promise<string>;
+/**
+ * Delete a profile
+ */
+export declare function deleteProfile(name: string): Promise<boolean>;
+/**
+ * Rename a profile
+ */
+export declare function renameProfile(oldName: string, newName: string): Promise<boolean>;
+/**
+ * Switch active profile
+ */
+export declare function useProfile(name: string): Promise<string>;
+/**
+ * Export profile to archive
+ */
+export declare function exportProfile(name: string, outputPath?: string): Promise<string>;
+/**
+ * Run hermes setup --non-interactive --reset to generate default config for current profile
+ */
+export declare function setupReset(): Promise<string>;
+/**
+ * Import profile from archive
+ */
+export declare function importProfile(archivePath: string, name?: string): Promise<string>;

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;