@vibecodetown/mcp-server 1.3.1 → 1.5.0

package/build/mcp/tools/vibe_pm/workspace_recipe.js

@@ -0,0 +1,65 @@
+import * as path from "node:path";
+import { z } from "zod";
+import { renderRecipe } from "../../recipe/index.js";
+import { withTimeout } from "../../../utils/with_timeout.js";
+const RECIPE_IDS = ["minimal", "full"];
+export const WorkspaceRecipeInputSchema = z.object({
+    recipe_id: z.enum(RECIPE_IDS).default("minimal"),
+    target_dir: z.string().min(1).default("."),
+    vars: z.record(z.string()).default({}),
+    dry_run: z.boolean().default(true),
+    timeout_ms: z.number().int().min(1_000).max(120_000).default(30_000),
+});
+const WorkspaceRecipeFileResultSchema = z.object({
+    path: z.string(),
+    action: z.enum(["create", "replace", "ensure_dir"]),
+    applied: z.boolean(),
+    skipped_reason: z.string().optional(),
+});
+export const WorkspaceRecipeOutputSchema = z.object({
+    status: z.enum(["PLANNED", "APPLIED"]),
+    recipe_id: z.enum(RECIPE_IDS),
+    target_dir: z.string().min(1),
+    dry_run: z.boolean(),
+    files: z.array(WorkspaceRecipeFileResultSchema),
+    commands_not_run: z.array(z.string()),
+    summary: z.string(),
+});
+function resolveTargetRoot(workspaceRoot, targetDir) {
+    const resolvedWorkspace = path.resolve(workspaceRoot);
+    const resolvedTarget = path.resolve(resolvedWorkspace, targetDir);
+    const isSame = resolvedTarget === resolvedWorkspace;
+    const isSubPath = resolvedTarget.startsWith(resolvedWorkspace + path.sep);
+    if (!isSame && !isSubPath) {
+        throw new Error("target_dir must stay inside workspace root");
+    }
+    return resolvedTarget;
+}
+export async function workspaceRecipe(input) {
+    const effectiveInput = WorkspaceRecipeInputSchema.parse(input);
+    const workspaceRoot = process.cwd();
+    const targetRoot = resolveTargetRoot(workspaceRoot, effectiveInput.target_dir);
+    const timeoutMs = effectiveInput.timeout_ms ?? 30_000;
+    const rendered = await withTimeout(renderRecipe({
+        recipe_id: effectiveInput.recipe_id,
+        project_root: targetRoot,
+        vars: effectiveInput.vars,
+        dry_run: effectiveInput.dry_run,
+    }), timeoutMs, "workspace_recipe");
+    const normalizedFiles = rendered.files.map((file) => {
+        const rootRelative = path.relative(workspaceRoot, path.resolve(targetRoot, file.path));
+        return {
+            ...file,
+            path: rootRelative || file.path,
+        };
+    });
+    return WorkspaceRecipeOutputSchema.parse({
+        status: effectiveInput.dry_run ? "PLANNED" : "APPLIED",
+        recipe_id: effectiveInput.recipe_id,
+        target_dir: path.relative(workspaceRoot, targetRoot) || ".",
+        dry_run: effectiveInput.dry_run,
+        files: normalizedFiles,
+        commands_not_run: ["No command execution is performed in workspace_recipe mode."],
+        summary: rendered.summary,
+    });
+}

package/build/mcp/transport/handlers.d.ts

@@ -4,8 +4,9 @@
  *
  * HTTP request handlers for MCP endpoints.
  */
-import type * as http from "node:http";
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type * as http from 'node:http';
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function getRegisteredToolCount(mcpServer: McpServer): number;
 /**
  * Send JSON response.
  */

package/build/mcp/transport/handlers.js

@@ -4,14 +4,42 @@
  *
  * HTTP request handlers for MCP endpoints.
  */
