@vibe-forge/tsconfigs 0.7.1 → 0.8.0

package/dist/apps/server/src/services/session/create.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSessionWithInitialMessage = createSessionWithInitialMessage;
+const index_js_1 = require("#~/db/index.js");
+const index_js_2 = require("#~/services/session/index.js");
+const runtime_js_1 = require("#~/services/session/runtime.js");
+async function createSessionWithInitialMessage(options) {
+    const { title, initialMessage, initialContent, parentSessionId, id, shouldStart = true, tags, model, promptType, promptName, permissionMode, systemPrompt, adapter } = options;
+    const db = (0, index_js_1.getDb)();
+    const session = db.createSession(title, id, undefined, parentSessionId);
+    if (model !== undefined || permissionMode !== undefined || adapter !== undefined) {
+        db.updateSession(session.id, { model, permissionMode, adapter });
+        const updatedSession = db.getSession(session.id);
+        if (updatedSession) {
+            Object.assign(session, updatedSession);
+        }
+    }
+    (0, runtime_js_1.notifySessionUpdated)(session.id, session);
+    if (tags && tags.length > 0) {
+        db.updateSessionTags(session.id, tags);
+        const updated = db.getSession(session.id);
+        if (updated) {
+            Object.assign(session, updated);
+            (0, runtime_js_1.notifySessionUpdated)(session.id, updated);
+        }
+    }
+    if ((initialMessage || initialContent) && shouldStart) {
+        try {
+            await (0, index_js_2.startAdapterSession)(session.id, { model, promptType, promptName, permissionMode, systemPrompt, adapter });
+            if (initialContent) {
+                (0, index_js_2.processUserMessage)(session.id, initialContent);
+            }
+            else if (initialMessage) {
+                (0, index_js_2.processUserMessage)(session.id, initialMessage);
+            }
+            const updated = db.getSession(session.id);
+            if (updated) {
+                Object.assign(session, updated);
+            }
+        }
+        catch (err) {
+            console.error(`[sessions] Failed to start session ${session.id}:`, err);
+            db.deleteSession(session.id);
+            throw err;
+        }
+    }
+    return session;
+}

package/dist/apps/server/src/services/session/events.d.ts

@@ -0,0 +1,7 @@
+import type { ChatMessage, Session, WSEvent } from '@vibe-forge/core';
+export interface SessionEventCallbacks {
+    broadcast?: (event: WSEvent) => void;
+    onSessionUpdated?: (session: Session) => void;
+}
+export declare function extractTextFromMessage(message: ChatMessage): string | undefined;
+export declare function applySessionEvent(sessionId: string, event: WSEvent, callbacks?: SessionEventCallbacks): void;

package/dist/apps/server/src/services/session/events.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractTextFromMessage = extractTextFromMessage;
+exports.applySessionEvent = applySessionEvent;
+const index_js_1 = require("#~/db/index.js");
+function extractTextFromMessage(message) {
+    if (typeof message.content === 'string') {
+        return message.content;
+    }
+    if (Array.isArray(message.content)) {
+        const textContent = message.content.find((c) => c.type === 'text');
+        if (textContent != null && 'text' in textContent) {
+            return textContent.text;
+        }
+    }
+    return undefined;
+}
+function applySessionEvent(sessionId, event, callbacks = {}) {
+    const db = (0, index_js_1.getDb)();
+    if (event.type !== 'session_updated') {
+        db.saveMessage(sessionId, event);
+    }
+    const updates = {};
+    if (event.type === 'message') {
+        const text = extractTextFromMessage(event.message);
+        if (text != null && text !== '') {
+            updates.lastMessage = text;
+            if (event.message.role === 'user') {
+                updates.lastUserMessage = text;
+            }
+        }
+        updates.status = 'running';
+    }
+    else if (event.type === 'interaction_request') {
+        updates.status = 'waiting_input';
+    }
+    else if (event.type === 'interaction_response') {
+        updates.status = 'running';
+    }
+    else if (event.type === 'error') {
+        if (event.data.fatal !== false) {
+            updates.status = 'failed';
+        }
+    }
+    if (Object.keys(updates).length > 0) {
+        db.updateSession(sessionId, updates);
+        const updated = db.getSession(sessionId);
+        if (updated != null && callbacks.onSessionUpdated) {
+            callbacks.onSessionUpdated(updated);
+        }
+    }
+    if (callbacks.broadcast) {
+        callbacks.broadcast(event);
+    }
+}

