@vibe-forge/tsconfigs 0.7.2 → 0.9.0

package/dist/packages/core/__tests__/hook-bridge.spec.js

@@ -0,0 +1,216 @@
+import { PassThrough } from 'node:stream';
+import { describe, expect, it, vi } from 'vitest';
+import { createAdapterHookBridge } from '#~/hooks/bridge.js';
+const { callHookMock } = vi.hoisted(() => ({
+    callHookMock: vi.fn()
+}));
+vi.mock('#~/hooks/call.js', () => ({
+    callHook: callHookMock
+}));
+const flushAsyncWork = async () => {
+    await Promise.resolve();
+    await Promise.resolve();
+    await new Promise(resolve => setTimeout(resolve, 0));
+};
+const createLogger = () => ({
+    stream: new PassThrough(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    debug: vi.fn()
+});
+describe('adapter hook bridge', () => {
+    it('fires session start and initial prompt hooks with bridge metadata', async () => {
+        const logger = createLogger();
+        callHookMock.mockResolvedValue({ continue: true });
+        const bridge = createAdapterHookBridge({
+            ctx: {
+                cwd: '/tmp/project',
+                env: {},
+                logger
+            },
+            adapter: 'codex',
+            runtime: 'server',
+            sessionId: 'session-1',
+            type: 'create',
+            model: 'gpt-5.4'
+        });
+        await bridge.start();
+        const prompt = await bridge.prepareInitialPrompt('Ship it');
+        expect(prompt).toBe('Ship it');
+        expect(callHookMock).toHaveBeenNthCalledWith(1, 'SessionStart', expect.objectContaining({
+            adapter: 'codex',
+            runtime: 'server',
+            hookSource: 'bridge',
+            canBlock: true,
+            source: 'startup',
+            model: 'gpt-5.4'
+        }), {});
+        expect(callHookMock).toHaveBeenNthCalledWith(2, 'UserPromptSubmit', expect.objectContaining({
+            adapter: 'codex',
+            runtime: 'server',
+            hookSource: 'bridge',
+            canBlock: true,
+            prompt: 'Ship it'
+        }), {});
+    });
+    it('drops outgoing messages when a prompt hook blocks them', async () => {
+        const logger = createLogger();
+        callHookMock.mockResolvedValue({ continue: false, stopReason: 'blocked by policy' });
+        const bridge = createAdapterHookBridge({
+            ctx: {
+                cwd: '/tmp/project',
+                env: {},
+                logger
+            },
+            adapter: 'claude-code',
+            runtime: 'cli',
+            sessionId: 'session-2',
+            type: 'create'
+        });
+        const session = {
+            kill: vi.fn(),
+            emit: vi.fn(),
+            pid: 123
+        };
+        const wrapped = bridge.wrapSession(session);
+        wrapped.emit({
+            type: 'message',
+            content: [{ type: 'text', text: 'blocked prompt' }]
+        });
+        await flushAsyncWork();
+        expect(session.emit).not.toHaveBeenCalled();
+        expect(logger.warn).toHaveBeenCalledWith('[HookBridge] Dropping outgoing message blocked by UserPromptSubmit hook', 'blocked by policy');
+    });
+    it('bridges tool lifecycle and stop/session end events from adapter output', async () => {
+        const logger = createLogger();
+        callHookMock.mockResolvedValue({ continue: true });
+        const bridge = createAdapterHookBridge({
+            ctx: {
+                cwd: '/tmp/project',
+                env: {},
+                logger
+            },
+            adapter: 'codex',
+            runtime: 'server',
+            sessionId: 'session-3',
+            type: 'resume'
+        });
+        const toolUseMessage = {
+            id: 'msg-tool-use',
+            role: 'assistant',
+            content: [{
+                    type: 'tool_use',
+                    id: 'tool-1',
+                    name: 'adapter:codex:Bash',
+                    input: { command: 'npm test' }
+                }],
+            createdAt: Date.now()
+        };
+        const toolResultMessage = {
+            id: 'msg-tool-result',
+            role: 'assistant',
+            content: [{
+                    type: 'tool_result',
+                    tool_use_id: 'tool-1',
+                    content: 'ok',
+                    is_error: false
+                }],
+            createdAt: Date.now()
+        };
+        const finalMessage = {
+            id: 'msg-final',
+            role: 'assistant',
+            content: 'All done',
+            createdAt: Date.now()
+        };
+        bridge.handleOutput({ type: 'message', data: toolUseMessage });
+        bridge.handleOutput({ type: 'message', data: toolResultMessage });
+        bridge.handleOutput({ type: 'message', data: finalMessage });
+        bridge.handleOutput({ type: 'stop', data: finalMessage });
+        bridge.handleOutput({ type: 'exit', data: { exitCode: 0 } });
+        await flushAsyncWork();
+        expect(callHookMock).toHaveBeenCalledWith('PreToolUse', expect.objectContaining({
+            adapter: 'codex',
+            hookSource: 'bridge',
+            canBlock: false,
+            toolCallId: 'tool-1',
+            toolName: 'adapter:codex:Bash',
+            toolInput: { command: 'npm test' }
+        }), {});
+        expect(callHookMock).toHaveBeenCalledWith('PostToolUse', expect.objectContaining({
+            adapter: 'codex',
+            hookSource: 'bridge',
+            canBlock: false,
+            toolCallId: 'tool-1',
+            toolName: 'adapter:codex:Bash',
+            toolInput: { command: 'npm test' },
+            toolResponse: 'ok',
+            isError: false
+        }), {});
+        expect(callHookMock).toHaveBeenCalledWith('Stop', expect.objectContaining({
+            adapter: 'codex',
+            hookSource: 'bridge',
+            canBlock: false,
+            lastAssistantMessage: 'All done'
+        }), {});
+        expect(callHookMock).toHaveBeenCalledWith('SessionEnd', expect.objectContaining({
+            adapter: 'codex',
+            hookSource: 'bridge',
+            canBlock: false,
+            reason: 'completed',
+            lastAssistantMessage: 'All done'
+        }), {});
+    });
+    it('skips bridge-native events when the adapter enables native hooks', async () => {
+        const logger = createLogger();
+        callHookMock.mockClear();
+        callHookMock.mockResolvedValue({ continue: true });
+        const bridge = createAdapterHookBridge({
+            ctx: {
+                cwd: '/tmp/project',
+                env: {},
+                logger
+            },
+            adapter: 'codex',
+            runtime: 'server',
+            sessionId: 'session-native',
+            type: 'create',
+            disabledEvents: ['SessionStart', 'UserPromptSubmit', 'PreToolUse', 'PostToolUse', 'Stop']
+        });
+        const prompt = await bridge.prepareInitialPrompt('native prompt');
+        await bridge.start();
+        bridge.handleOutput({
+            type: 'message',
+            data: {
+                id: 'msg-native-tool',
+                role: 'assistant',
+                content: [{
+                        type: 'tool_use',
+                        id: 'tool-1',
+                        name: 'Bash',
+                        input: { command: 'pwd' }
+                    }],
+                createdAt: Date.now()
+            }
+        });
+        bridge.handleOutput({
+            type: 'stop',
+            data: {
+                id: 'msg-native-stop',
+                role: 'assistant',
+                content: 'done',
+                createdAt: Date.now()
+            }
+        });
+        bridge.handleOutput({ type: 'exit', data: { exitCode: 0 } });
+        await flushAsyncWork();
+        expect(prompt).toBe('native prompt');
+        expect(callHookMock).toHaveBeenCalledTimes(1);
+        expect(callHookMock).toHaveBeenCalledWith('SessionEnd', expect.objectContaining({
+            adapter: 'codex',
+            hookSource: 'bridge',
+            reason: 'completed'
+        }), {});
+    });
+});

package/dist/packages/core/__tests__/hook-runtime.spec.d.ts

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

package/dist/packages/core/__tests__/hook-runtime.spec.js

@@ -0,0 +1,119 @@
+import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import fg from 'fast-glob';
+import { afterEach, describe, expect, it } from 'vitest';
+import { callHook } from '#~/hooks/call.js';
+const tempDirs = [];
+afterEach(async () => {
+    await Promise.all(tempDirs.splice(0).map(dir => rm(dir, { recursive: true, force: true })));
+});
+describe('hook runtime', () => {
+    it('executes hooks locally without requiring the server route', async () => {
+        const workspace = await mkdtemp(join(tmpdir(), 'vf-hook-'));
+        tempDirs.push(workspace);
+        await writeFile(join(workspace, '.ai.config.json'), JSON.stringify({
+            plugins: {
+                logger: {}
+            }
+        }));
+        const result = await callHook('TaskStart', {
+            cwd: workspace,
+            sessionId: 'session-1',
+            adapter: 'codex',
+            options: { cwd: workspace },
+            adapterOptions: { sessionId: 'session-1', runtime: 'cli', type: 'create' }
+        }, {
+            ...process.env,
+            __VF_PROJECT_AI_CTX_ID__: 'ctx-local-hook',
+            __VF_PROJECT_AI_SERVER_HOST__: '127.0.0.1',
+            __VF_PROJECT_AI_SERVER_PORT__: '1'
+        });
+        expect(result).toEqual({ continue: true });
+        const logFiles = await fg('.ai/logs/ctx-local-hook/**/*.log.md', {
+            cwd: workspace,
+            absolute: true
+        });
+        expect(logFiles).toHaveLength(1);
+        const logContent = await readFile(logFiles[0], 'utf-8');
+        expect(logContent).toContain('[TaskStart]');
+        expect(logContent).toContain('[plugin.logger]');
+    });
+    it('skips disabled hook plugins via enabledPlugins', async () => {
+        const workspace = await mkdtemp(join(tmpdir(), 'vf-hook-disabled-'));
+        tempDirs.push(workspace);
+        await writeFile(join(workspace, '.ai.config.json'), JSON.stringify({
+            plugins: {
+                logger: {}
+            },
+            enabledPlugins: {
+                logger: false
+            }
+        }));
+        const result = await callHook('TaskStart', {
+            cwd: workspace,
+            sessionId: 'session-2',
+            adapter: 'codex',
+            options: { cwd: workspace },
+            adapterOptions: { sessionId: 'session-2', runtime: 'cli', type: 'create' }
+        }, {
+            ...process.env,
+            __VF_PROJECT_AI_CTX_ID__: 'ctx-disabled-hook',
+            __VF_PROJECT_AI_SERVER_HOST__: '127.0.0.1',
+            __VF_PROJECT_AI_SERVER_PORT__: '1'
+        });
+        expect(result).toEqual({ continue: true });
+        const logFiles = await fg('.ai/logs/ctx-disabled-hook/**/*.log.md', {
+            cwd: workspace,
+            absolute: true
+        });
+        expect(logFiles).toHaveLength(1);
+        const logContent = await readFile(logFiles[0], 'utf-8');
+        expect(logContent).not.toContain('[plugin.logger]');
+    });
+    it('redacts secrets from logger hook output', async () => {
+        const workspace = await mkdtemp(join(tmpdir(), 'vf-hook-redact-'));
+        tempDirs.push(workspace);
+        await writeFile(join(workspace, '.ai.config.json'), JSON.stringify({
+            plugins: {
+                logger: {}
+            }
+        }));
+        const secretApiKey = 'sk-live-redaction-test';
+        const secretToken = 'bearer-super-secret';
+        const result = await callHook('TaskStart', {
+            cwd: workspace,
+            sessionId: 'session-redact',
+            adapter: 'codex',
+            options: {
+                env: {
+                    OPENAI_API_KEY: secretApiKey,
+                    SAFE_VALUE: 'visible'
+                }
+            },
+            adapterOptions: {
+                token: secretToken,
+                nested: {
+                    authorization: 'Bearer nested-secret'
+                }
+            }
+        }, {
+            ...process.env,
+            __VF_PROJECT_AI_CTX_ID__: 'ctx-redact-hook',
+            __VF_PROJECT_AI_SERVER_HOST__: '127.0.0.1',
+            __VF_PROJECT_AI_SERVER_PORT__: '1'
+        });
+        expect(result).toEqual({ continue: true });
+        const logFiles = await fg('.ai/logs/ctx-redact-hook/**/*.log.md', {
+            cwd: workspace,
+            absolute: true
+        });
+        expect(logFiles).toHaveLength(1);
+        const logContent = await readFile(logFiles[0], 'utf-8');
+        expect(logContent).toContain('[REDACTED]');
+        expect(logContent).toContain('OPENAI_API_KEY');
+        expect(logContent).not.toContain(secretApiKey);
+        expect(logContent).not.toContain(secretToken);
+        expect(logContent).not.toContain('nested-secret');
+    });
+});

package/dist/packages/core/__tests__/model-selection.spec.d.ts

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

package/dist/packages/core/__tests__/model-selection.spec.js

@@ -0,0 +1,153 @@
+import { describe, expect, it } from 'vitest';
+import { doesModelMatchSelector, evaluateAdapterModelRules, listServiceModels, resolveAdapterConfiguredDefaultModel, resolveAdapterModelCompatibility, resolveDefaultModelSelection, resolveModelDefaultAdapter, resolveModelMetadata, resolveModelSelection } from '#~/utils/model-selection.js';
+const modelServices = {
+    serviceA: {
+        apiBaseUrl: 'https://service-a.example.com',
+        apiKey: 'token-a',
+        models: ['modelX', 'modelAOnly']
+    },
+    serviceB: {
+        apiBaseUrl: 'https://service-b.example.com',
+        apiKey: 'token-b',
+        models: ['modelX', 'modelBOnly']
+    }
+};
+describe('model selection utilities', () => {
+    it('resolves exact selector metadata before service-level metadata', () => {
+        const models = {
+            serviceA: { defaultAdapter: 'claude-code' },
+            'serviceA,modelX': { defaultAdapter: 'codex' }
+        };
+        expect(resolveModelDefaultAdapter({
+            model: 'serviceA,modelX',
+            models
+        })).toBe('codex');
+        expect(resolveModelMetadata({
+            model: 'serviceA,modelAOnly',
+            models
+        })).toEqual({ defaultAdapter: 'claude-code' });
+    });
+    it('ignores invalid selector keys and falls back to service entries', () => {
+        const models = {
+            modelX: { defaultAdapter: 'codex' },
+            serviceB: { defaultAdapter: 'claude-code' }
+        };
+        expect(resolveModelDefaultAdapter({
+            model: 'serviceB,modelX',
+            models
+        })).toBe('claude-code');
+    });
+    it('resolves raw models through the preferred default service', () => {
+        const serviceModels = listServiceModels(modelServices);
+        expect(resolveModelSelection({
+            value: 'modelX',
+            serviceModels,
+            preferredServiceKey: 'serviceB',
+            preserveUnknown: false
+        })).toBe('serviceB,modelX');
+    });
+    it('falls back to default service first model when no explicit model is configured', () => {
+        const serviceModels = listServiceModels(modelServices);
+        expect(resolveDefaultModelSelection({
+            defaultModelService: 'serviceB',
+            serviceModels,
+            preserveUnknownDefaultModel: false
+        })).toBe('serviceB,modelX');
+    });
+    it('matches service selectors and exact selectors for routed models', () => {
+        expect(doesModelMatchSelector({
+            model: 'serviceA,modelX',
+            selector: 'serviceA'
+        })).toBe(true);
+        expect(doesModelMatchSelector({
+            model: 'serviceA,modelX',
+            selector: 'serviceA,modelX'
+        })).toBe(true);
+        expect(doesModelMatchSelector({
+            model: 'serviceA,modelX',
+            selector: 'serviceB'
+        })).toBe(false);
+    });
+    it('prefers adapter defaultModel before global defaults', () => {
+        const serviceModels = listServiceModels(modelServices);
+        expect(resolveAdapterConfiguredDefaultModel({
+            adapterConfig: {
+                defaultModel: 'serviceB,modelBOnly'
+            },
+            serviceModels,
+            preferredServiceKey: 'serviceA',
+            preserveUnknown: false
+        })).toBe('serviceB,modelBOnly');
+    });
+    it('treats service selectors as valid includeModels rules', () => {
+        expect(evaluateAdapterModelRules({
+            model: 'serviceA,modelX',
+            adapterConfig: {
+                includeModels: ['serviceA']
+            }
+        })).toMatchObject({
+            allowed: true
+        });
+        expect(evaluateAdapterModelRules({
+            model: 'serviceB,modelX',
+            adapterConfig: {
+                includeModels: ['serviceA']
+            }
+        })).toMatchObject({
+            allowed: false,
+            reason: 'not_included'
+        });
+    });
+    it('does not let includeModels reject the literal default model', () => {
+        expect(evaluateAdapterModelRules({
+            model: 'default',
+            adapterConfig: {
+                includeModels: ['serviceA']
+            }
+        })).toMatchObject({
+            allowed: true
+        });
+    });
+    it('falls back to adapter defaultModel when the selected model is excluded', () => {
+        const serviceModels = listServiceModels(modelServices);
+        expect(resolveAdapterModelCompatibility({
+            adapter: 'codex',
+            model: 'serviceA,modelX',
+            adapterConfig: {
+                defaultModel: 'serviceB,modelBOnly',
+                excludeModels: ['serviceA,modelX']
+            },
+            serviceModels,
+            preferredServiceKey: 'serviceA',
+            preserveUnknownDefaultModel: false
+        })).toMatchObject({
+            model: 'serviceB,modelBOnly',
+            warning: {
+                adapter: 'codex',
+                requestedModel: 'serviceA,modelX',
+                resolvedModel: 'serviceB,modelBOnly',
+                reason: 'excluded'
+            }
+        });
+    });
+    it('returns an error when adapter rules reject the model and no defaultModel exists', () => {
+        const serviceModels = listServiceModels(modelServices);
+        expect(resolveAdapterModelCompatibility({
+            adapter: 'codex',
+            model: 'serviceB,modelX',
+            adapterConfig: {
+                includeModels: ['serviceA']
+            },
+            serviceModels,
+            preferredServiceKey: 'serviceA',
+            preserveUnknownDefaultModel: false
+        })).toMatchObject({
+            error: {
+                type: 'missing_default_model',
+                adapter: 'codex',
+                requestedModel: 'serviceB,modelX',
+                reason: 'not_included'
+            }
+        });
+    });
+});

package/dist/packages/core/__tests__/run.spec.d.ts

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