@vibe-forge/tsconfigs 0.7.2 → 0.8.0

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;

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

@@ -0,0 +1,153 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configRouter = configRouter;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const router_1 = __importDefault(require("@koa/router"));
+const config_1 = require("@vibe-forge/config");
+const index_js_1 = require("#~/services/config/index.js");
+const http_js_1 = require("#~/utils/http.js");
+const sanitize = (value) => {
+    if (Array.isArray(value)) {
+        return value.map(item => sanitize(item));
+    }
+    if (value != null && typeof value === 'object') {
+        const entries = Object.entries(value);
+        return entries.reduce((acc, [key, val]) => {
+            acc[key] = sanitize(val);
+            return acc;
+        }, {});
+    }
+    return value;
+};
+const getAppInfo = async (workspaceFolder) => {
+    try {
+        const pkgPath = (0, node_path_1.resolve)(workspaceFolder, 'package.json');
+        const content = await (0, promises_1.readFile)(pkgPath, 'utf-8');
+        const pkg = JSON.parse(content);
+        return {
+            version: pkg.version,
+            lastReleaseAt: pkg.lastReleaseAt ?? pkg.releaseDate
+        };
+    }
+    catch {
+        return {};
+    }
+};
+const buildSections = (config) => {
+    const { baseDir, defaultAdapter, defaultModelService, defaultModel, recommendedModels, interfaceLanguage, modelLanguage, announcements, shortcuts, conversation, notifications } = config ?? {};
+    return {
+        general: {
+            baseDir,
+            defaultAdapter,
+            defaultModelService,
+            defaultModel,
+            recommendedModels: sanitize(recommendedModels),
+            interfaceLanguage,
+            modelLanguage,
+            announcements,
+            permissions: sanitize(config?.permissions),
+            env: sanitize(config?.env),
+            notifications: sanitize(notifications)
+        },
+        conversation: sanitize(conversation),
+        models: sanitize(config?.models),
+        modelServices: sanitize(config?.modelServices),
+        channels: sanitize(config?.channels),
+        adapters: sanitize(config?.adapters),
+        adapterBuiltinModels: {},
+        plugins: sanitize({
+            plugins: config?.plugins,
+            enabledPlugins: config?.enabledPlugins,
+            extraKnownMarketplaces: config?.extraKnownMarketplaces
+        }),
+        mcp: sanitize({
+            mcpServers: config?.mcpServers,
+            defaultIncludeMcpServers: config?.defaultIncludeMcpServers,
+            defaultExcludeMcpServers: config?.defaultExcludeMcpServers,
+            noDefaultVibeForgeMcpServer: config?.noDefaultVibeForgeMcpServer
+        }),
+        shortcuts: sanitize(shortcuts)
+    };
+};
+const loadAdapterBuiltinModels = (adapters) => {
+    const result = {};
+    if (!adapters)
+        return result;
+    for (const adapterKey of Object.keys(adapters)) {
+        try {
+            const packageName = adapterKey.startsWith('@') ? adapterKey : `@vibe-forge/adapter-${adapterKey}`;
+            // eslint-disable-next-line ts/no-require-imports
+            const mod = require(`${packageName}/models`);
+            if (Array.isArray(mod?.builtinModels)) {
+                result[adapterKey] = mod.builtinModels;
+            }
+        }
+        catch {
+            // Adapter does not export builtin models — skip
+        }
+    }
+    return result;
+};
+function configRouter() {
+    const router = new router_1.default();
+    router.get('/', async (ctx) => {
+        try {
+            const { workspaceFolder, projectConfig, userConfig, mergedConfig } = await (0, index_js_1.loadMergedConfig)();
+            const urls = {
+                repo: 'https://github.com/vibe-forge-ai/vibe-forge.ai',
+                docs: 'https://github.com/vibe-forge-ai/vibe-forge.ai',
+                contact: 'https://github.com/vibe-forge-ai/vibe-forge.ai',
+                issues: 'https://github.com/vibe-forge-ai/vibe-forge.ai/issues',
+                releases: 'https://github.com/vibe-forge-ai/vibe-forge.ai/releases'
+            };
+            const appInfo = await getAppInfo(workspaceFolder);
+            const mergedSections = buildSections(mergedConfig);
+            mergedSections.adapterBuiltinModels = loadAdapterBuiltinModels(mergedConfig.adapters);
+            ctx.body = {
+                sources: {
+                    project: buildSections(projectConfig),
+                    user: buildSections(userConfig),
+                    merged: mergedSections
+                },
+                meta: {
+                    workspaceFolder,
+                    configPresent: {
+                        project: projectConfig != null,
+                        user: userConfig != null
+                    },
+                    experiments: {},
+                    about: {
+                        version: appInfo.version,
+                        lastReleaseAt: appInfo.lastReleaseAt,
+                        urls
+                    }
+                }
+            };
+        }
+        catch (err) {
+            throw (0, http_js_1.internalServerError)('Failed to load config', { cause: err, code: 'config_load_failed' });
+        }
+    });
+    router.patch('/', async (ctx) => {
+        const { source, section, value } = ctx.request.body;
+        if (source !== 'project' && source !== 'user') {
+            throw (0, http_js_1.badRequest)('Invalid source', { source }, 'invalid_source');
+        }
+        if (section == null || typeof section !== 'string' || section.trim() === '') {
+            throw (0, http_js_1.badRequest)('Invalid section', { section }, 'invalid_section');
+        }
+        try {
+            const workspaceFolder = (0, index_js_1.getWorkspaceFolder)();
+            await (0, config_1.updateConfigFile)({ workspaceFolder, source, section, value });
+            ctx.body = { ok: true };
+        }
+        catch (err) {
+            throw (0, http_js_1.internalServerError)('Failed to update config', { cause: err, code: 'config_update_failed' });
+        }
+    });
+    return router;
+}

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

