@vibe-forge/tsconfigs 0.7.2 → 0.8.0

package/dist/apps/server/__tests__/services/session-start.spec.js

@@ -0,0 +1,319 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+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");
+const mocks = vitest_1.vi.hoisted(() => ({
+    run: vitest_1.vi.fn(),
+    generateAdapterQueryOptions: vitest_1.vi.fn(),
+    loadMergedConfig: vitest_1.vi.fn(),
+    handleChannelSessionEvent: vitest_1.vi.fn()
+}));
+vitest_1.vi.mock('#~/db/index.js', () => ({
+    getDb: vitest_1.vi.fn()
+}));
+vitest_1.vi.mock('@vibe-forge/app-runtime', () => ({
+    generateAdapterQueryOptions: mocks.generateAdapterQueryOptions,
+    run: mocks.run
+}));
+vitest_1.vi.mock('#~/channels/index.js', () => ({
+    handleChannelSessionEvent: mocks.handleChannelSessionEvent
+}));
+vitest_1.vi.mock('#~/services/config/index.js', () => ({
+    loadMergedConfig: mocks.loadMergedConfig
+}));
+vitest_1.vi.mock('#~/services/session/notification.js', () => ({
+    maybeNotifySession: vitest_1.vi.fn().mockResolvedValue(undefined)
+}));
+vitest_1.vi.mock('#~/services/session/runtime.js', async () => {
+    const actual = await vitest_1.vi.importActual('#~/services/session/runtime.js');
+    return {
+        ...actual,
+        notifySessionUpdated: vitest_1.vi.fn()
+    };
+});
+vitest_1.vi.mock('#~/utils/logger.js', () => ({
+    getSessionLogger: vitest_1.vi.fn(() => ({
+        info: vitest_1.vi.fn(),
+        warn: vitest_1.vi.fn(),
+        error: vitest_1.vi.fn()
+    }))
+}));
+(0, vitest_1.describe)('startAdapterSession', () => {
+    let currentSession;
+    const getMessages = vitest_1.vi.fn();
+    const saveMessage = vitest_1.vi.fn();
+    const createSession = vitest_1.vi.fn();
+    const updateSession = vitest_1.vi.fn();
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.clearAllMocks();
+        runtime_js_1.adapterSessionStore.clear();
+        runtime_js_1.externalSessionStore.clear();
+        currentSession = {
+            id: 'sess-1',
+            createdAt: Date.now(),
+            status: 'completed',
+            model: 'gpt-4o',
+            adapter: 'codex',
+            permissionMode: 'default'
+        };
+        getMessages.mockReturnValue([]);
+        createSession.mockImplementation((_title, id) => ({
+            id: id ?? 'sess-1',
+            createdAt: Date.now()
+        }));
+        updateSession.mockImplementation((_id, updates) => {
+            currentSession = { ...currentSession, ...updates };
+        });
+        vitest_1.vi.mocked(index_js_1.getDb).mockReturnValue({
+            getMessages,
+            saveMessage,
+            getSession: vitest_1.vi.fn(() => currentSession),
+            createSession,
+            updateSession
+        });
+        mocks.generateAdapterQueryOptions.mockResolvedValue([
+            {},
+            {
+                systemPrompt: undefined,
+                tools: undefined,
+                mcpServers: undefined
+            }
+        ]);
+        mocks.loadMergedConfig.mockResolvedValue({ mergedConfig: {} });
+        mocks.handleChannelSessionEvent.mockResolvedValue(undefined);
+    });
+    (0, vitest_1.it)('reuses the cached runtime when adapter config is unchanged', async () => {
+        const runtime = {
+            session: {
+                emit: vitest_1.vi.fn(),
+                kill: vitest_1.vi.fn()
+            },
+            sockets: new Set(),
+            messages: [],
+            config: {
+                runId: 'run-same',
+                model: 'gpt-4o',
+                adapter: 'codex',
+                permissionMode: 'default'
+            }
+        };
+        runtime_js_1.adapterSessionStore.set('sess-1', runtime);
+        const result = await (0, index_js_2.startAdapterSession)('sess-1', {
+            model: 'gpt-4o',
+            adapter: 'codex',
+            permissionMode: 'default'
+        });
+        (0, vitest_1.expect)(result).toBe(runtime);
+        (0, vitest_1.expect)(mocks.run).not.toHaveBeenCalled();
+        (0, vitest_1.expect)(runtime.session.kill).not.toHaveBeenCalled();
+    });
+    (0, vitest_1.it)('restarts the runtime when adapter changes and ignores stale exit events', async () => {
+        const oldKill = vitest_1.vi.fn();
+        const oldEmit = vitest_1.vi.fn();
+        const newKill = vitest_1.vi.fn();
+        const newEmit = vitest_1.vi.fn();
+        let oldOnEvent;
+        getMessages.mockReturnValue([
+            {
+                type: 'message',
+                message: {
+                    id: 'assist-1',
+                    role: 'assistant',
+                    content: 'previous answer',
+                    createdAt: Date.now()
+                }
+            }
+        ]);
+        mocks.run.mockImplementationOnce(async (_options, adapterOptions) => {
+            (0, vitest_1.expect)(adapterOptions.type).toBe('resume');
+            oldOnEvent = adapterOptions.onEvent;
+            return {
+                session: {
+                    kill: oldKill,
+                    emit: oldEmit
+                }
+            };
+        });
+        const initialRuntime = await (0, index_js_2.startAdapterSession)('sess-1', {
+            model: 'gpt-4o',
+            adapter: 'codex',
+            permissionMode: 'default'
+        });
+        (0, vitest_1.expect)(initialRuntime.config?.adapter).toBe('codex');
+        mocks.run.mockImplementationOnce(async (_options, adapterOptions) => {
+            (0, vitest_1.expect)(adapterOptions.type).toBe('create');
+            return {
+                session: {
+                    kill: newKill,
+                    emit: newEmit
+                }
+            };
+        });
+        const restartedRuntime = await (0, index_js_2.startAdapterSession)('sess-1', {
+            model: 'gpt-4o',
+            adapter: 'claude-code',
+            permissionMode: 'default'
+        });
+        (0, vitest_1.expect)(oldKill).toHaveBeenCalledOnce();
+        (0, vitest_1.expect)(restartedRuntime).not.toBe(initialRuntime);
+        (0, vitest_1.expect)(restartedRuntime.config?.adapter).toBe('claude-code');
+        (0, vitest_1.expect)(currentSession.adapter).toBe('claude-code');
+        oldOnEvent?.({
+            type: 'exit',
+            data: {
+                exitCode: 1,
+                stderr: 'old runtime exit'
+            }
+        });
+        (0, vitest_1.expect)(currentSession.status).toBe('completed');
+        (0, vitest_1.expect)(runtime_js_1.adapterSessionStore.get('sess-1')).toBe(restartedRuntime);
+        (0, vitest_1.expect)(vitest_1.vi.mocked(runtime_js_1.notifySessionUpdated)).toHaveBeenCalledWith('sess-1', vitest_1.expect.objectContaining({
+            adapter: 'claude-code'
+        }));
+        (0, vitest_1.expect)(newKill).not.toHaveBeenCalled();
+    });
+    (0, vitest_1.it)('marks the session as failed when adapter startup throws', async () => {
+        mocks.run.mockRejectedValueOnce(new Error('adapter init failed'));
+        await (0, vitest_1.expect)((0, index_js_2.startAdapterSession)('sess-1', {
+            model: 'gpt-4o',
+            adapter: 'codex',
+            permissionMode: 'default'
+        })).rejects.toThrow('adapter init failed');
+        (0, vitest_1.expect)(currentSession.status).toBe('failed');
+        (0, vitest_1.expect)(vitest_1.vi.mocked(runtime_js_1.notifySessionUpdated)).toHaveBeenCalledWith('sess-1', vitest_1.expect.objectContaining({
+            status: 'failed'
+        }));
+    });
+    (0, vitest_1.it)('replaces the generated system prompt when appendSystemPrompt is false', async () => {
+        mocks.generateAdapterQueryOptions.mockResolvedValueOnce([
+            {},
+            {
+                systemPrompt: 'generated prompt',
+                tools: undefined,
+                mcpServers: undefined
+            }
+        ]);
+        mocks.run.mockResolvedValueOnce({
+            session: {
+                emit: vitest_1.vi.fn(),
+                kill: vitest_1.vi.fn()
+            }
+        });
+        await (0, index_js_2.startAdapterSession)('sess-1', {
+            systemPrompt: 'custom prompt',
+            appendSystemPrompt: false
+        });
+        (0, vitest_1.expect)(mocks.run).toHaveBeenCalledOnce();
+        (0, vitest_1.expect)(mocks.run.mock.calls[0]?.[1]).toEqual(vitest_1.expect.objectContaining({
+            systemPrompt: 'custom prompt',
+            appendSystemPrompt: false
+        }));
+    });
+    (0, vitest_1.it)('keeps the session failed when a fatal error is followed by stop', async () => {
+        mocks.run.mockImplementationOnce(async (_options, adapterOptions) => {
+            adapterOptions.onEvent({
+                type: 'error',
+                data: {
+                    message: 'turn failed',
+                    fatal: true
+                }
+            });
+            adapterOptions.onEvent({
+                type: 'stop',
+                data: undefined
+            });
+            return {
+                session: {
+                    emit: vitest_1.vi.fn(),
+                    kill: vitest_1.vi.fn()
+                }
+            };
+        });
+        await (0, index_js_2.startAdapterSession)('sess-1', {
+            model: 'gpt-4o',
+            adapter: 'codex',
+            permissionMode: 'default'
+        });
+        (0, vitest_1.expect)(currentSession.status).toBe('failed');
+    });
+    (0, vitest_1.it)('restarts the adapter on demand when a follow-up user message arrives after completion', async () => {
+        const emit = vitest_1.vi.fn();
+        currentSession.status = 'completed';
+        getMessages.mockReturnValue([
+            {
+                type: 'message',
+                message: {
+                    id: 'assist-1',
+                    role: 'assistant',
+                    content: 'previous answer',
+                    createdAt: Date.now()
+                }
+            }
+        ]);
+        mocks.run.mockResolvedValueOnce({
+            session: {
+                emit,
+                kill: vitest_1.vi.fn()
+            }
+        });
+        await (0, index_js_2.processUserMessage)('sess-1', 'follow up');
+        (0, vitest_1.expect)(mocks.run).toHaveBeenCalledOnce();
+        (0, vitest_1.expect)(mocks.run.mock.calls[0]?.[1]).toEqual(vitest_1.expect.objectContaining({
+            type: 'resume',
+            sessionId: 'sess-1'
+        }));
+        (0, vitest_1.expect)(emit).toHaveBeenCalledWith({
+            type: 'message',
+            content: [{ type: 'text', text: 'follow up' }],
+            parentUuid: 'assist-1'
+        });
+        (0, vitest_1.expect)(currentSession.status).toBe('running');
+        (0, vitest_1.expect)(saveMessage).toHaveBeenCalledWith('sess-1', vitest_1.expect.objectContaining({
+            type: 'message',
+            message: vitest_1.expect.objectContaining({
+                role: 'user',
+                content: 'follow up'
+            })
+        }));
+    });
+    (0, vitest_1.it)('promotes passive session sockets when a follow-up user message restarts the adapter', async () => {
+        const emit = vitest_1.vi.fn();
+        const passiveSocket = {
+            readyState: 1,
+            send: vitest_1.vi.fn()
+        };
+        currentSession.status = 'completed';
+        getMessages.mockReturnValue([
+            {
+                type: 'message',
+                message: {
+                    id: 'assist-1',
+                    role: 'assistant',
+                    content: 'previous answer',
+                    createdAt: Date.now()
+                }
+            }
+        ]);
+        runtime_js_1.externalSessionStore.set('sess-1', {
+            sockets: new Set([passiveSocket]),
+            messages: []
+        });
+        mocks.run.mockResolvedValueOnce({
+            session: {
+                emit,
+                kill: vitest_1.vi.fn()
+            }
+        });
+        await (0, index_js_2.processUserMessage)('sess-1', 'follow up');
+        (0, vitest_1.expect)(runtime_js_1.externalSessionStore.has('sess-1')).toBe(false);
+        (0, vitest_1.expect)(runtime_js_1.adapterSessionStore.get('sess-1')?.sockets.has(passiveSocket)).toBe(true);
+        (0, vitest_1.expect)(passiveSocket.send).toHaveBeenCalledWith(vitest_1.expect.stringContaining('"type":"message"'));
+        (0, vitest_1.expect)(emit).toHaveBeenCalledWith({
+            type: 'message',
+            content: [{ type: 'text', text: 'follow up' }],
+            parentUuid: 'assist-1'
+        });
+    });
+});