package/dist/apps/server/src/services/session/index.d.ts

@@ -0,0 +1,14 @@
+import type { ChatMessageContent, Session, SessionPermissionMode } from '@vibe-forge/core';
+export declare function startAdapterSession(sessionId: string, options?: {
+    model?: string;
+    systemPrompt?: string;
+    appendSystemPrompt?: boolean;
+    permissionMode?: SessionPermissionMode;
+    promptType?: 'spec' | 'entity';
+    promptName?: string;
+    adapter?: string;
+}): Promise<import("#~/services/session/runtime.js").AdapterSessionRuntime>;
+export declare function processUserMessage(sessionId: string, content: string | ChatMessageContent[]): Promise<void>;
+export declare function updateAndNotifySession(id: string, updates: Partial<Omit<Session, 'id' | 'createdAt' | 'messageCount'>>): void;
+export declare function killSession(sessionId: string): void;
+export declare function interruptSession(sessionId: string): void;

package/dist/apps/server/src/services/session/index.js

@@ -0,0 +1,313 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startAdapterSession = startAdapterSession;
+exports.processUserMessage = processUserMessage;
+exports.updateAndNotifySession = updateAndNotifySession;
+exports.killSession = killSession;
+exports.interruptSession = interruptSession;
+const node_process_1 = require("node:process");
+const uuid_1 = require("uuid");
+const app_runtime_1 = require("@vibe-forge/app-runtime");
+const index_js_1 = require("#~/channels/index.js");
+const index_js_2 = require("#~/db/index.js");
+const index_js_3 = require("#~/services/config/index.js");
+const events_js_1 = require("#~/services/session/events.js");
+const notification_js_1 = require("#~/services/session/notification.js");
+const runtime_js_1 = require("#~/services/session/runtime.js");
+const logger_js_1 = require("#~/utils/logger.js");
+const activeAdapterRunStore = new Map();
+async function startAdapterSession(sessionId, options = {}) {
+    const db = (0, index_js_2.getDb)();
+    const historyMessages = db.getMessages(sessionId);
+    const hasHistory = historyMessages.length > 0;
+    const serverLogger = (0, logger_js_1.getSessionLogger)(sessionId, 'server');
+    const existing = db.getSession(sessionId);
+    const resolvedModel = options.model ?? existing?.model;
+    const resolvedAdapter = options.adapter ?? existing?.adapter;
+    const resolvedPermissionMode = options.permissionMode ?? existing?.permissionMode;
+    const adapterChanged = existing?.adapter != null && resolvedAdapter != null && existing.adapter !== resolvedAdapter;
+    const type = hasHistory && !adapterChanged ? 'resume' : 'create';
+    const cached = (0, runtime_js_1.getAdapterSessionRuntime)(sessionId);
+    if (cached != null) {
+        const currentModel = cached.config?.model ?? existing?.model;
+        const currentAdapter = cached.config?.adapter ?? existing?.adapter;
+        const currentPermissionMode = cached.config?.permissionMode ?? existing?.permissionMode;
+        const configChanged = currentModel !== resolvedModel ||
+            currentAdapter !== resolvedAdapter ||
+            currentPermissionMode !== resolvedPermissionMode;
+        if (!configChanged) {
+            serverLogger.info({ sessionId }, '[server] Reusing existing adapter process');
+            return cached;
+        }
+        serverLogger.info({
+            sessionId,
+            currentModel,
+            resolvedModel,
+            currentAdapter,
+            resolvedAdapter,
+            currentPermissionMode,
+            resolvedPermissionMode
+        }, '[server] Restarting adapter process due to session config change');
+        activeAdapterRunStore.delete(sessionId);
+        cached.session.kill();
+        (0, runtime_js_1.deleteAdapterSessionRuntime)(sessionId);
+    }
+    serverLogger.info({ sessionId, type }, '[server] Starting new adapter process');
+    if (existing == null) {
+        serverLogger.info({ sessionId }, '[server] Session not found in DB, creating new entry');
+        db.createSession(undefined, sessionId);
+    }
+    if (resolvedModel !== existing?.model || resolvedAdapter !== existing?.adapter ||
+        resolvedPermissionMode !== existing?.permissionMode) {
+        updateAndNotifySession(sessionId, {
+            model: resolvedModel,
+            adapter: resolvedAdapter,
+            permissionMode: resolvedPermissionMode
+        });
+    }
+    const connectionState = (0, runtime_js_1.takeExternalSessionRuntime)(sessionId) ?? (0, runtime_js_1.createSessionConnectionState)();
+    const runId = (0, uuid_1.v4)();
+    activeAdapterRunStore.set(sessionId, runId);
+    try {
+        const promptCwd = (0, node_process_1.cwd)();
+        const [data, resolvedConfig] = await (0, app_runtime_1.generateAdapterQueryOptions)(options.promptType, options.promptName, promptCwd);
+        const env = {
+            ...node_process_1.env,
+            __VF_PROJECT_AI_CTX_ID__: node_process_1.env.__VF_PROJECT_AI_CTX_ID__ ?? sessionId
+        };
+        const finalSystemPrompt = options.appendSystemPrompt === false
+            ? (options.systemPrompt ?? resolvedConfig.systemPrompt)
+            : [resolvedConfig.systemPrompt, options.systemPrompt]
+                .filter(Boolean)
+                .join('\n\n');
+        const { mergedConfig } = await (0, index_js_3.loadMergedConfig)().catch(() => ({ mergedConfig: {} }));
+        const { modelLanguage } = mergedConfig;
+        const languagePrompt = modelLanguage == null
+            ? undefined
+            : (modelLanguage === 'en' ? 'Please respond in English.' : '请使用中文进行对话。');
+        const mergedSystemPrompt = [
+            finalSystemPrompt,
+            languagePrompt
+        ].filter(Boolean).join('\n\n');
+        let sawFatalError = false;
+        const { session } = await (0, app_runtime_1.run)({
+            env,
+            cwd: promptCwd,
+            adapter: resolvedAdapter
+        }, {
+            type,
+            runtime: 'server',
+            sessionId,
+            model: resolvedModel,
+            systemPrompt: mergedSystemPrompt,
+            permissionMode: resolvedPermissionMode,
+            appendSystemPrompt: options.appendSystemPrompt ?? true,
+            tools: resolvedConfig.tools,
+            mcpServers: resolvedConfig.mcpServers,
+            promptAssetIds: resolvedConfig.promptAssetIds,
+            onEvent: (event) => {
+                if (activeAdapterRunStore.get(sessionId) !== runId) {
+                    return;
+                }
+                const broadcast = (ev) => {
+                    serverLogger.info({ event: 'broadcast', data: ev }, 'Broadcasting event');
+                    (0, runtime_js_1.emitRuntimeEvent)(connectionState, ev);
+                };
+                const applyEvent = (ev) => {
+                    (0, events_js_1.applySessionEvent)(sessionId, ev, {
+                        broadcast,
+                        onSessionUpdated: (session) => {
+                            (0, runtime_js_1.notifySessionUpdated)(sessionId, session);
+                        }
+                    });
+                    void (0, index_js_1.handleChannelSessionEvent)(sessionId, ev).catch(() => undefined);
+                };
+                switch (event.type) {
+                    case 'init':
+                        if ('model' in event.data) {
+                            updateAndNotifySession(sessionId, {
+                                model: typeof event.data.model === 'string'
+                                    ? event.data.model
+                                    : resolvedModel,
+                                adapter: typeof event.data.adapter === 'string'
+                                    ? event.data.adapter
+                                    : resolvedAdapter,
+                                permissionMode: resolvedPermissionMode
+                            });
+                            applyEvent({
+                                type: 'session_info',
+                                info: {
+                                    type: 'init',
+                                    ...event.data
+                                }
+                            });
+                        }
+                        break;
+                    case 'message':
+                        if ('role' in event.data) {
+                            applyEvent({
+                                type: 'message',
+                                message: event.data
+                            });
+                        }
+                        break;
+                    case 'error':
+                        if (event.data.fatal !== false) {
+                            sawFatalError = true;
+                        }
+                        applyEvent({
+                            type: 'error',
+                            data: event.data,
+                            message: event.data.message
+                        });
+                        break;
+                    case 'exit': {
+                        const { exitCode, stderr } = event.data;
+                        updateAndNotifySession(sessionId, {
+                            status: exitCode === 0 ? 'completed' : 'failed'
+                        });
+                        if (exitCode !== 0 && !sawFatalError) {
+                            (0, runtime_js_1.emitRuntimeEvent)(connectionState, {
+                                type: 'error',
+                                data: {
+                                    message: stderr !== ''
+                                        ? `Process exited with code ${exitCode}, stderr:\n${stderr}`
+                                        : `Process exited with code ${exitCode}`,
+                                    details: stderr !== '' ? { stderr } : undefined,
+                                    fatal: true
+                                },
+                                message: stderr !== ''
+                                    ? `Process exited with code ${exitCode}, stderr:\n${stderr}`
+                                    : `Process exited with code ${exitCode}`
+                            }, { recordMessage: false });
+                        }
+                        (0, runtime_js_1.deleteAdapterSessionRuntime)(sessionId);
+                        if (activeAdapterRunStore.get(sessionId) === runId) {
+                            activeAdapterRunStore.delete(sessionId);
+                        }
+                        break;
+                    }
+                    case 'summary': {
+                        const summaryData = event.data;
+                        applyEvent({
+                            type: 'session_info',
+                            info: {
+                                type: 'summary',
+                                summary: summaryData.summary,
+                                leafUuid: summaryData.leafUuid
+                            }
+                        });
+                        break;
+                    }
+                    case 'stop': {
+                        const latestSession = (0, index_js_2.getDb)().getSession(sessionId);
+                        if (latestSession?.status !== 'failed') {
+                            updateAndNotifySession(sessionId, { status: 'completed' });
+                        }
+                        break;
+                    }
+                }
+            }
+        });
+        return (0, runtime_js_1.setAdapterSessionRuntime)(sessionId, (0, runtime_js_1.bindAdapterSessionRuntime)(connectionState, session, {
+            runId,
+            model: resolvedModel,
+            adapter: resolvedAdapter,
+            permissionMode: resolvedPermissionMode
+        }));
+    }
+    catch (err) {
+        if (activeAdapterRunStore.get(sessionId) === runId) {
+            activeAdapterRunStore.delete(sessionId);
+        }
+        updateAndNotifySession(sessionId, { status: 'failed' });
+        serverLogger.error({ err, sessionId }, '[server] session init error');
+        throw err;
+    }
+}
+function extractTextFromContent(content) {
+    const textItem = content.find((item) => item.type === 'text' && item.text.trim() !== '');
+    return textItem?.text;
+}
+async function processUserMessage(sessionId, content) {
+    const serverLogger = (0, logger_js_1.getSessionLogger)(sessionId, 'server');
+    const userText = typeof content === 'string' ? String(content ?? '') : '';
+    const contentItems = Array.isArray(content)
+        ? content
+        : [{ type: 'text', text: userText }];
+    const summaryText = extractTextFromContent(contentItems) ?? '[图片]';
+    const userMessage = {
+        id: (0, uuid_1.v4)(),
+        role: 'user',
+        content: Array.isArray(content) ? contentItems : userText,
+        createdAt: Date.now()
+    };
+    const ev = { type: 'message', message: userMessage };
+    const db = (0, index_js_2.getDb)();
+    db.saveMessage(sessionId, ev);
+    const currentSessionData = db.getSession(sessionId);
+    const isExternalSession = currentSessionData?.parentSessionId != null;
+    const updates = {
+        lastMessage: summaryText,
+        lastUserMessage: summaryText,
+        status: 'running'
+    };
+    if (currentSessionData?.title == null || currentSessionData.title === '' ||
+        currentSessionData.title === 'New Session') {
+        const firstLine = summaryText.split('\n')[0].trim();
+        updates.title = firstLine.length > 50 ? `${firstLine.slice(0, 50)}...` : firstLine;
+    }
+    updateAndNotifySession(sessionId, updates);
+    const externalCached = (0, runtime_js_1.getExternalSessionRuntime)(sessionId);
+    if (isExternalSession && externalCached != null) {
+        (0, runtime_js_1.broadcastSessionEvent)(sessionId, ev);
+        return;
+    }
+    let runtime = (0, runtime_js_1.getAdapterSessionRuntime)(sessionId);
+    if (runtime == null) {
+        serverLogger.info({ sessionId }, '[server] Adapter runtime missing for user message, starting a new process');
+        runtime = await startAdapterSession(sessionId);
+    }
+    if (runtime == null) {
+        serverLogger.warn({ sessionId }, '[server] Adapter session not found when processing user message');
+        return;
+    }
+    (0, runtime_js_1.broadcastSessionEvent)(sessionId, ev);
+    const messageList = db.getMessages(sessionId);
+    const lastAssistantMessage = messageList
+        .filter((m) => m.type === 'message' && m.message.role === 'assistant' && (m.message.id != null && m.message.id !== ''))
+        .pop();
+    const parentUuid = lastAssistantMessage != null ? lastAssistantMessage.message.id : undefined;
+    runtime.session.emit({
+        type: 'message',
+        content: contentItems,
+        parentUuid
+    });
+}
+function updateAndNotifySession(id, updates) {
+    const db = (0, index_js_2.getDb)();
+    const previous = db.getSession(id);
+    db.updateSession(id, updates);
+    const updated = db.getSession(id);
+    if (updated) {
+        (0, runtime_js_1.notifySessionUpdated)(id, updated);
+        void (0, notification_js_1.maybeNotifySession)(previous?.status, updated.status, updated).catch(() => undefined);
+    }
+}
+function killSession(sessionId) {
+    const cached = (0, runtime_js_1.getAdapterSessionRuntime)(sessionId);
+    if (cached != null) {
+        activeAdapterRunStore.delete(sessionId);
+        (0, logger_js_1.getSessionLogger)(sessionId, 'server').info({ sessionId }, '[server] Killing adapter process by request');
+        cached.session.kill();
+        (0, runtime_js_1.deleteAdapterSessionRuntime)(sessionId);
+        updateAndNotifySession(sessionId, { status: 'terminated' });
+    }
+}
+function interruptSession(sessionId) {
+    const cached = (0, runtime_js_1.getAdapterSessionRuntime)(sessionId);
+    if (cached != null) {
+        (0, logger_js_1.getSessionLogger)(sessionId, 'server').info({ sessionId }, '[server] Interrupting adapter process by request');
+        cached.session.emit({ type: 'interrupt' });
+    }
+}

