@vibe-forge/tsconfigs 0.8.0 → 0.10.0

package/dist/apps/server/src/db/sessions/repo.js

@@ -105,7 +105,7 @@ function createSessionsRepo(db) {
             status: status ?? undefined
         };
         const stmt = db.prepare('INSERT INTO sessions (id, parentSessionId, title, createdAt, status) VALUES (?, ?, ?, ?, ?)');
-        stmt.run(session.id, session.parentSessionId ?? null, session.title, session.createdAt, session.status);
+        stmt.run(session.id, session.parentSessionId ?? null, session.title ?? null, session.createdAt, session.status ?? null);
         return session;
     };
     const setTitle = (id, title) => {

package/dist/apps/server/src/db/sessions/tags.repo.d.ts

@@ -1,5 +1,5 @@
-import type Database from 'better-sqlite3';
-export declare function createTagsRepo(db: Database.Database): {
+import type { SqliteDatabase } from '../sqlite';
+export declare function createTagsRepo(db: SqliteDatabase): {
     replace: (sessionId: string, tags: string[]) => void;
 };
 export type TagsRepo = ReturnType<typeof createTagsRepo>;

package/dist/apps/server/src/db/sqlite.d.ts

@@ -0,0 +1,44 @@
+type DatabaseSyncOptions = import('node:sqlite').DatabaseSyncOptions;
+type StatementSync = import('node:sqlite').StatementSync;
+export type SqliteBindValue = null | number | bigint | string | NodeJS.ArrayBufferView;
+export interface SqliteRunResult {
+    changes: number;
+    lastInsertRowid: number | bigint;
+}
+export interface SqliteStatement {
+    all: (...params: SqliteBindValue[]) => Record<string, unknown>[];
+    get: (...params: SqliteBindValue[]) => Record<string, unknown> | undefined;
+    run: (...params: SqliteBindValue[]) => SqliteRunResult;
+}
+type SqliteTransactionFn = (...args: unknown[]) => unknown;
+export interface SqliteDatabase {
+    close: () => void;
+    exec: (sql: string) => void;
+    prepare: (sql: string) => SqliteStatement;
+    transaction: <T extends SqliteTransactionFn>(fn: T) => T;
+}
+declare class NodeSqliteStatement implements SqliteStatement {
+    private readonly statement;
+    constructor(statement: StatementSync);
+    all(...params: SqliteBindValue[]): {
+        [x: string]: unknown;
+    }[];
+    get(...params: SqliteBindValue[]): {
+        [x: string]: unknown;
+    } | undefined;
+    run(...params: SqliteBindValue[]): {
+        changes: number;
+        lastInsertRowid: number | bigint;
+    };
+}
+declare class NodeSqliteDatabase implements SqliteDatabase {
+    private readonly database;
+    private savepointId;
+    constructor(database: DatabaseSync);
+    close(): void;
+    exec(sql: string): void;
+    prepare(sql: string): NodeSqliteStatement;
+    transaction<T extends SqliteTransactionFn>(fn: T): T;
+}
+export declare function createSqliteDatabase(path: string, options?: DatabaseSyncOptions): NodeSqliteDatabase;
+export {};

package/dist/apps/server/src/db/sqlite.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSqliteDatabase = createSqliteDatabase;
+const node_module_1 = require("node:module");
+const require = (0, node_module_1.createRequire)(import.meta.url);
+const { DatabaseSync } = require('node:sqlite');
+function cloneRow(row) {
+    return { ...row };
+}
+class NodeSqliteStatement {
+    statement;
+    constructor(statement) {
+        this.statement = statement;
+    }
+    all(...params) {
+        return this.statement
+            .all(...params)
+            .map(row => cloneRow(row));
+    }
+    get(...params) {
+        const row = this.statement.get(...params);
+        return row == null ? undefined : cloneRow(row);
+    }
+    run(...params) {
+        const result = this.statement.run(...params);
+        return {
+            changes: Number(result.changes),
+            lastInsertRowid: result.lastInsertRowid
+        };
+    }
+}
+class NodeSqliteDatabase {
+    database;
+    savepointId = 0;
+    constructor(database) {
+        this.database = database;
+    }
+    close() {
+        if (this.database.isOpen) {
+            this.database.close();
+        }
+    }
+    exec(sql) {
+        this.database.exec(sql);
+    }
+    prepare(sql) {
+        return new NodeSqliteStatement(this.database.prepare(sql));
+    }
+    transaction(fn) {
+        return ((...args) => {
+            const savepointName = this.database.isTransaction
+                ? `vf_tx_${++this.savepointId}`
+                : undefined;
+            this.database.exec(savepointName == null ? 'BEGIN' : `SAVEPOINT ${savepointName}`);
+            try {
+                const result = fn(...args);
+                this.database.exec(savepointName == null ? 'COMMIT' : `RELEASE SAVEPOINT ${savepointName}`);
+                return result;
+            }
+            catch (error) {
+                if (savepointName == null) {
+                    if (this.database.isTransaction) {
+                        this.database.exec('ROLLBACK');
+                    }
+                }
+                else {
+                    this.database.exec(`ROLLBACK TO SAVEPOINT ${savepointName}`);
+                    this.database.exec(`RELEASE SAVEPOINT ${savepointName}`);
+                }
+                throw error;
+            }
+        });
+    }
+}
+const defaultDatabaseOptions = {
+    enableForeignKeyConstraints: false
+};
+function createSqliteDatabase(path, options = {}) {
+    return new NodeSqliteDatabase(new DatabaseSync(path, {
+        ...defaultDatabaseOptions,
+        ...options
+    }));
+}

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

@@ -21,7 +21,7 @@ async function init() {
     const server = node_http_1.default.createServer((req, res) => {
         void handler(req, res);
     });
-    const { projectConfig, userConfig } = await (0, index_js_1.loadConfigSources)();
+    const { projectConfig, userConfig } = await (0, index_js_1.loadConfigState)();
     const configs = [projectConfig, userConfig];
     return { app, env, server, configs };
 }

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

@@ -96,7 +96,7 @@ function configRouter() {
     const router = new router_1.default();
     router.get('/', async (ctx) => {
         try {
-            const { workspaceFolder, projectConfig, userConfig, mergedConfig } = await (0, index_js_1.loadMergedConfig)();
+            const { workspaceFolder, projectConfig, userConfig, mergedConfig } = await (0, index_js_1.loadConfigState)();
             const urls = {
                 repo: 'https://github.com/vibe-forge-ai/vibe-forge.ai',
                 docs: 'https://github.com/vibe-forge-ai/vibe-forge.ai',

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

@@ -1,15 +1,9 @@
 import type { Config } from '@vibe-forge/types';
 export declare function getWorkspaceFolder(): string;
 export declare function buildConfigJsonVariables(workspaceFolder?: string): Record<string, string | null | undefined>;
-export declare function mergeConfigs(project?: Config, user?: Config): Config;
-export declare function loadConfigSources(): Promise<{
+export declare function loadConfigState(): Promise<{
     workspaceFolder: string;
     projectConfig: Config | undefined;
     userConfig: Config | undefined;
-}>;
-export declare function loadMergedConfig(): Promise<{
-    workspaceFolder: string;
-    projectConfig: Config | undefined;
-    userConfig: Config | undefined;
-    mergedConfig: Config;
+    mergedConfig: Config | undefined;
 }>;

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

@@ -2,61 +2,25 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getWorkspaceFolder = getWorkspaceFolder;
 exports.buildConfigJsonVariables = buildConfigJsonVariables;
-exports.mergeConfigs = mergeConfigs;
-exports.loadConfigSources = loadConfigSources;
-exports.loadMergedConfig = loadMergedConfig;
+exports.loadConfigState = loadConfigState;
 const node_process_1 = require("node:process");
 const config_1 = require("@vibe-forge/config");
-const utils_1 = require("@vibe-forge/utils");
 function getWorkspaceFolder() {
     return node_process_1.env.__VF_PROJECT_WORKSPACE_FOLDER__ ?? (0, node_process_1.cwd)();
 }
 function buildConfigJsonVariables(workspaceFolder = getWorkspaceFolder()) {
     return (0, config_1.buildConfigJsonVariables)(workspaceFolder, node_process_1.env);
 }
-const mergeRecord = (left, right) => {
-    if (left == null && right == null)
-        return undefined;
-    return {
-        ...(left ?? {}),
-        ...(right ?? {})
-    };
-};
-function mergeConfigs(project, user) {
-    return {
-        ...project,
-        ...user,
-        adapters: (0, utils_1.mergeAdapterConfigs)(project?.adapters, user?.adapters),
-        models: mergeRecord(project?.models, user?.models),
-        modelServices: mergeRecord(project?.modelServices, user?.modelServices),
-        channels: mergeRecord(project?.channels, user?.channels),
-        mcpServers: mergeRecord(project?.mcpServers, user?.mcpServers),
-        enabledPlugins: mergeRecord(project?.enabledPlugins, user?.enabledPlugins),
-        extraKnownMarketplaces: mergeRecord(project?.extraKnownMarketplaces, user?.extraKnownMarketplaces),
-        plugins: user?.plugins ?? project?.plugins,
-        shortcuts: mergeRecord(project?.shortcuts, user?.shortcuts),
-        conversation: mergeRecord(project?.conversation, user?.conversation),
-        notifications: mergeRecord(project?.notifications, user?.notifications)
-    };
-}
-async function loadConfigSources() {
+async function loadConfigState() {
     const workspaceFolder = getWorkspaceFolder();
     const [projectConfig, userConfig] = await (0, config_1.loadConfig)({
         cwd: workspaceFolder,
         jsonVariables: buildConfigJsonVariables(workspaceFolder)
     });
-    return {
-        workspaceFolder,
-        projectConfig,
-        userConfig
-    };
-}
-async function loadMergedConfig() {
-    const { workspaceFolder, projectConfig, userConfig } = await loadConfigSources();
     return {
         workspaceFolder,
         projectConfig,
         userConfig,
-        mergedConfig: mergeConfigs(projectConfig, userConfig)
+        mergedConfig: (0, config_1.mergeConfigs)(projectConfig, userConfig)
     };
 }

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

@@ -80,7 +80,7 @@ async function startAdapterSession(sessionId, options = {}) {
             : [resolvedConfig.systemPrompt, options.systemPrompt]
                 .filter(Boolean)
                 .join('\n\n');
-        const { mergedConfig } = await (0, index_js_3.loadMergedConfig)().catch(() => ({ mergedConfig: {} }));
+        const { mergedConfig } = await (0, index_js_3.loadConfigState)().catch(() => ({ mergedConfig: {} }));
         const { modelLanguage } = mergedConfig;
         const languagePrompt = modelLanguage == null
             ? undefined

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

@@ -36,7 +36,7 @@ async function maybeNotifySession(previousStatus, nextStatus, session) {
     const notificationTrigger = toNotificationTrigger(nextStatus);
     if (notificationTrigger == null)
         return;
-    const { mergedConfig } = await (0, index_js_1.loadMergedConfig)();
+    const { mergedConfig } = await (0, index_js_1.loadConfigState)();
     const { notifications, interfaceLanguage } = mergedConfig;
     if (notifications?.disabled === true)
         return;

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

@@ -94,6 +94,21 @@ describe('generateDefaultCCRConfigJSON', () => {
         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',

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

@@ -1,5 +1,11 @@
-import { describe, expect, it, vi } from 'vitest';
+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) => ({
@@ -19,6 +25,15 @@ const createCtx = (resumeState) => ({
     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',
@@ -28,6 +43,7 @@ describe('prepareClaudeExecution', () => {
             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');
@@ -41,10 +57,54 @@ describe('prepareClaudeExecution', () => {
             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';

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

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

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

@@ -0,0 +1,183 @@
+import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { generateDefaultCCRConfigJSON } from '../src/ccr/default-config';
+import { ensureClaudeCodeRouterReady } from '../src/runtime/router-daemon';
+const tempDirs = [];
+const createWorkspace = async () => {
+    const dir = await mkdtemp(join(tmpdir(), 'claude-code-router-'));
+    tempDirs.push(dir);
+    return dir;
+};
+const createCtx = (cwd, overrides) => ({
+    cwd,
+    env: {
+        TEST_ENV: 'router'
+    },
+    configs: [undefined, {
+            defaultModelService: 'gateway',
+            defaultModel: 'gpt-5.4',
+            modelServices: {
+                gateway: {
+                    apiBaseUrl: 'https://example.test/chat/completions',
+                    apiKey: 'provider-key',
+                    models: ['gpt-5.4'],
+                    timeoutMs: 120000
+                }
+            },
+            adapters: {
+                'claude-code': {
+                    ccrOptions: {
+                        PORT: '4123',
+                        APIKEY: 'router-key'
+                    }
+                }
+            },
+            ...(overrides ?? {})
+        }]
+});
+const getRouterPaths = (cwd) => ({
+    mockHome: join(cwd, '.ai', '.mock'),
+    routerHome: join(cwd, '.ai', '.mock', '.claude-code-router'),
+    configPath: join(cwd, '.ai', '.mock', '.claude-code-router', 'config.json'),
+    pidPath: join(cwd, '.ai', '.mock', '.claude-code-router', '.claude-code-router.pid')
+});
+describe('ensureClaudeCodeRouterReady', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    afterEach(async () => {
+        await Promise.all(tempDirs.splice(0).map(dir => rm(dir, { recursive: true, force: true })));
+    });
+    it('starts a detached router daemon when no pid file exists', async () => {
+        const workspace = await createWorkspace();
+        const ctx = createCtx(workspace);
+        const spawnDetached = vi.fn(async () => undefined);
+        const waitForReady = vi.fn(async () => undefined);
+        const connection = await ensureClaudeCodeRouterReady(ctx, {
+            resolveCliPath: () => '/bin/sh',
+            isProcessAlive: vi.fn(() => false),
+            spawnDetached,
+            stopProcess: vi.fn(async () => undefined),
+            waitForReady
+        });
+        const { configPath, mockHome } = getRouterPaths(workspace);
+        const config = JSON.parse(await readFile(configPath, 'utf8'));
+        expect(connection).toEqual({
+            host: '127.0.0.1',
+            port: 4123,
+            apiKey: 'router-key',
+            apiTimeoutMs: 120000
+        });
+        expect(config.PORT).toBe('4123');
+        expect(config.APIKEY).toBe('router-key');
+        expect(config.API_TIMEOUT_MS).toBe(120000);
+        expect(spawnDetached).toHaveBeenCalledWith({
+            cliPath: '/bin/sh',
+            cwd: workspace,
+            env: expect.objectContaining({
+                TEST_ENV: 'router',
+                HOME: mockHome
+            })
+        });
+        expect(waitForReady).toHaveBeenCalledWith(4123, 15000);
+    });
+    it('restarts the daemon when the pid file is stale', async () => {
+        const workspace = await createWorkspace();
+        const ctx = createCtx(workspace);
+        const { pidPath, routerHome } = getRouterPaths(workspace);
+        const spawnDetached = vi.fn(async () => undefined);
+        const isProcessAlive = vi.fn(() => false);
+        await mkdir(routerHome, { recursive: true });
+        await writeFile(pidPath, '4321', 'utf8');
+        await ensureClaudeCodeRouterReady(ctx, {
+            resolveCliPath: () => '/bin/sh',
+            isProcessAlive,
+            spawnDetached,
+            stopProcess: vi.fn(async () => undefined),
+            waitForReady: vi.fn(async () => undefined)
+        });
+        await expect(readFile(pidPath, 'utf8')).rejects.toThrow();
+        expect(isProcessAlive).toHaveBeenCalledWith(4321);
+        expect(spawnDetached).toHaveBeenCalledTimes(1);
+    });
+    it('reuses a live daemon when config is unchanged', async () => {
+        const workspace = await createWorkspace();
+        const ctx = createCtx(workspace);
+        const { configPath, pidPath, routerHome } = getRouterPaths(workspace);
+        const configText = generateDefaultCCRConfigJSON({
+            cwd: workspace,
+            userConfig: ctx.configs[1],
+            adapterOptions: ctx.configs[1].adapters['claude-code']
+        });
+        await mkdir(routerHome, { recursive: true });
+        await writeFile(configPath, configText, 'utf8');
+        await writeFile(pidPath, '2468', 'utf8');
+        const spawnDetached = vi.fn(async () => undefined);
+        const stopProcess = vi.fn(async () => undefined);
+        const waitForReady = vi.fn(async () => undefined);
+        const connection = await ensureClaudeCodeRouterReady(ctx, {
+            resolveCliPath: () => '/bin/sh',
+            isProcessAlive: vi.fn(() => true),
+            spawnDetached,
+            stopProcess,
+            waitForReady
+        });
+        expect(connection.port).toBe(4123);
+        expect(stopProcess).not.toHaveBeenCalled();
+        expect(spawnDetached).not.toHaveBeenCalled();
+        expect(waitForReady).toHaveBeenCalledWith(4123, 15000);
+        await expect(readFile(pidPath, 'utf8')).resolves.toBe('2468');
+    });
+    it('restarts a live daemon when config changes', async () => {
+        const workspace = await createWorkspace();
+        const ctx = createCtx(workspace);
+        const { configPath, pidPath, routerHome } = getRouterPaths(workspace);
+        const oldConfigText = generateDefaultCCRConfigJSON({
+            cwd: workspace,
+            userConfig: {
+                ...ctx.configs[1],
+                adapters: {
+                    'claude-code': {
+                        ccrOptions: {
+                            PORT: '4001',
+                            APIKEY: 'old-router-key'
+                        }
+                    }
+                }
+            },
+            adapterOptions: {
+                ccrOptions: {
+                    PORT: '4001',
+                    APIKEY: 'old-router-key'
+                }
+            }
+        });
+        await mkdir(routerHome, { recursive: true });
+        await writeFile(configPath, oldConfigText, 'utf8');
+        await writeFile(pidPath, '1357', 'utf8');
+        const spawnDetached = vi.fn(async () => undefined);
+        const stopProcess = vi.fn(async () => undefined);
+        const waitForReady = vi.fn(async () => undefined);
+        const connection = await ensureClaudeCodeRouterReady(ctx, {
+            resolveCliPath: () => '/bin/sh',
+            isProcessAlive: vi.fn(() => true),
+            spawnDetached,
+            stopProcess,
+            waitForReady
+        });
+        expect(connection).toEqual({
+            host: '127.0.0.1',
+            port: 4123,
+            apiKey: 'router-key',
+            apiTimeoutMs: 120000
+        });
+        expect(stopProcess).toHaveBeenCalledWith(1357);
+        expect(spawnDetached).toHaveBeenCalledTimes(1);
+        expect(stopProcess.mock.invocationCallOrder[0]).toBeLessThan(spawnDetached.mock.invocationCallOrder[0]);
+        expect(waitForReady).toHaveBeenCalledWith(4123, 15000);
+        await expect(readFile(pidPath, 'utf8')).rejects.toThrow();
+        expect(await readFile(configPath, 'utf8')).not.toBe(oldConfigText);
+    });
+});

package/dist/packages/adapters/claude-code/src/adapter-config.d.ts

@@ -13,6 +13,7 @@ declare module '@vibe-forge/types' {
                 LOG?: boolean;
                 PORT?: string;
                 HOST?: string;
+                APIKEY?: string;
                 API_TIMEOUT_MS?: number;
             };
             ccrTransformers?: {

package/dist/packages/adapters/claude-code/src/runtime/init.js

@@ -1,49 +1,4 @@
-import { spawn } from 'node:child_process';
-import { existsSync } from 'node:fs';
-import { mkdir, writeFile } from 'node:fs/promises';
-import { dirname, resolve } from 'node:path';
-import process from 'node:process';
-import { omitAdapterCommonConfig } from '@vibe-forge/utils';
-import { generateDefaultCCRConfigJSON } from '../ccr/default-config';
-import { resolveAdapterCliPath } from '../ccr/paths';
 import { ensureClaudeNativeHooksInstalled } from './native-hooks';
 export const initClaudeCodeAdapter = async (ctx) => {
-    const { cwd, env, configs: [config, userConfig] } = ctx;
-    const adapterOptions = omitAdapterCommonConfig({
-        ...(config?.adapters?.['claude-code'] ?? {}),
-        ...(userConfig?.adapters?.['claude-code'] ?? {})
-    });
-    const configPath = resolve(cwd, '.ai/.mock/.claude-code-router/config.json');
-    await mkdir(dirname(configPath), { recursive: true });
-    await writeFile(configPath, generateDefaultCCRConfigJSON({
-        cwd,
-        config,
-        userConfig,
-        adapterOptions
-    }));
     await ensureClaudeNativeHooksInstalled(ctx);
-    const homePath = resolve(cwd, '.ai/.mock');
-    const cliPath = resolveAdapterCliPath();
-    if (!existsSync(cliPath)) {
-        return;
-    }
-    await new Promise((resolvePromise, reject) => {
-        const proc = spawn(cliPath, ['restart'], {
-            env: {
-                ...process.env,
-                ...env,
-                HOME: homePath
-            },
-            cwd
-        });
-        proc.on('exit', (code) => {
-            if (code === 0) {
-                resolvePromise(null);
-            }
-            else {
-                reject(new Error(`ccr restart failed with code ${code}`));
-            }
-        });
-        proc.on('error', reject);
-    });
 };

package/dist/packages/adapters/claude-code/src/runtime/prepare.d.ts

@@ -1,14 +1,11 @@
 import type { AdapterCtx, AdapterQueryOptions } from '@vibe-forge/types';
-export declare const prepareClaudeExecution: (ctx: AdapterCtx, options: AdapterQueryOptions) => Promise<{
+interface PreparedClaudeExecution {
     cliPath: string;
     args: string[];
-    env: {
-        __VF_VIBE_FORGE_CLAUDE_HOOKS_ACTIVE__?: string | undefined;
-        __VF_VIBE_FORGE_HOOK_BRIDGE_ADAPTER__?: string | undefined;
-        __VF_CLAUDE_HOOK_RUNTIME__?: import("@vibe-forge/types").TaskRuntime | undefined;
-        __VF_CLAUDE_TASK_SESSION_ID__?: string | undefined;
-    };
+    env: Record<string, string | null | undefined>;
     cwd: string;
     sessionId: string;
-    executionType: string;
-}>;
+    executionType: 'create' | 'resume';
+}
+export declare const prepareClaudeExecution: (ctx: AdapterCtx, options: AdapterQueryOptions) => Promise<PreparedClaudeExecution>;
+export {};