@vibe-forge/tsconfigs 0.7.2 → 0.9.0

package/dist/apps/server/src/routes/ai.js

@@ -0,0 +1,285 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aiRouter = aiRouter;
+const node_path_1 = require("node:path");
+const node_process_1 = __importDefault(require("node:process"));
+const router_1 = __importDefault(require("@koa/router"));
+const definition_loader_1 = require("@vibe-forge/definition-loader");
+const http_js_1 = require("#~/utils/http.js");
+const getFirstNonEmptyLine = (text) => text
+    .split('\n')
+    .map(line => line.trim())
+    .find(Boolean);
+const toRelativePath = (absolutePath, cwd) => {
+    const rel = (0, node_path_1.relative)(cwd, absolutePath);
+    return rel.startsWith('..') ? absolutePath : rel;
+};
+const resolveSpecName = (spec) => {
+    const name = spec.attributes.name?.trim();
+    if (name)
+        return name;
+    const fileName = (0, node_path_1.basename)(spec.path);
+    if (fileName.toLowerCase() === 'index.md') {
+        return (0, node_path_1.basename)((0, node_path_1.dirname)(spec.path));
+    }
+    return fileName.replace(/\.[^/.]+$/, '');
+};
+const resolveEntityName = (entity) => {
+    const name = entity.attributes.name?.trim();
+    if (name)
+        return name;
+    const fileName = (0, node_path_1.basename)(entity.path);
+    if (fileName.toLowerCase() === 'index.json') {
+        return (0, node_path_1.basename)((0, node_path_1.dirname)(entity.path));
+    }
+    return fileName.replace(/\.[^/.]+$/, '');
+};
+const resolveRuleName = (rule) => {
+    const name = rule.attributes.name?.trim();
+    if (name)
+        return name;
+    const fileName = (0, node_path_1.basename)(rule.path);
+    return fileName.replace(/\.[^/.]+$/, '');
+};
+const toTagList = (value) => {
+    if (Array.isArray(value)) {
+        return value.filter((item) => typeof item === 'string');
+    }
+    if (value && typeof value === 'object') {
+        const include = value.include;
+        if (Array.isArray(include)) {
+            return include.filter((item) => typeof item === 'string');
+        }
+    }
+    return [];
+};
+const toSkillList = (value) => {
+    if (Array.isArray(value)) {
+        return value.filter((item) => typeof item === 'string');
+    }
+    if (value && typeof value === 'object') {
+        const list = value.list;
+        if (Array.isArray(list)) {
+            return list.filter((item) => typeof item === 'string');
+        }
+    }
+    return [];
+};
+const toRuleList = (value) => {
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((item) => {
+        if (typeof item === 'string')
+            return [item];
+        if (item == null || typeof item !== 'object')
+            return [];
+        const desc = typeof item.desc === 'string'
+            ? item.desc
+            : undefined;
+        if (item.type === 'remote') {
+            const tags = toStringList(item.tags);
+            return [desc ?? (tags.length > 0 ? `remote:${tags.join(',')}` : 'remote')];
+        }
+        const path = typeof item.path === 'string'
+            ? item.path
+            : undefined;
+        return [desc ?? path].filter((rule) => Boolean(rule));
+    });
+};
+const toStringList = (value) => {
+    if (Array.isArray(value)) {
+        return value.filter((item) => typeof item === 'string');
+    }
+    if (typeof value === 'string')
+        return [value];
+    return [];
+};
+function aiRouter() {
+    const router = new router_1.default();
+    const workspaceRoot = node_process_1.default.env.WORKSPACE_FOLDER || node_process_1.default.cwd();
+    const loader = new definition_loader_1.DefinitionLoader(workspaceRoot);
+    router.get('/specs', async (ctx) => {
+        try {
+            const specs = await loader.loadDefaultSpecs();
+            ctx.body = {
+                specs: specs.map((spec) => {
+                    const name = resolveSpecName(spec);
+                    const description = spec.attributes.description ?? getFirstNonEmptyLine(spec.body) ?? name;
+                    const tags = toTagList(spec.attributes.tags);
+                    return {
+                        id: toRelativePath(spec.path, workspaceRoot),
+                        name,
+                        description,
+                        params: spec.attributes.params ?? [],
+                        always: spec.attributes.always ?? true,
+                        tags,
+                        skills: toTagList(spec.attributes.skills),
+                        rules: toTagList(spec.attributes.rules)
+                    };
+                })
+            };
+        }
+        catch (err) {
+            throw (0, http_js_1.internalServerError)('Failed to load specs', { cause: err, code: 'ai_specs_load_failed' });
+        }
+    });
+    router.get('/specs/detail', async (ctx) => {
+        const targetPath = typeof ctx.query.path === 'string' ? ctx.query.path : undefined;
+        if (!targetPath) {
+            throw (0, http_js_1.badRequest)('Missing path', undefined, 'missing_path');
+        }
+        try {
+            const specs = await loader.loadDefaultSpecs();
+            const spec = specs.find((item) => {
+                const relativePath = toRelativePath(item.path, workspaceRoot);
+                return relativePath === targetPath || item.path === targetPath;
+            });
+            if (!spec) {
+                throw (0, http_js_1.notFound)('Spec not found', { path: targetPath }, 'spec_not_found');
+            }
+            const name = resolveSpecName(spec);
+            const description = spec.attributes.description ?? getFirstNonEmptyLine(spec.body) ?? name;
+            const tags = toTagList(spec.attributes.tags);
+            ctx.body = {
+                spec: {
+                    id: toRelativePath(spec.path, workspaceRoot),
+                    name,
+                    description,
+                    params: spec.attributes.params ?? [],
+                    always: spec.attributes.always ?? true,
+                    tags,
+                    skills: toTagList(spec.attributes.skills),
+                    rules: toTagList(spec.attributes.rules),
+                    body: spec.body ?? ''
+                }
+            };
+        }
+        catch (err) {
+            if ((0, http_js_1.isHttpError)(err))
+                throw err;
+            throw (0, http_js_1.internalServerError)('Failed to load spec detail', { cause: err, code: 'ai_spec_detail_load_failed' });
+        }
+    });
+    router.get('/entities', async (ctx) => {
+        try {
+            const entities = await loader.loadDefaultEntities();
+            ctx.body = {
+                entities: entities.map((entity) => {
+                    const name = resolveEntityName(entity);
+                    const description = entity.attributes.description ?? getFirstNonEmptyLine(entity.body) ?? name;
+                    const tags = toTagList(entity.attributes.tags);
+                    return {
+                        id: toRelativePath(entity.path, workspaceRoot),
+                        name,
+                        description,
+                        always: entity.attributes.always ?? true,
+                        tags,
+                        skills: toSkillList(entity.attributes.skills),
+                        rules: toRuleList(entity.attributes.rules)
+                    };
+                })
+            };
+        }
+        catch (err) {
+            throw (0, http_js_1.internalServerError)('Failed to load entities', { cause: err, code: 'ai_entities_load_failed' });
+        }
+    });
+    router.get('/rules', async (ctx) => {
+        try {
+            const rules = await loader.loadDefaultRules();
+            ctx.body = {
+                rules: rules.map((rule) => {
+                    const name = resolveRuleName(rule);
+                    const description = rule.attributes.description ?? getFirstNonEmptyLine(rule.body) ?? name;
+                    const alwaysApply = rule.attributes.alwaysApply;
+                    return {
+                        id: toRelativePath(rule.path, workspaceRoot),
+                        name,
+                        description,
+                        always: rule.attributes.always ?? alwaysApply ?? true,
+                        globs: toStringList(rule.attributes.globs ??
+                            rule.attributes.glob)
+                    };
+                })
+            };
+        }
+        catch (err) {
+            throw (0, http_js_1.internalServerError)('Failed to load rules', { cause: err, code: 'ai_rules_load_failed' });
+        }
+    });
+    router.get('/rules/detail', async (ctx) => {
+        const targetPath = typeof ctx.query.path === 'string' ? ctx.query.path : undefined;
+        if (!targetPath) {
+            throw (0, http_js_1.badRequest)('Missing path', undefined, 'missing_path');
+        }
+        try {
+            const rules = await loader.loadDefaultRules();
+            const rule = rules.find((item) => {
+                const relativePath = toRelativePath(item.path, workspaceRoot);
+                return relativePath === targetPath || item.path === targetPath;
+            });
+            if (!rule) {
+                throw (0, http_js_1.notFound)('Rule not found', { path: targetPath }, 'rule_not_found');
+            }
+            const name = resolveRuleName(rule);
+            const description = rule.attributes.description ?? getFirstNonEmptyLine(rule.body) ?? name;
+            const alwaysApply = rule.attributes.alwaysApply;
+            ctx.body = {
+                rule: {
+                    id: toRelativePath(rule.path, workspaceRoot),
+                    name,
+                    description,
+                    always: rule.attributes.always ?? alwaysApply ?? true,
+                    globs: toStringList(rule.attributes.globs ??
+                        rule.attributes.glob),
+                    body: rule.body ?? ''
+                }
+            };
+        }
+        catch (err) {
+            if ((0, http_js_1.isHttpError)(err))
+                throw err;
+            throw (0, http_js_1.internalServerError)('Failed to load rule detail', { cause: err, code: 'ai_rule_detail_load_failed' });
+        }
+    });
+    router.get('/entities/detail', async (ctx) => {
+        const targetPath = typeof ctx.query.path === 'string' ? ctx.query.path : undefined;
+        if (!targetPath) {
+            throw (0, http_js_1.badRequest)('Missing path', undefined, 'missing_path');
+        }
+        try {
+            const entities = await loader.loadDefaultEntities();
+            const entity = entities.find((item) => {
+                const relativePath = toRelativePath(item.path, workspaceRoot);
+                return relativePath === targetPath || item.path === targetPath;
+            });
+            if (!entity) {
+                throw (0, http_js_1.notFound)('Entity not found', { path: targetPath }, 'entity_not_found');
+            }
+            const name = resolveEntityName(entity);
+            const description = entity.attributes.description ?? getFirstNonEmptyLine(entity.body) ?? name;
+            const tags = toTagList(entity.attributes.tags);
+            ctx.body = {
+                entity: {
+                    id: toRelativePath(entity.path, workspaceRoot),
+                    name,
+                    description,
+                    always: entity.attributes.always ?? true,
+                    tags,
+                    skills: toSkillList(entity.attributes.skills),
+                    rules: toRuleList(entity.attributes.rules),
+                    body: entity.body ?? ''
+                }
+            };
+        }
+        catch (err) {
+            if ((0, http_js_1.isHttpError)(err))
+                throw err;
+            throw (0, http_js_1.internalServerError)('Failed to load entity detail', { cause: err, code: 'ai_entity_detail_load_failed' });
+        }
+    });
+    return router;
+}