package/dist/apps/server/src/services/session/interaction.d.ts

@@ -0,0 +1,9 @@
+import type { AskUserQuestionParams } from '@vibe-forge/core';
+export declare function getSessionInteraction(sessionId: string): import("#~/services/session/runtime.js").SessionInteractionState | undefined;
+export declare function setSessionInteraction(sessionId: string, interaction: {
+    id: string;
+    payload: AskUserQuestionParams;
+}): void;
+export declare function clearSessionInteraction(sessionId: string, interactionId: string): void;
+export declare function requestInteraction(params: AskUserQuestionParams): Promise<string | string[]>;
+export declare function handleInteractionResponse(sessionId: string, interactionId: string, data: unknown): void;

package/dist/apps/server/src/services/session/interaction.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSessionInteraction = getSessionInteraction;
+exports.setSessionInteraction = setSessionInteraction;
+exports.clearSessionInteraction = clearSessionInteraction;
+exports.requestInteraction = requestInteraction;
+exports.handleInteractionResponse = handleInteractionResponse;
+const uuid_1 = require("uuid");
+const index_js_1 = require("#~/db/index.js");
+const events_js_1 = require("#~/services/session/events.js");
+const index_js_2 = require("#~/services/session/index.js");
+const runtime_js_1 = require("#~/services/session/runtime.js");
+function getSessionInteraction(sessionId) {
+    return (0, runtime_js_1.getSessionConnectionState)(sessionId)?.currentInteraction;
+}
+function setSessionInteraction(sessionId, interaction) {
+    const runtime = (0, runtime_js_1.getSessionConnectionState)(sessionId);
+    if (runtime != null) {
+        runtime.currentInteraction = interaction;
+    }
+}
+function clearSessionInteraction(sessionId, interactionId) {
+    const runtime = (0, runtime_js_1.getSessionConnectionState)(sessionId);
+    if (runtime?.currentInteraction?.id === interactionId) {
+        runtime.currentInteraction = undefined;
+    }
+}
+function requestInteraction(params) {
+    const { sessionId } = params;
+    const runtime = (0, runtime_js_1.getSessionConnectionState)(sessionId);
+    if (runtime == null || runtime.sockets.size === 0) {
+        return Promise.reject(new Error(`Session ${sessionId} is not active`));
+    }
+    const interactionId = (0, uuid_1.v4)();
+    const event = {
+        type: 'interaction_request',
+        id: interactionId,
+        payload: params
+    };
+    runtime.currentInteraction = { id: interactionId, payload: params };
+    (0, runtime_js_1.emitRuntimeEvent)(runtime, event, { recordMessage: false });
+    (0, index_js_2.updateAndNotifySession)(sessionId, { status: 'waiting_input' });
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            (0, runtime_js_1.deletePendingSessionInteraction)(interactionId);
+            if (runtime.currentInteraction?.id === interactionId) {
+                runtime.currentInteraction = undefined;
+            }
+            reject(new Error('Interaction timed out'));
+        }, 5 * 60 * 1000);
+        (0, runtime_js_1.setPendingSessionInteraction)(interactionId, { resolve, reject, timer });
+    });
+}
+function handleInteractionResponse(sessionId, interactionId, data) {
+    const sessionData = (0, index_js_1.getDb)().getSession(sessionId);
+    const isExternalSession = sessionData?.parentSessionId != null;
+    if (isExternalSession) {
+        clearSessionInteraction(sessionId, interactionId);
+        const event = { type: 'interaction_response', id: interactionId, data: data };
+        (0, events_js_1.applySessionEvent)(sessionId, event, {
+            broadcast: (nextEvent) => (0, runtime_js_1.broadcastSessionEvent)(sessionId, nextEvent),
+            onSessionUpdated: (session) => {
+                (0, runtime_js_1.notifySessionUpdated)(sessionId, session);
+            }
+        });
+        return;
+    }
+    const pending = (0, runtime_js_1.getPendingSessionInteraction)(interactionId);
+    if (pending == null) {
+        return;
+    }
+    clearTimeout(pending.timer);
+    clearSessionInteraction(sessionId, interactionId);
+    (0, index_js_2.updateAndNotifySession)(sessionId, { status: 'running' });
+    pending.resolve(data);
+    (0, runtime_js_1.deletePendingSessionInteraction)(interactionId);
+}

