hermes-web-ui 0.1.2 → 0.1.4

package/dist/server/routes/filesystem.js

@@ -0,0 +1,427 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fsRoutes = void 0;
+const router_1 = __importDefault(require("@koa/router"));
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+const os_1 = require("os");
+const authPath = (0, path_1.resolve)((0, os_1.homedir)(), '.hermes', 'auth.json');
+async function loadAuthJson() {
+    try {
+        const raw = await (0, promises_1.readFile)(authPath, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+async function fetchProviderModels(baseUrl, apiKey) {
+    try {
+        const url = baseUrl.replace(/\/+$/, '') + '/models';
+        const res = await fetch(url, {
+            headers: { Authorization: `Bearer ${apiKey}` },
+            signal: AbortSignal.timeout(8000),
+        });
+        if (!res.ok) {
+            console.error(`[available-models] ${baseUrl} returned ${res.status}`);
+            return [];
+        }
+        const data = await res.json();
+        if (!Array.isArray(data.data)) {
+            console.error(`[available-models] ${baseUrl} returned unexpected format`);
+            return [];
+        }
+        return data.data.map(m => m.id).sort();
+    }
+    catch (err) {
+        console.error(`[available-models] ${baseUrl} failed: ${err.message}`);
+        return [];
+    }
+}
+exports.fsRoutes = new router_1.default();
+const hermesDir = (0, path_1.resolve)((0, os_1.homedir)(), '.hermes');
+// --- Helpers ---
+function extractDescription(content) {
+    // SKILL.md format: YAML frontmatter between --- delimiters, then markdown body
+    // Extract first non-empty, non-frontmatter, non-heading line as description
+    const lines = content.split('\n');
+    let inFrontmatter = false;
+    let bodyStarted = false;
+    for (const line of lines) {
+        if (!bodyStarted && line.trim() === '---') {
+            if (!inFrontmatter) {
+                inFrontmatter = true;
+                continue;
+            }
+            else {
+                inFrontmatter = false;
+                bodyStarted = true;
+                continue;
+            }
+        }
+        if (inFrontmatter)
+            continue;
+        if (line.trim() === '')
+            continue;
+        if (line.startsWith('#'))
+            continue;
+        // Return first meaningful line, truncated
+        return line.trim().slice(0, 80);
+    }
+    return '';
+}
+async function safeReadFile(filePath) {
+    try {
+        return await (0, promises_1.readFile)(filePath, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+}
+async function safeStat(filePath) {
+    try {
+        const s = await (0, promises_1.stat)(filePath);
+        return { mtime: Math.round(s.mtimeMs) };
+    }
+    catch {
+        return null;
+    }
+}
+// --- Skills Routes ---
+// List all skills grouped by category
+exports.fsRoutes.get('/api/skills', async (ctx) => {
+    const skillsDir = (0, path_1.join)(hermesDir, 'skills');
+    try {
+        const entries = await (0, promises_1.readdir)(skillsDir, { withFileTypes: true });
+        const categories = [];
+        for (const entry of entries) {
+            if (!entry.isDirectory() || entry.name.startsWith('.'))
+                continue;
+            const catDir = (0, path_1.join)(skillsDir, entry.name);
+            const catDesc = await safeReadFile((0, path_1.join)(catDir, 'DESCRIPTION.md'));
+            const catDescription = catDesc ? catDesc.trim().split('\n')[0].replace(/^#+\s*/, '').slice(0, 100) : '';
+            const skillEntries = await (0, promises_1.readdir)(catDir, { withFileTypes: true });
+            const skills = [];
+            for (const se of skillEntries) {
+                if (!se.isDirectory())
+                    continue;
+                const skillMd = await safeReadFile((0, path_1.join)(catDir, se.name, 'SKILL.md'));
+                if (skillMd) {
+                    skills.push({
+                        name: se.name,
+                        description: extractDescription(skillMd),
+                    });
+                }
+            }
+            if (skills.length > 0) {
+                categories.push({ name: entry.name, description: catDescription, skills });
+            }
+        }
+        // Sort categories alphabetically
+        categories.sort((a, b) => a.name.localeCompare(b.name));
+        for (const cat of categories) {
+            cat.skills.sort((a, b) => a.name.localeCompare(b.name));
+        }
+        ctx.body = { categories };
+    }
+    catch (err) {
+        ctx.status = 500;
+        ctx.body = { error: `Failed to read skills directory: ${err.message}` };
+    }
+});
+// List files in a skill directory (for references/templates/scripts)
+// Must be registered before the wildcard route
+async function listFilesRecursive(dir, prefix) {
+    const result = [];
+    let entries;
+    try {
+        entries = await (0, promises_1.readdir)(dir, { withFileTypes: true });
+    }
+    catch {
+        return result;
+    }
+    for (const entry of entries) {
+        const relPath = prefix ? `${prefix}/${entry.name}` : entry.name;
+        if (entry.isDirectory()) {
+            result.push(...await listFilesRecursive((0, path_1.join)(dir, entry.name), relPath));
+        }
+        else {
+            result.push({ path: relPath, name: entry.name });
+        }
+    }
+    return result;
+}
+exports.fsRoutes.get('/api/skills/:category/:skill/files', async (ctx) => {
+    const { category, skill } = ctx.params;
+    const skillDir = (0, path_1.join)(hermesDir, 'skills', category, skill);
+    try {
+        const allFiles = await listFilesRecursive(skillDir, '');
+        const files = allFiles.filter(f => f.path !== 'SKILL.md');
+        ctx.body = { files };
+    }
+    catch (err) {
+        ctx.status = 500;
+        ctx.body = { error: err.message };
+    }
+});
+// Read a specific file under skills/
+exports.fsRoutes.get('/api/skills/:path(.+)', async (ctx) => {
+    const filePath = ctx.params.path;
+    const fullPath = (0, path_1.resolve)((0, path_1.join)(hermesDir, 'skills', filePath));
+    // Security: ensure path stays within skills directory
+    if (!fullPath.startsWith((0, path_1.join)(hermesDir, 'skills'))) {
+        ctx.status = 403;
+        ctx.body = { error: 'Access denied' };
+        return;
+    }
+    const content = await safeReadFile(fullPath);
+    if (content === null) {
+        ctx.status = 404;
+        ctx.body = { error: 'File not found' };
+        return;
+    }
+    ctx.body = { content };
+});
+// --- Memory Routes ---
+// Read MEMORY.md and USER.md
+exports.fsRoutes.get('/api/memory', async (ctx) => {
+    const memoryPath = (0, path_1.join)(hermesDir, 'memories', 'MEMORY.md');
+    const userPath = (0, path_1.join)(hermesDir, 'memories', 'USER.md');
+    const [memory, user, memoryStat, userStat] = await Promise.all([
+        safeReadFile(memoryPath),
+        safeReadFile(userPath),
+        safeStat(memoryPath),
+        safeStat(userPath),
+    ]);
+    ctx.body = {
+        memory: memory || '',
+        user: user || '',
+        memory_mtime: memoryStat?.mtime || null,
+        user_mtime: userStat?.mtime || null,
+    };
+});
+// Write MEMORY.md or USER.md
+exports.fsRoutes.post('/api/memory', async (ctx) => {
+    const { section, content } = ctx.request.body;
+    if (!section || !content) {
+        ctx.status = 400;
+        ctx.body = { error: 'Missing section or content' };
+        return;
+    }
+    if (section !== 'memory' && section !== 'user') {
+        ctx.status = 400;
+        ctx.body = { error: 'Section must be "memory" or "user"' };
+        return;
+    }
+    const fileName = section === 'memory' ? 'MEMORY.md' : 'USER.md';
+    const filePath = (0, path_1.join)(hermesDir, 'memories', fileName);
+    try {
+        await (0, promises_1.writeFile)(filePath, content, 'utf-8');
+        ctx.body = { success: true };
+    }
+    catch (err) {
+        ctx.status = 500;
+        ctx.body = { error: err.message };
+    }
+});
+// --- Config Model Routes ---
+const configPath = (0, path_1.resolve)((0, os_1.homedir)(), '.hermes/config.yaml');
+// Build model list from user's actual config.yaml configuration
+// Only shows models the user has explicitly configured, not entire provider catalogs
+function buildModelGroups(yaml) {
+    let defaultModel = '';
+    let defaultProvider = '';
+    const groups = [];
+    const allModelIds = new Set();
+    // 1. Extract current model from `model:` section
+    const defaultMatch = yaml.match(/^model:\s*\n\s+default:\s*(.+)/m);
+    if (defaultMatch)
+        defaultModel = defaultMatch[1].trim();
+    const providerMatch = yaml.match(/^model:\s*\n(?:.*\n)*?\s+provider:\s*(.+)/m);
+    if (providerMatch)
+        defaultProvider = providerMatch[1].trim();
+    // 2. Extract providers: section (user-defined endpoints)
+    const providersSection = yaml.match(/^providers:\s*\n((?:  .+\n(?:    .+\n)*)*)/m);
+    if (providersSection) {
+        const entries = providersSection[1].match(/^  (\S+):\s*\n((?:    .+\n)*)/gm);
+        if (entries) {
+            for (const entry of entries) {
+                const nameMatch = entry.match(/^  (\S+):/);
+                const baseUrlMatch = entry.match(/base_url:\s*(.+)/);
+                const name = nameMatch?.[1]?.trim();
+                if (name) {
+                    // Provider entry itself — mark as available but don't add model yet
+                    // (it's an endpoint the user can switch to, models are fetched at runtime)
+                }
+            }
+        }
+    }
+    // 3. Extract custom_providers: section
+    const customSection = yaml.match(/^custom_providers:\s*\n((?:\s*- .+\n(?:  .+\n)*)*)/m);
+    if (customSection) {
+        const entryBlocks = customSection[1].match(/\s*- name:\s*(.+)\n((?:  .+\n)*)/g);
+        if (entryBlocks) {
+            const customModels = [];
+            for (const block of entryBlocks) {
+                const cName = block.match(/name:\s*(.+)/)?.[1]?.trim();
+                const cModel = block.match(/model:\s*(.+)/)?.[1]?.trim();
+                if (cName && cModel) {
+                    customModels.push({ id: cModel, label: `${cName}: ${cModel}` });
+                    allModelIds.add(cModel);
+                }
+            }
+            if (customModels.length > 0) {
+                groups.push({ provider: 'Custom', models: customModels });
+            }
+        }
+    }
+    // 4. Add current default model (if not already in custom_providers)
+    if (defaultModel && !allModelIds.has(defaultModel)) {
+        groups.unshift({ provider: 'Current', models: [{ id: defaultModel, label: defaultModel }] });
+    }
+    return { default: defaultModel, groups };
+}
+// GET /api/available-models — fetch models from all credential pool endpoints
+exports.fsRoutes.get('/api/available-models', async (ctx) => {
+    try {
+        const auth = await loadAuthJson();
+        const pool = auth?.credential_pool || {};
+        // Read current default model from config.yaml
+        const yaml = await safeReadFile(configPath) || '';
+        const defaultMatch = yaml.match(/^model:\s*\n\s+default:\s*(.+)/m);
+        const currentDefault = defaultMatch?.[1]?.trim() || '';
+        // Collect unique endpoints from credential pool
+        const endpoints = [];
+        const seenUrls = new Set();
+        for (const [providerKey, entries] of Object.entries(pool)) {
+            if (!Array.isArray(entries) || entries.length === 0)
+                continue;
+            const entry = entries.find(e => e.last_status !== 'exhausted') || entries[0];
+            if (!entry?.base_url || !entry?.access_token)
+                continue;
+            const baseUrl = entry.base_url.replace(/\/+$/, '');
+            if (seenUrls.has(baseUrl))
+                continue;
+            seenUrls.add(baseUrl);
+            endpoints.push({
+                key: providerKey,
+                label: providerKey.replace(/^custom:/, '') || entry.label || baseUrl,
+                base_url: baseUrl,
+                token: entry.access_token,
+            });
+        }
+        // Fetch all provider models in parallel
+        const results = await Promise.allSettled(endpoints.map(async (ep) => {
+            const models = await fetchProviderModels(ep.base_url, ep.token);
+            return { ...ep, models };
+        }));
+        const groups = [];
+        for (const result of results) {
+            if (result.status === 'fulfilled' && result.value.models.length > 0) {
+                const { key, label, base_url, models } = result.value;
+                groups.push({ provider: key, label, base_url, models });
+            }
+            else if (result.status === 'rejected') {
+                console.error(`[available-models] Failed: ${result.reason?.message || result.reason}`);
+            }
+        }
+        // Fallback: if no providers returned models, fall back to config.yaml parsing
+        if (groups.length === 0) {
+            const fallback = buildModelGroups(yaml);
+            ctx.body = fallback;
+            return;
+        }
+        ctx.body = { default: currentDefault, groups };
+    }
+    catch (err) {
+        ctx.status = 500;
+        ctx.body = { error: err.message };
+    }
+});
+// GET /api/config/models
+exports.fsRoutes.get('/api/config/models', async (ctx) => {
+    try {
+        const yaml = await safeReadFile(configPath);
+        ctx.body = yaml ? buildModelGroups(yaml) : { default: '', groups: [] };
+    }
+    catch (err) {
+        ctx.status = 500;
+        ctx.body = { error: err.message };
+    }
+});
+// PUT /api/config/model
+exports.fsRoutes.put('/api/config/model', async (ctx) => {
+    const { default: defaultModel, provider: reqProvider } = ctx.request.body;
+    if (!defaultModel) {
+        ctx.status = 400;
+        ctx.body = { error: 'Missing default model' };
+        return;
+    }
+    try {
+        await (0, promises_1.copyFile)(configPath, configPath + '.bak');
+        let yaml = await safeReadFile(configPath) || '';
+        // Rebuild the model: block
+        const modelBlockMatch = yaml.match(/^(model:\s*\n(?:  .+\n)*)/m);
+        if (modelBlockMatch) {
+            const lines = [`model:`, `  default: ${defaultModel}`];
+            if (reqProvider) {
+                // Provider from credential pool key (e.g. "zai" or "custom:subrouter.ai")
+                // Hermes resolves base_url/api_key from auth.json automatically
+                lines.push(`  provider: ${reqProvider}`);
+            }
+            yaml = yaml.replace(modelBlockMatch[1], lines.join('\n') + '\n');
+        }
+        await (0, promises_1.writeFile)(configPath, yaml, 'utf-8');
+        ctx.body = { success: true };
+    }
+    catch (err) {
+        ctx.status = 500;
+        ctx.body = { error: err.message };
+    }
+});
+// POST /api/config/providers
+exports.fsRoutes.post('/api/config/providers', async (ctx) => {
+    const { name, base_url, api_key, model } = ctx.request.body;
+    if (!name || !base_url || !model) {
+        ctx.status = 400;
+        ctx.body = { error: 'Missing name, base_url, or model' };
+        return;
+    }
+    try {
+        await (0, promises_1.copyFile)(configPath, configPath + '.bak');
+        let yaml = await safeReadFile(configPath) || '';
+        const newEntry = `- name: ${name}\n  base_url: ${base_url}\n  api_key: ${api_key || ''}\n  model: ${model}\n`;
+        if (/^custom_providers:/m.test(yaml)) {
+            yaml = yaml.replace(/^(custom_providers:)/m, `$1\n${newEntry}`);
+        }
+        else {
+            yaml = yaml.trimEnd() + `\n\ncustom_providers:\n${newEntry}\n`;
+        }
+        await (0, promises_1.writeFile)(configPath, yaml, 'utf-8');
+        ctx.body = { success: true };
+    }
+    catch (err) {
+        ctx.status = 500;
+        ctx.body = { error: err.message };
+    }
+});
+// DELETE /api/config/providers/:name
+exports.fsRoutes.delete('/api/config/providers/:name', async (ctx) => {
+    const name = ctx.params.name;
+    try {
+        await (0, promises_1.copyFile)(configPath, configPath + '.bak');
+        let yaml = await safeReadFile(configPath) || '';
+        const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const blockRegex = new RegExp(`  - name:\\s*${escaped}\\s*\\n(?:    .+\\n)*`, 'g');
+        yaml = yaml.replace(blockRegex, '');
+        await (0, promises_1.writeFile)(configPath, yaml, 'utf-8');
+        ctx.body = { success: true };
+    }
+    catch (err) {
+        ctx.status = 500;
+        ctx.body = { error: err.message };
+    }
+});

package/dist/server/routes/logs.d.ts

@@ -0,0 +1,2 @@
+import Router from '@koa/router';
+export declare const logRoutes: Router<import("koa").DefaultState, import("koa").DefaultContext>;

package/dist/server/routes/logs.js

@@ -0,0 +1,87 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": 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"));
+exports.logRoutes = new router_1.default();
+// List available log files
+exports.logRoutes.get('/api/logs', async (ctx) => {
+    const files = await hermesCli.listLogFiles();
+    ctx.body = { files };
+});
+// Parse a single log line into structured entry
+function parseLine(line) {
+    // Match: 2026-04-11 20:16:16,289 INFO aiohttp.access: message
+    const match = line.match(/^(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2},\d{3})\s+(DEBUG|INFO|WARNING|ERROR|CRITICAL)\s+(\S+?):\s(.*)$/);
+    if (match) {
+        return {
+            timestamp: match[1],
+            level: match[2],
+            logger: match[3],
+            message: match[4],
+            raw: line,
+        };
+    }
+    // Unparseable line (e.g. traceback continuation)
+    return null;
+}
+// Read log lines (parsed)
+exports.logRoutes.get('/api/logs/:name', async (ctx) => {
+    const logName = ctx.params.name;
+    const lines = ctx.query.lines ? parseInt(ctx.query.lines, 10) : 100;
+    const level = ctx.query.level || undefined;
+    const session = ctx.query.session || undefined;
+    const since = ctx.query.since || undefined;
+    try {
+        const content = await hermesCli.readLogs(logName, lines, level, session, since);
+        const rawLines = content.split('\n');
+        const entries = [];
+        for (const line of rawLines) {
+            // Skip header lines like "--- ~/.hermes/logs/agent.log (last 100) ---"
+            if (line.startsWith('---') || line.trim() === '')
+                continue;
+            entries.push(parseLine(line));
+        }
+        ctx.body = { entries };
+    }
+    catch (err) {
+        ctx.status = 500;
+        ctx.body = { error: err.message };
+    }
+});

package/dist/server/routes/proxy-handler.d.ts

@@ -0,0 +1,2 @@
+import type { Context } from 'koa';
+export declare function proxy(ctx: Context): Promise<void>;

package/dist/server/routes/proxy-handler.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.proxy = proxy;
+const config_1 = require("../config");
+async function proxy(ctx) {
+    const upstream = config_1.config.upstream.replace(/\/$/, '');
+    const url = `${upstream}${ctx.path}${ctx.search || ''}`;
+    console.log(`[PROXY] ${ctx.method} ${ctx.path} -> ${url}`);
+    // Build headers — forward most, strip browser-specific ones
+    const headers = {};
+    for (const [key, value] of Object.entries(ctx.headers)) {
+        if (value == null)
+            continue;
+        const lower = key.toLowerCase();
+        if (lower === 'host') {
+            headers['host'] = new URL(upstream).host;
+        }
+        else if (lower !== 'origin' && lower !== 'referer' && lower !== 'connection') {
+            const v = Array.isArray(value) ? value[0] : value;
+            if (v)
+                headers[key] = v;
+        }
+    }
+    // Add SSE-friendly headers
+    if (ctx.path.match(/\/events$/)) {
+        headers['x-accel-buffering'] = 'no';
+        headers['cache-control'] = 'no-cache';
+    }
+    try {
+        // Build request body from raw body
+        let body;
+        if (ctx.req.method !== 'GET' && ctx.req.method !== 'HEAD') {
+            body = ctx.request.rawBody;
+        }
+        const res = await fetch(url, {
+            method: ctx.req.method,
+            headers,
+            body,
+        });
+        // Set response headers
+        const resHeaders = {};
+        res.headers.forEach((value, key) => {
+            const lower = key.toLowerCase();
+            if (lower !== 'transfer-encoding' && lower !== 'connection') {
+                resHeaders[key] = value;
+            }
+        });
+        if (ctx.path.match(/\/events$/)) {
+            resHeaders['x-accel-buffering'] = 'no';
+            resHeaders['cache-control'] = 'no-cache';
+        }
+        ctx.status = res.status;
+        ctx.set(resHeaders);
+        // Stream response body
+        if (res.body) {
+            const reader = res.body.getReader();
+            const pump = async () => {
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    ctx.res.write(value);
+                }
+                ctx.res.end();
+            };
+            await pump();
+        }
+        else {
+            ctx.res.end();
+        }
+    }
+    catch (err) {
+        if (!ctx.res.headersSent) {
+            ctx.status = 502;
+            ctx.set('Content-Type', 'application/json');
+            ctx.body = { error: { message: `Proxy error: ${err.message}` } };
+        }
+        else {
+            ctx.res.end();
+        }
+    }
+}

package/dist/server/routes/proxy.d.ts

@@ -0,0 +1,2 @@
+import Router from '@koa/router';
+export declare const proxyRoutes: Router<import("koa").DefaultState, import("koa").DefaultContext>;

package/dist/server/routes/proxy.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.proxyRoutes = void 0;
+const router_1 = __importDefault(require("@koa/router"));
+const proxy_handler_1 = require("./proxy-handler");
+exports.proxyRoutes = new router_1.default();
+// Proxy all /api/*, /v1/* to upstream Hermes API
+exports.proxyRoutes.all('/api/(.*)', proxy_handler_1.proxy);
+exports.proxyRoutes.all('/v1/(.*)', proxy_handler_1.proxy);

package/dist/server/routes/sessions.d.ts

@@ -0,0 +1,2 @@
+import Router from '@koa/router';
+export declare const sessionRoutes: Router<import("koa").DefaultState, import("koa").DefaultContext>;