@@ -0,0 +1,5 @@
+import type Koa from 'koa';
+import type { loadEnv } from '@vibe-forge/core';
+export declare const mountRoutes: (app: Koa, env: ReturnType<typeof loadEnv>) => Promise<{
+    onListen: (httpHost: string) => void;
+}>;

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

@@ -0,0 +1,110 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mountRoutes = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_process_1 = require("node:process");
+const router_1 = __importDefault(require("@koa/router"));
+const logger_js_1 = require("#~/utils/logger.js");
+const ai_1 = require("./ai");
+const automation_1 = require("./automation");
+const benchmark_1 = require("./benchmark");
+const config_1 = require("./config");
+const interact_1 = require("./interact");
+const sessions_1 = require("./sessions");
+const ui_1 = require("./ui");
+const DEFAULT_CLIENT_BASE = '/ui/';
+const DEFAULT_BASE_PLACEHOLDER = '/__VF_PROJECT_AI_CLIENT_BASE__/';
+const normalizeBase = (value) => {
+    let base = value?.trim() || DEFAULT_CLIENT_BASE;
+    if (!base.startsWith('/')) {
+        base = `/${base}`;
+    }
+    if (!base.endsWith('/')) {
+        base += '/';
+    }
+    return base;
+};
+const resolveClientDistPath = (distPath) => {
+    const workspaceFolder = node_process_1.env.__VF_PROJECT_WORKSPACE_FOLDER__ ?? (0, node_process_1.cwd)();
+    const packageDir = node_process_1.env.__VF_PROJECT_PACKAGE_DIR__ ?? (0, node_process_1.cwd)();
+    const candidates = [];
+    if (distPath?.trim()) {
+        const rawPath = distPath.trim();
+        const resolved = node_path_1.default.isAbsolute(rawPath) ? rawPath : node_path_1.default.resolve(workspaceFolder, rawPath);
+        candidates.push(resolved);
+    }
+    candidates.push(node_path_1.default.resolve(workspaceFolder, 'apps/client/dist'), node_path_1.default.resolve(workspaceFolder, 'client/dist'), node_path_1.default.resolve(packageDir, '../client/dist'), node_path_1.default.resolve(packageDir, '../../client/dist'), node_path_1.default.resolve(workspaceFolder, 'node_modules/@vibe-forge/client/dist'), node_path_1.default.resolve(packageDir, '../../node_modules/@vibe-forge/client/dist'));
+    const seen = new Set();
+    for (const candidate of candidates) {
+        if (seen.has(candidate))
+            continue;
+        seen.add(candidate);
+        if (node_fs_1.default.existsSync(node_path_1.default.join(candidate, 'index.html'))) {
+            return candidate;
+        }
+    }
+    return null;
+};
+const createRuntimeScript = (env, clientBase) => {
+    const runtimeEnv = {
+        __VF_PROJECT_AI_SERVER_HOST__: env.__VF_PROJECT_AI_SERVER_HOST__,
+        __VF_PROJECT_AI_SERVER_PORT__: String(env.__VF_PROJECT_AI_SERVER_PORT__),
+        __VF_PROJECT_AI_SERVER_WS_PATH__: env.__VF_PROJECT_AI_SERVER_WS_PATH__,
+        __VF_PROJECT_AI_CLIENT_BASE__: clientBase
+    };
+    return `<script>window.__VF_PROJECT_AI_RUNTIME_ENV__=${JSON.stringify(runtimeEnv)}</script>`;
+};
+const mountRoutes = async (app, env) => {
+    // Routes
+    const router = new router_1.default();
+    // Register routers
+    const routers = [
+        { prefix: '/api/sessions', router: (0, sessions_1.sessionsRouter)() },
+        { prefix: '/api/interact', router: (0, interact_1.interactRouter)() },
+        { prefix: '/api/ai', router: (0, ai_1.aiRouter)() },
+        { prefix: '/api/benchmark', router: (0, benchmark_1.benchmarkRouter)() },
+        { prefix: '/api/automation', router: (0, automation_1.automationRouter)() },
+        { prefix: '/api/config', router: (0, config_1.configRouter)() }
+    ];
+    const clientMode = env.__VF_PROJECT_AI_CLIENT_MODE__;
+    const clientBase = normalizeBase(env.__VF_PROJECT_AI_CLIENT_BASE__);
+    const clientDistPath = clientMode === 'dev'
+        ? null
+        : resolveClientDistPath(env.__VF_PROJECT_AI_CLIENT_DIST_PATH__);
+    const runtimeScript = createRuntimeScript(env, clientBase);
+    if (clientDistPath && clientMode !== 'dev') {
+        routers.push({
+            prefix: clientBase,
+            router: (0, ui_1.uiRouter)({
+                base: clientBase,
+                distPath: clientDistPath,
+                runtimeScript,
+                basePlaceholder: DEFAULT_BASE_PLACEHOLDER
+            })
+        });
+    }
+    for (const { prefix, router: childRouter } of routers) {
+        router
+            .use(prefix, childRouter.routes(), childRouter.allowedMethods());
+    }
+    app
+        .use(router.routes())
+        .use(router.allowedMethods());
+    return {
+        onListen: (httpHost) => {
+            if (clientMode !== 'dev') {
+                if (clientDistPath) {
+                    logger_js_1.logger.info(`[server]              ${httpHost}${clientBase} from ${clientDistPath}`);
+                }
+                else {
+                    logger_js_1.logger.info('[server] client dist not found, static hosting disabled');
+                }
+            }
+        }
+    };
+};
+exports.mountRoutes = mountRoutes;

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

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