package/dist/apps/server/src/routes/automation.d.ts

@@ -0,0 +1,2 @@
+import Router from '@koa/router';
+export declare function automationRouter(): Router;

package/dist/apps/server/src/routes/automation.js

@@ -0,0 +1,205 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.automationRouter = automationRouter;
+const node_crypto_1 = require("node:crypto");
+const router_1 = __importDefault(require("@koa/router"));
+const cron_parser_1 = require("cron-parser");
+const index_js_1 = require("#~/db/index.js");
+const index_js_2 = require("#~/services/automation/index.js");
+const http_js_1 = require("#~/utils/http.js");
+let schedulerReady = false;
+const invalidPayload = () => (0, http_js_1.badRequest)('Invalid payload', undefined, 'invalid_payload');
+const normalizeTrigger = (trigger, isValidCron) => {
+    const type = trigger.type === 'webhook'
+        ? 'webhook'
+        : trigger.type === 'cron'
+            ? 'cron'
+            : 'interval';
+    const intervalMs = trigger.intervalMs ?? null;
+    const cronExpression = (trigger.cronExpression ?? '').trim();
+    const webhookKey = (trigger.webhookKey ?? '').trim();
+    if (type === 'interval' && (intervalMs == null || intervalMs <= 0)) {
+        throw (0, http_js_1.badRequest)('Invalid interval', undefined, 'invalid_interval');
+    }
+    if (type === 'cron' && !isValidCron(cronExpression)) {
+        throw (0, http_js_1.badRequest)('Invalid cron expression', undefined, 'invalid_cron_expression');
+    }
+    return {
+        id: trigger.id ?? (0, node_crypto_1.randomUUID)(),
+        type,
+        intervalMs: type === 'interval' ? intervalMs : null,
+        cronExpression: type === 'cron' ? cronExpression : null,
+        webhookKey: type === 'webhook' ? (webhookKey !== '' ? webhookKey : (0, node_crypto_1.randomUUID)()) : null
+    };
+};
+const normalizeTask = (task, index) => {
+    const title = (task.title ?? '').trim() || `任务 ${index + 1}`;
+    const prompt = (task.prompt ?? '').trim();
+    if (prompt === '') {
+        throw (0, http_js_1.badRequest)('Invalid task prompt', undefined, 'invalid_task_prompt');
+    }
+    return {
+        id: task.id ?? (0, node_crypto_1.randomUUID)(),
+        title,
+        prompt
+    };
+};
+function automationRouter() {
+    const router = new router_1.default();
+    const db = (0, index_js_1.getDb)();
+    if (!schedulerReady) {
+        (0, index_js_2.initAutomationScheduler)();
+        schedulerReady = true;
+    }
+    const isValidCron = (expression) => {
+        if (!expression)
+            return false;
+        try {
+            (0, cron_parser_1.parseExpression)(expression);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    router.get('/rules', (ctx) => {
+        ctx.body = { rules: db.listAutomationRuleDetails() };
+    });
+    router.post('/rules', async (ctx) => {
+        const body = ctx.request.body;
+        const name = (body.name ?? '').trim();
+        const description = (body.description ?? '').trim();
+        const enabled = body.enabled !== false;
+        const triggers = Array.isArray(body.triggers) ? body.triggers : [];
+        const tasks = Array.isArray(body.tasks) ? body.tasks : [];
+        const immediateRun = body.immediateRun === true;
+        if (name === '' || triggers.length === 0 || tasks.length === 0) {
+            throw invalidPayload();
+        }
+        const normalizedTriggers = triggers.map(trigger => normalizeTrigger(trigger, isValidCron));
+        const normalizedTasks = tasks.map((task, index) => normalizeTask(task, index));
+        const primaryTrigger = normalizedTriggers[0];
+        const primaryTask = normalizedTasks[0];
+        const rule = {
+            id: (0, node_crypto_1.randomUUID)(),
+            name,
+            description: description === '' ? null : description,
+            type: primaryTrigger?.type ?? 'interval',
+            intervalMs: primaryTrigger?.intervalMs ?? null,
+            webhookKey: primaryTrigger?.webhookKey ?? null,
+            cronExpression: primaryTrigger?.cronExpression ?? null,
+            prompt: primaryTask?.prompt ?? '',
+            enabled,
+            createdAt: Date.now(),
+            lastRunAt: null,
+            lastSessionId: null
+        };
+        db.createAutomationRule(rule);
+        db.replaceAutomationTriggers(rule.id, normalizedTriggers);
+        db.replaceAutomationTasks(rule.id, normalizedTasks);
+        if (enabled) {
+            (0, index_js_2.scheduleAutomationRule)(rule.id);
+        }
+        const detail = db.getAutomationRuleDetail(rule.id);
+        if (immediateRun) {
+            await (0, index_js_2.runAutomationRule)(rule.id, { ignoreEnabled: true });
+        }
+        ctx.body = { rule: detail };
+    });
+    router.patch('/rules/:id', async (ctx) => {
+        const { id } = ctx.params;
+        const existing = db.getAutomationRule(id);
+        if (!existing) {
+            throw (0, http_js_1.notFound)('Rule not found', { id }, 'rule_not_found');
+        }
+        const body = ctx.request.body;
+        const updates = {};
+        const immediateRun = body.immediateRun === true;
+        if (body.name !== undefined)
+            updates.name = body.name.trim();
+        if (body.description !== undefined)
+            updates.description = body.description.trim();
+        if (body.enabled !== undefined)
+            updates.enabled = body.enabled;
+        if (updates.name !== undefined && updates.name.trim() === '') {
+            throw invalidPayload();
+        }
+        if (body.triggers) {
+            if (!Array.isArray(body.triggers) || body.triggers.length === 0) {
+                throw invalidPayload();
+            }
+            const normalizedTriggers = body.triggers.map(trigger => normalizeTrigger(trigger, isValidCron));
+            const primaryTrigger = normalizedTriggers[0];
+            updates.type = primaryTrigger?.type ?? updates.type ?? existing.type;
+            updates.intervalMs = primaryTrigger?.intervalMs ?? null;
+            updates.webhookKey = primaryTrigger?.webhookKey ?? null;
+            updates.cronExpression = primaryTrigger?.cronExpression ?? null;
+            (0, index_js_2.removeAutomationRuleSchedule)(id);
+            db.replaceAutomationTriggers(id, normalizedTriggers);
+        }
+        if (body.tasks) {
+            if (!Array.isArray(body.tasks) || body.tasks.length === 0) {
+                throw invalidPayload();
+            }
+            const normalizedTasks = body.tasks.map((task, index) => normalizeTask(task, index));
+            const primaryTask = normalizedTasks[0];
+            updates.prompt = primaryTask?.prompt ?? updates.prompt ?? existing.prompt;
+            db.replaceAutomationTasks(id, normalizedTasks);
+        }
+        db.updateAutomationRule(id, updates);
+        const updated = db.getAutomationRule(id);
+        if (updated?.enabled) {
+            (0, index_js_2.scheduleAutomationRule)(id);
+        }
+        if (immediateRun) {
+            await (0, index_js_2.runAutomationRule)(id, { ignoreEnabled: true });
+        }
+        ctx.body = { rule: db.getAutomationRuleDetail(id) };
+    });
+    router.delete('/rules/:id', (ctx) => {
+        const { id } = ctx.params;
+        const removed = db.deleteAutomationRule(id);
+        if (removed) {
+            (0, index_js_2.removeAutomationRuleSchedule)(id);
+        }
+        ctx.body = { ok: true, removed };
+    });
+    router.post('/rules/:id/run', async (ctx) => {
+        const { id } = ctx.params;
+        const result = await (0, index_js_2.runAutomationRule)(id);
+        if (!result) {
+            throw (0, http_js_1.conflict)('Rule disabled or missing', { id }, 'rule_unavailable');
+        }
+        ctx.body = { ok: true, ...result };
+    });
+    router.get('/rules/:id/runs', (ctx) => {
+        const { id } = ctx.params;
+        const { limit } = ctx.query;
+        const parsedLimit = limit ? Number.parseInt(limit, 10) : 50;
+        const safeLimit = Number.isNaN(parsedLimit) ? 50 : Math.min(Math.max(parsedLimit, 1), 200);
+        ctx.body = { runs: db.listAutomationRuns(id, safeLimit) };
+    });
+    router.post('/webhook/:id', async (ctx) => {
+        const { id } = ctx.params;
+        const trigger = db.getAutomationTrigger(id);
+        if (!trigger) {
+            throw (0, http_js_1.notFound)('Trigger not found', { id }, 'trigger_not_found');
+        }
+        if (trigger.type !== 'webhook') {
+            throw (0, http_js_1.badRequest)('Not a webhook trigger', { id }, 'invalid_trigger_type');
+        }
+        const key = ctx.query.key ?? ctx.get('x-automation-key');
+        if (key == null || key !== trigger.webhookKey) {
+            throw (0, http_js_1.unauthorized)('Invalid key', { id }, 'invalid_webhook_key');
+        }
+        const result = await (0, index_js_2.runAutomationRule)(trigger.ruleId);
+        if (!result) {
+            throw (0, http_js_1.conflict)('Rule disabled', { ruleId: trigger.ruleId }, 'rule_disabled');
+        }
+        ctx.body = { ok: true, ...result };
+    });
+    return router;
+}

package/dist/apps/server/src/routes/benchmark.d.ts

@@ -0,0 +1,2 @@
+import Router from '@koa/router';
+export declare function benchmarkRouter(): Router;

package/dist/apps/server/src/routes/benchmark.js

@@ -0,0 +1,188 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.benchmarkRouter = benchmarkRouter;
+const node_crypto_1 = require("node:crypto");
+const node_process_1 = __importDefault(require("node:process"));
+const router_1 = __importDefault(require("@koa/router"));
+const app_runtime_1 = require("@vibe-forge/app-runtime");
+const http_js_1 = require("#~/utils/http.js");
+const runRegistry = new Map();
+const upsertRun = (run) => {
+    runRegistry.set(run.runId, run);
+    return run;
+};
+const markRunMessage = (runId, message) => {
+    const current = runRegistry.get(runId);
+    if (current == null)
+        return;
+    runRegistry.set(runId, {
+        ...current,
+        lastMessage: message
+    });
+};
+const incrementCompletedCount = (runId) => {
+    const current = runRegistry.get(runId);
+    if (current == null)
+        return;
+    runRegistry.set(runId, {
+        ...current,
+        completedCount: (current.completedCount ?? 0) + 1
+    });
+};
+function benchmarkRouter() {
+    const router = new router_1.default();
+    router.get('/categories', async (ctx) => {
+        ctx.body = {
+            categories: await (0, app_runtime_1.listBenchmarkCategories)()
+        };
+    });
+    router.get('/cases', async (ctx) => {
+        const { category } = ctx.query;
+        ctx.body = {
+            cases: await (0, app_runtime_1.listBenchmarkCases)({ category })
+        };
+    });
+    router.get('/cases/:category/:title', async (ctx) => {
+        const { category, title } = ctx.params;
+        const caseItem = await (0, app_runtime_1.getBenchmarkCase)({ category, title });
+        if (caseItem == null) {
+            throw (0, http_js_1.notFound)('Benchmark case not found', { category, title }, 'benchmark_case_not_found');
+        }
+        ctx.body = { case: caseItem };
+    });
+    router.get('/results', async (ctx) => {
+        const { category, title } = ctx.query;
+        const results = await (0, app_runtime_1.listBenchmarkResults)(undefined, category);
+        ctx.body = {
+            results: title == null ? results : results.filter((item) => item.title === title)
+        };
+    });
+    router.get('/results/:category/:title', async (ctx) => {
+        const { category, title } = ctx.params;
+        const result = await (0, app_runtime_1.readBenchmarkResult)(node_process_1.default.cwd(), category, title);
+        if (result == null) {
+            throw (0, http_js_1.notFound)('Benchmark result not found', { category, title }, 'benchmark_result_not_found');
+        }
+        ctx.body = { result };
+    });
+    router.get('/runs/:runId', (ctx) => {
+        const { runId } = ctx.params;
+        const run = runRegistry.get(runId);
+        if (run == null) {
+            throw (0, http_js_1.notFound)('Benchmark run not found', { runId }, 'benchmark_run_not_found');
+        }
+        ctx.body = { run };
+    });
+    router.post('/run', async (ctx) => {
+        const body = ctx.request.body;
+        const category = (body.category ?? '').trim();
+        const title = (body.title ?? '').trim();
+        if (category === '') {
+            throw (0, http_js_1.badRequest)('category is required', undefined, 'category_required');
+        }
+        const runId = (0, node_crypto_1.randomUUID)();
+        const availableCases = await (0, app_runtime_1.listBenchmarkCases)({ category });
+        const targetCases = title === ''
+            ? availableCases
+            : availableCases.filter((item) => item.title === title);
+        if (targetCases.length === 0) {
+            throw (0, http_js_1.notFound)('No benchmark cases matched the request', { category, title }, 'benchmark_cases_not_found');
+        }
+        const initialRun = upsertRun({
+            runId,
+            category,
+            title: title || undefined,
+            status: 'queued',
+            startedAt: Date.now(),
+            totalCount: targetCases.length,
+            completedCount: 0,
+            lastMessage: 'Benchmark queued'
+        });
+        ctx.body = { run: initialRun };
+        void (async () => {
+            upsertRun({
+                ...initialRun,
+                status: 'running',
+                lastMessage: 'Benchmark running'
+            });
+            try {
+                if (title !== '') {
+                    const output = await (0, app_runtime_1.runBenchmarkCase)({
+                        category,
+                        title,
+                        adapter: body.adapter,
+                        model: body.model,
+                        systemPrompt: body.systemPrompt,
+                        permissionMode: body.permissionMode,
+                        runtime: 'server',
+                        runId,
+                        onEvent: (event) => {
+                            markRunMessage(runId, event.message);
+                            if (event.phase === 'result') {
+                                incrementCompletedCount(runId);
+                            }
+                        }
+                    });
+                    upsertRun({
+                        runId,
+                        category,
+                        title,
+                        status: 'completed',
+                        startedAt: initialRun.startedAt,
+                        finishedAt: Date.now(),
+                        totalCount: 1,
+                        completedCount: 1,
+                        result: output.result,
+                        lastMessage: output.result.judgeSummary
+                    });
+                    return;
+                }
+                const output = await (0, app_runtime_1.runBenchmarkCategory)({
+                    category,
+                    concurrency: body.concurrency,
+                    adapter: body.adapter,
+                    model: body.model,
+                    systemPrompt: body.systemPrompt,
+                    permissionMode: body.permissionMode,
+                    runtime: 'server',
+                    runId,
+                    onEvent: (event) => {
+                        markRunMessage(runId, event.message);
+                        if (event.phase === 'result' && event.scope === 'case') {
+                            incrementCompletedCount(runId);
+                        }
+                    }
+                });
+                upsertRun({
+                    runId,
+                    category,
+                    status: 'completed',
+                    startedAt: initialRun.startedAt,
+                    finishedAt: Date.now(),
+                    totalCount: output.results.length,
+                    completedCount: output.results.length,
+                    results: output.results,
+                    lastMessage: 'Benchmark category run completed'
+                });
+            }
+            catch (error) {
+                upsertRun({
+                    runId,
+                    category,
+                    title: title || undefined,
+                    status: 'failed',
+                    startedAt: initialRun.startedAt,
+                    finishedAt: Date.now(),
+                    totalCount: initialRun.totalCount,
+                    completedCount: initialRun.completedCount,
+                    error: error instanceof Error ? error.message : String(error),
+                    lastMessage: 'Benchmark run failed'
+                });
+            }
+        })();
+    });
+    return router;
+}

package/dist/apps/server/src/routes/config.d.ts

@@ -0,0 +1,2 @@
+import Router from '@koa/router';
+export declare function configRouter(): Router;