@vibe-forge/tsconfigs 0.7.2 → 0.9.0

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

@@ -0,0 +1,143 @@
+import { NATIVE_HOOK_BRIDGE_ADAPTER_ENV } from '@vibe-forge/hooks';
+import { ensureClaudeCodeRouterReady } from './router-daemon';
+export const prepareClaudeExecution = async (ctx, options) => {
+    const { env, cwd, cache, configs: [config, userConfig] } = ctx;
+    const assetPlan = options.assetPlan;
+    const nativeHooksAvailable = env.__VF_PROJECT_AI_CLAUDE_NATIVE_HOOKS_AVAILABLE__ === '1';
+    const { description, sessionId, model, type, systemPrompt, appendSystemPrompt = true, permissionMode, mcpServers: inputMCPServersRule, tools: inputToolsRule } = options;
+    const resumeState = await cache.get('adapter.claude-code.resume-state');
+    const executionType = type === 'resume' && resumeState?.canResume === true ? 'resume' : 'create';
+    const settings = {
+        mcpServers: assetPlan?.mcpServers ?? {
+            ...config?.mcpServers,
+            ...userConfig?.mcpServers
+        },
+        permissions: {
+            allow: [
+                ...(config?.permissions?.allow ?? []),
+                ...(userConfig?.permissions?.allow ?? [])
+            ],
+            deny: [
+                ...(config?.permissions?.deny ?? []),
+                ...(userConfig?.permissions?.deny ?? [])
+            ],
+            ask: [
+                ...(config?.permissions?.ask ?? []),
+                ...(userConfig?.permissions?.ask ?? [])
+            ],
+            defaultMode: permissionMode ??
+                userConfig?.permissions?.defaultMode ??
+                config?.permissions?.defaultMode
+        },
+        defaultIncludeMcpServers: [
+            ...(config?.defaultIncludeMcpServers ?? []),
+            ...(userConfig?.defaultIncludeMcpServers ?? [])
+        ],
+        defaultExcludeMcpServers: [
+            ...(config?.defaultExcludeMcpServers ?? []),
+            ...(userConfig?.defaultExcludeMcpServers ?? [])
+        ],
+        plansDirectory: './.ai/works',
+        env: {
+            ...(config?.env ?? {}),
+            ...(userConfig?.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
+                }
+                : {})
+        },
+        companyAnnouncements: [
+            ...(config?.announcements ?? []),
+            ...(userConfig?.announcements ?? [])
+        ],
+        enabledPlugins: assetPlan?.native.enabledPlugins ?? {
+            ...(config?.enabledPlugins ?? {}),
+            ...(userConfig?.enabledPlugins ?? {})
+        },
+        extraKnownMarketplaces: assetPlan?.native.extraKnownMarketplaces ?? {
+            ...(config?.extraKnownMarketplaces ?? {}),
+            ...(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 ?? []),
+        ...(inputToolsRule?.include ?? [])
+    ];
+    unresolvedSettings.permissions.deny = [
+        ...(unresolvedSettings.permissions.deny ?? []),
+        ...(inputToolsRule?.exclude ?? [])
+    ];
+    const includeMcpServers = inputMCPServersRule?.include ?? settings.defaultIncludeMcpServers;
+    const excludeMcpServers = inputMCPServersRule?.exclude ?? settings.defaultExcludeMcpServers;
+    if ((includeMcpServers?.length ?? 0) > 0) {
+        Object.keys(mcpServers).forEach((key) => {
+            if (!includeMcpServers?.includes(key)) {
+                delete mcpServers[key];
+            }
+        });
+    }
+    if ((excludeMcpServers?.length ?? 0) > 0) {
+        Object.keys(mcpServers).forEach((key) => {
+            if (excludeMcpServers?.includes(key)) {
+                delete mcpServers[key];
+            }
+        });
+    }
+    const { cachePath: mcpCachePath } = await cache.set('adapter.claude-code.mcp', { mcpServers });
+    const { cachePath: settingsCachePath } = await cache.set('adapter.claude-code.settings', settings);
+    const args = [
+        ...(description
+            ? [JSON.stringify(`${(description?.trimStart().startsWith('-') ? '\0' : '')}${(description.replace(/`/g, "'"))}`)]
+            : []),
+        '--mcp-config',
+        mcpCachePath,
+        '--settings',
+        settingsCachePath
+    ].filter((a) => typeof a === 'string');
+    if (executionType === 'create') {
+        args.push('--session-id', sessionId);
+    }
+    else {
+        args.push('--resume', sessionId);
+    }
+    if (model != null && model !== '')
+        args.push('--model', model);
+    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: 'claude',
+        args,
+        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/adapters/claude-code/src/runtime/session.d.ts

@@ -0,0 +1,6 @@
+import type { AdapterCtx, AdapterEvent, AdapterQueryOptions } from '@vibe-forge/types';
+export declare const createClaudeSession: (ctx: AdapterCtx, options: AdapterQueryOptions) => Promise<{
+    kill: () => boolean;
+    emit: (event: AdapterEvent) => void;
+    pid: number | undefined;
+}>;

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

@@ -0,0 +1,261 @@
+import { spawn } from 'node:child_process';
+import { uuid } from '@vibe-forge/utils/uuid';
+import { mapAdapterContentToClaudeContent } from '../protocol/content';
+import { handleIncomingEvent } from '../protocol/incoming';
+import { prepareClaudeExecution } from './prepare';
+const stripAnsiSequences = (value) => {
+    let output = '';
+    let index = 0;
+    while (index < value.length) {
+        if (value.charCodeAt(index) === 27 && value[index + 1] === '[') {
+            index += 2;
+            while (index < value.length) {
+                const code = value.charCodeAt(index);
+                if (code >= 64 && code <= 126) {
+                    index += 1;
+                    break;
+                }
+                index += 1;
+            }
+            continue;
+        }
+        output += value[index];
+        index += 1;
+    }
+    return output;
+};
+export const createClaudeSession = async (ctx, options) => {
+    const { logger } = ctx;
+    const { onEvent, description, mode = 'stream', extraOptions } = options;
+    const { cliPath, args, env, cwd, sessionId, executionType } = await prepareClaudeExecution(ctx, options);
+    let didEmitFatalError = false;
+    const emitEvent = (event) => {
+        if (event.type === 'error' && event.data.fatal !== false) {
+            didEmitFatalError = true;
+        }
+        onEvent(event);
+    };
+    if (mode === 'stream') {
+        args.push('--print', '--verbose', '--debug', '--output-format', 'stream-json', '--input-format', 'stream-json', ...(extraOptions ?? []));
+        logger.info('Claude Code CLI command:', {
+            cliPath,
+            args,
+            mode
+        });
+        const proc = spawn(cliPath, args, {
+            env: { ...env, FORCE_COLOR: '1' },
+            cwd,
+            stdio: 'pipe'
+        });
+        let stdoutBuffer = '';
+        let canResumeMarked = executionType === 'resume';
+        const markResumeReady = async () => {
+            if (canResumeMarked)
+                return;
+            canResumeMarked = true;
+            await ctx.cache.set('adapter.claude-code.resume-state', { canResume: true });
+        };
+        const clearResumeReady = async () => {
+            canResumeMarked = false;
+            await ctx.cache.set('adapter.claude-code.resume-state', { canResume: false });
+        };
+        proc.stdout.on('data', (buf) => {
+            const rawStr = String(buf);
+            stdoutBuffer += rawStr;
+            const lines = stdoutBuffer.split('\n');
+            stdoutBuffer = lines.pop() ?? '';
+            for (const line of lines) {
+                logger.debug('Claude Code CLI stdout:', { line });
+                const cleanedLine = stripAnsiSequences(line);
+                const trimmed = cleanedLine.trim();
+                if (trimmed.startsWith('{') && trimmed.endsWith('}')) {
+                    try {
+                        const parsed = JSON.parse(trimmed);
+                        if (parsed.type === 'result' &&
+                            parsed.subtype === 'error_during_execution' &&
+                            parsed.errors.some(error => error.includes(`No conversation found with session ID: ${sessionId}`))) {
+                            void clearResumeReady();
+                        }
+                        if (executionType === 'create' &&
+                            ((parsed.type === 'system' && parsed.subtype === 'init') ||
+                                parsed.type === 'assistant' ||
+                                (parsed.type === 'result' && parsed.subtype === 'success'))) {
+                            void markResumeReady();
+                        }
+                        handleIncomingEvent(parsed, emitEvent);
+                    }
+                    catch (err) {
+                        console.error('Failed to parse JSON:', trimmed, err);
+                    }
+                }
+            }
+        });
+        const stderrBuffer = [];
+        proc.stderr.on('data', (buf) => {
+            const rawStr = String(buf);
+            stderrBuffer.push(rawStr);
+        });
+        let didEmitExit = false;
+        const emitExit = (data) => {
+            if (didEmitExit)
+                return;
+            didEmitExit = true;
+            emitEvent({
+                type: 'exit',
+                data
+            });
+        };
+        proc.on('error', (err) => {
+            const message = err instanceof Error ? err.message : String(err);
+            if (!didEmitFatalError) {
+                emitEvent({
+                    type: 'error',
+                    data: {
+                        message,
+                        details: err,
+                        fatal: true
+                    }
+                });
+            }
+            emitExit({
+                exitCode: 1,
+                stderr: message
+            });
+        });
+        proc.on('exit', (code) => {
+            const stderr = stderrBuffer.join('');
+            if ((code ?? 0) !== 0 && !didEmitFatalError) {
+                emitEvent({
+                    type: 'error',
+                    data: {
+                        message: stderr !== '' ? stderr : `Process exited with code ${code ?? 1}`,
+                        details: stderr !== '' ? { stderr } : { exitCode: code ?? 1 },
+                        fatal: true
+                    }
+                });
+            }
+            emitExit({
+                exitCode: code ?? undefined,
+                stderr
+            });
+        });
+        const emit = (event) => {
+            let outputEvent = {
+                uuid: uuid(),
+                timestamp: new Date().toISOString(),
+                sessionId,
+                cwd
+            };
+            switch (event.type) {
+                case 'message': {
+                    outputEvent = {
+                        ...outputEvent,
+                        type: 'user',
+                        parentUuid: event.parentUuid ?? null,
+                        message: {
+                            id: `msg_${Date.now()}`,
+                            type: 'message',
+                            role: 'user',
+                            content: mapAdapterContentToClaudeContent(event.content),
+                            uuid: uuid()
+                        }
+                    };
+                    break;
+                }
+                case 'interrupt': {
+                    outputEvent = {
+                        ...outputEvent,
+                        type: 'user',
+                        message: {
+                            role: 'user',
+                            content: [{ type: 'text', text: '[Request interrupted by user]' }]
+                        }
+                    };
+                    break;
+                }
+                case 'stop': {
+                    proc.stdin.end();
+                    return;
+                }
+                default:
+                    logger.warn('Unknown event:', event);
+                    break;
+            }
+            proc.stdin.write(`${JSON.stringify(outputEvent)}\n`);
+        };
+        if (description) {
+            emit({
+                type: 'message',
+                content: [
+                    { type: 'text', text: description }
+                ]
+            });
+        }
+        return {
+            kill: () => proc.kill(),
+            emit,
+            pid: proc.pid
+        };
+    }
+    args.push(...(extraOptions ?? []));
+    logger.info('Claude Code CLI command:', {
+        cliPath,
+        args,
+        extraOptions,
+        mode
+    });
+    const proc = spawn(cliPath, args, {
+        env: { ...env, FORCE_COLOR: '1' },
+        cwd,
+        stdio: 'inherit'
+    });
+    let didEmitExit = false;
+    const emitExit = (data) => {
+        if (didEmitExit)
+            return;
+        didEmitExit = true;
+        emitEvent({
+            type: 'exit',
+            data
+        });
+    };
+    proc.on('error', (err) => {
+        const message = err instanceof Error ? err.message : String(err);
+        if (!didEmitFatalError) {
+            emitEvent({
+                type: 'error',
+                data: {
+                    message,
+                    details: err,
+                    fatal: true
+                }
+            });
+        }
+        emitExit({
+            exitCode: 1,
+            stderr: message
+        });
+    });
+    proc.on('exit', (code) => {
+        if ((code ?? 0) !== 0 && !didEmitFatalError) {
+            emitEvent({
+                type: 'error',
+                data: {
+                    message: `Process exited with code ${code ?? 1}`,
+                    details: { exitCode: code ?? 1 },
+                    fatal: true
+                }
+            });
+        }
+        emitExit({
+            exitCode: code ?? undefined
+        });
+    });
+    return {
+        kill: () => proc.kill(),
+        emit: () => {
+            console.warn('emit() is not supported in direct mode');
+        },
+        pid: proc.pid
+    };
+};