@vibe-forge/tsconfigs 0.7.2 → 0.9.0

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.loadConfigState)();
+            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>;

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

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.interactRouter = interactRouter;
+const router_1 = __importDefault(require("@koa/router"));
+const schema_1 = require("@vibe-forge/core/schema");
+const interaction_js_1 = require("#~/services/session/interaction.js");
+const http_js_1 = require("#~/utils/http.js");
+function interactRouter() {
+    const router = new router_1.default();
+    router.post('/ask', async (ctx) => {
+        const body = ctx.request.body;
+        const result = schema_1.AskUserQuestionParamsSchema.safeParse(body);
+        if (!result.success) {
+            throw (0, http_js_1.badRequest)('Invalid parameters', result.error.errors, 'invalid_parameters');
+        }
+        try {
+            const answer = await (0, interaction_js_1.requestInteraction)(result.data);
+            ctx.body = { result: answer };
+        }
+        catch (err) {
+            if (err instanceof Error && err.message.includes('not active')) {
+                throw (0, http_js_1.notFound)(err.message, undefined, 'interaction_not_active');
+            }
+            throw (0, http_js_1.requestTimeout)(err instanceof Error ? err.message : String(err), undefined, 'interaction_timeout');
+        }
+    });
+    return router;
+}

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

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

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