package/dist/apps/server/__tests__/services/session.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/apps/server/__tests__/services/session.spec.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const index_js_1 = require("#~/db/index.js");
+const index_js_2 = require("#~/services/session/index.js");
+const notification_js_1 = require("#~/services/session/notification.js");
+const runtime_js_1 = require("#~/services/session/runtime.js");
+vitest_1.vi.mock('#~/db/index.js', () => ({
+    getDb: vitest_1.vi.fn()
+}));
+vitest_1.vi.mock('#~/channels/index.js', () => ({
+    handleChannelSessionEvent: vitest_1.vi.fn()
+}));
+vitest_1.vi.mock('#~/services/session/runtime.js', async () => {
+    const actual = await vitest_1.vi.importActual('#~/services/session/runtime.js');
+    return {
+        ...actual,
+        notifySessionUpdated: vitest_1.vi.fn()
+    };
+});
+vitest_1.vi.mock('#~/services/session/notification.js', () => ({
+    maybeNotifySession: vitest_1.vi.fn().mockResolvedValue(undefined)
+}));
+vitest_1.vi.mock('#~/utils/logger.js', () => ({
+    getSessionLogger: vitest_1.vi.fn(() => ({
+        info: vitest_1.vi.fn(),
+        warn: vitest_1.vi.fn(),
+        error: vitest_1.vi.fn()
+    }))
+}));
+(0, vitest_1.describe)('session service', () => {
+    const saveMessage = vitest_1.vi.fn();
+    const getMessages = vitest_1.vi.fn();
+    const updateSession = vitest_1.vi.fn();
+    let currentSession;
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.clearAllMocks();
+        runtime_js_1.adapterSessionStore.clear();
+        runtime_js_1.externalSessionStore.clear();
+        currentSession = {
+            id: 'sess-1',
+            title: 'New Session',
+            status: 'idle',
+            createdAt: Date.now(),
+            messageCount: 0
+        };
+        updateSession.mockImplementation((_id, updates) => {
+            currentSession = { ...currentSession, ...updates };
+        });
+        vitest_1.vi.mocked(index_js_1.getDb).mockReturnValue({
+            saveMessage,
+            getMessages,
+            getSession: vitest_1.vi.fn(() => currentSession),
+            updateSession
+        });
+    });
+    (0, vitest_1.it)('processes user messages through the active adapter session cache', async () => {
+        const socket = { readyState: 1, send: vitest_1.vi.fn() };
+        const emit = vitest_1.vi.fn();
+        const messageHistory = [
+            {
+                type: 'message',
+                message: {
+                    id: 'assistant-1',
+                    role: 'assistant',
+                    content: 'previous',
+                    createdAt: 1
+                }
+            }
+        ];
+        getMessages.mockReturnValue(messageHistory);
+        runtime_js_1.adapterSessionStore.set('sess-1', {
+            session: {
+                emit,
+                kill: vitest_1.vi.fn()
+            },
+            sockets: new Set([socket]),
+            messages: messageHistory
+        });
+        await (0, index_js_2.processUserMessage)('sess-1', 'hello world');
+        (0, vitest_1.expect)(saveMessage).toHaveBeenCalledOnce();
+        (0, vitest_1.expect)(saveMessage).toHaveBeenCalledWith('sess-1', vitest_1.expect.objectContaining({
+            type: 'message',
+            message: vitest_1.expect.objectContaining({
+                role: 'user',
+                content: 'hello world'
+            })
+        }));
+        (0, vitest_1.expect)(updateSession).toHaveBeenCalledWith('sess-1', vitest_1.expect.objectContaining({
+            title: 'hello world',
+            lastMessage: 'hello world',
+            lastUserMessage: 'hello world',
+            status: 'running'
+        }));
+        (0, vitest_1.expect)(vitest_1.vi.mocked(runtime_js_1.notifySessionUpdated)).toHaveBeenCalledWith('sess-1', vitest_1.expect.objectContaining({
+            status: 'running',
+            title: 'hello world'
+        }));
+        (0, vitest_1.expect)(vitest_1.vi.mocked(notification_js_1.maybeNotifySession)).toHaveBeenCalledWith('idle', 'running', vitest_1.expect.objectContaining({ status: 'running' }));
+        (0, vitest_1.expect)(socket.send).toHaveBeenCalledOnce();
+        (0, vitest_1.expect)(String(vitest_1.vi.mocked(socket.send).mock.calls[0][0])).toContain('"type":"message"');
+        (0, vitest_1.expect)(emit).toHaveBeenCalledWith({
+            type: 'message',
+            content: [{ type: 'text', text: 'hello world' }],
+            parentUuid: 'assistant-1'
+        });
+    });
+    (0, vitest_1.it)('kills active sessions and updates the persisted status', () => {
+        const kill = vitest_1.vi.fn();
+        runtime_js_1.adapterSessionStore.set('sess-1', {
+            session: {
+                emit: vitest_1.vi.fn(),
+                kill
+            },
+            sockets: new Set(),
+            messages: []
+        });
+        (0, index_js_2.killSession)('sess-1');
+        (0, vitest_1.expect)(kill).toHaveBeenCalledOnce();
+        (0, vitest_1.expect)(runtime_js_1.adapterSessionStore.has('sess-1')).toBe(false);
+        (0, vitest_1.expect)(updateSession).toHaveBeenCalledWith('sess-1', { status: 'terminated' });
+        (0, vitest_1.expect)(vitest_1.vi.mocked(runtime_js_1.notifySessionUpdated)).toHaveBeenCalledWith('sess-1', vitest_1.expect.objectContaining({
+            status: 'terminated'
+        }));
+    });
+});

