@vibe-forge/tsconfigs 0.7.1 → 0.8.0

package/dist/apps/cli/src/mcp-sync/index.js

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractTextFromMessage = exports.fetchSessionMessages = exports.postSessionEvent = exports.createChildSession = exports.getParentSessionId = void 0;
+const node_process_1 = __importDefault(require("node:process"));
+const getServerBaseUrl = () => {
+    const host = node_process_1.default.env.__VF_PROJECT_AI_SERVER_HOST__ ?? 'localhost';
+    const port = node_process_1.default.env.__VF_PROJECT_AI_SERVER_PORT__ ?? '8787';
+    return `http://${host}:${port}`;
+};
+const getParentSessionId = () => {
+    const ctxId = node_process_1.default.env.__VF_PROJECT_AI_CTX_ID__;
+    return ctxId ?? undefined;
+};
+exports.getParentSessionId = getParentSessionId;
+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();
+};
+exports.createChildSession = createChildSession;
+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}`);
+    }
+};
+exports.postSessionEvent = postSessionEvent;
+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 ?? [];
+};
+exports.fetchSessionMessages = fetchSessionMessages;
+const extractTextFromMessage = (message) => {
+    if (typeof message.content === 'string') {
+        return message.content;
+    }
+    if (Array.isArray(message.content)) {
+        return message.content
+            .filter((c) => c.type === 'text')
+            .map((c) => ('text' in c ? c.text : ''))
+            .join('');
+    }
+    return '';
+};
+exports.extractTextFromMessage = extractTextFromMessage;

package/dist/apps/cli/src/mcp-tools/general/wait.d.ts

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

package/dist/apps/cli/src/mcp-tools/general/wait.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const zod_1 = require("zod");
+const types_1 = require("../types");
+exports.default = (0, types_1.defineRegister)(({ registerTool }) => {
+    registerTool('wait', {
+        title: 'Wait Tool',
+        description: 'Wait for a specified amount of time (milliseconds)',
+        inputSchema: zod_1.z.object({
+            ms: zod_1.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/apps/cli/src/mcp-tools/index.d.ts

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

package/dist/apps/cli/src/mcp-tools/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tools = void 0;
+const wait_1 = __importDefault(require("./general/wait"));
+const ask_user_1 = __importDefault(require("./interaction/ask-user"));
+const task_1 = __importDefault(require("./task"));
+exports.tools = {
+    general: (server) => {
+        (0, wait_1.default)(server);
+    },
+    interaction: (server) => {
+        (0, ask_user_1.default)(server);
+    },
+    task: (server) => {
+        (0, task_1.default)(server);
+    }
+};

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

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

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

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_process_1 = __importDefault(require("node:process"));
+const zod_1 = require("zod");
+const types_1 = require("../types");
+const Schema = zod_1.z.object({
+    question: zod_1.z.string().describe('The question to ask the user'),
+    options: zod_1.z.array(zod_1.z.object({
+        label: zod_1.z.string().describe('The label of the option'),
+        description: zod_1.z.string().optional().describe('The description of the option')
+    })).optional().describe('The options for the user to select from'),
+    multiselect: zod_1.z.boolean().optional().describe('Whether the user can select multiple options')
+});
+exports.default = (0, types_1.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 = node_process_1.default.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 = node_process_1.default.env.__VF_PROJECT_AI_SERVER_HOST__ ?? 'localhost';
+        const port = node_process_1.default.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/apps/cli/src/mcp-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/apps/cli/src/mcp-tools/proxy.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldEnableCategory = void 0;
+exports.createFilteredRegister = createFilteredRegister;
+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;
+        }
+    };
+}
+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;
+};
+exports.shouldEnableCategory = shouldEnableCategory;

package/dist/apps/cli/src/mcp-tools/task/index.d.ts

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

package/dist/apps/cli/src/mcp-tools/task/index.js

@@ -0,0 +1,140 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_process_1 = __importDefault(require("node:process"));
+const zod_1 = require("zod");
+const hooks_1 = require("@vibe-forge/core/hooks");
+const uuid_1 = require("@vibe-forge/core/utils/uuid");
+const index_js_1 = require("#~/mcp-sync/index.js");
+const types_1 = require("../types");
+const manager_1 = require("./manager");
+exports.default = (0, types_1.defineRegister)((server) => {
+    server.registerTool('StartTasks', {
+        title: 'Start Tasks',
+        description: 'Start multiple tasks in background or foreground',
+        inputSchema: zod_1.z.object({
+            tasks: zod_1.z
+                .array(zod_1.z.object({
+                description: zod_1.z
+                    .string()
+                    .describe('The description or prompt for the task'),
+                type: zod_1.z
+                    .enum([
+                    'default',
+                    'spec',
+                    'entity'
+                ])
+                    .describe('The type of definition to load (default, spec or entity)'),
+                name: zod_1.z
+                    .string()
+                    .describe('The name of the spec or entity to load, if type is spec or entity. Otherwise, ignored.')
+                    .optional(),
+                adapter: zod_1.z
+                    .string()
+                    .describe('The adapter to use for the task (e.g. claude-code)')
+                    .optional(),
+                permissionMode: zod_1.z
+                    .enum(['default', 'acceptEdits', 'plan', 'dontAsk', 'bypassPermissions'])
+                    .describe('Permission mode for the task')
+                    .optional(),
+                background: zod_1.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: (0, uuid_1.uuid)()
+        }));
+        const parentSessionId = (0, index_js_1.getParentSessionId)();
+        await (0, hooks_1.callHook)('StartTasks', {
+            cwd: node_process_1.default.cwd(),
+            sessionId: node_process_1.default.env.__VF_PROJECT_AI_SESSION_ID__,
+            tasks
+        });
+        const syncResults = parentSessionId
+            ? await Promise.allSettled(resolvedTasks.map(task => (0, index_js_1.createChildSession)({
+                id: task.taskId,
+                title: task.name ?? task.description,
+                parentSessionId
+            })))
+            : [];
+        const results = await Promise.allSettled(resolvedTasks
+            .map((task, idx) => manager_1.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 = manager_1.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: zod_1.z.object({
+            taskId: zod_1.z.string().describe('The ID of the task to check')
+        })
+    }, async ({ taskId }) => {
+        const task = manager_1.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: zod_1.z.object({
+            taskId: zod_1.z.string().describe('The ID of the task to stop')
+        })
+    }, async ({ taskId }) => {
+        const success = manager_1.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: zod_1.z.object({})
+    }, async () => {
+        const tasks = manager_1.taskManager.getAllTasks();
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify(tasks.map(({ session, onStop, serverSync, createdAt, ...task }) => task))
+                }]
+        };
+    });
+});

package/dist/apps/cli/src/mcp-tools/task/manager.d.ts

@@ -0,0 +1,49 @@
+import type { AdapterSession } from '@vibe-forge/core';
+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?: 'default' | 'acceptEdits' | 'plan' | 'dontAsk' | 'bypassPermissions';
+    background?: boolean;
+    status: 'running' | 'completed' | 'failed';
+    exitCode?: number;
+    logs: string[];
+    session?: AdapterSession;
+    createdAt: number;
+    onStop?: () => void;
+    serverSync?: ServerSyncState;
+}
+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 declare const taskManager: TaskManager;
+export {};