package/dist/apps/server/src/services/session/notification.d.ts

@@ -0,0 +1,2 @@
+import type { Session, SessionStatus } from '@vibe-forge/core';
+export declare function maybeNotifySession(previousStatus: SessionStatus | undefined, nextStatus: SessionStatus | undefined, session: Session): Promise<void>;

package/dist/apps/server/src/services/session/notification.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.maybeNotifySession = maybeNotifySession;
+const system_1 = require("@vibe-forge/utils/system");
+const index_js_1 = require("#~/services/config/index.js");
+const toNotificationTrigger = (status) => {
+    if (status === 'completed' || status === 'failed' || status === 'terminated' || status === 'waiting_input') {
+        return status;
+    }
+    return undefined;
+};
+const resolveNotificationText = (status, session, language) => {
+    const sessionLabel = session.title && session.title.trim() !== '' ? session.title : session.id;
+    if (language === 'en') {
+        if (status === 'completed') {
+            return { title: 'Session completed', description: `Session "${sessionLabel}" completed.` };
+        }
+        if (status === 'failed')
+            return { title: 'Session failed', description: `Session "${sessionLabel}" failed.` };
+        if (status === 'terminated') {
+            return { title: 'Session terminated', description: `Session "${sessionLabel}" terminated.` };
+        }
+        return { title: 'Session needs input', description: `Session "${sessionLabel}" is waiting for input.` };
+    }
+    if (status === 'completed')
+        return { title: '会话已完成', description: `会话「${sessionLabel}」已完成。` };
+    if (status === 'failed')
+        return { title: '会话失败', description: `会话「${sessionLabel}」失败。` };
+    if (status === 'terminated')
+        return { title: '会话已终止', description: `会话「${sessionLabel}」已终止。` };
+    return { title: '会话等待输入', description: `会话「${sessionLabel}」正在等待输入。` };
+};
+async function maybeNotifySession(previousStatus, nextStatus, session) {
+    if (nextStatus == null || nextStatus === previousStatus)
+        return;
+    const notificationTrigger = toNotificationTrigger(nextStatus);
+    if (notificationTrigger == null)
+        return;
+    const { mergedConfig } = await (0, index_js_1.loadMergedConfig)();
+    const { notifications, interfaceLanguage } = mergedConfig;
+    if (notifications?.disabled === true)
+        return;
+    const eventConfig = notifications?.events?.[notificationTrigger];
+    if (eventConfig?.disabled === true)
+        return;
+    const fallbackText = resolveNotificationText(notificationTrigger, session, interfaceLanguage);
+    const title = eventConfig?.title && eventConfig.title.trim() !== ''
+        ? eventConfig.title
+        : fallbackText.title;
+    const description = eventConfig?.description && eventConfig.description.trim() !== ''
+        ? eventConfig.description
+        : fallbackText.description;
+    const sound = eventConfig?.sound;
+    const resolvedSound = typeof sound === 'string' && sound.trim() !== '' ? sound.trim() : undefined;
+    await (0, system_1.notify)({
+        title,
+        description,
+        sound: resolvedSound,
+        volume: notifications?.volume,
+        timeout: false
+    });
+}