@@ -0,0 +1,278 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sessionsRouter = sessionsRouter;
+const router_1 = __importDefault(require("@koa/router"));
+const index_js_1 = require("#~/db/index.js");
+const create_js_1 = require("#~/services/session/create.js");
+const events_js_1 = require("#~/services/session/events.js");
+const index_js_2 = require("#~/services/session/index.js");
+const interaction_js_1 = require("#~/services/session/interaction.js");
+const runtime_js_1 = require("#~/services/session/runtime.js");
+const http_js_1 = require("#~/utils/http.js");
+function sessionsRouter() {
+    const router = new router_1.default();
+    const db = (0, index_js_1.getDb)();
+    const parseLimit = (limit) => {
+        if (limit == null) {
+            return null;
+        }
+        const n = Number.parseInt(limit, 10);
+        return Number.isNaN(n) ? null : n;
+    };
+    router.get(['/', ''], (ctx) => {
+        ctx.body = { sessions: db.getSessions('active') };
+    });
+    router.get('/archived', (ctx) => {
+        ctx.body = { sessions: db.getSessions('archived') };
+    });
+    router.get('/:id/messages', (ctx) => {
+        const { id } = ctx.params;
+        const { limit } = ctx.query;
+        const messages = db.getMessages(id);
+        const session = db.getSession(id);
+        const interaction = (0, interaction_js_1.getSessionInteraction)(id);
+        const parsedLimit = parseLimit(limit);
+        const responseMessages = parsedLimit == null ? messages : messages.slice(-parsedLimit);
+        ctx.body = { messages: responseMessages, session, interaction };
+    });
+    router.patch('/:id', (ctx) => {
+        const { id } = ctx.params;
+        const { title, isStarred, isArchived, tags } = ctx.request.body;
+        if (title !== undefined || isStarred !== undefined) {
+            (0, index_js_2.updateAndNotifySession)(id, { title, isStarred });
+        }
+        if (isArchived !== undefined) {
+            const updatedIds = db.updateSessionArchivedWithChildren(id, isArchived);
+            for (const updatedId of updatedIds) {
+                const updatedSession = db.getSession(updatedId);
+                if (updatedSession != null) {
+                    (0, runtime_js_1.notifySessionUpdated)(updatedId, updatedSession);
+                }
+            }
+        }
+        if (tags !== undefined) {
+            db.updateSessionTags(id, tags);
+            const updatedSession = db.getSession(id);
+            if (updatedSession != null) {
+                (0, runtime_js_1.notifySessionUpdated)(id, updatedSession);
+            }
+        }
+        ctx.body = { ok: true };
+    });
+    router.post(['/', ''], async (ctx) => {
+        const { id, title, initialMessage, initialContent, parentSessionId, start, model, promptType, promptName, permissionMode, adapter } = ctx.request.body;
+        const session = await (0, create_js_1.createSessionWithInitialMessage)({
+            title,
+            initialMessage,
+            initialContent,
+            parentSessionId,
+            id,
+            shouldStart: start !== false,
+            model,
+            promptType,
+            promptName,
+            permissionMode,
+            adapter
+        });
+        ctx.body = { session };
+    });
+    router.post('/:id/events', (ctx) => {
+        const { id } = ctx.params;
+        const existing = db.getSession(id);
+        if (existing == null) {
+            throw (0, http_js_1.notFound)('Session not found', { id }, 'session_not_found');
+        }
+        const body = ctx.request.body;
+        const onSessionUpdated = (session) => {
+            (0, runtime_js_1.notifySessionUpdated)(id, session);
+        };
+        if (body.type === 'message' && body.data != null) {
+            const event = { type: 'message', message: body.data };
+            (0, events_js_1.applySessionEvent)(id, event, {
+                broadcast: (ev) => (0, runtime_js_1.broadcastSessionEvent)(id, ev),
+                onSessionUpdated
+            });
+            ctx.body = { ok: true };
+            return;
+        }
+        if (body.type === 'message' && body.message != null && typeof body.message !== 'string') {
+            const event = { type: 'message', message: body.message };
+            (0, events_js_1.applySessionEvent)(id, event, {
+                broadcast: (ev) => (0, runtime_js_1.broadcastSessionEvent)(id, ev),
+                onSessionUpdated
+            });
+            ctx.body = { ok: true };
+            return;
+        }
+        if (body.type === 'summary' && body.data?.summary) {
+            const info = {
+                type: 'summary',
+                summary: body.data.summary,
+                leafUuid: body.data.leafUuid ?? ''
+            };
+            const event = { type: 'session_info', info };
+            (0, events_js_1.applySessionEvent)(id, event, {
+                broadcast: (ev) => (0, runtime_js_1.broadcastSessionEvent)(id, ev),
+                onSessionUpdated
+            });
+            ctx.body = { ok: true };
+            return;
+        }
+        if (body.type === 'summary' && typeof body.summary === 'string') {
+            const info = {
+                type: 'summary',
+                summary: body.summary,
+                leafUuid: body.leafUuid ?? ''
+            };
+            const event = { type: 'session_info', info };
+            (0, events_js_1.applySessionEvent)(id, event, {
+                broadcast: (ev) => (0, runtime_js_1.broadcastSessionEvent)(id, ev),
+                onSessionUpdated
+            });
+            ctx.body = { ok: true };
+            return;
+        }
+        if (body.type === 'init' && body.data) {
+            const infoData = body.data;
+            const info = {
+                ...infoData,
+                type: 'init'
+            };
+            const event = { type: 'session_info', info };
+            (0, events_js_1.applySessionEvent)(id, event, {
+                broadcast: (ev) => (0, runtime_js_1.broadcastSessionEvent)(id, ev),
+                onSessionUpdated
+            });
+            ctx.body = { ok: true };
+            return;
+        }
+        if (body.type === 'interaction_request' && body.id && body.payload) {
+            const event = {
+                type: 'interaction_request',
+                id: body.id,
+                payload: body.payload
+            };
+            (0, interaction_js_1.setSessionInteraction)(id, { id: body.id, payload: body.payload });
+            (0, events_js_1.applySessionEvent)(id, event, {
+                broadcast: (ev) => (0, runtime_js_1.broadcastSessionEvent)(id, ev),
+                onSessionUpdated
+            });
+            ctx.body = { ok: true };
+            return;
+        }
+        if (body.type === 'interaction_response' && body.id && body.data != null) {
+            const event = {
+                type: 'interaction_response',
+                id: body.id,
+                data: body.data
+            };
+            (0, interaction_js_1.clearSessionInteraction)(id, body.id);
+            (0, events_js_1.applySessionEvent)(id, event, {
+                broadcast: (ev) => (0, runtime_js_1.broadcastSessionEvent)(id, ev),
+                onSessionUpdated
+            });
+            ctx.body = { ok: true };
+            return;
+        }
+        if (body.type === 'error' && body.data?.message) {
+            const event = {
+                type: 'error',
+                data: body.data,
+                message: body.data.message
+            };
+            (0, events_js_1.applySessionEvent)(id, event, {
+                broadcast: (ev) => (0, runtime_js_1.broadcastSessionEvent)(id, ev),
+                onSessionUpdated
+            });
+            ctx.body = { ok: true };
+            return;
+        }
+        if (body.type === 'error' && typeof body.message === 'string') {
+            const event = {
+                type: 'error',
+                data: {
+                    message: body.message,
+                    fatal: true
+                },
+                message: body.message
+            };
+            (0, events_js_1.applySessionEvent)(id, event, {
+                broadcast: (ev) => (0, runtime_js_1.broadcastSessionEvent)(id, ev),
+                onSessionUpdated
+            });
+            ctx.body = { ok: true };
+            return;
+        }
+        if (body.type === 'exit') {
+            const exitCode = Number(body.data?.exitCode ?? body.exitCode ?? 0);
+            if (exitCode === 0) {
+                (0, index_js_2.updateAndNotifySession)(id, { status: 'completed' });
+            }
+            else {
+                const stderr = body.data?.stderr ?? body.stderr ?? '';
+                const latestSession = db.getSession(id);
+                if (latestSession?.status !== 'failed') {
+                    const message = stderr !== ''
+                        ? `Process exited with code ${exitCode}, stderr:\n${stderr}`
+                        : `Process exited with code ${exitCode}`;
+                    const event = {
+                        type: 'error',
+                        data: {
+                            message,
+                            details: stderr !== '' ? { stderr } : undefined,
+                            fatal: true
+                        },
+                        message
+                    };
+                    (0, events_js_1.applySessionEvent)(id, event, {
+                        broadcast: (ev) => (0, runtime_js_1.broadcastSessionEvent)(id, ev),
+                        onSessionUpdated
+                    });
+                }
+            }
+            ctx.body = { ok: true };
+            return;
+        }
+        if (body.type === 'stop') {
+            const latestSession = db.getSession(id);
+            if (latestSession?.status !== 'failed') {
+                (0, index_js_2.updateAndNotifySession)(id, { status: 'completed' });
+            }
+            ctx.body = { ok: true };
+            return;
+        }
+        throw (0, http_js_1.badRequest)('Invalid event', { type: body.type }, 'invalid_event');
+    });
+    router.delete('/:id', (ctx) => {
+        const { id } = ctx.params;
+        db.deleteChannelSessionBySessionId(id);
+        const removed = db.deleteSession(id);
+        if (removed) {
+            // 显式销毁会话进程
+            (0, index_js_2.killSession)(id);
+            (0, runtime_js_1.notifySessionUpdated)(id, { id, isDeleted: true });
+        }
+        ctx.body = { ok: true, removed };
+    });
+    router.post('/:id/fork', (ctx) => {
+        const { id } = ctx.params;
+        const { title } = ctx.request.body;
+        const original = db.getSession(id);
+        if (!original) {
+            throw (0, http_js_1.notFound)('Original session not found', { id }, 'original_session_not_found');
+        }
+        // 创建新会话
+        const newSession = db.createSession((title != null && title !== '') ? title : `${original.title} (Fork)`);
+        // 同步历史消息
+        db.copyMessages(id, newSession.id);
+        (0, runtime_js_1.notifySessionUpdated)(newSession.id, newSession);
+        ctx.body = { session: newSession };
+    });
+    router.all('/:id', (ctx) => {
+        throw (0, http_js_1.methodNotAllowed)('Method Not Allowed', { path: ctx.path }, 'method_not_allowed');
+    });
+    return router;
+}

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