package/dist/apps/server/__tests__/utils/compose.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/apps/server/__tests__/utils/compose.spec.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const compose_js_1 = require("#~/utils/compose.js");
+(0, vitest_1.describe)('compose', () => {
+    (0, vitest_1.it)('calls a single middleware', async () => {
+        const ctx = { value: 0 };
+        const mw = vitest_1.vi.fn(async (_ctx, next) => {
+            _ctx.value = 1;
+            await next();
+        });
+        await (0, compose_js_1.compose)(mw)(ctx);
+        (0, vitest_1.expect)(mw).toHaveBeenCalledOnce();
+        (0, vitest_1.expect)(ctx.value).toBe(1);
+    });
+    (0, vitest_1.it)('calls middlewares in order', async () => {
+        const order = [];
+        const ctx = {};
+        const mw1 = async (_ctx, next) => {
+            order.push(1);
+            await next();
+            order.push(4);
+        };
+        const mw2 = async (_ctx, next) => {
+            order.push(2);
+            await next();
+            order.push(3);
+        };
+        await (0, compose_js_1.compose)(mw1, mw2)(ctx);
+        (0, vitest_1.expect)(order).toEqual([1, 2, 3, 4]);
+    });
+    (0, vitest_1.it)('passes the same ctx object through the chain', async () => {
+        const ctx = { steps: [] };
+        const mw1 = async (_ctx, next) => {
+            _ctx.steps.push('a');
+            await next();
+        };
+        const mw2 = async (_ctx, next) => {
+            _ctx.steps.push('b');
+            await next();
+        };
+        await (0, compose_js_1.compose)(mw1, mw2)(ctx);
+        (0, vitest_1.expect)(ctx.steps).toEqual(['a', 'b']);
+    });
+    (0, vitest_1.it)('stops the chain when next() is not called', async () => {
+        const ctx = { reached: false };
+        const mw1 = async (_ctx, _next) => {
+            // deliberately does not call next
+        };
+        const mw2 = async (_ctx, next) => {
+            _ctx.reached = true;
+            await next();
+        };
+        await (0, compose_js_1.compose)(mw1, mw2)(ctx);
+        (0, vitest_1.expect)(ctx.reached).toBe(false);
+    });
+    (0, vitest_1.it)('handles an empty middleware list', async () => {
+        const ctx = {};
+        await (0, vitest_1.expect)((0, compose_js_1.compose)()(ctx)).resolves.toBeUndefined();
+    });
+    (0, vitest_1.it)('propagates errors thrown in middleware', async () => {
+        const ctx = {};
+        const boom = new Error('boom');
+        const mw = async (_ctx, _next) => {
+            throw boom;
+        };
+        await (0, vitest_1.expect)((0, compose_js_1.compose)(mw)(ctx)).rejects.toThrow('boom');
+    });
+    (0, vitest_1.it)('propagates errors thrown in downstream middleware', async () => {
+        const ctx = {};
+        const boom = new Error('downstream');
+        const mw1 = async (_ctx, next) => {
+            await next();
+        };
+        const mw2 = async (_ctx, _next) => {
+            throw boom;
+        };
+        await (0, vitest_1.expect)((0, compose_js_1.compose)(mw1, mw2)(ctx)).rejects.toThrow('downstream');
+    });
+    (0, vitest_1.it)('supports async work before and after next()', async () => {
+        const ctx = { log: [] };
+        const delay = (ms) => new Promise((r) => setTimeout(r, ms));
+        const mw1 = async (_ctx, next) => {
+            await delay(1);
+            _ctx.log.push('before');
+            await next();
+            _ctx.log.push('after');
+        };
+        const mw2 = async (_ctx, next) => {
+            _ctx.log.push('inner');
+            await next();
+        };
+        await (0, compose_js_1.compose)(mw1, mw2)(ctx);
+        (0, vitest_1.expect)(ctx.log).toEqual(['before', 'inner', 'after']);
+    });
+});

package/dist/apps/server/__tests__/websocket/server.spec.d.ts

@@ -0,0 +1 @@
+export {};