package/dist/apps/server/src/services/session/runtime.d.ts

@@ -0,0 +1,58 @@
+import type { AskUserQuestionParams, Session, SessionPermissionMode, WSEvent } from '@vibe-forge/core';
+import type { AdapterSession } from '@vibe-forge/types';
+import { WebSocket as WebSocketImpl } from 'ws';
+import type { WebSocket } from 'ws';
+export interface SessionInteractionState {
+    id: string;
+    payload: AskUserQuestionParams;
+}
+export interface SessionConnectionState {
+    sockets: Set<WebSocket>;
+    messages: WSEvent[];
+    currentInteraction?: SessionInteractionState;
+}
+export interface AdapterSessionConfig {
+    runId: string;
+    model?: string;
+    adapter?: string;
+    permissionMode?: SessionPermissionMode;
+}
+export interface AdapterSessionRuntime extends SessionConnectionState {
+    session: AdapterSession;
+    config?: AdapterSessionConfig;
+}
+export interface PendingSessionInteraction {
+    resolve: (data: string | string[]) => void;
+    reject: (reason: unknown) => void;
+    timer: NodeJS.Timeout;
+}
+export declare const adapterSessionStore: Map<string, AdapterSessionRuntime>;
+export declare const externalSessionStore: Map<string, SessionConnectionState>;
+export declare const sessionSubscriberSockets: Set<WebSocketImpl>;
+export declare const pendingSessionInteractionStore: Map<string, PendingSessionInteraction>;
+export declare function createSessionConnectionState(): SessionConnectionState;
+export declare function bindAdapterSessionRuntime(connectionState: SessionConnectionState, session: AdapterSession, config?: AdapterSessionConfig): AdapterSessionRuntime;
+export declare function getAdapterSessionRuntime(sessionId: string): AdapterSessionRuntime | undefined;
+export declare function setAdapterSessionRuntime(sessionId: string, runtime: AdapterSessionRuntime): AdapterSessionRuntime;
+export declare function deleteAdapterSessionRuntime(sessionId: string): void;
+export declare function getExternalSessionRuntime(sessionId: string): SessionConnectionState | undefined;
+export declare function takeExternalSessionRuntime(sessionId: string): SessionConnectionState | undefined;
+export declare function ensureExternalSessionRuntime(sessionId: string): SessionConnectionState;
+export declare function deleteExternalSessionRuntime(sessionId: string): void;
+export declare function getSessionConnectionState(sessionId: string): SessionConnectionState | undefined;
+export declare function emitRuntimeEvent(runtime: SessionConnectionState, event: WSEvent, options?: {
+    recordMessage?: boolean;
+}): void;
+export declare function broadcastSessionEvent(sessionId: string, event: WSEvent): void;
+export declare function notifySessionUpdated(sessionId: string, session: Session | {
+    id: string;
+    isDeleted: boolean;
+}): void;
+export declare function addSessionSubscriberSocket(socket: WebSocket): void;
+export declare function removeSessionSubscriberSocket(socket: WebSocket): void;
+export declare function attachSocketToSession(sessionId: string, socket: WebSocket, mode: 'adapter' | 'external'): SessionConnectionState | undefined;
+export declare function detachSocketFromSession(sessionId: string, socket: WebSocket): SessionConnectionState | undefined;
+export declare function interruptAdapterSession(sessionId: string): void;
+export declare function getPendingSessionInteraction(interactionId: string): PendingSessionInteraction | undefined;
+export declare function setPendingSessionInteraction(interactionId: string, interaction: PendingSessionInteraction): void;
+export declare function deletePendingSessionInteraction(interactionId: string): void;