@@ -0,0 +1,8 @@
+import Router from '@koa/router';
+export interface ClientStaticOptions {
+    base: string;
+    basePlaceholder: string;
+    distPath: string;
+    runtimeScript: string;
+}
+export declare const uiRouter: ({ base, basePlaceholder, distPath, runtimeScript }: ClientStaticOptions) => Router<import("koa").DefaultState, import("koa").DefaultContext>;

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

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uiRouter = void 0;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const router_1 = __importDefault(require("@koa/router"));
+const koa_send_1 = __importDefault(require("koa-send"));
+const replaceBase = (content, base, placeholder) => {
+    if (!placeholder || placeholder === base) {
+        return content;
+    }
+    return content.split(placeholder).join(base);
+};
+const uiRouter = ({ base, basePlaceholder, distPath, runtimeScript }) => {
+    const router = new router_1.default();
+    let cachedIndexHtml = null;
+    const loadIndexHtml = async () => {
+        if (cachedIndexHtml)
+            return cachedIndexHtml;
+        const raw = await (0, promises_1.readFile)(node_path_1.default.join(distPath, 'index.html'), 'utf8');
+        const replaced = replaceBase(raw, base, basePlaceholder);
+        cachedIndexHtml = replaced
+            .replace('</head>', `${runtimeScript}</head>`);
+        return cachedIndexHtml;
+    };
+    router.get('assets/:path(.*)', async (ctx) => {
+        try {
+            const assetPath = ctx.params.path
+                ? `assets/${ctx.params.path}`
+                : 'assets';
+            await (0, koa_send_1.default)(ctx, assetPath, { root: distPath });
+            if (!ctx.body) {
+                ctx.status = 404;
+                ctx.body = { error: 'Asset not found' };
+            }
+        }
+        catch (err) {
+            console.error('[ui] Failed to serve asset:', err);
+            ctx.status = 404;
+            ctx.body = { error: 'Asset not found' };
+        }
+    });
+    const handleIndex = async (ctx) => {
+        try {
+            const html = await loadIndexHtml();
+            ctx.type = 'text/html';
+            ctx.body = html;
+        }
+        catch (err) {
+            console.error('[ui] Failed to load index.html:', err);
+            ctx.status = 500;
+            ctx.body = { error: 'Failed to load UI' };
+        }
+    };
+    router.get('/', handleIndex);
+    router.get(':path(.*)', handleIndex);
+    return router;
+};
+exports.uiRouter = uiRouter;

package/dist/apps/server/src/services/automation/execution.d.ts

@@ -0,0 +1,7 @@
+import type { AutomationRule } from '#~/db/index.js';
+export declare function ensureLegacyRuleData(rule: AutomationRule): void;
+export declare function runAutomationRule(id: string, options?: {
+    ignoreEnabled?: boolean;
+}): Promise<{
+    sessionIds: string[];
+} | null>;