@vibe-forge/tsconfigs 0.8.0 → 0.10.0

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

@@ -1,5 +1,5 @@
 import { NATIVE_HOOK_BRIDGE_ADAPTER_ENV } from '@vibe-forge/hooks';
-import { resolveAdapterCliPath } from '../ccr/paths';
+import { ensureClaudeCodeRouterReady } from './router-daemon';
 export const prepareClaudeExecution = async (ctx, options) => {
     const { env, cwd, cache, configs: [config, userConfig] } = ctx;
     const assetPlan = options.assetPlan;
@@ -63,6 +63,17 @@ export const prepareClaudeExecution = async (ctx, options) => {
             ...(userConfig?.extraKnownMarketplaces ?? {})
         }
     };
+    const useCCR = typeof model === 'string' && model.includes(',');
+    if (useCCR) {
+        const router = await ensureClaudeCodeRouterReady(ctx);
+        settings.env = {
+            ...settings.env,
+            ANTHROPIC_BASE_URL: `http://${router.host}:${router.port}`,
+            ANTHROPIC_AUTH_TOKEN: router.apiKey,
+            ANTHROPIC_API_KEY: '',
+            API_TIMEOUT_MS: String(router.apiTimeoutMs)
+        };
+    }
     const { mcpServers, ...unresolvedSettings } = settings;
     unresolvedSettings.permissions.allow = [
         ...(unresolvedSettings.permissions.allow ?? []),
@@ -90,21 +101,7 @@ export const prepareClaudeExecution = async (ctx, options) => {
     }
     const { cachePath: mcpCachePath } = await cache.set('adapter.claude-code.mcp', { mcpServers });
     const { cachePath: settingsCachePath } = await cache.set('adapter.claude-code.settings', settings);
-    // Routing: model with "," → CCR proxy; model without "," → native claude binary.
-    //   "serviceKey,modelName" → ccr code ... --model serviceKey,modelName
-    //   "opus" / undefined     → claude ... --model opus  (or omit --model)
-    const useCCR = typeof model === 'string' && model.includes(',');
-    let cliPath;
-    const prefixArgs = [];
-    if (useCCR) {
-        cliPath = resolveAdapterCliPath();
-        prefixArgs.push('code');
-    }
-    else {
-        cliPath = 'claude';
-    }
     const args = [
-        ...prefixArgs,
         ...(description
             ? [JSON.stringify(`${(description?.trimStart().startsWith('-') ? '\0' : '')}${(description.replace(/`/g, "'"))}`)]
             : []),
@@ -124,20 +121,21 @@ export const prepareClaudeExecution = async (ctx, options) => {
     if (systemPrompt != null && systemPrompt !== '') {
         args.push(appendSystemPrompt ? '--append-system-prompt' : '--system-prompt', systemPrompt.replace(/`/g, "'"));
     }