+function toToolRegistryEntries(registry) {
+    if (!registry) {
+        return [];
+    }
+    if (registry instanceof Map) {
+        return Array.from(registry.entries());
+    }
+    if (typeof registry === 'object') {
+        return Object.entries(registry);
+    }
+    return [];
+}
+function getToolByName(registry, name) {
+    if (!registry) {
+        return undefined;
+    }
+    if (registry instanceof Map) {
+        return registry.get(name);
+    }
+    if (typeof registry === 'object') {
+        return registry[name];
+    }
+    return undefined;
+}
+export function getRegisteredToolCount(mcpServer) {
+    const serverAny = mcpServer;
+    return toToolRegistryEntries(serverAny._registeredTools).length;
+}
 /**
  * Send JSON response.
  */
 export function sendJson(res, status, data) {
     const body = JSON.stringify(data);
     res.writeHead(status, {
-        "Content-Type": "application/json",
-        "Content-Length": Buffer.byteLength(body),
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(body),
     });
     res.end(body);
 }
@@ -22,19 +50,19 @@ export async function readBody(req, maxBytes) {
     return new Promise((resolve, reject) => {
         const chunks = [];
         let totalBytes = 0;
-        req.on("data", (chunk) => {
+        req.on('data', (chunk) => {
             totalBytes += chunk.length;
             if (totalBytes > maxBytes) {
                 req.destroy();
-                reject(new Error("Request body too large"));
+                reject(new Error('Request body too large'));
                 return;
             }
             chunks.push(chunk);
         });
-        req.on("end", () => {
-            resolve(Buffer.concat(chunks).toString("utf-8"));
+        req.on('end', () => {
+            resolve(Buffer.concat(chunks).toString('utf-8'));
         });
-        req.on("error", reject);
+        req.on('error', reject);
     });
 }
 /**
@@ -43,24 +71,20 @@ export async function readBody(req, maxBytes) {
 export function createToolsListHandler(mcpServer) {
     return (_req, res) => {
         try {
-            // Get registered tools from MCP server
-            // The MCP SDK stores tools internally, we need to access them
             const serverAny = mcpServer;
             const tools = [];
-            if (serverAny._registeredTools) {
-                for (const [name, tool] of serverAny._registeredTools.entries()) {
-                    tools.push({
-                        name,
-                        description: tool.description,
-                    });
-                }
+            for (const [name, tool] of toToolRegistryEntries(serverAny._registeredTools)) {
+                tools.push({
+                    name,
+                    description: tool.description,
+                });
             }
             sendJson(res, 200, { tools });
         }
         catch (error) {
             sendJson(res, 500, {
                 success: false,
-                error: error instanceof Error ? error.message : "Failed to list tools",
+                error: error instanceof Error ? error.message : 'Failed to list tools',
             });
         }
     };
@@ -79,29 +103,27 @@ export function createToolCallHandler(mcpServer, maxBodyBytes) {
             catch {
                 sendJson(res, 400, {
                     success: false,
-                    error: "Invalid JSON body",
+                    error: 'Invalid JSON body',
                 });
                 return;
             }
             const { name, input } = parsed;
-            if (!name || typeof name !== "string") {
+            if (!name || typeof name !== 'string') {
                 sendJson(res, 400, {
                     success: false,
-                    error: "Missing or invalid tool name",
+                    error: 'Missing or invalid tool name',
                 });
                 return;
             }
-            // Call the tool through MCP server
-            // We need to simulate what the SDK does internally
             const serverAny = mcpServer;
-            if (!serverAny._registeredTools?.has(name)) {
+            const tool = getToolByName(serverAny._registeredTools, name);
+            if (!tool || typeof tool.handler !== 'function') {
                 sendJson(res, 404, {
                     success: false,
                     error: `Tool not found: ${name}`,
                 });
                 return;
             }
-            const tool = serverAny._registeredTools.get(name);
             const result = await tool.handler(input ?? {});
             sendJson(res, 200, {
                 success: true,
@@ -111,7 +133,7 @@ export function createToolCallHandler(mcpServer, maxBodyBytes) {
         catch (error) {
             sendJson(res, 500, {
                 success: false,
-                error: error instanceof Error ? error.message : "Tool call failed",
+                error: error instanceof Error ? error.message : 'Tool call failed',
             });
         }
     };

package/build/mcp/transport/http.d.ts

@@ -5,10 +5,14 @@
  * HTTP server wrapper for MCP, enabling K8s deployment.
  *
  * Endpoints:
- *   GET  /healthz     - K8s liveness probe
- *   GET  /readyz      - K8s readiness probe
- *   GET  /mcp/tools   - List available tools
- *   POST /mcp/call    - Call a tool
+ *   GET  /healthz           - K8s liveness probe
+ *   GET  /readyz            - K8s readiness probe
+ *   GET  /metrics           - Prometheus metrics (text format)
+ *   GET  /mcp/tools         - List available tools
+ *   POST /mcp/call          - Call a tool
+ *   POST /workers/register  - Register a remote worker
+ *   DELETE /workers/:id     - Unregister a remote worker
+ *   GET  /workers           - List remote workers
  *
  * Usage:
  *   const handle = await startHttpTransport(mcpServer, {
@@ -16,8 +20,8 @@
  *     host: "0.0.0.0",
  *   });
  */
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import type { HttpTransportOptions, HttpTransportHandle } from "./types.js";
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { HttpTransportOptions, HttpTransportHandle } from './types.js';
 /**
  * Start MCP HTTP transport server.
  *

package/build/mcp/transport/http.js

@@ -5,10 +5,14 @@
  * HTTP server wrapper for MCP, enabling K8s deployment.
  *
  * Endpoints:
- *   GET  /healthz     - K8s liveness probe
- *   GET  /readyz      - K8s readiness probe
- *   GET  /mcp/tools   - List available tools
- *   POST /mcp/call    - Call a tool
+ *   GET  /healthz           - K8s liveness probe
+ *   GET  /readyz            - K8s readiness probe
+ *   GET  /metrics           - Prometheus metrics (text format)
+ *   GET  /mcp/tools         - List available tools
+ *   POST /mcp/call          - Call a tool
+ *   POST /workers/register  - Register a remote worker
+ *   DELETE /workers/:id     - Unregister a remote worker
+ *   GET  /workers           - List remote workers
  *
  * Usage:
  *   const handle = await startHttpTransport(mcpServer, {
@@ -16,9 +20,14 @@
  *     host: "0.0.0.0",
  *   });
  */
-import * as http from "node:http";
-import { sendJson, createToolsListHandler, createToolCallHandler, } from "./handlers.js";
-import { createLivenessHandler, createReadinessHandler, customChecker, } from "../../health/index.js";
+import { logger } from '../../shared/logger.js';
+import * as http from 'node:http';
+import { sendJson, readBody, createToolsListHandler, createToolCallHandler, getRegisteredToolCount, } from './handlers.js';
+import { createLivenessHandler, createReadinessHandler, customChecker, } from '../../health/index.js';
+import { RemoteRegistry } from '../../pool-manager/remote-registry.js';
+import { extractBearerToken, validateBearerToken } from '../../pool-manager/remote-auth.js';
+import { getGlobalRegistry } from '../metrics/collector.js';
+import { isOtelActive } from '../../observability/otel.js';
 const DEFAULT_MAX_BODY_BYTES = 1_000_000; // 1MB
 /**
  * Start MCP HTTP transport server.
@@ -32,77 +41,174 @@ export async function startHttpTransport(mcpServer, options) {
     // Create health handlers
     const handleLiveness = createLivenessHandler({
         version,
-        component: "mcp-server",
+        component: 'mcp-server',
     });
     const handleReadiness = createReadinessHandler([
-        customChecker("tools_registered", () => {
-            const serverAny = mcpServer;
-            return (serverAny._registeredTools?.size ?? 0) > 0;
-        }, (ready) => {
-            const serverAny = mcpServer;
-            const count = serverAny._registeredTools?.size ?? 0;
-            return ready ? `${count} tools registered` : "No tools registered";
+        customChecker('tools_registered', () => getRegisteredToolCount(mcpServer) > 0, ready => {
+            const count = getRegisteredToolCount(mcpServer);
+            return ready ? `${count} tools registered` : 'No tools registered';
         }),
     ]);
     // Create MCP handlers
     const handleToolsList = createToolsListHandler(mcpServer);
     const handleToolCall = createToolCallHandler(mcpServer, maxBodyBytes);
+    // Remote worker registry (shared across requests)
+    const remoteRegistry = new RemoteRegistry();
+    /**
+     * Validate the pool auth token from the Authorization header.
+     * Returns true if authorized, false (and sends 401) otherwise.
+     */
+    function authorizePoolRequest(req, res) {
+        const expectedToken = process.env.VIBE_POOL_AUTH_TOKEN ?? '';
+        if (!expectedToken) {
+            sendJson(res, 401, { error: 'Pool auth not configured (VIBE_POOL_AUTH_TOKEN missing)' });
+            return false;
+        }
+        const authHeader = req.headers.authorization ?? '';
+        const token = extractBearerToken(authHeader);
+        if (!token || !validateBearerToken(token, expectedToken)) {
+            sendJson(res, 401, { error: 'Unauthorized' });
+            return false;
+        }
+        return true;
+    }
     // Create HTTP server
     const server = http.createServer(async (req, res) => {
-        const url = new URL(req.url || "/", `http://${host}:${port}`);
+        const url = new URL(req.url || '/', `http://${host}:${port}`);
         // CORS headers
-        res.setHeader("Access-Control-Allow-Origin", "*");
-        res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
-        res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, DELETE, OPTIONS');
+        res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
         // CORS preflight
-        if (req.method === "OPTIONS") {
+        if (req.method === 'OPTIONS') {
             res.writeHead(204);
             res.end();
             return;
         }
         try {
             // Health endpoints
-            if (req.method === "GET" && url.pathname === "/healthz") {
+            if (req.method === 'GET' && url.pathname === '/healthz') {
                 handleLiveness(req, res);
                 return;
             }
-            if (req.method === "GET" && url.pathname === "/readyz") {
+            if (req.method === 'GET' && url.pathname === '/readyz') {
                 await handleReadiness(req, res);
                 return;
             }
+            // Prometheus metrics endpoint
+            if (req.method === 'GET' && url.pathname === '/metrics') {
+                try {
+                    const registry = getGlobalRegistry();
+                    const metricsText = registry.exportText();
+                    // If OTel is active, append a comment so scrapers can identify the source
+                    const header = isOtelActive()
+                        ? '# OTel bridge active\n'
+                        : '';
+                    const body = header + metricsText;
+                    res.writeHead(200, {
+                        'Content-Type': 'text/plain; version=0.0.4; charset=utf-8',
+                        'Cache-Control': 'no-cache',
+                    });
+                    res.end(body);
+                }
+                catch (error) {
+                    sendJson(res, 500, {
+                        error: error instanceof Error ? error.message : 'Metrics export failed',
+                    });
+                }
+                return;
+            }
             // MCP endpoints
-            if (req.method === "GET" && url.pathname === "/mcp/tools") {
+            if (req.method === 'GET' && url.pathname === '/mcp/tools') {
                 handleToolsList(req, res);
                 return;
             }
-            if (req.method === "POST" && url.pathname === "/mcp/call") {
+            if (req.method === 'POST' && url.pathname === '/mcp/call') {
                 await handleToolCall(req, res);
                 return;
             }
+            // ============================================================
+            // Remote Worker Pool endpoints
+            // ============================================================
+            // POST /workers/register
+            if (req.method === 'POST' && url.pathname === '/workers/register') {
+                if (!authorizePoolRequest(req, res))
+                    return;
+                const body = await readBody(req, maxBodyBytes);
+                let parsed;
+                try {
+                    parsed = JSON.parse(body);
+                }
+                catch {
+                    sendJson(res, 400, { error: 'Invalid JSON body' });
+                    return;
+                }
+                const workerId = typeof parsed.worker_id === 'string' ? parsed.worker_id : '';
+                const type = typeof parsed.type === 'string' ? parsed.type : '';
+                const endpoint = typeof parsed.endpoint === 'string' ? parsed.endpoint : '';
+                const authToken = typeof parsed.auth_token === 'string' ? parsed.auth_token : '';
+                if (!workerId || !type || !endpoint || !authToken) {
+                    sendJson(res, 400, {
+                        error: 'Missing required fields: worker_id, type, endpoint, auth_token',
+                    });
+                    return;
+                }
+                const entry = remoteRegistry.register({ worker_id: workerId, type, endpoint, auth_token: authToken });
+                if (!entry) {
+                    sendJson(res, 409, { error: `Worker already registered: ${workerId}` });
+                    return;
+                }
+                sendJson(res, 201, { ok: true, worker: entry });
+                return;
+            }
+            // DELETE /workers/:id
+            if (req.method === 'DELETE' && url.pathname.startsWith('/workers/')) {
+                if (!authorizePoolRequest(req, res))
+                    return;
+                const workerId = decodeURIComponent(url.pathname.slice('/workers/'.length));
+                if (!workerId) {
+                    sendJson(res, 400, { error: 'Missing worker id' });
+                    return;
+                }
+                const removed = remoteRegistry.unregister(workerId);
+                if (!removed) {
+                    sendJson(res, 404, { error: `Worker not found: ${workerId}` });
+                    return;
+                }
+                sendJson(res, 200, { ok: true, worker_id: workerId });
+                return;
+            }
+            // GET /workers
+            if (req.method === 'GET' && url.pathname === '/workers') {
+                if (!authorizePoolRequest(req, res))
+                    return;
+                sendJson(res, 200, { workers: remoteRegistry.list() });
+                return;
+            }
             // 404
-            sendJson(res, 404, { error: "Not found", path: url.pathname });
+            sendJson(res, 404, { error: 'Not found', path: url.pathname });
         }
         catch (error) {
-            console.error("[mcp-http] Request error:", error);
+            logger.error({ err: error }, '[mcp-http] Request error');
             sendJson(res, 500, {
-                error: error instanceof Error ? error.message : "Internal server error",
+                error: error instanceof Error ? error.message : 'Internal server error',
             });
         }
     });
     // Start server
     return new Promise((resolve, reject) => {
-        server.on("error", reject);
+        server.on('error', reject);
         server.listen(port, host, () => {
             const addr = server.address();
-            const actualPort = typeof addr === "object" && addr ? addr.port : port;
+            const actualPort = typeof addr === 'object' && addr ? addr.port : port;
             const serverUrl = `http://${host}:${actualPort}`;
-            console.error(`[mcp-http] Listening on ${serverUrl}`);
+            logger.error(`[mcp-http] Listening on ${serverUrl}`);
             resolve({
                 server,
                 port: actualPort,
                 url: serverUrl,
                 close: () => new Promise((resolveClose, rejectClose) => {
-                    server.close((err) => {
+                    server.close(err => {
                         if (err)
                             rejectClose(err);
                         else

package/build/native/block-writer-wrapper.d.ts

@@ -0,0 +1,48 @@
+/**
+ * BlockStoreWriter Wrapper
+ *
+ * Provides a unified API that uses native bindings when available,
+ * with a fallback to the existing TypeScript BlockStore.
+ */
+/** Result of writing a block */
+export interface WriteBlockResult {
+    blockId: string;
+    stored: boolean;
+}
+/** Result of creating a chain */
+export interface CreateChainResult {
+    rootHash: string;
+    storedCount: number;
+    skippedCount: number;
+}
+/** Block input for chain creation */
+export interface BlockInput {
+    content: string;
+    blockType?: string;
+    sourceRef: string;
+    tokenEstimate?: number;
+    metadata?: Record<string, unknown>;
+}
+/** Unified BlockStoreWriter interface */
+export interface BlockStoreWriter {
+    put(blockJson: string): WriteBlockResult;
+    has(blockId: string): boolean;
+    delete(blockId: string): boolean;
+    createChain(sourcePath: string, blocks: BlockInput[]): CreateChainResult;
+    putChain(chainJson: string): void;
+    deleteChain(rootHash: string): boolean;
+    invalidateCache(): void;
+    getIndexJson(): string;
+}
+/**
+ * Create a BlockStoreWriter using native bindings if available.
+ * Falls back to null if native is unavailable (use TypeScript BlockStore instead).
+ *
+ * @param workspaceRoot - Root path of the workspace
+ * @returns BlockStoreWriter or null if native unavailable
+ */
+export declare function createNativeBlockStoreWriter(workspaceRoot: string): BlockStoreWriter | null;
+/**
+ * Check if native BlockStoreWriter is available.
+ */
+export declare function isNativeBlockStoreWriter(): boolean;

package/build/native/block-writer-wrapper.js

@@ -0,0 +1,58 @@
+/**
+ * BlockStoreWriter Wrapper
+ *
+ * Provides a unified API that uses native bindings when available,
+ * with a fallback to the existing TypeScript BlockStore.
+ */
+import { loadNative, isNativeAvailable } from './loader.js';
+/**
+ * Create a BlockStoreWriter using native bindings if available.
+ * Falls back to null if native is unavailable (use TypeScript BlockStore instead).
+ *
+ * @param workspaceRoot - Root path of the workspace
+ * @returns BlockStoreWriter or null if native unavailable
+ */
+export function createNativeBlockStoreWriter(workspaceRoot) {
+    const native = loadNative();
+    if (!native)
+        return null;
+    const inner = new native.BlockStoreWriter(workspaceRoot);
+    return {
+        put(blockJson) {
+            const r = inner.put(blockJson);
+            return { blockId: r.blockId, stored: r.stored };
+        },
+        has(blockId) {
+            return inner.has(blockId);
+        },
+        delete(blockId) {
+            return inner.delete(blockId);
+        },
+        createChain(sourcePath, blocks) {
+            const r = inner.createChain(sourcePath, JSON.stringify(blocks));
+            return {
+                rootHash: r.rootHash,
+                storedCount: r.storedCount,
+                skippedCount: r.skippedCount,
+            };
+        },
+        putChain(chainJson) {
+            inner.putChain(chainJson);
+        },
+        deleteChain(rootHash) {
+            return inner.deleteChain(rootHash);
+        },
+        invalidateCache() {
+            inner.invalidateCache();
+        },
+        getIndexJson() {
+            return inner.getIndexJson();
+        },
+    };
+}
+/**
+ * Check if native BlockStoreWriter is available.
+ */
+export function isNativeBlockStoreWriter() {
+    return isNativeAvailable();
+}

package/build/native/bloom-wrapper.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Bloom Filter Wrapper
+ *
+ * Provides a unified API that uses native bindings when available,
+ * with a pure JavaScript fallback.
+ */
+/**
+ * Unified Bloom Filter interface.
+ */
+export interface BloomFilter {
+    insert(item: string): void;
+    contains(item: string): boolean;
+    merge(other: BloomFilter): void;
+    count(): number;
+    size(): number;
+    estimatedFalsePositiveRate(): number;
+    clear(): void;
+    toBytes(): Buffer;
+}
+/**
+ * Create a Bloom Filter using native bindings if available,
+ * otherwise use JavaScript fallback.
+ *
+ * @param size - Number of bits in the filter
+ * @param numHashes - Number of hash functions to use
+ */
+export declare function createBloomFilter(size: number, numHashes: number): BloomFilter;
+/**
+ * Create a Bloom Filter optimized for expected items and false positive rate.
+ * Only available with native bindings, falls back to default JS implementation.
+ *
+ * @param expectedItems - Expected number of items
+ * @param falsePositiveRate - Desired false positive rate (e.g., 0.01 for 1%)
+ */
+export declare function createBloomFilterWithRate(expectedItems: number, falsePositiveRate: number): BloomFilter;
+/**
+ * Check if native Bloom Filter is being used.
+ */
+export declare function isNativeBloomFilter(): boolean;