@vibe-forge/tsconfigs 0.7.2 → 0.8.0

package/dist/packages/mcp/src/sync.js

@@ -0,0 +1,52 @@
+import process from 'node:process';
+import { extractTextFromMessage } from '@vibe-forge/utils/chat-message';
+const getServerBaseUrl = () => {
+    const host = process.env.__VF_PROJECT_AI_SERVER_HOST__ ?? 'localhost';
+    const port = process.env.__VF_PROJECT_AI_SERVER_PORT__ ?? '8787';
+    return `http://${host}:${port}`;
+};
+export const getParentSessionId = () => {
+    const ctxId = process.env.__VF_PROJECT_AI_CTX_ID__;
+    return ctxId ?? undefined;
+};
+export const createChildSession = async (params) => {
+    const baseUrl = getServerBaseUrl();
+    const response = await fetch(`${baseUrl}/api/sessions`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+            id: params.id,
+            title: params.title,
+            parentSessionId: params.parentSessionId,
+            start: false
+        })
+    });
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Failed to create session: ${response.statusText} - ${errorText}`);
+    }
+    return response.json();
+};
+export const postSessionEvent = async (sessionId, payload) => {
+    const baseUrl = getServerBaseUrl();
+    const response = await fetch(`${baseUrl}/api/sessions/${sessionId}/events`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(payload)
+    });
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Failed to post session event: ${response.statusText} - ${errorText}`);
+    }
+};
+export const fetchSessionMessages = async (sessionId) => {
+    const baseUrl = getServerBaseUrl();
+    const response = await fetch(`${baseUrl}/api/sessions/${sessionId}/messages`);
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Failed to fetch session messages: ${response.statusText} - ${errorText}`);
+    }
+    const data = await response.json();
+    return data.messages ?? [];
+};
+export { extractTextFromMessage };

package/dist/packages/mcp/src/task-bindings.d.ts

@@ -0,0 +1,2 @@
+import type { McpTaskBindings } from '@vibe-forge/types';
+export declare const createMcpTaskBindings: () => McpTaskBindings;

package/dist/packages/mcp/src/task-bindings.js

@@ -0,0 +1,14 @@
+import { loadInjectDefaultSystemPromptValue, mergeSystemPrompts } from '@vibe-forge/config';
+import { callHook } from '@vibe-forge/hooks';
+import { generateAdapterQueryOptions, run } from '@vibe-forge/task';
+import { extractTextFromMessage } from '@vibe-forge/utils/chat-message';
+import { uuid } from '@vibe-forge/utils/uuid';
+export const createMcpTaskBindings = () => ({
+    createTaskId: uuid,
+    callHook: callHook,
+    generateAdapterQueryOptions: generateAdapterQueryOptions,
+    run: run,
+    loadInjectDefaultSystemPromptValue,
+    mergeSystemPrompts,
+    extractTextFromMessage
+});

package/dist/packages/mcp/src/tools/general/wait.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../types").Register;
+export default _default;

package/dist/packages/mcp/src/tools/general/wait.js

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { defineRegister } from '../types';
+export default defineRegister(({ registerTool }) => {
+    registerTool('wait', {
+        title: 'Wait Tool',
+        description: 'Wait for a specified amount of time (milliseconds)',
+        inputSchema: z.object({
+            ms: z.number().min(0).max(60000).describe('Time to wait in milliseconds')
+        })
+    }, async ({ ms }) => {
+        await new Promise((resolve) => setTimeout(resolve, ms));
+        return {
+            content: [{ type: 'text', text: `Finished waiting for ${ms}ms` }]
+        };
+    });
+});

package/dist/packages/mcp/src/tools/index.d.ts

@@ -0,0 +1,2 @@
+import type { Register } from './types';
+export declare const createMcpTools: () => Record<string, Register>;

package/dist/packages/mcp/src/tools/index.js

@@ -0,0 +1,12 @@
+import wait from './general/wait';
+import askUser from './interaction/ask-user';
+import { createTaskRegister } from './task';
+export const createMcpTools = () => ({
+    general: (server) => {
+        wait(server);
+    },
+    interaction: (server) => {
+        askUser(server);
+    },
+    task: createTaskRegister()
+});

package/dist/packages/mcp/src/tools/interaction/ask-user.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../types").Register;
+export default _default;

package/dist/packages/mcp/src/tools/interaction/ask-user.js

@@ -0,0 +1,51 @@
+import process from 'node:process';
+import { z } from 'zod';
+import { defineRegister } from '../types';
+const Schema = z.object({
+    question: z.string().describe('The question to ask the user'),
+    options: z.array(z.object({
+        label: z.string().describe('The label of the option'),
+        description: z.string().optional().describe('The description of the option')
+    })).optional().describe('The options for the user to select from'),
+    multiselect: z.boolean().optional().describe('Whether the user can select multiple options')
+});
+export default defineRegister(({ registerTool }) => {
+    registerTool('AskUserQuestion', {
+        title: 'Ask User Question',
+        description: 'Ask the user a question via the web interface',
+        inputSchema: Schema
+    }, async (args) => {
+        const { question, options, multiselect } = args;
+        const sessionId = process.env.__VF_PROJECT_AI_SESSION_ID__;
+        if (!sessionId) {
+            throw new Error('Session ID not found in environment variables. This tool can only be used within a Vibe Forge session.');
+        }
+        const host = process.env.__VF_PROJECT_AI_SERVER_HOST__ ?? 'localhost';
+        const port = process.env.__VF_PROJECT_AI_SERVER_PORT__ ?? '8787';
+        const response = await fetch(`http://${host}:${port}/api/interact/ask`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                sessionId,
+                question,
+                options,
+                multiselect
+            })
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Failed to ask user question: ${response.statusText} - ${errorText}`);
+        }
+        const result = await response.json();
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(result.result)
+                }
+            ]
+        };
+    });
+});

package/dist/packages/mcp/src/tools/proxy.d.ts

@@ -0,0 +1,12 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { Register } from './types.js';
+export interface FilterOptions {
+    include?: string[];
+    exclude?: string[];
+}
+export declare function createFilteredRegister(server: McpServer, options: {
+    tools?: FilterOptions;
+    prompts?: FilterOptions;
+    resources?: FilterOptions;
+}): Parameters<Register>[0];
+export declare const shouldEnableCategory: (category: string, options: FilterOptions) => boolean;

package/dist/packages/mcp/src/tools/proxy.js

@@ -0,0 +1,47 @@
+export function createFilteredRegister(server, options) {
+    const shouldEnable = (name, filter) => {
+        if (!filter)
+            return true;
+        const { include = [], exclude = [] } = filter;
+        if (include.length > 0 && !include.includes(name))
+            return false;
+        if (exclude.includes(name))
+            return false;
+        return true;
+    };
+    return {
+        registerTool: (...args) => {
+            const tool = server.registerTool(...args);
+            const name = args[0];
+            if (!shouldEnable(name, options.tools)) {
+                tool.disable();
+            }
+            return tool;
+        },
+        registerPrompt: (...args) => {
+            const prompt = server.registerPrompt(...args);
+            const name = args[0];
+            if (!shouldEnable(name, options.prompts)) {
+                prompt.disable();
+            }
+            return prompt;
+        },
+        registerResource: (...args) => {
+            // @ts-ignore - McpServer types have complex overloads that are hard to proxy perfectly
+            const resource = server.registerResource(...args);
+            const name = args[0];
+            if (!shouldEnable(name, options.resources)) {
+                resource.disable();
+            }
+            return resource;
+        }
+    };
+}
+export const shouldEnableCategory = (category, options) => {
+    const { include = [], exclude = [] } = options;
+    if (include.length > 0 && !include.includes(category))
+        return false;
+    if (exclude.includes(category))
+        return false;
+    return true;
+};

package/dist/packages/mcp/src/tools/task/index.d.ts

@@ -0,0 +1 @@
+export declare const createTaskRegister: () => import("../types").Register;

package/dist/packages/mcp/src/tools/task/index.js

@@ -0,0 +1,138 @@
+import process from 'node:process';
+import { callHook } from '@vibe-forge/hooks';
+import { uuid } from '@vibe-forge/utils/uuid';
+import { z } from 'zod';
+import { createChildSession, getParentSessionId } from '#~/sync.js';
+import { defineRegister } from '../types';
+import { TaskManager } from './manager';
+export const createTaskRegister = () => {
+    const taskManager = new TaskManager();
+    return defineRegister((server) => {
+        server.registerTool('StartTasks', {
+            title: 'Start Tasks',
+            description: 'Start multiple tasks in background or foreground',
+            inputSchema: z.object({
+                tasks: z
+                    .array(z.object({
+                    description: z
+                        .string()
+                        .describe('The description or prompt for the task'),
+                    type: z
+                        .enum([
+                        'default',
+                        'spec',
+                        'entity'
+                    ])
+                        .describe('The type of definition to load (default, spec or entity)'),
+                    name: z
+                        .string()
+                        .describe('The name of the spec or entity to load, if type is spec or entity. Otherwise, ignored.')
+                        .optional(),
+                    adapter: z
+                        .string()
+                        .describe('The adapter to use for the task (e.g. claude-code)')
+                        .optional(),
+                    permissionMode: z
+                        .enum(['default', 'acceptEdits', 'plan', 'dontAsk', 'bypassPermissions'])
+                        .describe('Permission mode for the task')
+                        .optional(),
+                    background: z
+                        .boolean()
+                        .describe('Whether to run in background (default: true). If false, waits for completion and returns logs.')
+                        .optional()
+                }))
+                    .describe('List of tasks to start')
+            })
+        }, async ({ tasks }) => {
+            const resolvedTasks = tasks.map((task) => ({
+                ...task,
+                taskId: uuid()
+            }));
+            const parentSessionId = getParentSessionId();
+            await callHook('StartTasks', {
+                cwd: process.cwd(),
+                sessionId: process.env.__VF_PROJECT_AI_SESSION_ID__,
+                tasks
+            });
+            const syncResults = parentSessionId
+                ? await Promise.allSettled(resolvedTasks.map(task => createChildSession({
+                    id: task.taskId,
+                    title: task.name ?? task.description,
+                    parentSessionId
+                })))
+                : [];
+            const results = await Promise.allSettled(resolvedTasks
+                .map((task, idx) => taskManager.startTask({
+                ...task,
+                enableServerSync: parentSessionId != null && syncResults[idx]?.status === 'fulfilled'
+            })));
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify(results.map((r, idx) => {
+                            const { taskId, description } = resolvedTasks[idx];
+                            const info = taskManager.getTask(taskId);
+                            const { session, onStop, serverSync, createdAt, ...safeInfo } = info ?? {};
+                            return {
+                                taskId,
+                                description,
+                                status: info?.status ?? r.status,
+                                logs: info?.logs ?? [],
+                                ...safeInfo
+                            };
+                        }))
+                    }]
+            };
+        });
+        server.registerTool('GetTaskInfo', {
+            title: 'Get Task Info',
+            description: 'Get the status and logs of a specific task',
+            inputSchema: z.object({
+                taskId: z.string().describe('The ID of the task to check')
+            })
+        }, async ({ taskId }) => {
+            const task = taskManager.getTask(taskId);
+            if (!task) {
+                return {
+                    content: [{ type: 'text', text: `Task ${taskId} not found.` }],
+                    isError: true
+                };
+            }
+            const { session, onStop, serverSync, createdAt, ...safeTask } = task;
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify([safeTask])
+                    }]
+            };
+        });
+        server.registerTool('StopTask', {
+            title: 'Stop Task',
+            description: 'Stop a running task',
+            inputSchema: z.object({
+                taskId: z.string().describe('The ID of the task to stop')
+            })
+        }, async ({ taskId }) => {
+            const success = taskManager.stopTask(taskId);
+            return {
+                content: [{
+                        type: 'text',
+                        text: success ? `Task ${taskId} stopped.` : `Failed to stop task ${taskId} (not found or already stopped).`
+                    }]
+            };
+        });
+        server.registerTool('ListTasks', {
+            title: 'List Tasks',
+            description: 'List all managed tasks',
+            inputSchema: z.object({})
+        }, async () => {
+            const tasks = taskManager.getAllTasks();
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify(tasks.map(({ session, onStop, serverSync, createdAt, ...task }) => task))
+                    }]
+            };
+        });
+    });
+};

package/dist/packages/mcp/src/tools/task/manager.d.ts

@@ -0,0 +1,48 @@
+import type { McpTaskSession, SessionPermissionMode } from '@vibe-forge/types';
+interface ServerSyncState {
+    sessionId: string;
+    lastEventIndex: number;
+    lastAssistantMessageId?: string;
+    seenMessageIds: Set<string>;
+    poller?: NodeJS.Timeout;
+}
+export interface TaskInfo {
+    taskId: string;
+    adapter?: string;
+    description: string;
+    type?: 'default' | 'spec' | 'entity';
+    name?: string;
+    permissionMode?: SessionPermissionMode;
+    background?: boolean;
+    status: 'running' | 'completed' | 'failed';
+    exitCode?: number;
+    logs: string[];
+    session?: McpTaskSession;
+    createdAt: number;
+    onStop?: () => void;
+    serverSync?: ServerSyncState;
+}
+export declare class TaskManager {
+    private tasks;
+    startTask(options: {
+        taskId: string;
+        description: string;
+        type?: 'default' | 'spec' | 'entity';
+        name?: string;
+        permissionMode?: 'default' | 'acceptEdits' | 'plan' | 'dontAsk' | 'bypassPermissions';
+        adapter?: string;
+        background?: boolean;
+        enableServerSync?: boolean;
+    }): Promise<{
+        taskId: string;
+        logs?: string[];
+    }>;
+    private handleEvent;
+    private startServerPolling;
+    private stopServerPolling;
+    private syncEvent;
+    getTask(taskId: string): TaskInfo | undefined;
+    getAllTasks(): TaskInfo[];
+    stopTask(taskId: string): boolean;
+}
+export {};

package/dist/packages/mcp/src/tools/task/manager.js

@@ -0,0 +1,255 @@
+import process from 'node:process';
+import { loadInjectDefaultSystemPromptValue, mergeSystemPrompts } from '@vibe-forge/config';
+import { callHook } from '@vibe-forge/hooks';
+import { generateAdapterQueryOptions, run } from '@vibe-forge/task';
+import { extractTextFromMessage } from '@vibe-forge/utils/chat-message';
+import { fetchSessionMessages, postSessionEvent } from '#~/sync.js';
+export class TaskManager {
+    tasks = new Map();
+    async startTask(options) {
+        const { taskId, adapter, description, type, name, permissionMode, background = true, enableServerSync } = options;
+        // Initialize Task Info
+        const taskInfo = {
+            taskId,
+            adapter,
+            description,
+            type,
+            name,
+            permissionMode,
+            background,
+            status: 'running',
+            logs: [],
+            createdAt: Date.now()
+        };
+        if (enableServerSync) {
+            taskInfo.serverSync = {
+                sessionId: taskId,
+                lastEventIndex: 0,
+                seenMessageIds: new Set()
+            };
+        }
+        this.tasks.set(taskId, taskInfo);
+        try {
+            // Resolve Config
+            const promptType = type !== 'default' ? type : undefined;
+            const promptName = name;
+            const promptCWD = process.cwd();
+            const [data, resolvedConfig] = await generateAdapterQueryOptions(promptType, promptName, promptCWD);
+            const env = {
+                ...process.env,
+                __VF_PROJECT_AI_CTX_ID__: process.env.__VF_PROJECT_AI_CTX_ID__ ?? taskId
+            };
+            await callHook('GenerateSystemPrompt', {
+                cwd: promptCWD,
+                sessionId: taskId,
+                type: promptType,
+                name: promptName,
+                data
+            }, env);
+            const injectDefaultSystemPrompt = await loadInjectDefaultSystemPromptValue(promptCWD);
+            // Start Task
+            const ctxId = process.env.__VF_PROJECT_AI_CTX_ID__ ?? taskId;
+            const { session } = await run({
+                adapter,
+                cwd: process.cwd(),
+                env: {
+                    ...process.env,
+                    __VF_PROJECT_AI_CTX_ID__: ctxId
+                }
+            }, {
+                type: 'create',
+                runtime: 'mcp',
+                mode: 'stream',
+                sessionId: taskId,
+                systemPrompt: mergeSystemPrompts({
+                    generatedSystemPrompt: resolvedConfig.systemPrompt,
+                    injectDefaultSystemPrompt
+                }),
+                permissionMode,
+                tools: resolvedConfig.tools,
+                skills: resolvedConfig.skills,
+                mcpServers: resolvedConfig.mcpServers,
+                promptAssetIds: resolvedConfig.promptAssetIds,
+                onEvent: (event) => {
+                    this.handleEvent(taskId, event);
+                }
+            });
+            // Store session for control
+            const task = this.tasks.get(taskId);
+            if (task) {
+                task.session = session;
+                // Send initial prompt (description)
+                session.emit({
+                    type: 'message',
+                    content: [{ type: 'text', text: description }]
+                });
+                this.startServerPolling(taskId);
+            }
+            if (!background) {
+                // Wait for completion
+                await new Promise((resolve) => {
+                    const task = this.tasks.get(taskId);
+                    if (!task) {
+                        resolve();
+                        return;
+                    }
+                    // Check if already finished
+                    if (task.status !== 'running') {
+                        resolve();
+                        return;
+                    }
+                    // Register callback
+                    task.onStop = resolve;
+                });
+                return { taskId, logs: taskInfo.logs };
+            }
+        }
+        catch (err) {
+            const task = this.tasks.get(taskId);
+            if (task) {
+                task.status = 'failed';
+                task.logs.push(`Failed to start task: ${err instanceof Error ? err.message : String(err)}`);
+                task.onStop?.();
+            }
+            throw err;
+        }
+        return { taskId };
+    }
+    handleEvent(taskId, event) {
+        const task = this.tasks.get(taskId);
+        if (!task)
+            return;
+        void this.syncEvent(task, event);
+        switch (event.type) {
+            case 'message': {
+                const message = event.data;
+                if (message?.id) {
+                    task.serverSync?.seenMessageIds.add(message.id);
+                }
+                if (message?.role === 'assistant' && message.id) {
+                    if (task.serverSync) {
+                        task.serverSync.lastAssistantMessageId = message.id;
+                    }
+                }
+                const content = event.data.content;
+                let text = '';
+                if (typeof content === 'string') {
+                    text = content;
+                }
+                else if (Array.isArray(content)) {
+                    text = content.map(c => c.type === 'text' ? c.text : '').join('');
+                }
+                if (text) {
+                    task.logs.push(text);
+                }
+                break;
+            }
+            case 'error': {
+                task.logs.push(event.data.message);
+                if (event.data.fatal !== false) {
+                    task.status = 'failed';
+                    this.stopServerPolling(taskId);
+                    task.onStop?.();
+                }
+                break;
+            }
+            case 'stop': {
+                if (task.status === 'failed') {
+                    this.stopServerPolling(taskId);
+                    task.onStop?.();
+                    break;
+                }
+                task.status = 'completed';
+                this.stopServerPolling(taskId);
+                task.onStop?.();
+                break;
+            }
+            case 'exit':
+                task.status = event.data.exitCode === 0 ? 'completed' : 'failed';
+                task.exitCode = event.data.exitCode ?? undefined;
+                task.logs.push(`Process exited with code ${event.data.exitCode}`);
+                this.stopServerPolling(taskId);
+                task.onStop?.();
+                break;
+        }
+    }
+    startServerPolling(taskId) {
+        const task = this.tasks.get(taskId);
+        if (!task?.serverSync)
+            return;
+        if (task.serverSync.poller)
+            return;
+        const poll = async () => {
+            const current = this.tasks.get(taskId);
+            if (!current?.serverSync || !current.session)
+                return;
+            try {
+                const events = await fetchSessionMessages(current.serverSync.sessionId);
+                const startIndex = current.serverSync.lastEventIndex;
+                const newEvents = events.slice(startIndex);
+                current.serverSync.lastEventIndex = events.length;
+                for (const ev of newEvents) {
+                    if (ev.type !== 'message')
+                        continue;
+                    if (ev.message.role !== 'user')
+                        continue;
+                    if (ev.message.id && current.serverSync.seenMessageIds.has(ev.message.id)) {
+                        continue;
+                    }
+                    if (ev.message.id) {
+                        current.serverSync.seenMessageIds.add(ev.message.id);
+                    }
+                    const text = extractTextFromMessage(ev.message).trim();
+                    if (text === '')
+                        continue;
+                    current.session.emit({
+                        type: 'message',
+                        content: [{ type: 'text', text }],
+                        parentUuid: current.serverSync.lastAssistantMessageId
+                    });
+                }
+            }
+            catch { }
+        };
+        task.serverSync.poller = setInterval(() => {
+            void poll();
+        }, 1000);
+        void poll();
+    }
+    stopServerPolling(taskId) {
+        const task = this.tasks.get(taskId);
+        if (task?.serverSync?.poller) {
+            clearInterval(task.serverSync.poller);
+            task.serverSync.poller = undefined;
+        }
+    }
+    async syncEvent(task, event) {
+        if (!task.serverSync)
+            return;
+        try {
+            await postSessionEvent(task.serverSync.sessionId, event);
+        }
+        catch (err) {
+            task.logs.push(`Sync event failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    getTask(taskId) {
+        return this.tasks.get(taskId);
+    }
+    getAllTasks() {
+        return Array.from(this.tasks.values());
+    }
+    stopTask(taskId) {
+        const task = this.tasks.get(taskId);
+        if (task && task.session) {
+            task.session.kill();
+            task.logs.push('Task stopped by user');
+            task.status = 'failed'; // or 'stopped' if we had that status
+            this.stopServerPolling(taskId);
+            if (task.onStop)
+                task.onStop();
+            return true;
+        }
+        return false;
+    }
+}