@vibe-forge/tsconfigs 0.7.2 → 0.9.0

package/dist/packages/adapter/src/type.d.ts

@@ -0,0 +1,114 @@
+import type { AdapterAssetPlan, AdapterModelFallbackWarning, AssetDiagnostic, Cache, ChatMessage, ChatMessageContent, Config, TaskRuntime, WorkspaceAssetBundle } from '@vibe-forge/types';
+import type { Logger } from '@vibe-forge/utils/create-logger';
+export type { AssetDiagnostic } from '@vibe-forge/types';
+export type AdapterMessageContent = ChatMessageContent;
+export interface AdapterErrorData {
+    message: string;
+    code?: string;
+    details?: unknown;
+    fatal?: boolean;
+}
+export type AdapterOutputEvent = {
+    type: 'init';
+    data: SessionInitInfo;
+} | {
+    type: 'summary';
+    data: SessionSummaryInfo;
+} | {
+    type: 'message';
+    data: ChatMessage;
+} | {
+    type: 'error';
+    data: AdapterErrorData;
+} | {
+    type: 'exit';
+    data: {
+        exitCode?: number;
+        stderr?: string;
+    };
+} | {
+    type: 'stop';
+    data?: ChatMessage;
+};
+export type SessionInfo = ({
+    type: 'init';
+} & SessionInitInfo) | ({
+    type: 'summary';
+} & SessionSummaryInfo);
+export interface SessionInitInfo {
+    uuid: string;
+    model: string;
+    adapter?: string;
+    version: string;
+    tools: string[];
+    slashCommands: string[];
+    cwd: string;
+    agents: string[];
+    title?: string;
+    selectionWarnings?: AdapterModelFallbackWarning[];
+    assetDiagnostics?: AssetDiagnostic[];
+}
+export interface SessionSummaryInfo {
+    summary: string;
+    leafUuid: string;
+}
+export type AdapterEvent = {
+    type: 'message';
+    content: AdapterMessageContent[];
+    parentUuid?: string;
+} | {
+    type: 'interrupt';
+} | {
+    type: 'stop';
+};
+export interface AdapterCtx {
+    ctxId: string;
+    cwd: string;
+    env: Record<string, string | null | undefined>;
+    cache: {
+        set: <K extends keyof Cache>(key: K, value: Cache[K]) => Promise<{
+            cachePath: string;
+        }>;
+        get: <K extends keyof Cache>(key: K) => Promise<Cache[K] | undefined>;
+    };
+    logger: Logger;
+    configs: [Config?, Config?];
+    assets?: WorkspaceAssetBundle;
+}
+export interface AdapterQueryOptions {
+    description?: string;
+    type: 'create' | 'resume';
+    runtime: TaskRuntime;
+    sessionId: string;
+    model?: string;
+    mode?: 'stream' | 'direct';
+    systemPrompt?: string;
+    appendSystemPrompt?: boolean;
+    permissionMode?: 'default' | 'acceptEdits' | 'plan' | 'dontAsk' | 'bypassPermissions';
+    mcpServers?: {
+        include?: string[];
+        exclude?: string[];
+    };
+    useDefaultVibeForgeMcpServer?: boolean;
+    tools?: {
+        include?: string[];
+        exclude?: string[];
+    };
+    skills?: {
+        include?: string[];
+        exclude?: string[];
+    };
+    extraOptions?: string[];
+    promptAssetIds?: string[];
+    assetPlan?: AdapterAssetPlan;
+    onEvent: (event: AdapterOutputEvent) => void;
+}
+export interface AdapterSession {
+    kill: () => void;
+    emit: (event: AdapterEvent) => void;
+    pid?: number;
+}
+export interface Adapter {
+    init?: (ctx: AdapterCtx) => Promise<void>;
+    query: (ctx: AdapterCtx, options: AdapterQueryOptions) => Promise<AdapterSession>;
+}

package/dist/packages/adapter/src/type.js

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

package/dist/packages/adapters/claude-code/__tests__/default-config.spec.d.ts

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

package/dist/packages/adapters/claude-code/__tests__/default-config.spec.js

