@vibecodetown/mcp-server 1.3.1

package/build/mapper-worker/client.js

@@ -0,0 +1,360 @@
+/**
+ * Mapper Worker - HTTP Client
+ * ===========================
+ *
+ * Client for calling Mapper HTTP worker.
+ * Supports single worker and pool modes with fallback to sync execution.
+ */
+import { isMapperWorkerEnabled, isMapperPoolEnabled, getMapperWorkerUrl, getMapperTimeout, isMapperFallbackEnabled, } from "./types.js";
+// ============================================================
+// HTTP Client
+// ============================================================
+/**
+ * Mapper Worker HTTP Client
+ */
+export class MapperWorkerClient {
+    baseUrl;
+    timeoutMs;
+    fallbackEnabled;
+    constructor(options) {
+        this.baseUrl = options?.baseUrl ?? getMapperWorkerUrl();
+        this.timeoutMs = options?.timeoutMs ?? getMapperTimeout();
+        this.fallbackEnabled = options?.fallbackEnabled ?? isMapperFallbackEnabled();
+    }
+    /**
+     * Check if worker is available
+     */
+    async isAvailable() {
+        try {
+            const health = await this.health();
+            return health.ok;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Get worker health status
+     */
+    async health() {
+        const response = await this.fetch("/health", {
+            method: "GET",
+        });
+        if (!response.ok) {
+            throw new Error(`Health check failed: ${response.status}`);
+        }
+        return response.json();
+    }
+    /**
+     * Run diff scan via worker
+     */
+    async diffScan(workspaceRoot, runId, baseRef, headRef) {
+        const request = {
+            type: "diff_scan",
+            workspace_root: workspaceRoot,
+            run_id: runId,
+            base_ref: baseRef,
+            head_ref: headRef,
+        };
+        const response = await this.fetch("/scan", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(request),
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Diff scan failed: ${response.status} - ${error}`);
+        }
+        const result = (await response.json());
+        if (!result.ok) {
+            throw new Error(result.error ?? "Unknown error");
+        }
+        return result.result;
+    }
+    /**
+     * Run staged scan via worker
+     */
+    async stagedScan(workspaceRoot, runId) {
+        const request = {
+            type: "staged_scan",
+            workspace_root: workspaceRoot,
+            run_id: runId,
+        };
+        const response = await this.fetch("/scan", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(request),
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Staged scan failed: ${response.status} - ${error}`);
+        }
+        const result = (await response.json());
+        if (!result.ok) {
+            throw new Error(result.error ?? "Unknown error");
+        }
+        return result.result;
+    }
+    /**
+     * Internal fetch with timeout
+     */
+    async fetch(path, init) {
+        const url = `${this.baseUrl}${path}`;
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+        try {
+            return await fetch(url, {
+                ...init,
+                signal: controller.signal,
+            });
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+    /**
+     * Check if fallback is enabled
+     */
+    shouldFallback() {
+        return this.fallbackEnabled;
+    }
+}
+// ============================================================
+// Pooled Client
+// ============================================================
+/**
+ * Mapper Worker client that uses a pool for load balancing
+ */
+export class PooledMapperWorkerClient extends MapperWorkerClient {
+    pool;
+    lastSelectedWorker = null;
+    pooledTimeoutMs;
+    pooledFallbackEnabled;
+    constructor(pool, options) {
+        super(options);
+        this.pool = pool;
+        this.pooledTimeoutMs = options?.timeoutMs ?? getMapperTimeout();
+        this.pooledFallbackEnabled = options?.fallbackEnabled ?? isMapperFallbackEnabled();
+    }
+    /**
+     * Internal fetch to selected worker
+     */
+    async fetchToWorker(worker, path, init) {
+        const url = `${worker.url}${path}`;
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), this.pooledTimeoutMs);
+        try {
+            return await fetch(url, {
+                ...init,
+                signal: controller.signal,
+            });
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+    /**
+     * Select worker and run diff scan
+     */
+    async diffScan(workspaceRoot, runId, baseRef, headRef) {
+        const worker = this.pool.selectWorker();
+        if (!worker) {
+            throw new Error("No healthy workers available");
+        }
+        this.lastSelectedWorker = worker;
+        const request = {
+            type: "diff_scan",
+            workspace_root: workspaceRoot,
+            run_id: runId,
+            base_ref: baseRef,
+            head_ref: headRef,
+        };
+        const response = await this.fetchToWorker(worker, "/scan", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(request),
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Diff scan failed: ${response.status} - ${error}`);
+        }
+        const result = (await response.json());
+        if (!result.ok) {
+            throw new Error(result.error ?? "Unknown error");
+        }
+        return result.result;
+    }
+    /**
+     * Select worker and run staged scan
+     */
+    async stagedScan(workspaceRoot, runId) {
+        const worker = this.pool.selectWorker();
+        if (!worker) {
+            throw new Error("No healthy workers available");
+        }
+        this.lastSelectedWorker = worker;
+        const request = {
+            type: "staged_scan",
+            workspace_root: workspaceRoot,
+            run_id: runId,
+        };
+        const response = await this.fetchToWorker(worker, "/scan", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(request),
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Staged scan failed: ${response.status} - ${error}`);
+        }
+        const result = (await response.json());
+        if (!result.ok) {
+            throw new Error(result.error ?? "Unknown error");
+        }
+        return result.result;
+    }
+    /**
+     * Get last selected worker
+     */
+    getLastSelectedWorker() {
+        return this.lastSelectedWorker;
+    }
+    /**
+     * Check if fallback is enabled
+     */
+    shouldFallback() {
+        return this.pooledFallbackEnabled;
+    }
+}
+// ============================================================
+// Global Client
+// ============================================================
+let globalClient = null;
+let poolInitialized = false;
+/**
+ * Get or create global client instance
+ */
+export function getMapperClient() {
+    if (!globalClient) {
+        if (isMapperPoolEnabled() && !poolInitialized) {
+            console.log("[MapperClient] Pool mode enabled, but pool not initialized yet. Using single worker.");
+        }
+        globalClient = new MapperWorkerClient();
+    }
+    return globalClient;
+}
+/**
+ * Initialize pooled client with pool handle
+ */
+export function initPooledMapperClient(pool) {
+    const client = new PooledMapperWorkerClient(pool);
+    globalClient = client;
+    poolInitialized = true;
+    console.log("[MapperClient] Pooled client initialized");
+    return client;
+}
+/**
+ * Reset global client (for testing)
+ */
+export function resetMapperClient() {
+    globalClient = null;
+    poolInitialized = false;
+}
+// ============================================================
+// High-Level API with Fallback
+// ============================================================
+/**
+ * Run diff scan via worker with fallback to sync
+ */
+export async function diffScanViaWorkerOrFallback(workspaceRoot, runId, baseRef, headRef, fallbackFn) {
+    // If worker not enabled, use fallback
+    if (!isMapperWorkerEnabled()) {
+        try {
+            const data = fallbackFn();
+            return { success: true, data, usedWorker: false };
+        }
+        catch (e) {
+            return {
+                success: false,
+                error: e instanceof Error ? e.message : String(e),
+                usedWorker: false,
+            };
+        }
+    }
+    const client = getMapperClient();
+    try {
+        const result = await client.diffScan(workspaceRoot, runId, baseRef, headRef);
+        return { success: true, data: result.files, usedWorker: true };
+    }
+    catch (e) {
+        const errorMsg = e instanceof Error ? e.message : String(e);
+        if (client.shouldFallback()) {
+            console.warn(`[MapperWorker] Worker failed (${errorMsg}), falling back to sync`);
+            try {
+                const data = fallbackFn();
+                return { success: true, data, usedWorker: false };
+            }
+            catch (fallbackError) {
+                return {
+                    success: false,
+                    error: fallbackError instanceof Error
+                        ? fallbackError.message
+                        : String(fallbackError),
+                    usedWorker: false,
+                };
+            }
+        }
+        return {
+            success: false,
+            error: errorMsg,
+            usedWorker: true,
+        };
+    }
+}
+/**
+ * Run staged scan via worker with fallback to sync
+ */
+export async function stagedScanViaWorkerOrFallback(workspaceRoot, runId, fallbackFn) {
+    if (!isMapperWorkerEnabled()) {
+        try {
+            const data = fallbackFn();
+            return { success: true, data, usedWorker: false };
+        }
+        catch (e) {
+            return {
+                success: false,
+                error: e instanceof Error ? e.message : String(e),
+                usedWorker: false,
+            };
+        }
+    }
+    const client = getMapperClient();
+    try {
+        const result = await client.stagedScan(workspaceRoot, runId);
+        return { success: true, data: result.files, usedWorker: true };
+    }
+    catch (e) {
+        const errorMsg = e instanceof Error ? e.message : String(e);
+        if (client.shouldFallback()) {
+            console.warn(`[MapperWorker] Worker failed (${errorMsg}), falling back to sync`);
+            try {
+                const data = fallbackFn();
+                return { success: true, data, usedWorker: false };
+            }
+            catch (fallbackError) {
+                return {
+                    success: false,
+                    error: fallbackError instanceof Error
+                        ? fallbackError.message
+                        : String(fallbackError),
+                    usedWorker: false,
+                };
+            }
+        }
+        return {
+            success: false,
+            error: errorMsg,
+            usedWorker: true,
+        };
+    }
+}

package/build/mapper-worker/index.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Mapper Worker Module
+ * ====================
+ *
+ * Async git operations and mapping worker.
+ *
+ * Usage:
+ * ```ts
+ * import { startMapperWorkerServer } from './mapper-worker';
+ *
+ * const handle = startMapperWorkerServer({ port: 8850 });
+ * // ...
+ * await handle.close();
+ * ```
+ *
+ * Pool Mode:
+ * ```ts
+ * import { startMapperPoolIfEnabled, getMapperPool, initPooledMapperClient } from './mapper-worker';
+ *
+ * const pool = await startMapperPoolIfEnabled();
+ * if (pool) {
+ *   initPooledMapperClient(pool);
+ * }
+ * ```
+ */
+export { isMapperWorkerEnabled, isMapperPoolEnabled, isMapperFallbackEnabled, getMapperWorkerUrl, getMapperTimeout, getMapperPoolSize, getMapperPoolBasePort, getMapperHealthPollMs, getMapperOptionsFromEnv, MAPPER_ENV_VARS, type MapperOperationType, type MapperRequest, type MapperResponse, type DiffScanResult, type ImportScanResult, type PipelineResult, type MapperMetrics, type MapperHealthResponse, type MapperWorkerStatus, type MapperPoolWorker, type MapperPoolOptions, type MapperPoolHandle, type MapperClientOptions, type MapperCallResult, } from "./types.js";
+export { startMapperWorkerServer, scanChangedFilesAsync, scanStagedFilesAsync, runGitAsync, type MapperWorkerOptions, type MapperWorkerHandle, } from "./server.js";
+export { createMapperPool, getMapperPool, startMapperPoolIfEnabled, shutdownMapperPool, } from "./pool.js";
+export { MapperWorkerClient, PooledMapperWorkerClient, getMapperClient, initPooledMapperClient, resetMapperClient, diffScanViaWorkerOrFallback, stagedScanViaWorkerOrFallback, } from "./client.js";

package/build/mapper-worker/index.js

@@ -0,0 +1,33 @@
+/**
+ * Mapper Worker Module
+ * ====================
+ *
+ * Async git operations and mapping worker.
+ *
+ * Usage:
+ * ```ts
+ * import { startMapperWorkerServer } from './mapper-worker';
+ *
+ * const handle = startMapperWorkerServer({ port: 8850 });
+ * // ...
+ * await handle.close();
+ * ```
+ *
+ * Pool Mode:
+ * ```ts
+ * import { startMapperPoolIfEnabled, getMapperPool, initPooledMapperClient } from './mapper-worker';
+ *
+ * const pool = await startMapperPoolIfEnabled();
+ * if (pool) {
+ *   initPooledMapperClient(pool);
+ * }
+ * ```
+ */
+// Types
+export { isMapperWorkerEnabled, isMapperPoolEnabled, isMapperFallbackEnabled, getMapperWorkerUrl, getMapperTimeout, getMapperPoolSize, getMapperPoolBasePort, getMapperHealthPollMs, getMapperOptionsFromEnv, MAPPER_ENV_VARS, } from "./types.js";
+// Server
+export { startMapperWorkerServer, scanChangedFilesAsync, scanStagedFilesAsync, runGitAsync, } from "./server.js";
+// Pool
+export { createMapperPool, getMapperPool, startMapperPoolIfEnabled, shutdownMapperPool, } from "./pool.js";
+// Client
+export { MapperWorkerClient, PooledMapperWorkerClient, getMapperClient, initPooledMapperClient, resetMapperClient, diffScanViaWorkerOrFallback, stagedScanViaWorkerOrFallback, } from "./client.js";

package/build/mapper-worker/pool.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Mapper Worker - Pool Manager
+ * ============================
+ *
+ * Manages a pool of mapper worker processes (4-16 workers).
+ * Unlike BitNet workers, mapper workers are lightweight and can scale higher.
+ */
+import type { MapperPoolOptions, MapperPoolHandle } from "./types.js";
+/**
+ * Create a mapper pool manager
+ */
+export declare function createMapperPool(opts?: MapperPoolOptions): MapperPoolHandle;
+/**
+ * Get or create global pool instance
+ */
+export declare function getMapperPool(): MapperPoolHandle;
+/**
+ * Start global pool if pool mode is enabled
+ */
+export declare function startMapperPoolIfEnabled(): Promise<MapperPoolHandle | null>;
+/**
+ * Shutdown global pool
+ */
+export declare function shutdownMapperPool(): Promise<void>;