+    const executionEnv = {
+        ...env,
+        ...(nativeHooksAvailable
+            ? {
+                __VF_VIBE_FORGE_CLAUDE_HOOKS_ACTIVE__: '1',
+                [NATIVE_HOOK_BRIDGE_ADAPTER_ENV]: 'claude-code',
+                __VF_CLAUDE_HOOK_RUNTIME__: options.runtime,
+                __VF_CLAUDE_TASK_SESSION_ID__: sessionId
+            }
+            : {})
+    };
     return {
-        cliPath: cliPath,
+        cliPath: 'claude',
         args,
-        env: {
-            ...env,
-            ...(nativeHooksAvailable
-                ? {
-                    __VF_VIBE_FORGE_CLAUDE_HOOKS_ACTIVE__: '1',
-                    [NATIVE_HOOK_BRIDGE_ADAPTER_ENV]: 'claude-code',
-                    __VF_CLAUDE_HOOK_RUNTIME__: options.runtime,
-                    __VF_CLAUDE_TASK_SESSION_ID__: sessionId
-                }
-                : {})
-        },
+        env: executionEnv,
         cwd,
         sessionId,
         executionType

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

@@ -0,0 +1,19 @@
+import type { AdapterCtx } from '@vibe-forge/types';
+export interface ClaudeCodeRouterConnection {
+    apiKey: string;
+    apiTimeoutMs: number;
+    host: string;
+    port: number;
+}
+export interface ClaudeCodeRouterDeps {
+    isProcessAlive: (pid: number) => boolean;
+    resolveCliPath: () => string;
+    spawnDetached: (params: {
+        cliPath: string;
+        cwd: string;
+        env: NodeJS.ProcessEnv;
+    }) => Promise<void>;
+    stopProcess: (pid: number) => Promise<void>;
+    waitForReady: (port: number, timeoutMs: number) => Promise<void>;
+}
+export declare const ensureClaudeCodeRouterReady: (ctx: Pick<AdapterCtx, "configs" | "cwd" | "env">, deps?: Partial<ClaudeCodeRouterDeps>) => Promise<ClaudeCodeRouterConnection>;

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

@@ -0,0 +1,189 @@
+import { spawn } from 'node:child_process';
+import { access, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import net from 'node:net';
+import { dirname, resolve } from 'node:path';
+import process from 'node:process';
+import { setTimeout as delay } from 'node:timers/promises';
+import { omitAdapterCommonConfig } from '@vibe-forge/utils';
+import { generateDefaultCCRConfigJSON } from '../ccr/default-config';
+import { resolveAdapterCliPath } from '../ccr/paths';
+const DEFAULT_ROUTER_HOST = '127.0.0.1';
+const DEFAULT_ROUTER_PORT = 3456;
+const DEFAULT_ROUTER_API_TIMEOUT_MS = 600000;
+const ROUTER_READY_TIMEOUT_MS = 15000;
+const ROUTER_STOP_TIMEOUT_MS = 5000;
+const ROUTER_POLL_INTERVAL_MS = 100;
+const normalizePositiveInteger = (value) => (typeof value === 'number' && Number.isFinite(value) && value > 0
+    ? Math.floor(value)
+    : typeof value === 'string' && /^\d+$/.test(value) && Number(value) > 0
+        ? Number(value)
+        : undefined);
+const buildRouterPaths = (cwd) => {
+    const mockHome = resolve(cwd, '.ai/.mock');
+    const routerHome = resolve(mockHome, '.claude-code-router');
+    return {
+        mockHome,
+        routerHome,
+        configPath: resolve(routerHome, 'config.json'),
+        pidPath: resolve(routerHome, '.claude-code-router.pid')
+    };
+};
+const parseRouterConnection = (configText) => {
+    const config = JSON.parse(configText);
+    return {
+        host: DEFAULT_ROUTER_HOST,
+        port: normalizePositiveInteger(config.PORT) ?? DEFAULT_ROUTER_PORT,
+        apiKey: typeof config.APIKEY === 'string' && config.APIKEY.trim() !== ''
+            ? config.APIKEY
+            : 'test',
+        apiTimeoutMs: normalizePositiveInteger(config.API_TIMEOUT_MS) ?? DEFAULT_ROUTER_API_TIMEOUT_MS
+    };
+};
+const readPidFile = async (pidPath) => {
+    try {
+        const raw = await readFile(pidPath, 'utf8');
+        const pid = Number.parseInt(raw.trim(), 10);
+        return Number.isFinite(pid) && pid > 0 ? pid : undefined;
+    }
+    catch {
+        return undefined;
+    }
+};
+const isProcessAliveDefault = (pid) => {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+const waitForProcessExit = async (pid, timeoutMs, isProcessAlive) => {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (!isProcessAlive(pid))
+            return;
+        await delay(ROUTER_POLL_INTERVAL_MS);
+    }
+};
+const stopProcessDefault = async (pid) => {
+    try {
+        process.kill(pid);
+    }
+    catch {
+        return;
+    }
+    await waitForProcessExit(pid, ROUTER_STOP_TIMEOUT_MS, isProcessAliveDefault);
+    if (isProcessAliveDefault(pid)) {
+        try {
+            process.kill(pid, 'SIGKILL');
+        }
+        catch {
+            return;
+        }
+        await waitForProcessExit(pid, ROUTER_STOP_TIMEOUT_MS, isProcessAliveDefault);
+    }
+};
+const spawnDetachedDefault = async ({ cliPath, cwd, env }) => {
+    await new Promise((resolvePromise, reject) => {
+        const proc = spawn(cliPath, ['start'], {
+            cwd,
+            env,
+            detached: true,
+            stdio: 'ignore'
+        });
+        proc.once('error', reject);
+        proc.unref();
+        setImmediate(resolvePromise);
+    });
+};
+const waitForReadyDefault = async (port, timeoutMs) => {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        const isReady = await new Promise((resolvePromise) => {
+            const socket = net.createConnection({
+                host: DEFAULT_ROUTER_HOST,
+                port
+            });
+            const finalize = (ready) => {
+                socket.removeAllListeners();
+                socket.destroy();
+                resolvePromise(ready);
+            };
+            socket.once('connect', () => finalize(true));
+            socket.once('error', () => finalize(false));
+        });
+        if (isReady)
+            return;
+        await delay(ROUTER_POLL_INTERVAL_MS);
+    }
+    throw new Error(`claude-code-router did not become ready on port ${port}`);
+};
+const defaultRouterDeps = {
+    resolveCliPath: resolveAdapterCliPath,
+    isProcessAlive: isProcessAliveDefault,
+    spawnDetached: spawnDetachedDefault,
+    stopProcess: stopProcessDefault,
+    waitForReady: waitForReadyDefault
+};
+const resolveAdapterOptions = (params) => {
+    const { config, userConfig } = params;
+    return omitAdapterCommonConfig({
+        ...(config?.adapters?.['claude-code'] ?? {}),
+        ...(userConfig?.adapters?.['claude-code'] ?? {})
+    });
+};
+export const ensureClaudeCodeRouterReady = async (ctx, deps = {}) => {
+    const { cwd, env, configs: [config, userConfig] } = ctx;
+    const adapterOptions = resolveAdapterOptions({ config, userConfig });
+    const configText = generateDefaultCCRConfigJSON({
+        cwd,
+        config,
+        userConfig,
+        adapterOptions
+    });
+    const connection = parseRouterConnection(configText);
+    const { configPath, mockHome, pidPath } = buildRouterPaths(cwd);
+    const routerDeps = {
+        ...defaultRouterDeps,
+        ...deps
+    };
+    await mkdir(dirname(configPath), { recursive: true });
+    let previousConfigText;
+    try {
+        previousConfigText = await readFile(configPath, 'utf8');
+    }
+    catch {
+        previousConfigText = undefined;
+    }
+    const configChanged = previousConfigText !== configText;
+    if (configChanged) {
+        await writeFile(configPath, configText, 'utf8');
+    }
+    let pid = await readPidFile(pidPath);
+    let isRunning = pid != null && routerDeps.isProcessAlive(pid);
+    if (!isRunning && pid != null) {
+        await rm(pidPath, { force: true });
+        pid = undefined;
+    }
+    if (isRunning && configChanged && pid != null) {
+        await routerDeps.stopProcess(pid);
+        await rm(pidPath, { force: true });
+        isRunning = false;
+    }
+    if (!isRunning) {
+        const cliPath = routerDeps.resolveCliPath();
+        await access(cliPath);
+        await routerDeps.spawnDetached({
+            cliPath,
+            cwd,
+            env: {
+                ...process.env,
+                ...env,
+                HOME: mockHome
+            }
+        });
+    }
+    await routerDeps.waitForReady(connection.port, ROUTER_READY_TIMEOUT_MS);
+    return connection;
+};

package/dist/packages/channels/lark/src/index.d.ts

@@ -40,10 +40,10 @@ export declare const channelDefinition: import("@vibe-forge/core/channel").Chann
     type: "lark";
     appId: string;
     appSecret: string;
-    title?: string | undefined;
-    enabled?: boolean | undefined;
     description?: string | undefined;
     systemPrompt?: string | undefined;
+    title?: string | undefined;
+    enabled?: boolean | undefined;
     access?: {
         admins?: string[] | undefined;
         allowPrivateChat?: boolean | undefined;
@@ -60,10 +60,10 @@ export declare const channelDefinition: import("@vibe-forge/core/channel").Chann
     type: "lark";
     appId: string;
     appSecret: string;
-    title?: string | undefined;
-    enabled?: boolean | undefined;
     description?: string | undefined;
     systemPrompt?: string | undefined;
+    title?: string | undefined;
+    enabled?: boolean | undefined;
     access?: {
         admins?: string[] | undefined;
         allowPrivateChat?: boolean | undefined;

package/dist/packages/config/__tests__/load.spec.js

@@ -1,8 +1,8 @@
-import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import process from 'node:process';
-import { describe, expect, it } from 'vitest';
+import { describe, expect, it, vi } from 'vitest';
 import { loadConfig, resetConfigCache } from '#~/load.js';
 const DISABLE_DEV_CONFIG_ENV = '__VF_PROJECT_AI_DISABLE_DEV_CONFIG__';
 describe('loadConfig', () => {
@@ -38,4 +38,221 @@ describe('loadConfig', () => {
             await rm(tempDir, { force: true, recursive: true });
         }
     });
+    it('resolves extend chains with layered merge semantics', async () => {
+        const tempDir = await mkdtemp(path.join(os.tmpdir(), 'vf-config-extend-'));
+        try {
+            await writeFile(path.join(tempDir, 'base.yaml'), `
+defaultModelService: openai
+env:
+  BASE_URL: https://base.example.com
+permissions:
+  allow:
+    - Read
+announcements:
+  - base
+defaultIncludeMcpServers:
+  - docs
+notifications:
+  events:
+    completed:
+      title: Base Title
+plugins:
+  logger:
+    level: info
+adapters:
+  codex:
+    defaultModel: gpt-4.1
+`);
+            await writeFile(path.join(tempDir, '.ai.config.json'), JSON.stringify({
+                extend: './base.yaml',
+                defaultModel: 'project-model',
+                env: {
+                    API_KEY: '${TEST_API_KEY}'
+                },
+                permissions: {
+                    allow: ['Edit']
+                },
+                announcements: ['project'],
+                defaultIncludeMcpServers: ['browser'],
+                notifications: {
+                    events: {
+                        completed: {
+                            description: 'Project Description'
+                        }
+                    }
+                },
+                plugins: {
+                    chrome: {
+                        headless: true
+                    }
+                },
+                adapters: {
+                    codex: {
+                        excludeModels: ['gpt-4.1-mini']
+                    }
+                }
+            }, null, 2));
+            await writeFile(path.join(tempDir, 'user-base.json'), JSON.stringify({
+                enabledPlugins: {
+                    logger: true
+                },
+                shortcuts: {
+                    openConfig: 'cmd+,'
+                }
+            }, null, 2));
+            await writeFile(path.join(tempDir, '.ai.dev.config.yaml'), `
+extend:
+  - ./user-base.json
+enabledPlugins:
+  chrome: false
+shortcuts:
+  newSession: cmd+n
+`);
+            resetConfigCache();
+            const [projectConfig, userConfig] = await loadConfig({
+                cwd: tempDir,
+                jsonVariables: {
+                    TEST_API_KEY: 'secret-key'
+                }
+            });
+            expect(projectConfig).toMatchObject({
+                defaultModelService: 'openai',
+                defaultModel: 'project-model',
+                env: {
+                    BASE_URL: 'https://base.example.com',
+                    API_KEY: 'secret-key'
+                },
+                permissions: {
+                    allow: ['Read', 'Edit']
+                },
+                announcements: ['base', 'project'],
+                defaultIncludeMcpServers: ['docs', 'browser'],
+                notifications: {
+                    events: {
+                        completed: {
+                            title: 'Base Title',
+                            description: 'Project Description'
+                        }
+                    }
+                },
+                plugins: {
+                    logger: {
+                        level: 'info'
+                    },
+                    chrome: {
+                        headless: true
+                    }
+                },
+                adapters: {
+                    codex: {
+                        defaultModel: 'gpt-4.1',
+                        excludeModels: ['gpt-4.1-mini']
+                    }
+                }
+            });
+            expect(projectConfig?.extend).toBeUndefined();
+            expect(userConfig).toMatchObject({
+                enabledPlugins: {
+                    logger: true,
+                    chrome: false
+                },
+                shortcuts: {
+                    openConfig: 'cmd+,',
+                    newSession: 'cmd+n'
+                }
+            });
+            expect(userConfig?.extend).toBeUndefined();
+        }
+        finally {
+            resetConfigCache();
+            await rm(tempDir, { force: true, recursive: true });
+        }
+    });
+    it('resolves extend from dependency packages and package subpaths', async () => {
+        const tempDir = await mkdtemp(path.join(os.tmpdir(), 'vf-config-extend-package-'));
+        try {
+            const packageRoot = path.join(tempDir, 'node_modules', '@acme', 'vf-preset');
+            await mkdir(path.join(packageRoot, 'presets'), { recursive: true });
+            await writeFile(path.join(packageRoot, 'package.json'), JSON.stringify({
+                name: '@acme/vf-preset',
+                version: '1.0.0'
+            }, null, 2));
+            await writeFile(path.join(packageRoot, '.ai.config.yaml'), `
+defaultModelService: preset-service
+announcements:
+  - package-root
+`);
+            await writeFile(path.join(packageRoot, 'presets', 'web.yaml'), `
+permissions:
+  allow:
+    - Browser
+modelServices:
+  browser:
+    apiBaseUrl: https://browser.example.com
+    apiKey: browser-key
+`);
+            await writeFile(path.join(tempDir, '.ai.config.yaml'), `
+extend:
+  - "@acme/vf-preset"
+  - "@acme/vf-preset/presets/web"
+defaultModel: package-model
+`);
+            resetConfigCache();
+            const [projectConfig, userConfig] = await loadConfig({
+                cwd: tempDir,
+                jsonVariables: {}
+            });
+            expect(projectConfig).toMatchObject({
+                defaultModelService: 'preset-service',
+                defaultModel: 'package-model',
+                announcements: ['package-root'],
+                permissions: {
+                    allow: ['Browser']
+                },
+                modelServices: {
+                    browser: {
+                        apiBaseUrl: 'https://browser.example.com',
+                        apiKey: 'browser-key'
+                    }
+                }
+            });
+            expect(projectConfig?.extend).toBeUndefined();
+            expect(userConfig).toBeUndefined();
+        }
+        finally {
+            resetConfigCache();
+            await rm(tempDir, { force: true, recursive: true });
+        }
+    });
+    it('returns an empty project config when extend chain is circular', async () => {
+        const tempDir = await mkdtemp(path.join(os.tmpdir(), 'vf-config-extend-cycle-'));
+        const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+        try {
+            await writeFile(path.join(tempDir, 'base.json'), JSON.stringify({
+                extend: './child.json',
+                defaultModel: 'base'
+            }, null, 2));
+            await writeFile(path.join(tempDir, 'child.json'), JSON.stringify({
+                extend: './base.json',
+                defaultModel: 'child'
+            }, null, 2));
+            await writeFile(path.join(tempDir, '.ai.config.json'), JSON.stringify({
+                extend: './base.json',
+                defaultModel: 'project'
+            }, null, 2));
+            resetConfigCache();
+            const [projectConfig, userConfig] = await loadConfig({
+                cwd: tempDir,
+                jsonVariables: {}
+            });
+            expect(projectConfig).toBeUndefined();
+            expect(userConfig).toBeUndefined();
+            expect(errorSpy).toHaveBeenCalled();
+        }
+        finally {
+            errorSpy.mockRestore();
+            resetConfigCache();
+            await rm(tempDir, { force: true, recursive: true });
+        }
+    });
 });

package/dist/packages/config/__tests__/merge.spec.d.ts

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

package/dist/packages/config/__tests__/merge.spec.js

@@ -0,0 +1,92 @@
+import { describe, expect, it } from 'vitest';
+import { mergeConfigs } from '#~/merge.js';
+describe('mergeConfigs', () => {
+    it('merges layered config values with config-specific rules', () => {
+        const merged = mergeConfigs({
+            defaultModel: 'base-model',
+            adapters: {
+                codex: {
+                    defaultModel: 'gpt-4.1',
+                    includeModels: ['gpt-4.1']
+                }
+            },
+            env: {
+                BASE_URL: 'https://base.example.com'
+            },
+            permissions: {
+                allow: ['Read'],
+                defaultMode: 'plan'
+            },
+            announcements: ['base'],
+            defaultIncludeMcpServers: ['docs'],
+            notifications: {
+                events: {
+                    completed: {
+                        title: 'Base Title'
+                    }
+                }
+            },
+            plugins: {
+                logger: {
+                    level: 'info'
+                }
+            }
+        }, {
+            adapters: {
+                codex: {
+                    excludeModels: ['gpt-4.1-mini']
+                }
+            },
+            env: {
+                API_KEY: 'secret'
+            },
+            permissions: {
+                allow: ['Edit']
+            },
+            announcements: ['override'],
+            defaultIncludeMcpServers: ['browser', 'docs'],
+            notifications: {
+                events: {
+                    completed: {
+                        description: 'Child Description'
+                    }
+                }
+            },
+            plugins: {
+                chrome: {
+                    headless: true
+                }
+            }
+        });
+        expect(merged.defaultModel).toBe('base-model');
+        expect(merged.adapters?.codex).toEqual({
+            defaultModel: 'gpt-4.1',
+            includeModels: ['gpt-4.1'],
+            excludeModels: ['gpt-4.1-mini']
+        });
+        expect(merged.env).toEqual({
+            BASE_URL: 'https://base.example.com',
+            API_KEY: 'secret'
+        });
+        expect(merged.permissions).toEqual({
+            allow: ['Read', 'Edit'],
+            defaultMode: 'plan',
+            deny: undefined,
+            ask: undefined
+        });
+        expect(merged.announcements).toEqual(['base', 'override']);
+        expect(merged.defaultIncludeMcpServers).toEqual(['docs', 'browser']);
+        expect(merged.notifications?.events?.completed).toEqual({
+            title: 'Base Title',
+            description: 'Child Description'
+        });
+        expect(merged.plugins).toEqual({
+            logger: {
+                level: 'info'
+            },
+            chrome: {
+                headless: true
+            }
+        });
+    });
+});

package/dist/packages/config/src/index.d.ts

@@ -1,5 +1,6 @@
 export * from './default-vibe-forge-mcp';
 export * from './define';
 export * from './load';
+export * from './merge';
 export * from './system-prompt';
 export * from './update';

package/dist/packages/config/src/index.js

@@ -1,5 +1,6 @@
 export * from './default-vibe-forge-mcp';
 export * from './define';
 export * from './load';
+export * from './merge';
 export * from './system-prompt';
 export * from './update';

package/dist/packages/config/src/load.d.ts

@@ -9,5 +9,5 @@ export declare const buildConfigJsonVariables: (cwd: string, env?: Record<string
 };
 export declare const DISABLE_DEV_CONFIG_ENV = "__VF_PROJECT_AI_DISABLE_DEV_CONFIG__";
 export declare const resetConfigCache: (cwd?: string) => void;
-export declare const loadConfig: <TConfig = Record<string, unknown>>(options?: LoadConfigOptions) => Promise<readonly [TConfig | undefined, TConfig | undefined]>;
+export declare const loadConfig: <TConfig extends Record<string, unknown> = Record<string, unknown>>(options?: LoadConfigOptions) => Promise<readonly [TConfig | undefined, TConfig | undefined]>;
 export declare const loadAdapterConfig: <TAdapterConfig = unknown>(name: string, options?: LoadConfigOptions) => Promise<TAdapterConfig>;