@@ -0,0 +1,160 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { generateDefaultCCRConfigJSON } from '../src/ccr/default-config';
+describe('generateDefaultCCRConfigJSON', () => {
+    const baseUserConfig = {
+        defaultModelService: 'gpt-responses',
+        defaultModel: 'gpt-5.2-codex-2026-01-14',
+        modelServices: {
+            'gpt-responses': {
+                apiBaseUrl: 'http://aidp.bytedance.net/api/modelhub/online/responses',
+                apiKey: 'test-key',
+                models: ['gpt-5.2-codex-2026-01-14']
+            }
+        }
+    };
+    afterEach(() => {
+        vi.unstubAllEnvs();
+    });
+    it('appends configured query params to CCR provider URLs', () => {
+        const raw = generateDefaultCCRConfigJSON({
+            cwd: '/tmp/project',
+            userConfig: {
+                defaultModelService: 'gpt-responses',
+                defaultModel: 'gpt-5.2-codex-2026-01-14',
+                modelServices: {
+                    'gpt-responses': {
+                        apiBaseUrl: 'http://aidp.bytedance.net/api/modelhub/online/responses',
+                        apiKey: 'test-key',
+                        models: ['gpt-5.2-codex-2026-01-14'],
+                        extra: {
+                            codex: {
+                                queryParams: {
+                                    ak: 'test-key'
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        });
+        const config = JSON.parse(raw);
+        expect(config.Providers).toMatchObject([
+            {
+                name: 'gpt-responses',
+                api_base_url: 'http://aidp.bytedance.net/api/modelhub/online/responses?ak=test-key'
+            }
+        ]);
+        expect(config.Router.default).toBe('gpt-responses,gpt-5.2-codex-2026-01-14');
+    });
+    it('keeps provider URLs unchanged when no query params are configured', () => {
+        const raw = generateDefaultCCRConfigJSON({
+            cwd: '/tmp/project',
+            userConfig: {
+                defaultModelService: 'gpt',
+                defaultModel: 'gpt-5.4-2026-03-05',
+                modelServices: {
+                    gpt: {
+                        apiBaseUrl: 'https://search.bytedance.net/gpt/openapi/online/v2/crawl',
+                        apiKey: 'test-key',
+                        models: ['gpt-5.4-2026-03-05']
+                    }
+                }
+            }
+        });
+        const config = JSON.parse(raw);
+        expect(config.Providers).toMatchObject([
+            {
+                name: 'gpt',
+                api_base_url: 'https://search.bytedance.net/gpt/openapi/online/v2/crawl'
+            }
+        ]);
+    });
+    it('maps model service timeout to CCR API_TIMEOUT_MS and prefers the default service when values differ', () => {
+        const raw = generateDefaultCCRConfigJSON({
+            cwd: '/tmp/project',
+            userConfig: {
+                defaultModelService: 'fast',
+                defaultModel: 'gpt-5.4-mini',
+                modelServices: {
+                    fast: {
+                        apiBaseUrl: 'https://example.test/fast/chat/completions',
+                        apiKey: 'fast-key',
+                        models: ['gpt-5.4-mini'],
+                        timeoutMs: 120000
+                    },
+                    slow: {
+                        apiBaseUrl: 'https://example.test/slow/chat/completions',
+                        apiKey: 'slow-key',
+                        models: ['gpt-5.4'],
+                        timeoutMs: 600000
+                    }
+                }
+            }
+        });
+        const config = JSON.parse(raw);
+        expect(config.API_TIMEOUT_MS).toBe(120000);
+    });
+    it('preserves explicit CCR router network options', () => {
+        const raw = generateDefaultCCRConfigJSON({
+            cwd: '/tmp/project',
+            userConfig: baseUserConfig,
+            adapterOptions: {
+                ccrOptions: {
+                    PORT: '4123',
+                    APIKEY: 'router-key'
+                }
+            }
+        });
+        const config = JSON.parse(raw);
+        expect(config.PORT).toBe('4123');
+        expect(config.APIKEY).toBe('router-key');
+    });
+    it('adds a maxtoken transformer for model service maxOutputTokens without clobbering existing transformers', () => {
+        const raw = generateDefaultCCRConfigJSON({
+            cwd: '/tmp/project',
+            userConfig: {
+                defaultModelService: 'gateway',
+                defaultModel: 'gpt-5.4',
+                modelServices: {
+                    gateway: {
+                        apiBaseUrl: 'https://example.test/chat/completions',
+                        apiKey: 'gateway-key',
+                        models: ['gpt-5.4'],
+                        maxOutputTokens: 8192,
+                        extra: {
+                            claudeCodeRouterTransformer: {
+                                use: ['openrouter']
+                            }
+                        }
+                    }
+                }
+            }
+        });
+        const config = JSON.parse(raw);
+        expect(config.Providers[0]?.transformer?.use).toEqual([
+            'openrouter',
+            ['maxtoken', { max_tokens: 8192 }]
+        ]);
+    });
+    it('injects logger transformer by default', () => {
+        const raw = generateDefaultCCRConfigJSON({
+            cwd: '/tmp/project',
+            userConfig: baseUserConfig
+        });
+        const config = JSON.parse(raw);
+        expect(config.transformers.some(item => item.path.endsWith('logger.js'))).toBe(true);
+    });
+    it('allows disabling logger transformer explicitly', () => {
+        const raw = generateDefaultCCRConfigJSON({
+            cwd: '/tmp/project',
+            userConfig: baseUserConfig,
+            adapterOptions: {
+                ccrTransformers: {
+                    logger: false
+                }
+            }
+        });
+        const config = JSON.parse(raw);
+        expect(config.transformers.some(item => item.path.endsWith('logger.js'))).toBe(false);
+    });
+});

package/dist/packages/adapters/claude-code/__tests__/hook-bridge.spec.d.ts

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

package/dist/packages/adapters/claude-code/__tests__/hook-bridge.spec.js

@@ -0,0 +1,31 @@
+import { describe, expect, it } from 'vitest';
+import { mapClaudeHookInputToVibeForge } from '../src/hook-bridge';
+describe('claude native hook bridge helpers', () => {
+    it('maps supported Claude native hooks into the unified hook shape', () => {
+        const result = mapClaudeHookInputToVibeForge({
+            cwd: '/tmp/project',
+            sessionId: 'session-1',
+            hookEventName: 'PreToolUse',
+            toolName: 'Read',
+            toolInput: {
+                filePath: 'README.md'
+            }
+        });
+        expect(result).toMatchObject({
+            adapter: 'claude-code',
+            hookSource: 'native',
+            canBlock: true,
+            hookEventName: 'PreToolUse',
+            toolName: 'Read'
+        });
+    });
+    it('skips Claude events that Vibe Forge keeps on the framework bridge', () => {
+        const result = mapClaudeHookInputToVibeForge({
+            cwd: '/tmp/project',
+            sessionId: 'session-1',
+            hookEventName: 'SessionEnd',
+            reason: 'completed'
+        });
+        expect(result).toBeUndefined();
+    });
+});

package/dist/packages/adapters/claude-code/__tests__/incoming.spec.d.ts

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

package/dist/packages/adapters/claude-code/__tests__/incoming.spec.js

@@ -0,0 +1,93 @@
+import { describe, expect, it } from 'vitest';
+import { handleIncomingEvent } from '../src/protocol/incoming';
+describe('claude-code incoming error handling', () => {
+    it('emits a standard error event for error_during_execution results', () => {
+        const events = [];
+        handleIncomingEvent({
+            type: 'result',
+            subtype: 'error_during_execution',
+            uuid: 'evt-1',
+            timestamp: new Date().toISOString(),
+            sessionId: 'sess-1',
+            cwd: '/tmp',
+            session_id: 'sess-1',
+            errors: ['Incomplete response returned', 'reason=max_output_tokens']
+        }, (event) => events.push(event));
+        expect(events).toEqual([
+            {
+                type: 'error',
+                data: {
+                    message: 'Incomplete response returned',
+                    details: {
+                        errors: ['Incomplete response returned', 'reason=max_output_tokens'],
+                        sessionId: 'sess-1'
+                    },
+                    fatal: true
+                }
+            }
+        ]);
+    });
+    it('emits a standard error event for success results flagged as is_error', () => {
+        const events = [];
+        handleIncomingEvent({
+            type: 'result',
+            subtype: 'success',
+            uuid: 'evt-2',
+            timestamp: new Date().toISOString(),
+            sessionId: 'sess-2',
+            cwd: '/tmp',
+            is_error: true,
+            duration_ms: 123,
+            duration_api_ms: 45,
+            num_turns: 1,
+            result: 'API Error: 400 {"error":{"message":"Mock bad request"}}',
+            session_id: 'sess-2',
+            total_cost_usd: 0,
+            usage: {
+                input_tokens: 0,
+                cache_creation_input_tokens: 0,
+                cache_read_input_tokens: 0,
+                output_tokens: 0
+            },
+            permission_denials: []
+        }, (event) => events.push(event));
+        expect(events).toEqual([
+            {
+                type: 'error',
+                data: {
+                    message: 'API Error: 400 {"error":{"message":"Mock bad request"}}',
+                    details: {
+                        sessionId: 'sess-2',
+                        durationMs: 123,
+                        durationApiMs: 45,
+                        numTurns: 1,
+                        totalCostUsd: 0,
+                        usage: {
+                            input_tokens: 0,
+                            cache_creation_input_tokens: 0,
+                            cache_read_input_tokens: 0,
+                            output_tokens: 0
+                        },
+                        permissionDenials: []
+                    },
+                    fatal: true
+                }
+            },
+            {
+                type: 'stop',
+                data: {
+                    id: 'evt-2',
+                    role: 'assistant',
+                    content: 'API Error: 400 {"error":{"message":"Mock bad request"}}',
+                    createdAt: expect.any(Number),
+                    usage: {
+                        input_tokens: 0,
+                        cache_creation_input_tokens: 0,
+                        cache_read_input_tokens: 0,
+                        output_tokens: 0
+                    }
+                }
+            }
+        ]);
+    });
+});

package/dist/packages/adapters/claude-code/__tests__/native-hooks.spec.d.ts

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

package/dist/packages/adapters/claude-code/__tests__/native-hooks.spec.js

@@ -0,0 +1,107 @@
+import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { ensureClaudeNativeHooksInstalled } from '../src/runtime/native-hooks';
+const tempDirs = [];
+const createWorkspace = async () => {
+    const dir = await mkdtemp(join(tmpdir(), 'claude-hooks-'));
+    tempDirs.push(dir);
+    return dir;
+};
+afterEach(async () => {
+    await Promise.all(tempDirs.splice(0).map(dir => rm(dir, { recursive: true, force: true })));
+});
+describe('ensureClaudeNativeHooksInstalled', () => {
+    it('writes managed hooks into the isolated mock home settings file', async () => {
+        const workspace = await createWorkspace();
+        const mockHome = join(workspace, '.ai', '.mock');
+        const ctx = {
+            cwd: workspace,
+            env: {
+                HOME: mockHome
+            },
+            logger: {
+                info: vi.fn(),
+                warn: vi.fn(),
+                error: vi.fn(),
+                debug: vi.fn()
+            },
+            assets: {
+                hookPlugins: [
+                    {
+                        id: 'hookPlugin:project:logger'
+                    }
+                ]
+            }
+        };
+        const installed = await ensureClaudeNativeHooksInstalled(ctx);
+        const settings = JSON.parse(await readFile(join(mockHome, '.claude', 'settings.json'), 'utf8'));
+        expect(installed).toBe(true);
+        expect(ctx.env.__VF_PROJECT_AI_CLAUDE_NATIVE_HOOKS_AVAILABLE__).toBe('1');
+        expect(settings.hooks?.SessionStart).toHaveLength(1);
+        expect(settings.hooks?.PreToolUse?.[0]?.matcher).toBe('.*');
+        expect(settings.hooks?.PostToolUse?.[0]?.matcher).toBe('.*');
+        expect(JSON.stringify(settings)).toContain('call-hook.js');
+        expect(JSON.stringify(settings)).not.toContain('claude-hook.js');
+    });
+    it('does not duplicate native hooks already provided by project-level vf-call-hook settings', async () => {
+        const workspace = await createWorkspace();
+        const mockHome = join(workspace, '.ai', '.mock');
+        await mkdir(join(workspace, '.claude'), { recursive: true });
+        await writeFile(join(workspace, '.claude', 'settings.json'), JSON.stringify({
+            hooks: {
+                SessionStart: [{
+                        matcher: '*',
+                        hooks: [{ type: 'command', command: '$CLAUDE_PROJECT_DIR/node_modules/.bin/vf-call-hook' }]
+                    }],
+                UserPromptSubmit: [{
+                        matcher: '*',
+                        hooks: [{ type: 'command', command: '$CLAUDE_PROJECT_DIR/node_modules/.bin/vf-call-hook' }]
+                    }],
+                PreToolUse: [{
+                        matcher: '*',
+                        hooks: [{ type: 'command', command: '$CLAUDE_PROJECT_DIR/node_modules/.bin/vf-call-hook' }]
+                    }],
+                PostToolUse: [{
+                        matcher: '*',
+                        hooks: [{ type: 'command', command: '$CLAUDE_PROJECT_DIR/node_modules/.bin/vf-call-hook' }]
+                    }],
+                Stop: [{
+                        matcher: '*',
+                        hooks: [{ type: 'command', command: '$CLAUDE_PROJECT_DIR/node_modules/.bin/vf-call-hook' }]
+                    }]
+            }
+        }, null, 2));
+        const ctx = {
+            cwd: workspace,
+            env: {
+                HOME: mockHome
+            },
+            logger: {
+                info: vi.fn(),
+                warn: vi.fn(),
+                error: vi.fn(),
+                debug: vi.fn()
+            },
+            assets: {
+                hookPlugins: [
+                    {
+                        id: 'hookPlugin:project:logger'
+                    }
+                ]
+            }
+        };
+        const installed = await ensureClaudeNativeHooksInstalled(ctx);
+        const settings = JSON.parse(await readFile(join(mockHome, '.claude', 'settings.json'), 'utf8'));
+        expect(installed).toBe(true);
+        expect(ctx.env.__VF_PROJECT_AI_CLAUDE_NATIVE_HOOKS_AVAILABLE__).toBe('1');
+        expect(settings.hooks?.SessionStart ?? []).toEqual([]);
+        expect(settings.hooks?.UserPromptSubmit ?? []).toEqual([]);
+        expect(settings.hooks?.PreToolUse ?? []).toEqual([]);
+        expect(settings.hooks?.PostToolUse ?? []).toEqual([]);
+        expect(settings.hooks?.Stop ?? []).toEqual([]);
+        expect(settings.hooks?.Notification).toHaveLength(1);
+        expect(JSON.stringify(settings)).toContain('call-hook.js');
+    });
+});

package/dist/packages/adapters/claude-code/__tests__/prepare.spec.d.ts

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

package/dist/packages/adapters/claude-code/__tests__/prepare.spec.js

@@ -0,0 +1,124 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { NATIVE_HOOK_BRIDGE_ADAPTER_ENV } from '@vibe-forge/hooks';
+const mocks = vi.hoisted(() => ({
+    ensureClaudeCodeRouterReady: vi.fn()
+}));
+vi.mock('../src/runtime/router-daemon', () => ({
+    ensureClaudeCodeRouterReady: mocks.ensureClaudeCodeRouterReady
+}));
+import { prepareClaudeExecution } from '../src/runtime/prepare';
+const sessionId = '6cd99e50-d3be-4070-b408-8133cfc42750';
+const createCtx = (resumeState) => ({
+    ctxId: 'test-ctx',
+    cwd: '/tmp/workspace',
+    env: {},
+    cache: {
+        get: vi.fn(async (key) => (key === 'adapter.claude-code.resume-state' ? resumeState : undefined)),
+        set: vi.fn(async () => ({ cachePath: '/tmp/cache.json' }))
+    },
+    logger: {
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+        debug: vi.fn()
+    },
+    configs: [undefined, undefined]
+});
+describe('prepareClaudeExecution', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mocks.ensureClaudeCodeRouterReady.mockResolvedValue({
+            host: '127.0.0.1',
+            port: 4123,
+            apiKey: 'router-key',
+            apiTimeoutMs: 120000
+        });
+    });
+    it('falls back to create mode when no resume state exists', async () => {
+        const result = await prepareClaudeExecution(createCtx(), {
+            type: 'resume',
+            runtime: 'server',
+            sessionId,
+            model: 'gpt-responses,gpt-5.2-codex-2026-01-14',
+            onEvent: vi.fn()
+        });
+        expect(result.executionType).toBe('create');
+        expect(result.cliPath).toBe('claude');
+        expect(result.args).toContain('--session-id');
+        expect(result.args).toContain(sessionId);
+        expect(result.args).not.toContain('--resume');
+    });
+    it('keeps resume mode when the session has been initialized before', async () => {
+        const result = await prepareClaudeExecution(createCtx({ canResume: true }), {
+            type: 'resume',
+            runtime: 'server',
+            sessionId,
+            model: 'gpt-responses,gpt-5.2-codex-2026-01-14',
+            onEvent: vi.fn()
+        });
+        expect(result.executionType).toBe('resume');
+        expect(result.cliPath).toBe('claude');
+        expect(result.args).toContain('--resume');
+        expect(result.args).toContain(sessionId);
+        expect(result.args).not.toContain('--session-id');
+    });
+    it('routes service-qualified models through the reusable CCR daemon via settings env only', async () => {
+        const ctx = createCtx();
+        const result = await prepareClaudeExecution(ctx, {
+            type: 'create',
+            runtime: 'server',
+            sessionId,
+            model: 'gpt-responses,gpt-5.2-codex-2026-01-14',
+            onEvent: vi.fn()
+        });
+        expect(result.cliPath).toBe('claude');
+        expect(result.args).toContain('--model');
+        expect(result.args).toContain('gpt-responses,gpt-5.2-codex-2026-01-14');
+        expect(result.env.ANTHROPIC_BASE_URL).toBeUndefined();
+        expect(result.env.ANTHROPIC_AUTH_TOKEN).toBeUndefined();
+        expect(mocks.ensureClaudeCodeRouterReady).toHaveBeenCalledWith(ctx);
+        expect(ctx.cache.set).toHaveBeenCalledWith('adapter.claude-code.settings', expect.objectContaining({
+            env: expect.objectContaining({
+                ANTHROPIC_BASE_URL: 'http://127.0.0.1:4123',
+                ANTHROPIC_AUTH_TOKEN: 'router-key',
+                ANTHROPIC_API_KEY: '',
+                API_TIMEOUT_MS: '120000'
+            })
+        }));
+    });
+    it('keeps native Claude execution untouched for non-CCR models', async () => {
+        const ctx = createCtx();
+        await prepareClaudeExecution(ctx, {
+            type: 'create',
+            runtime: 'server',
+            sessionId,
+            model: 'claude-sonnet-4-20250514',
+            onEvent: vi.fn()
+        });
+        expect(mocks.ensureClaudeCodeRouterReady).not.toHaveBeenCalled();
+        expect(ctx.cache.set).toHaveBeenCalledWith('adapter.claude-code.settings', expect.objectContaining({
+            env: expect.not.objectContaining({
+                ANTHROPIC_BASE_URL: expect.any(String),
+                ANTHROPIC_AUTH_TOKEN: expect.any(String),
+                ANTHROPIC_API_KEY: expect.any(String),
+                API_TIMEOUT_MS: expect.any(String)
+            })
+        }));
+    });
+    it('injects the shared native hook bridge adapter env when claude native hooks are enabled', async () => {
+        const ctx = createCtx();
+        ctx.env.__VF_PROJECT_AI_CLAUDE_NATIVE_HOOKS_AVAILABLE__ = '1';
+        const result = await prepareClaudeExecution(ctx, {
+            type: 'create',
+            runtime: 'server',
+            sessionId,
+            onEvent: vi.fn()
+        });
+        expect(result.env[NATIVE_HOOK_BRIDGE_ADAPTER_ENV]).toBe('claude-code');
+        expect(ctx.cache.set).toHaveBeenCalledWith('adapter.claude-code.settings', expect.objectContaining({
+            env: expect.objectContaining({
+                [NATIVE_HOOK_BRIDGE_ADAPTER_ENV]: 'claude-code'
+            })
+        }));
+    });
+});

package/dist/packages/adapters/claude-code/__tests__/router-daemon.spec.d.ts

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